@pulse-compute/cli 0.0.0 → 1.0.0-beta.2

package/docs/examples.md

@@ -0,0 +1,112 @@
+# Canonical examples
+
+Every top-level example is a complete Pulse project with a handler, config,
+tests, TypeScript config, and package metadata. The executable documentation
+lane runs every example except 10 through `doctor`, `inspect`, `test`, and
+`build`; it also starts the hello project with `dev`, sends a request, and
+verifies shutdown. Example 10 uses its focused orchestration proof while
+ordinary package-loader and Native-intrinsic integration remain candidate
+blockers.
+
+| Example | Demonstrates |
+|---|---|
+| [`01-hello-json`](../examples/01-hello-json/) | Request branching and JSON/text responses. |
+| [`02-request-schema`](../examples/02-request-schema/) | Explicit request and response schemas. |
+| [`03-fetch-composition`](../examples/03-fetch-composition/) | One fetch, sequential composition, and explicit `ctx.parallel` concurrency. |
+| [`05-fastly-capabilities`](../examples/05-fastly-capabilities/) | Config, secrets, KV, a named backend, and package-root GRIP broadcast. |
+| [`07-opaque-proxy`](../examples/07-opaque-proxy/) | Direct binary/stream pass-through without body inspection. |
+| [`09-router-lowering`](../examples/09-router-lowering/) | Mounted routes, scoped terminal middleware, fallthrough, error transfer, parameters, wildcards, and entry-aware effects. |
+| [`10-entities-tools`](../examples/10-entities-tools/) | Experimental schema-bound entities, deterministic catalog discovery, JSON-RPC dispatch, and an external tools facade. |
+| [`11-events`](../examples/11-events/) | Static event ingress, schema/no-payload frames, exact outbound acceptance, and separate HTTP/event entries. |
+| [`12-mcp-proxy`](../examples/12-mcp-proxy/) | A bounded JSON-RPC request seam and opaque upstream response pass-through. |
+| [`13-jwt-es256`](../examples/13-jwt-es256/) | ES256 bearer verification with an explicit guest-linked Native realization. |
+
+## Wasm size at a glance
+
+The Native rows compare the ordinary build with
+`pulse build --experimental-native-size`. Values are uncompressed on-disk
+sizes; each example page includes exact byte counts.
+
+| Example | Default Native Wasm | Size-optimized Native Wasm | Reduction | Deployable Fastly module |
+|---|---:|---:|---:|---:|
+| `01-hello-json` | 2.2 KiB | 2.0 KiB | 7.0% | — |
+| `02-request-schema` | 38.9 KiB | 30.8 KiB | 20.6% | — |
+| `03-fetch-composition` | 5.0 KiB | 4.2 KiB | 15.0% | — |
+| `05-fastly-capabilities` | 5.3 KiB | 4.8 KiB | 10.4% | 40.4 → 33.7 KiB |
+| `07-opaque-proxy` | 2.1 KiB | 2.1 KiB | 4.5% | 28.9 → 25.3 KiB |
+| `09-router-lowering` | 6.1 KiB | 5.4 KiB | 12.4% | — |
+| `10-entities-tools` | — | — | Not applicable | JavaScript-first candidate |
+| `11-events` | 38.4 KiB | 30.6 KiB | 20.4% | — |
+| `12-mcp-proxy` | 2.5 KiB | 2.4 KiB | 6.6% | — |
+| `13-jwt-es256` | 23.1 KiB | 22.9 KiB | 0.8% | — |
+
+Run the normal workflow from any example directory:
+
+```bash
+pulse doctor
+pulse test
+pulse dev
+pulse build
+```
+
+Use `pulse inspect` when you need to examine the plan; it is not required before
+`build`. Each example README contains exact source-bound handler/config blocks
+and executable evidence selected by the docs lane. Every page also records the
+default and experimental size-optimized Wasm outputs; Fastly pages separate the
+provider-neutral guest from the deployable module, and the JavaScript-first
+Entities page explicitly records that no comparable application Wasm is
+emitted. The same gate rebuilds and verifies every exact byte count. See
+[Project lifecycle](./guides/project-lifecycle.md).
+
+Examples 01, 02, 03, 05, 07, 11, 12, and 13 use current package-root application
+surfaces. Example 09 retains the lower-level Router surface. Example 10 uses
+the synchronized `@pulse-compute/entities` Beta package; executable examples do
+not themselves authorize publication. Example 11 is executable only through
+the Node JavaScript/Native reference adapter. It does not claim a public
+listener, delivery, or Fastly/browser/ESP32 event support; see
+[Static events and outbound emission](./guides/events.md).
+
+Example 12 is an MCP-shaped HTTP proxy, not an MCP server. The incoming body is
+materialized once as bounded text because Pulse has no opaque incoming-body
+forwarding contract; the fetched response remains opaque.
+
+Example 13 pins the guest-linked ES256 realization for Native. Its harness
+executes valid, invalid-signature, and disallowed-algorithm cases against the
+exact linked artifact; only the public P-256 JWK is included in the example.
+
+## Verified native Fastly build
+
+This documented build is executed against the config/secret example and must
+produce the configured-provider native Fastly module. The portable compiler
+runs before the exact artifact crosses the provider boundary; the provider
+target receives no compiler service and does not invoke one.
+
+<!-- pulse-doc-run {"project":"examples/05-fastly-capabilities","args":["build","--out",".pulse-docs-build","--json"],"timeoutMs":360000} -->
+```bash
+pulse build --out .pulse-docs-build --json
+```
+```json
+{
+  "status": "built",
+  "provider": "fastly",
+  "manifest": {
+    "providerTarget": {
+      "sourceOnly": false,
+      "compiledWasmPresent": true,
+      "target": "fastly-compute-native",
+      "javascriptRuntime": false,
+      "compiler": {
+        "package": "assemblyscript",
+        "version": "0.28.18",
+        "invoked": false
+      },
+      "wasm": {
+        "file": "bin/main.wasm",
+        "magic": "0061736d01000000"
+      }
+    }
+  }
+}
+```
+
+Fastly configured tests and `pulse dev` use the local-conformance runtime. The separate reality profile delegates execution of the native provider module to `fastly compute serve`.

