Pulse#

Pulse is a compiler-driven TypeScript application layer for small, portable edge and WebAssembly services.

A conventional Pulse project is an async-shaped Pulse or low-level Router application plus a .pulse/config.ts workspace and dedicated test harness. The pulse CLI resolves the complete project, including explicit JSON schemas and package-owned capabilities, then realizes the exact provider and target selected by the active profile.

canonical TypeScript
→ pulse CLI
├→ Native: whole-project lowering → effects/continuations → Node or Fastly Wasm
└→ JavaScript: reachable source graph → live packages → Node or Fastly lifecycle

Start here#

# From the repository checkout after restoring lockfile-pinned dependencies
pnpm pulse -- init ./my-app
cd ./my-app
npm install
npm run doctor
npm test
npm run dev
npm run build

pulse init writes exact package versions but does not perform network installation. Packed-package acceptance installs the synchronized release set and verifies this path without workspace links. Published package availability remains defined by the 18-package release manifest.

This is the normal application lifecycle. Use pulse inspect when you need to examine the compiler/provider plan, and use the advanced provider-neutral pulse compile command when you specifically need the portable pulse_host Wasm boundary. Neither command is a prerequisite for pulse build. See the project lifecycle guide.

A minimal managed handler is async-shaped and provider-neutral. Native lowering erases the wrapper and lowers only trusted Pulse effects; it does not add a Promise runtime or Asyncify. The source shown here is copied exactly from examples/01-hello-json/src/index.ts:

import { Pulse } from '@pulse-compute/pulse'

const app = new Pulse({ auto: true })

app.get('/health', async (ctx) => ctx.json({ ok: true }))
app.get('/hello', async (ctx) => ctx.json({ message: 'hello from Pulse' }))
app.get('/*', async (ctx) => ctx.text('not found', { status: 404 }))

export default app

The matching project configuration is source-bound as well:

import { defineConfig } from '@pulse-compute/pulse'

export default defineConfig((_scope) => ({
  pulse: {
    entry: 'src/index.ts',
    tests: 'tests/pulse.harness.ts',
    defaultProfile: 'local',
    strict: true,
  },
  local: {
    host: 'node',
    target: 'native',
    outDir: 'dist',
    dev: { host: '127.0.0.1', port: 8787 },
  },
}))

Implemented Beta surface#

Pulse currently supports:

• request method, URL, path, headers, text, and JSON;
• explicit TypeScript JSON schemas compiled with the project;
• branching and structured value manipulation;
• static Router authoring with mounted exact, parameter, wildcard, GET, HEAD, and POST routes;
• single, grouped, and dependent outbound fetches;
• JSON, text, custom, and direct pass-through responses;
• provider-neutral config, secret, and KV capabilities;
• synchronous thresholded ctx.log.error|warn|info|debug with redaction;
• opaque binary/stream pass-through without userland inspection;
• package-root GRIP framing/broadcast and Assets realization;
• explicit Node Native, Node JavaScript, Fastly Native, and Fastly JavaScript modes;
• deterministic JavaScript source packages and offline Fastly deployment candidates;
• init, doctor, inspect, test, dev, compile, and build through one CLI.

All four modes share one conformance corpus and never substitute targets automatically. Candidate validation is offline: it does not deploy, activate, or publish a Fastly service.

The Beta deliberately does not expose general Promise-based Native semantics, provider SDKs, ambient environment authority, arbitrary binary inspection, userland stream transforms, background tasks, or raw sockets.

Public packages#

The public 1.0.0-beta.1 catalog is defined by the release manifest.

@pulse-compute/pulse and @pulse-compute/runtime are layered public application contracts: the former owns conventional project ergonomics and the latter owns the low-level portable runtime surface. Native and JavaScript execution are explicitly selected targets over the same canonical model; Pulse never changes targets automatically.

Documentation#

The public Pulse site introduces the compiler and links into the layered documentation. Exact hosted documentation is release-pinned; repository Markdown remains the reviewable source.

• Documentation index
• Changelog
• Public-site and documentation presentation system
• Getting started
• Project lifecycle
• Handler authoring and target compatibility
• Node build and execution
• Fastly deployment candidates
• Beta scope
• Task-oriented guides
• Concepts: lowering, effects, bodies, and providers
• Package guides and support policy
• API, CLI, config, diagnostics, and environment reference
• Contributor tutorials
• Maintainer governance and support
• Release acceptance

Maintenance and support#

Pulse uses a repository-encoded resident-maintainer control plane. Codex can classify, review, reproduce, document, and prepare bounded patches; human maintainers retain architecture, merge, repository-setting, and release authority.

• Contributing
• Support
• Security policy
• Maintainer charter
• Scope policy
• Generated maintenance policy

Run npm run maintainer:check before opening a pull request.

Portable dependency bundle and restore tooling is distributed separately from the source snapshot. A handoff should pair this repository with a target-specific dependency archive and its matching verified restore script; the source workspace does not expose stale versioned wrapper commands.

Examples#

The top-level examples/ directory contains complete canonical projects for JSON responses, schemas, fetch workflows, Fastly capabilities, opaque proxying, GRIP, and static Router lowering. Each example can be driven with the same CLI commands used by a normal project.

License#

Pulse is licensed under the Apache License 2.0.