@pulse-compute/cli 1.0.0-beta.1 → 1.0.0-beta.3

package/API.md

@@ -30,7 +30,7 @@ process, provider SDK, or global network surface behind it.
 | [`ctx.emit`](#ctxemit) | HTTP and event handlers | One-way, schema-bound event acceptance effect. |
 | [`ctx.log`](#ctxlog) | HTTP and event handlers | Synchronous thresholded logging. |
 | [`ctx.config`, `ctx.secret`](#config-and-secrets) | HTTP and event handlers | Explicit configured binding reads. |
-| [`ctx.kv(name)`](#kv) | HTTP and event handlers | Bound `get` and `put` storage effects. |
+| [`ctx.kv(name)`](#kv) | HTTP and event handlers | Bound reads, writes, and conditional KV effects (Node reference). |
 | [`ctx.json`, `ctx.text`, `ctx.response`](#response-builders) | HTTP handlers and middleware | Synchronous response construction. |
 | `ctx.event` | Event handlers only | Exact event type and immutable validated payload. |
 
@@ -83,7 +83,7 @@ app.mount('/api', api)
 export default app
 ```
 
-`Router` is a compile-time marker. Canonical v2 supports `get`, `head`, `post`, exact paths, named parameters, a trailing wildcard, static mounts, global/path-scoped/mounted middleware, route fallthrough, and error middleware. `ctx.param(name)` returns the matched named parameter inside route handlers.
+`Router` is a compile-time marker. Canonical v2 supports `get`, `head`, `post`, `put`, `patch`, `delete`, exact paths, named parameters, a trailing wildcard, static mounts, global/path-scoped/mounted middleware, route fallthrough, and error middleware. `Pulse` inherits these registrations. `ctx.param(name)` returns the matched named parameter inside route handlers.
 
 `next()` is a terminal control transfer. `return next()` advances the normal Router cursor and permanently ends the current handler scope. `return next(error)` enters or advances the error lane. There is no onion-style downstream return or post-`next()` resume. Normal and error exhaustion produce compiler-owned 404 and 500 responses respectively.
 
@@ -400,7 +400,7 @@ const value = await sessions.get('current')
 if (value !== undefined) await sessions.put('last', value)
 ```
 
-The Beta supports `get` and `put`. Store names and keys are
+The existing `get` and `put` operations remain available. Store names and keys are
 provider-neutral logical bindings. Values are bounded, detached, deeply frozen
 JSON-compatible trees; accessors, symbols, sparse arrays, repeated references,
 cycles, class instances, nonfinite numbers, and nested `undefined` are rejected.
@@ -408,6 +408,39 @@ cycles, class instances, nonfinite numbers, and nested `undefined` are rejected.
 and cross-request lifetime remain provider capabilities rather than properties
 of the common API.
 
+The Node reference on JavaScript and Native, and the Fastly Native adapter,
+realize these operations through direct await or keyed `ctx.parallel`:
+
+| Method | Result |
+| --- | --- |
+| `getVersioned(key)` | `found` with one observed `value` and opaque `generation`, `not-found`, or `failed` with a reason. |
+| `insertIfAbsent(key, value)` | Atomically creates an absent key. |
+| `compareAndSwap(key, generation, value)` | Atomically replaces the value only when its current generation matches. |
+
+Conditional writes return `stored`, `conflict`, `not-stored` with a reason, or
+`unknown` with a reason. `unknown` may have committed; Pulse never automatically
+retries or rebases. A write acknowledgement carries no new generation. An absent
+CAS conflicts. A read may be stale, but its value and token describe the same
+observation. Tokens are bounded opaque strings, never JavaScript numbers or
+application revision counters.
+
+Namespaces must be literal bindings; keys, generations, and candidates are runtime
+data. Candidates are snapshotted at admission. Keys are exact Unicode scalar
+strings of 1–1,024 UTF-8 bytes without C0/C1 controls; tokens are 1–256 visible
+ASCII bytes. Values retain the 65,536-byte JSON, depth-64 and 10,000-entry bounds.
+The host owns the ten-second operation deadline, shortened by a request deadline.
+Timeouts before dispatch are `not-stored`; unconfirmed writes after dispatch are
+`unknown`. Request cancellation follows the existing managed lifecycle and
+never implies rollback.
+
+The Node realization is an explicit in-memory reference instance, not a durable
+storage guarantee. Fastly Native uses lossless 64-bit generation metadata and
+conditional host operations with bounded readiness and body acquisition. Deployed
+cross-location acceptance remains a separate gate. The Fastly JavaScript SDK is
+incomplete capability mapping and does not define or block
+Pulse's contract. Conditional wire values use the strict
+`{"__pulseKv":1,"value":...}` envelope; legacy raw JSON requires explicit migration.
+
 ## Explicit JSON schemas
 
 <!-- pulse-doc-source: examples/02-request-schema/.pulse/config.ts -->
@@ -454,7 +487,7 @@ Older `/pulsewasm` imports are compatibility-only and are isolated in the
 
 ## Entities API
 
-`@pulse-compute/entities` is part of the synchronized `1.0.0-beta.1` package
+`@pulse-compute/entities` is part of the synchronized `1.0.0-beta.3` package
 set. The application surface has two runtime values:
 
 ```ts

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 Pulse follows semantic versioning for public releases. The repository begins its public history with the `1.0.0-beta.1` prerelease.
 
+## 1.0.0-beta.3 — Beta (2026-09-14)
+
+- Fix CLI storage execution on Node Native, Node JavaScript and the Fastly Native local fixture host, including S3 response streams, bindings and conditional KV.
+- Keep the last working Native application available when a development reload fails.
+- Allow bounded npm registry propagation time and publish future releases directly under the `latest` npm tag while retaining the Beta release label.
+
+## 1.0.0-beta.2 — Beta (2026-09-13)
+
+This candidate synchronizes the 19-package release catalog and prepares the
+next npm `beta` release:
+
+- adds bounded S3-compatible object storage in `@pulse-compute/s3`, backed by
+  the Crypto hashing and signing primitives; the Assets contract stays intact;
+- adds conditional KV operations and opaque generation tokens, with explicit
+  conflict handling and no non-atomic emulation;
+- propagates explicit JavaScript targets through project analysis, retaining
+  resolved static third-party imports and ordinary awaited calls while
+  checking Native eligibility independently;
+- clarifies maintainer ownership, target boundaries, evidence requirements,
+  and human release authority;
+- links public and internal package listings to npm and preserves the exact
+  published beta.1 documentation snapshot alongside the beta.2 documentation.
+
+Conditional KV acceptance remains gated separately from the aggregate seal:
+Viceroy 0.21.0 creates a missing key for an existing-generation CAS, contrary to
+the required conflict behavior, and deployed Pulse cross-location acceptance
+is still pending. The standalone live Fastly probe confirms missing-key
+rejection but does not satisfy those Pulse acceptance gates. See
+[`wasm/test/kv/K4.md`](https://github.com/pulse-compute/pulse/blob/16444cc5e116498e1fdf5f1e4815b4b8c3c74349/wasm/test/kv/K4.md) for the evidence and release boundary.
+
 ## 1.0.0-beta.1 — Beta (2026-08-01)
 
 The first public Beta establishes a native-first Pulse application contract

package/README.md

@@ -6,13 +6,14 @@
 > **Install directly:** Yes. Install the package globally or as a project development dependency.<br>
 > **Supported entry points:** `pulse binary`, `@pulse-compute/cli`, `@pulse-compute/cli/workflow`, `@pulse-compute/cli/project-config`, `@pulse-compute/cli/project-execution`, `@pulse-compute/cli/project-config-schema`, `@pulse-compute/cli/diagnostics`, `@pulse-compute/cli/project-config.schema.json`, `@pulse-compute/cli/cli-spec.json`, `@pulse-compute/cli/release-manifest.json`, `@pulse-compute/cli/documentation-versions.json`, `@pulse-compute/cli/documentation-site.json`<br>
 > **Stability:** Supported Beta workflow and project-configuration contract.<br>
-> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.1/packages/cli/)
+> **npm:** [`@pulse-compute/cli`](https://www.npmjs.com/package/@pulse-compute/cli)<br>
+> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.3/packages/cli/)
 >
-> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.1` package policy.
+> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.3` package policy.
 <!-- pulse-package-status:end -->
 
 The public CLI and conventional `@pulse-compute/pulse` application root are
-both part of the synchronized `1.0.0-beta.1` release set. Validate the generated
+both part of the synchronized `1.0.0-beta.3` release set. Validate the generated
 workflow from the repository or the exact packed acceptance set:
 
 ```bash

package/cli-spec.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": "pulse.cli-command-spec.v5",
-  "cliVersion": "1.0.0-beta.1",
+  "cliVersion": "1.0.0-beta.3",
   "completionShells": [
     "bash",
     "zsh",

package/docs/README.md

@@ -1,6 +1,6 @@
 # Pulse documentation
 
-Pulse documentation is organized in layers so you can stop when you have enough detail. The `1.0.0-beta.1` candidate uses async-shaped managed handlers, trusted Pulse effects, a conventional `.pulse/config.ts` workspace, and the `pulse` CLI. The synchronized 18-package release catalog remains the authority for npm availability and support tiers.
+Pulse documentation is organized in layers so you can stop when you have enough detail. The `1.0.0-beta.3` candidate uses async-shaped managed handlers, trusted Pulse effects, a conventional `.pulse/config.ts` workspace, and the `pulse` CLI. The synchronized 18-package release catalog remains the authority for npm availability and support tiers.
 
 ## 1. Start and ship a first project
 

package/docs/architecture/current-contracts.md

@@ -52,6 +52,14 @@ their own topology while normalizing handler bodies into the same canonical IR.
 Provider realization begins only after the complete reachable program and its
 capability requirements are known.
 
+HTTP Router authoring supports static `get`, `head`, `post`, `put`, `patch`,
+and `delete` registrations, inherited by `Pulse`. The owned Router API registry
+defines compiler admission; topology and lifecycle method catalogs derive from
+that registry. Each verb uses the existing route entry, exact-method dispatch,
+terminal transfer and 404/500 exhaustion contracts. This expands ingress
+registration without changing outgoing fetch methods or the effect/continuation
+ABI.
+
 The compiler also recognizes root-only `Pulse.on(type, { schema }, handler)`
 declarations as a separate static event topology. Event types and schema IDs
 must be literal, schema IDs must resolve through the project registry, each
@@ -115,10 +123,10 @@ See [Compilation and lowering](../concepts/compilation-and-lowering.md) and the
 
 ## Execution ownership
 
-Host authority is explicit. Fetch, config, secrets, KV, GRIP, assets, and future
-host operations enter the program as canonical capabilities or package
-operations. Provider SDK objects, ambient process state, and hidden host
-namespaces do not enter handler scope.
+Pulse-provided host authority is explicit. Fetch, config, secrets, KV, GRIP,
+assets, and future host operations enter the program as canonical capabilities
+or package operations. Pulse does not expose provider SDK objects, ambient
+process state, or hidden host namespaces through the handler context.
 
 Native execution erases managed async notation into explicit effects and
 single-use continuations. JavaScript targets execute the same application
@@ -133,6 +141,19 @@ authority but do
 not expose a Request, Response, route parameters, Router transfer, middleware,
 or response builders.
 
+Conditional KV is owned by the portable runtime authoring/host contract.
+`kv.getVersioned`, `kv.insertIfAbsent`, and `kv.compareAndSwap` lower through the
+ordinary effect and continuation machinery, including Native value handles.
+The Node reference supplies one explicit local key authority; provider
+preparation and the send boundary remain distinct so unconfirmed writes preserve
+`unknown`. The Native host imports the existing workspace runtime owner rather
+than duplicating its validation, snapshots, limits, or outcome normalization.
+The Fastly Native provider realizes conditional KV directly through its host ABI,
+with lossless generations, conditional options, bounded metadata/body reads and
+readiness deadlines. Its AssemblyScript limits come from the runtime owner; the
+shared corpus checks its wire and outcome semantics. Fastly JavaScript remains
+incomplete capability mapping. Deployed acceptance remains a separate gate. See [conditional KV](../concepts/effects-and-continuations.md#conditional-kv).
+
 `ctx.parallel({ ... })` is the explicit cross-target concurrency form. Router
 `next()` and `next(error)` are terminal cursor transfers, not onion-style calls:
 no application code resumes after the transfer. Normal exhaustion produces
@@ -161,6 +182,25 @@ A generally available target can reject an ineligible project. A passing local
 runtime does not claim that an external deployment, binding, service, or
 provider control plane is healthy.
 
+The selected target reaches project linking and handler validation explicitly.
+For `javascript`, resolved static package imports and project-relative helper
+imports remain source-runtime boundaries; they do not acquire Native lowerer
+authority. Canonical application topology, schemas, effect-await rules, graph
+containment and entry lifecycle checks still apply. An ordinary imported async
+call may be awaited in a JavaScript handler. Native compilation continues to
+reject unsupported imports and awaits, including when graph eligibility is
+requested in record-only mode.
+
+JavaScript compilation returns canonical inspection metadata without an
+executable normalized generator. The provider's graph-backed loader and source
+packager execute the original module closure with its JavaScript async semantics.
+Inspection describes recognized Pulse effects; it does not infer effects inside
+ordinary dependency implementations or certify their isolation. An ordinary
+JavaScript import gains no compiler/lowerer authority or Native guest sandbox
+guarantee. Native inspection compiles the source
+independently under Native rules. Its failure is advisory for a selected
+JavaScript target; `pulse compile` still requires a real Native compilation.
+
 Provider packages own descriptors, configuration normalization, local
 execution, target generation, source packaging, deployment bindings, and target
 support policy. The compiler owns the neutral bootstrap, contract validation,
@@ -198,6 +238,18 @@ guest-link packaging authorization have already been checked. It does not
 contain a TypeScript AST/service, compiler cache, builder, mutable manifest,
 compiled-program object, raw target option bag, or alternate target.
 
+CLI Native test/dev execution that needs guest crypto or conditional KV uses
+an optional provider-owned `prepareNativeExecution` driver hook. It receives the
+same immutable, validated invocation with action `execute-native` and returns a
+local request executor. The CLI never substitutes another provider's host.
+Node executes the compiled neutral Wasm with its provider adapter. Fastly
+realizes its own Native artifact and runs the existing fixture ABI, including
+the conditional-KV authority. Its result identifies the artifact hash and fixture
+kind; unavailable effect telemetry is reported as such. This does not establish
+Viceroy or deployed Fastly acceptance. S3 fixtures preserve raw response streams
+inside the provider transport while ordinary fetch retains its opaque response
+contract. Dev retains a last-good Native executor if recompilation fails.
+
 Native realization and JavaScript source packaging are normalized into
 versioned, data-only results before the CLI consumes them. Provider packaging
 must report the same artifact identity authorized by the final guest audit.
@@ -295,7 +347,7 @@ without moving package semantics into the compiler or widening the trust model.
 
 ## JWT verification
 
-The synchronized `1.0.0-beta.1` JWT/crypto packages compose
+The synchronized `1.0.0-beta.3` JWT/crypto packages compose
 `@pulse-compute/jwt` over the lower-level, provider-neutral verification
 contract owned by `@pulse-compute/crypto`. The executable algorithm set is
 HS256 and ES256. Crypto verifies a MAC or signature over caller-supplied bytes
@@ -312,7 +364,7 @@ objects do not merge. An empty declaration enables no algorithms. An unknown,
 missing, unavailable, or failed realization stops with a normalized diagnostic
 and never authorizes fallback.
 
-JavaScript targets select `runtime-builtin` and use Web Crypto with explicit
+For JWT verification, JavaScript targets select `runtime-builtin` and use Web Crypto with explicit
 HMAC/SHA-256 or ECDSA/P-256/SHA-256 parameters. The crypto boundary receives a
 normalized 64-byte P-256 point; its JavaScript adapter validates that point and
 constructs the runtime-private JWK used for import. Native HS256 selects
@@ -321,6 +373,41 @@ primary module, while Native ES256 selects the audited
 `guest-linked:pulse-es256-rustcrypto-p256` unit. Neither algorithm retries a
 different realization.
 
+S3 operations require exact `SHA-256` and `HMAC-SHA256` selection. Native
+composes the same Crypto-owned source once; Node JavaScript explicitly selects
+Crypto's `runtime-builtin` Web Crypto byte realization through the trusted
+`@pulse-compute/crypto/provider` export. Both return 32-byte results, cap data
+at 32 KiB and HMAC keys at 8 KiB, and snapshot and wipe staging inputs. Native
+also checks guest memory ranges. JWT verification retains its separate limits.
+No target probes or falls back to a different realization.
+
+The supported-extension `@pulse-compute/s3` package owns `head`, `getText` and `putText`,
+literal binding/options authority, runtime key/text lowering, SigV4 composition
+and bounded results. Node and Fastly own fixed endpoint/bucket/region mappings,
+credential lookup, deadlines and transport. Fastly requires a static backend.
+Reads and writes bypass cache, disable decompression and redirects, preserve
+exact bytes and do not retry. PUT distinguishes pre-dispatch failure and
+complete rejection (`not-stored`) from unconfirmed dispatched writes (`unknown`).
+Only a complete 200 acknowledgement with a bounded empty body yields `stored`;
+its digest describes sent bytes, not durability. Request cancellation retains
+existing lifecycle behavior and does not fabricate a typed S3 outcome. Fastly
+pending requests lack a cancel ABI; invocation termination owns their release.
+
+One canonical consumer exercises Node Native, Node JavaScript and Fastly Native
+PUT/HEAD/GET, integrity, bounded acknowledgements and cancellation. Fastly Native
+runs compiled Wasm against a host ABI fixture. This is local evidence, not live
+Object Storage proof. Fastly JavaScript remains ineligible: its SDK projects raw
+response headers, losing multiplicity and aggregate-size evidence required by
+O1. The provider-specific limitation is documented in `wasm/test/s3/O3.md` and
+does not gate supported targets. O4 adds S3 to the synchronized release package
+set and repeats the three-target read/write corpus against isolated exact
+tarballs, including package-owned lowering. These are local candidate checks;
+live origin acceptance follows T2. Assets alignment remains separate.
+
+Package redaction declarations survive Handler IR projection into the Native
+plan. Native host effect traces omit declared private payloads and results;
+applications still control their own response and logging use of returned data.
+
 All four target classes—Node JavaScript, Fastly JavaScript, Node Native, and
 Fastly Native—execute the same HS256 semantics. ES256 adds exact default and
 size-oriented Native artifact cells, producing a six-cell 38-case matrix:
@@ -341,7 +428,7 @@ publish, promote, deploy, or activate the release.
 
 ## Support, release, and authority
 
-Pulse `1.0.0-beta.1` is a Beta intended for the `beta` channel.
+Pulse `1.0.0-beta.3` is a Beta intended for the `beta` channel.
 Documented, evidence-backed behavior is intentional, but public surfaces may
 change deliberately before a compatibility-bearing release. Unsupported
 behavior fails explicitly, historical and implementation subpaths gain no
@@ -361,6 +448,20 @@ architecture, merge, repository-setting, and release authority. Codex may
 analyze, review, reproduce, and prepare bounded patches; deterministic checks
 remain authoritative even when Codex is unavailable.
 
+A protected-path match requires a boundary declaration and review; it does not
+establish that the patch changes that boundary's semantics. Human direction
+already supplied for a bounded task covers its necessary implementation, tests,
+canonical documentation, regeneration and PR preparation. The PR records that
+direction and any remaining decision. A new semantic or authority change beyond
+the authorized scope requires new direction. Implementation approval does not
+transfer merge, publication, deployment or self-approval authority.
+
+Validation claims distinguish injected hosts, local Compute engines, standalone
+live probes and deployed Pulse artifacts. SDK capability mappings and observed
+provider discrepancies do not redefine Pulse's contract. Required acceptance
+gates remain separate from the aggregate release command; their status and any
+human-directed policy changes must be explicit before claiming release readiness.
+
 See the [maintainer charter](../maintainers/maintainer-charter.md),
 [release acceptance](../maintainers/release-acceptance.md),
 [npm publishing](../maintainers/npm-publishing.md), and

package/docs/concepts/compilation-and-lowering.md

@@ -408,7 +408,7 @@ generic loader handles reachable-graph discovery and trusted invocation. Older
 `/pulsewasm` imports are isolated in the
 [compatibility migration guide](../guides/compatibility-imports.md).
 
-In Pulse `1.0.0-beta.1`, package-owned builders must declare `compiler.trust: 'first-party'` and ship in the synchronized release set. This is an internal contributor mechanism, not a general third-party plugin API. See [Add a first-party package-owned lowerer](../contributing/adding-first-party-lowerer.md).
+In Pulse `1.0.0-beta.3`, package-owned builders must declare `compiler.trust: 'first-party'` and ship in the synchronized release set. This is an internal contributor mechanism, not a general third-party plugin API. See [Add a first-party package-owned lowerer](../contributing/adding-first-party-lowerer.md).
 
 ## Provider lowering is a second contract
 

package/docs/concepts/contracts-and-providers.md

@@ -38,7 +38,7 @@ GRIP uses the same split. `isWebSocket`, `subscribe`, and `handoff` are pure HTT
 
 ## Provider selection
 
-Pulse `1.0.0-beta.1` has three provider driver identifiers:
+Pulse `1.0.0-beta.3` has three provider driver identifiers:
 
 | Provider | Local execution | Deployable build | Purpose |
 |---|---:|---:|---|
@@ -96,7 +96,7 @@ For Fastly, `pulse build` additionally emits a real Compute target. The explicit
 
 ## Current extension boundary
 
-There is no automatic provider plugin registry in `1.0.0-beta.1`. Configuration
+There is no automatic provider plugin registry in `1.0.0-beta.3`. Configuration
 selects a bare host ID, internal `none`, or an exact scoped project-installed
 package name. Bare IDs resolve by the `@pulse-compute/provider-<id>` convention.
 A package is loadable only when selected and when it exports the versioned

package/docs/concepts/effects-and-continuations.md

@@ -241,3 +241,60 @@ pulse test ./my-app --json
 - [Fetching and composing data](../guides/fetching-and-composition.md)
 - [Project configuration](../reference/project-config.md)
 - [Troubleshooting](../guides/troubleshooting.md)
+
+## Conditional KV
+
+`ctx.kv<T>('name')` exposes `getVersioned(key)`, `insertIfAbsent(key, value)`, and
+`compareAndSwap(key, generation, value)` as direct awaited or keyed parallel
+effects. The Node reference implements the contract for JavaScript and compiled
+Native control flow. Fastly Native implements it through direct KV hostcalls;
+Fastly JavaScript conditional KV remains explicitly incomplete.
+
+The condition and mutation are atomic at one key's authority. A versioned read
+returns a value and an opaque generation from the same observation, which may be
+stale. Generations are strings, not numbers, hashes or application versions.
+Create conflicts when present; CAS conflicts when absent or when its token is
+stale. Equal-byte replacement is still a write and changes its generation.
+Existing unconditional `get` and `put` remain available.
+
+A write returns `stored`, `conflict`, `not-stored` with a bounded reason, or
+`unknown` with a bounded reason. Unknown may have committed. A complete explicit
+provider rejection establishes no write; an exception from a send primitive
+does not. Pulse does not retry, reread-and-rebase, or invent a generation from a
+write acknowledgement. A subsequent missing or stale read cannot resolve an
+ambiguous write by itself.
+
+Admission detaches and freezes the candidate before provider preparation. The
+host's monotonic ten-second deadline starts at admission and is shortened by an
+owning request deadline. Preparation may resolve bindings and stage data but
+cannot send. Entry into the returned provider primitive marks dispatch even if
+it throws synchronously. Timeout before that boundary is `not-stored`; timeout
+or transport loss after it is `unknown`. Cancellation suppresses delivery to an
+inactive execution and records whether dispatch occurred; it promises no rollback.
+
+Exact keys are bounded Unicode scalar strings; generations are bounded visible
+ASCII strings. Values retain the portable KV JSON limits. Conditional storage
+uses a strict UTF-8 JSON envelope with exactly `__pulseKv: 1` and `value`, rejecting
+duplicate members, invalid values, and oversized bodies. The wrapper is not
+recursively unwrapped. Legacy raw JSON requires explicit migration. Keys, tokens,
+and values are omitted or redacted from runtime evidence and managed errors;
+application responses are not silently rewritten.
+
+Node reference instances retain nonreused generation identities for their own
+lifetime. Host code can explicitly reuse one reference across requests and target
+runners; independent instances isolate their state. Deterministic identities,
+clocks, and failure hooks belong to host evidence, not handler authority. This
+local model does not establish durability, global visibility, cross-key
+transactions, or a portable physical-delete/recreate guarantee. Fastly SDK
+limitations cannot redefine this contract or gate other targets.
+
+Fastly Native preserves all 64 generation bits in an opaque string. ADD and
+generation-conditioned overwrite remain distinct operations, including an explicit
+condition for zero bits. The adapter stages the complete envelope before dispatch,
+uses monotonic deadlines and readiness selection before pending waits and body
+reads, and closes acquired bodies. It accepts up to 65,560 wire bytes, including
+wrapper overhead. Provider key restrictions return `invalid-key` without changing
+the key. Pending KV operations have no cancellation hostcall; an expired operation
+is abandoned to invocation teardown and may still commit. Host termination never
+resumes an inactive handler. Local Wasm evidence is separate from K4's deployed
+cross-location acceptance.

package/docs/concepts/package-owned-lowering.md

@@ -2,7 +2,7 @@
 
 Package-owned lowering lets a synchronized Pulse package extend the canonical compiler with narrow, statically recognized operations while keeping domain rules out of compiler core.
 
-The synchronized `1.0.0-beta.1` release uses this pattern for Assets, GRIP,
+The synchronized `1.0.0-beta.3` release uses this pattern for Assets, GRIP,
 JWT, and Entities.
 It is a **trusted first-party synchronization mechanism**, not a public
 registry that executes arbitrary npm compiler plugins.

package/docs/concepts/targets-and-hosts.md

@@ -6,9 +6,17 @@ branches on. The release distinguishes current execution proof from forward
 host work so architectural direction does not become an accidental support
 claim.
 
+An explicit JavaScript profile can retain resolved static package imports and
+project-relative helpers, including awaited calls into ordinary JavaScript
+dependencies. Pulse checks the canonical application surface and packages its
+original source graph. Native eligibility is reported separately and does not
+block JavaScript execution. Unsupported dynamic module boundaries and missing
+`await` on Pulse effects still fail validation. `pulse compile` continues to
+require Native-compatible source; use `pulse build` for a JavaScript package.
+
 ## Current Beta targets
 
-`1.0.0-beta.1` exercises four explicit modes through one conformance corpus:
+`1.0.0-beta.3` exercises four explicit modes through one conformance corpus:
 
 | Host | Target | Current release status | Build shape |
 |---|---|---|---|
@@ -37,7 +45,7 @@ adapter, lifecycle, conformance evidence, and package claim.
 The [ESP32 reference host](https://github.com/pulsecompute/pulse-esp32-host)
 tests whether the event/effect/continuation model remains useful without a
 JavaScript fallback, abundant memory, or an HTTP-centered lifecycle. It is a
-boundary witness, not a `1.0.0-beta.1` provider or compatibility promise. The
+boundary witness, not a `1.0.0-beta.3` provider or compatibility promise. The
 [architecture vision](../architecture/vision.md#esp32-as-a-boundary-witness)
 describes the intended host-owned interrupt queue and non-reentrant Wasm entry.
 

package/docs/contributing/adding-core-provider.md

@@ -75,7 +75,7 @@ Descriptors are normalized by the shared provider contract. A conceptual descrip
 ```js
 const EXAMPLE_PROVIDER_DESCRIPTOR = createProviderDescriptor({
   id: 'example',
-  providerVersion: '1.0.0-beta.1',
+  providerVersion: '1.0.0-beta.3',
   package: '@pulse-compute/provider-example',
   runtime: 'pulse.canonical-example-runtime.v1',
   buildTarget: 'example-edge',

package/docs/contributing/adding-first-party-lowerer.md

@@ -11,7 +11,7 @@ Start with [Pulse-aware package authoring](./pulse-aware-packages.md) to decide
 whether the package needs Native lowering at all. Ordinary target-compatible
 JavaScript packages do not require a compiler builder.
 
-> **Scope and trust boundary:** Pulse `1.0.0-beta.1` executes package-owned compiler builders only when their manifest declares `compiler.trust: 'first-party'` and the package is part of the synchronized release set. This is a core-repository contributor workflow, **not an external plugin** interface or a supported third-party plugin API. An external package cannot self-register arbitrary compiler code.
+> **Scope and trust boundary:** Pulse `1.0.0-beta.3` executes package-owned compiler builders only when their manifest declares `compiler.trust: 'first-party'` and the package is part of the synchronized release set. This is a core-repository contributor workflow, **not an external plugin** interface or a supported third-party plugin API. An external package cannot self-register arbitrary compiler code.
 
 A package-owned lowerer lets one release package define a narrow TypeScript facade and keep its domain-specific static validation outside compiler core. GRIP is the clearest current example; assets is the second implementation proving that the generic loader is not GRIP-specific.
 

package/docs/contributing/package-lowerer-contract.md

@@ -8,7 +8,7 @@ pulse-doc-meta:end -->
 # Package lowerer contract reference
 
 This reference describes the internal first-party lowerer protocol used by the
-synchronized `1.0.0-beta.1` release. It documents current repository
+synchronized `1.0.0-beta.3` release. It documents current repository
 interfaces; it is not a third-party plugin compatibility promise. Package
 availability remains owned by the release catalog.
 
@@ -370,7 +370,7 @@ Package lowerer code must not choose `node.*`, `fastly.*`, backend names, store
 
 ## Compatibility status
 
-This protocol is synchronized inside the `1.0.0-beta.1` release set. It can change with compiler implementation needs. Only explicitly documented application facades carry the package support promise.
+This protocol is synchronized inside the `1.0.0-beta.3` release set. It can change with compiler implementation needs. Only explicitly documented application facades carry the package support promise.
 
 A public external lowerer API would require a new contract that addresses trust, sandboxing, provenance, protocol negotiation, resource limits, lifecycle support, and semver compatibility.
 

package/docs/guides/migrating-from-express.md

@@ -117,12 +117,12 @@ normal lane ends as `404 Not Found`; an unhandled error lane ends as
 
 The Beta Router supports:
 
-- `use`, `get`, `head`, `post`, `mount`, and `error`;
+- `use`, `get`, `head`, `post`, `put`, `patch`, `delete`, `mount`, and `error`;
 - exact paths, named `:parameters`, and a trailing `*` wildcard;
 - statically declared, acyclic mounted routers;
 - first-match order and explicit route fallthrough.
 
-It does not support `put`, `patch`, `delete`, regular-expression routes,
+It does not support `options`, `trace`, `connect`, regular-expression routes,
 runtime route registration, Express Router plugins, or hidden server lifecycle
 hooks. Keep an unsupported endpoint on its existing service or redesign it
 before moving that endpoint into Pulse; selecting a JavaScript target does not
@@ -165,7 +165,7 @@ Pulse never changes targets or falls back automatically.
 
 1. Inventory routes, methods, middleware order, error paths, body parsing, and
    ambient host dependencies.
-2. Move one supported `GET`, `HEAD`, or `POST` route to a statically declared
+2. Move one supported `GET`, `HEAD`, `POST`, `PUT`, `PATCH`, or `DELETE` route to a statically declared
    `Pulse` application.
 3. Replace response mutation with returned `ctx.json`, `ctx.text`, or
    `ctx.response` results.

package/docs/guides/routing.md

@@ -76,7 +76,7 @@ export default app
 
 - `new Router()` with a default-exported root router;
 - `use(handler)` and `use(path, handler)` middleware;
-- `get`, `head`, and `post` registrations;
+- `get`, `head`, `post`, `put`, `patch`, and `delete` registrations;
 - exact paths, named `:parameters`, and a trailing `*` wildcard;
 - static acyclic `mount` composition;
 - named or inline async-shaped route handlers using `(ctx)` or `(ctx, next)`;
@@ -87,6 +87,24 @@ export default app
 
 Every Router handler uses the normal canonical context. Fetches, schemas, config, secrets, KV, opaque responses, and trusted package effects lower into the same native execution plan as single-handler authoring.
 
+`Pulse` inherits the same route registration methods. Each registration matches
+its exact HTTP method; a method mismatch advances the route cursor and normal
+exhaustion remains `404`. There is no automatic `OPTIONS` or `405` response.
+Ingress route methods do not widen the separate outbound `ctx.fetch` contract.
+
+The `catalog-router-parity` conformance task exercises the original Catalog
+consumer probe and all 14 of its PUT/PATCH/DELETE operations with their existing
+methods and paths. Its shared cases check mounted parameters, request text,
+middleware state, exact method misses, registration order, terminal fallthrough,
+404 exhaustion and handled errors on Node/Fastly JavaScript and Native. Native
+lanes execute compiled Wasm; Fastly evidence uses local provider emulation and
+the target ABI mock host, not a deployed service. The fixtures establish routing
+acceptance only; they do not implement Catalog persistence or authorization.
+
+```sh
+node wasm/scripts/run-wasm-tests.cjs --task catalog-router-parity --no-report
+```
+
 ## `next()` is a terminal transfer
 
 `next()` is not an onion-style callback. It is a compiler-visible control transfer:

package/docs/maintainers/documentation-deployment.md

@@ -31,7 +31,7 @@ GitHub Pages deployment is no longer part of the repository workflow. The releas
 
 ## Object classes
 
-The `1.0.0-beta.1` layout is:
+The `1.0.0-beta.3` layout is:
 
 ```text
 <bucket>/pulse/
@@ -41,8 +41,8 @@ The `1.0.0-beta.1` layout is:
   versions.json                      mutable
   site-manifest.json                 mutable
   public-site-manifest.json          mutable
-  v1.0.0-beta.1/**                         immutable
-  deployments/v1.0.0-beta.1.json           immutable receipt
+  v1.0.0-beta.3/**                         immutable
+  deployments/v1.0.0-beta.3.json           immutable receipt
 ```
 
 The exact-version tree is the archival release. Root and `latest` are convenience surfaces promoted only after exact-version verification and matching npm package verification.
@@ -72,7 +72,7 @@ npm run docs:deployment:prepare
 npm run docs:deployment:verify
 ```
 
-`.pulse-documentation-deployment/documentation-deployment-manifest.json` records every object key, local source, byte length, SHA-256, content type, cache class, mutability, source commit, public documentation route, and independent storage prefix. Its deterministic deployment receipt records the complete generated-site digest and the exact-version object inventory and tree digest for `deployments/v1.0.0-beta.1.json`. Candidate verification rejects any root or site file outside that sealed inventory.
+`.pulse-documentation-deployment/documentation-deployment-manifest.json` records every object key, local source, byte length, SHA-256, content type, cache class, mutability, source commit, public documentation route, and independent storage prefix. Its deterministic deployment receipt records the complete generated-site digest and the exact-version object inventory and tree digest for `deployments/v1.0.0-beta.3.json`. Candidate verification rejects any root or site file outside that sealed inventory.
 
 A local adapter exercised by `npm run publication:check` proves:
 

package/docs/maintainers/documentation-versioning.md

@@ -26,7 +26,7 @@ The homepage and exact current documentation load the same assets under `/v<vers
 The canonical URL for this release begins with:
 
 ```text
-https://pulsecompute.io/v1.0.0-beta.1/
+https://pulsecompute.io/v1.0.0-beta.3/
 ```
 
 Diagnostics, package status blocks, and package metadata use exact-version URLs. This prevents a diagnostic emitted by an older CLI from silently opening instructions for a newer contract.