package/docs/fixtures/inspect-fetch-composition.selected.json

@@ -0,0 +1,181 @@
+{
+  "status": "ok",
+  "project": {
+    "provider": "node",
+    "entry": "src/index.ts"
+  },
+  "compiler": {
+    "version": "pulse.canonical-api-compiler.v7",
+    "capabilities": [
+      "fetch",
+      "response.json",
+      "response.text"
+    ],
+    "effects": [
+      {
+        "id": "fetch-1",
+        "kind": "fetch",
+        "operation": "dispatch",
+        "capability": "fetch",
+        "resource": {
+          "kind": "literal",
+          "value": "https://users.example.test/users/123",
+          "origin": "https://users.example.test"
+        },
+        "grouped": false
+      },
+      {
+        "id": "fetch-2",
+        "kind": "fetch",
+        "operation": "dispatch",
+        "capability": "fetch",
+        "resource": {
+          "kind": "literal",
+          "value": "https://users.example.test/users/123",
+          "origin": "https://users.example.test"
+        },
+        "grouped": true
+      },
+      {
+        "id": "fetch-3",
+        "kind": "fetch",
+        "operation": "dispatch",
+        "capability": "fetch",
+        "resource": {
+          "kind": "literal",
+          "value": "https://stats.example.test/users/123",
+          "origin": "https://stats.example.test"
+        },
+        "grouped": true
+      },
+      {
+        "id": "fetch-4",
+        "kind": "fetch",
+        "operation": "dispatch",
+        "capability": "fetch",
+        "resource": {
+          "kind": "literal",
+          "value": "https://flags.example.test/users/123",
+          "origin": "https://flags.example.test"
+        },
+        "grouped": true
+      },
+      {
+        "id": "fetch-5",
+        "kind": "fetch",
+        "operation": "dispatch",
+        "capability": "fetch",
+        "resource": {
+          "kind": "literal",
+          "value": "https://users.example.test/users/123",
+          "origin": "https://users.example.test"
+        },
+        "grouped": true,
+        "groupKey": "user"
+      },
+      {
+        "id": "fetch-6",
+        "kind": "fetch",
+        "operation": "dispatch",
+        "capability": "fetch",
+        "resource": {
+          "kind": "literal",
+          "value": "https://stats.example.test/users/123",
+          "origin": "https://stats.example.test"
+        },
+        "grouped": true,
+        "groupKey": "stats"
+      },
+      {
+        "id": "fetch-7",
+        "kind": "fetch",
+        "operation": "dispatch",
+        "capability": "fetch",
+        "resource": {
+          "kind": "literal",
+          "value": "https://flags.example.test/users/123",
+          "origin": "https://flags.example.test"
+        },
+        "grouped": true,
+        "groupKey": "flags"
+      }
+    ],
+    "continuations": [
+      {
+        "id": "continuation-1",
+        "kind": "single-fetch",
+        "effectIds": [
+          "fetch-1"
+        ]
+      },
+      {
+        "id": "continuation-2",
+        "kind": "fetch-group",
+        "effectIds": [
+          "fetch-2",
+          "fetch-3",
+          "fetch-4"
+        ]
+      },
+      {
+        "id": "continuation-3",
+        "kind": "parallel-group",
+        "effectIds": [
+          "fetch-5",
+          "fetch-6",
+          "fetch-7"
+        ]
+      }
+    ],
+    "providerLowering": {
+      "version": "pulse.canonical-provider-plan.v1",
+      "contractVersion": "pulse.canonical-provider-contract.v1",
+      "provider": "node",
+      "requirements": [
+        "fetch",
+        "response.json",
+        "response.text"
+      ],
+      "operations": [
+        {
+          "id": "fetch-1",
+          "lowering": "node.fetch.dispatch",
+          "binding": "https://users.example.test"
+        },
+        {
+          "id": "fetch-2",
+          "lowering": "node.fetch.dispatch",
+          "binding": "https://users.example.test"
+        },
+        {
+          "id": "fetch-3",
+          "lowering": "node.fetch.dispatch",
+          "binding": "https://stats.example.test"
+        },
+        {
+          "id": "fetch-4",
+          "lowering": "node.fetch.dispatch",
+          "binding": "https://flags.example.test"
+        },
+        {
+          "id": "fetch-5",
+          "lowering": "node.fetch.dispatch",
+          "binding": "https://users.example.test"
+        },
+        {
+          "id": "fetch-6",
+          "lowering": "node.fetch.dispatch",
+          "binding": "https://stats.example.test"
+        },
+        {
+          "id": "fetch-7",
+          "lowering": "node.fetch.dispatch",
+          "binding": "https://flags.example.test"
+        }
+      ],
+      "providerSpecificUserland": false,
+      "providerSdkUserland": false,
+      "capabilityDiscoveryFromUserland": false
+    }
+  }
+}

package/docs/getting-started.md

@@ -0,0 +1,128 @@
+# Getting started
+
+This page creates and verifies a first project. The normal application journey
+continues through `init → doctor → test → dev → build`; see [Project
+lifecycle](./guides/project-lifecycle.md) for the canonical sequence and the
+optional `inspect` and advanced `compile` branches.
+
+## Requirements
+
+- Node.js `22.14.0` or newer on the 22.x line, or Node.js 24.x (`^22.14.0 || ^24.0.0`).
+- npm 10 or another npm-compatible package manager.
+- A repository checkout with its lockfile-pinned dependencies restored, using `pnpm pulse -- <command>`, or the synchronized public package set produced by release acceptance.
+- A Fastly local execution engine only when running the external Fastly Compute reality workflow. Native compilation and configured-provider builds do not require one. The gate accepts the Fastly CLI through `PATH`/`PULSE_FASTLY_BIN` or direct Viceroy through `PULSE_VICEROY_BIN`.
+
+## Create a project
+
+The command and documented result below are executed by the documentation test lane.
+
+<!-- pulse-doc-run {"temp":true,"args":["init","hello-pulse","--json"],"display":"pnpm pulse -- init ./hello-pulse --json"} -->
+```bash
+pnpm pulse -- init ./hello-pulse --json
+```
+```json
+{
+  "status": "initialized",
+  "files": [
+    ".gitignore",
+    ".pulse/.gitignore",
+    ".pulse/config.ts",
+    "README.md",
+    "package.json",
+    "src/index.ts",
+    "tests/pulse.harness.ts",
+    "tsconfig.json"
+  ]
+}
+```
+
+Then enter the project and install the exact dependencies written by `pulse init`:
+
+```bash
+cd ./hello-pulse
+npm install
+```
+
+`pulse init` never runs a package manager or performs hidden network work.
+
+The generated project uses the conventional `.pulse/config.ts` workspace,
+an async `Pulse` application root from `@pulse-compute/pulse`, and a dedicated
+`tests/pulse.harness.ts` case module. The `.pulse/.gitignore` keeps generated
+workspace artifacts out of version control while retaining the project config.
+
+## Verify the project
+
+```bash
+npm run doctor
+npm test
+```
+
+- `doctor` validates configuration, entry resolution, schema declarations, provider support, output safety, and required toolchains.
+- `test` executes the configured cases through the selected provider’s local runtime.
+
+Use `npm run inspect` when you need the capabilities, effects, continuations,
+schemas, target-support decision, or provider lowering required by the handler.
+It is observability, not a required lifecycle stage.
+
+## Run locally
+
+```bash
+npm run dev
+```
+
+`pulse dev` is a foreground server. It watches the handler and schema dependency graph, recompiles on change, and exits when the process receives a normal termination signal. It does not create a daemon or background worker. The executable docs lane starts it with `--once`, sends a real request, verifies the response, and checks clean shutdown.
+
+## Advanced: compile portable Pulse Wasm
+
+```bash
+npm run compile
+```
+
+`pulse compile` lowers the canonical handler into a deterministic provider-neutral execution plan and writes compact Pulse-owned WebAssembly. The output includes `pulse-compile.json`, `canonical-native-plan.json`, generated AssemblyScript, Wasm, WAT, and the native ABI manifest. It does not package a deployment provider or embed the Fastly JavaScript runtime.
+
+The provider selected by the active `.pulse/config.ts` profile remains relevant to `test`, `dev`, and `build`, but it does not change the portable artifact produced by `compile`. Normal projects can proceed directly from `dev` to `build`; `compile` is not a prerequisite.
+
+## Build
+
+```bash
+npm run build
+```
+
+For Node, the build emits the canonical handler, program metadata, schema registry/codecs when configured, and `pulse-build.json`.
+
+For Fastly, `pulse build` reads the provider and bindings from the selected `.pulse/config.ts` profile, compiles the same provider-neutral native plan, and emits generated Fastly-targeted AssemblyScript plus compact direct-host-ABI WebAssembly at `bin/main.wasm`:
+
+```bash
+npm run build
+```
+
+The public CLI does not accept provider overrides. Use `pulse compile` when only the portable `pulse_host` module is needed; use `pulse build` when the configured deployment realization is needed. Native builds always preserve generated source and Wasm together.
+
+Provider-neutral compilation and Native provider builds may opt into the
+explicitly experimental size optimizer:
+
+```bash
+pulse compile --experimental-native-size
+pulse build --experimental-native-size
+```
+
+The Native compiler resolves that intent to its experimental size profile. The
+current runtime and export surface remain unchanged, the default build is
+unaffected, and portable and provider manifests record the resolved profile.
+JavaScript build targets reject the flag.
+
+For candidate-specific output and proof boundaries, continue with [Node build
+and execution](./guides/deploying-node.md) or [Fastly deployment
+candidates](./guides/deploying-fastly.md).
+
+## Diagnose failures
+
+Run `pulse doctor --json` and use the stable diagnostic code. See [Troubleshooting](guides/troubleshooting.md) and the [diagnostics reference](reference/diagnostics.md).
+
+## Next steps
+
+- Start with [`examples/01-hello-json`](../examples/01-hello-json/).
+- Add upstream data with [fetching and composition](./guides/fetching-and-composition.md).
+- Add bounded validation with [explicit JSON schemas](./guides/json-schemas.md).
+- Map platform data using [Fastly capabilities](./guides/fastly-capabilities.md).
+- Check source eligibility in [Managed handler TypeScript and JavaScript](./reference/handler-authoring.md), then confirm the selected mode in [Provider and target compatibility](./reference/compatibility-matrix.md).

package/docs/guides/compatibility-imports.md

@@ -0,0 +1,60 @@
+# Compatibility imports and migration
+
+Current application code imports Assets and GRIP from their package roots:
+
+```ts
+import { assets } from '@pulse-compute/assets'
+import { grip } from '@pulse-compute/grip'
+```
+
+Older fixtures may import `@pulse-compute/assets/pulsewasm` or
+`@pulse-compute/grip/pulsewasm`. Those subpaths remain bounded compatibility
+surfaces; they are not the recommended starting point for a new application and
+do not define a general package-extension convention.
+
+## Assets
+
+Replace the compatibility import with the package root:
+
+```diff
+- import { assets } from '@pulse-compute/assets/pulsewasm'
++ import { assets } from '@pulse-compute/assets'
+```
+
+The supported package-root surface uses `assets.lookup(ctx, ...)` for the
+request-bound effect and `assets.respond(...)` for response adoption. Check
+argument eligibility when the selected target is Native; JavaScript execution
+does not widen the Native lowering contract.
+
+See the [Assets package guide](../packages/assets.md).
+
+## GRIP
+
+GRIP migration is an API migration, not only an import rewrite. The compatibility
+facade exposes the older `channel`, `hold`, and `publish` shape. The package root
+separates pure HTTP framing from the request-bound broadcast effect:
+
+- `grip.isWebSocket(request)` classifies a request;
+- `grip.subscribe(response, options)` decorates a response;
+- `grip.handoff(options)` constructs a gateway handoff response;
+- `await grip.broadcast(ctx, message)` emits configured outbound work.
+
+Move new route code to that package-root model and keep gateway connection
+ownership outside Pulse. The canonical Fastly example now uses the package-root
+`grip.broadcast` contract; the older compatibility fixture is no longer part of
+the public examples set.
+
+See the [GRIP package guide](../packages/grip.md) and
+[GRIP/Fanout guide](./grip.md).
+
+## Internal filenames are not authoring paths
+
+First-party packages still contain names such as `pulsewasm.manifest.cjs`,
+`pulsewasm.compiler.cjs`, and `pulsewasm.lowerable-library-manifest.v2`. Those
+are repository and toolchain protocol names. They do not imply that an
+application should import a `/pulsewasm` subpath or that third-party compiler
+builders can self-register.
+
+The current trust boundary is documented in
+[Package-owned lowering](../concepts/package-owned-lowering.md). Contributor
+protocol details remain internal to the synchronized release set.

package/docs/guides/deploying-fastly.md

@@ -0,0 +1,188 @@
+# Fastly deployment candidates
+
+Pulse produces separate Fastly Native and Fastly JavaScript Compute candidates.
+Local conformance, target building, external provider reality, remote
+deployment, and service activation are different proof levels.
+
+This guide does not claim that a local simulation or offline build is a
+production deployment.
+
+## Configure bindings and target
+
+The config/secret example is source-bound to a Fastly Native profile:
+
+<!-- pulse-doc-source: examples/05-fastly-capabilities/.pulse/config.ts -->
+```ts
+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: 'fastly',
+    target: 'native',
+    outDir: 'dist',
+    apiBase: scope.config('API_BASE'),
+    apiToken: scope.secret('API_TOKEN'),
+    dev: {
+      config: { API_BASE: 'https://api.example.com' },
+      secrets: {
+        API_TOKEN: 'local-example-secret',
+        GRIP_TOKEN: 'local-grip-secret',
+      },
+      kv: {
+        sessions: { 'session:123': { userId: 123 } },
+      },
+      fetches: {
+        'https://api.example.com/users/7': {
+          value: { id: 7, name: 'Ada' },
+        },
+        'POST https://publisher.example.com/publish': {
+          status: 202,
+          value: { accepted: true, messageId: 'message-1' },
+        },
+      },
+    },
+    fastly: {
+      bindings: {
+        configStore: 'app_config',
+        secretStore: 'app_secrets',
+        kv: { sessions: 'app_sessions' },
+        backends: {
+          'https://api.example.com': 'api_backend',
+          'https://publisher.example.com': 'publisher_backend',
+        },
+        dynamicBackends: false,
+        grip: {
+          publishEndpoint: 'https://publisher.example.com/publish',
+          publishBackend: 'publisher_backend',
+          authentication: {
+            scheme: 'bearer',
+            secretRef: 'GRIP_TOKEN',
+          },
+        },
+      },
+      build: { name: 'pulse-fastly-capabilities-example' },
+    },
+  },
+}))
+```
+<!-- /pulse-doc-source -->
+
+Select the JavaScript candidate explicitly with `target: 'javascript'`.
+
+The `dev` values and fixtures are local conformance inputs. They do not create
+or populate Fastly Config Stores, Secret Stores, KV Stores, backends, Fanout
+resources, or services. Deployment resource names belong under
+`fastly.bindings`.
+
+## Validate locally
+
+```bash
+pulse doctor
+pulse test
+pulse dev
+```
+
+For both Fastly targets, `test` and `dev` use provider-owned local execution.
+Fastly JavaScript identifies this as provider emulation. Fastly Native uses the
+canonical local runtime. Neither path contacts or proves a deployed service.
+
+## Build Fastly Native
+
+```bash
+pulse build
+```
+
+With `target: 'native'`, Pulse compiles the provider-neutral plan and emits
+generated `src/main.as.ts` plus compact direct-host-ABI:
+
+```text
+bin/main.wasm
+```
+
+The Wasm imports the required `fastly_*` hostcalls directly. It does not contain
+the Fastly JavaScript runtime, `pulse_host`, or a WASI dependency. The build
+manifest records exact provider bindings, required capabilities, target
+identity, compiler identity, and artifact hashes.
+
+## Build Fastly JavaScript
+
+With `target: 'javascript'`, `pulse build` emits a deterministic source and
+deployment closure:
+
+```text
+src/index.js
+src/application.js
+fastly.toml
+package.json
+pulse-esbuild.config.js
+pulse-fastly-javascript-candidate.json
+pulse-fastly-javascript-deployment.json
+pulse-fastly-javascript-source-package.json
+```
+
+The closure pins `esbuild` and `@fastly/js-compute`, bundles the reachable Pulse
+application and supported package implementations, and contains no Pulse
+Native artifact. Its downstream build produces `bin/main.wasm`; the candidate
+and deployment manifests bind that runtime artifact by SHA-256 and retain
+`automaticFallback: false`.
+
+Pulse claims deterministic bytes for its source closure and deployment
+metadata. It does not claim byte-identical Wizer-owned runtime snapshots.
+
+## Provider reality is a separate gate
+
+The external Native reality lane discovers the Fastly CLI and invokes:
+
+```text
+fastly compute serve --file <candidate>/bin/main.wasm
+```
+
+and sends real HTTP requests through the generated module. It covers schemas,
+config, secrets, KV persistence, named-backend fetch, opaque bytes, repeated
+headers, and GRIP hold/publish.
+
+The Fastly JavaScript offline candidate lane runs the exact pinned downstream
+compiler and validates the resulting runtime Wasm. It does not currently claim
+the same `fastly compute serve` reality execution.
+
+The Sprint 7 final candidate must pass its mandatory external reality gate in
+the later packed/provider-reality checkpoint. Checkpoint 5 documents the
+boundary; it does not mark that external gate complete.
+
+## Remote deployment and activation
+
+`pulse build` never runs `fastly compute deploy`. After candidate review, a
+human deployment owner must:
+
+1. create or select the Fastly service and required resources;
+2. ensure every configured binding names the intended resource;
+3. supply account, service, and token authority outside the handler;
+4. run the provider deployment command against the reviewed candidate;
+5. verify the deployed service and external origins;
+6. decide activation, traffic migration, and rollback.
+
+Remote deployment and activation require explicit human authorization. A
+successful local conformance run, offline build, downstream JavaScript compile,
+or Native reality serve does not authorize those actions.
+
+## Proof-level checklist
+
+| Proof level | What it establishes | What it does not establish |
+|---|---|---|
+| `pulse test` / `pulse dev` | Canonical behavior and configured local mapping | Remote resources or deployed service health |
+| `pulse build` | Deterministic provider candidate and metadata | External provider execution or deployment |
+| Native reality gate | Real Fastly CLI-managed host-ABI execution | Remote service deployment or activation |
+| JavaScript offline candidate gate | Exact downstream runtime compilation | Fastly serve, remote deployment, or activation |
+| Human remote verification | Deployed service/resource behavior | Permission to publish or promote other release surfaces |
+
+See [Project lifecycle](./project-lifecycle.md), [Fastly config, secrets, and
+KV](./fastly-capabilities.md), [`@pulse-compute/provider-fastly`](../packages/provider-fastly.md),
+[Managed handler TypeScript and JavaScript](../reference/handler-authoring.md),
+[Provider and target compatibility](../reference/compatibility-matrix.md),
+and [Release acceptance](../maintainers/release-acceptance.md).