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

package/README.md

@@ -6,9 +6,10 @@
 > **Install directly:** Yes. Install it in every Pulse application.<br>
 > **Supported entry points:** `@pulse-compute/runtime`<br>
 > **Stability:** Supported application authoring and execution contract.<br>
-> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.1/packages/runtime/)
+> **npm:** [`@pulse-compute/runtime`](https://www.npmjs.com/package/@pulse-compute/runtime)<br>
+> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.3/packages/runtime/)
 >
-> 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 -->
 
 `@pulse-compute/runtime` is the low-level, provider-neutral Pulse application contract.

package/docs/API.md

@@ -1,11 +1,11 @@
 # Pulse runtime contract
 
 For source eligibility, use [Managed handler TypeScript and
-JavaScript](https://pulsecompute.io/v1.0.0-beta.1/reference/handler-authoring/). For provider and target
+JavaScript](https://pulsecompute.io/v1.0.0-beta.3/reference/handler-authoring/). For provider and target
 differences, use the [compatibility
-matrix](https://pulsecompute.io/v1.0.0-beta.1/reference/compatibility-matrix/). For CLI and runtime failures,
+matrix](https://pulsecompute.io/v1.0.0-beta.3/reference/compatibility-matrix/). For CLI and runtime failures,
 use the stable codes in the [diagnostics
-reference](https://pulsecompute.io/v1.0.0-beta.1/reference/diagnostics/).
+reference](https://pulsecompute.io/v1.0.0-beta.3/reference/diagnostics/).
 
 This document describes the provider-neutral TypeScript application contract compiled by Pulse. Low-level authoring types and the static `Router` come from `@pulse-compute/runtime`. The public `@pulse-compute/pulse` package owns the conventional `Pulse` application root, deferred project configuration, and schema declarations, while `@pulse-compute/cli` owns workspace orchestration.
 
@@ -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. |
 
@@ -49,7 +49,7 @@ Every managed handler is async-shaped:
 type Handler = (ctx: PulseContext) => Promise<PulseResult | PulseFetchResponse>
 ```
 
-For native targets the compiler erases the async wrapper. Awaited Pulse effects lower into the existing explicit effect and continuation state machine; no Promise runtime or Asyncify transform is linked. Awaiting a proven synchronous `ctx` expression is redundant and may warn, while arbitrary non-Pulse awaits mark the native eligibility boundary. The canonical [handler authoring reference](https://pulsecompute.io/v1.0.0-beta.1/reference/handler-authoring/) defines the static language subset; the [compatibility matrix](https://pulsecompute.io/v1.0.0-beta.1/reference/compatibility-matrix/) owns the tested four-mode claims.
+For native targets the compiler erases the async wrapper. Awaited Pulse effects lower into the existing explicit effect and continuation state machine; no Promise runtime or Asyncify transform is linked. Awaiting a proven synchronous `ctx` expression is redundant and may warn, while arbitrary non-Pulse awaits mark the native eligibility boundary. The canonical [handler authoring reference](https://pulsecompute.io/v1.0.0-beta.3/reference/handler-authoring/) defines the static language subset; the [compatibility matrix](https://pulsecompute.io/v1.0.0-beta.3/reference/compatibility-matrix/) owns the tested four-mode claims.
 
 ## Static `Router`
 
@@ -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.
 
@@ -137,9 +137,9 @@ eligibility. Fastly targets fail closed because no event ingress/emit adapter is
 claimed. There is no public event injection command, no event-aware development
 listener, no HTTP/GRIP translation, and no automatic target fallback.
 
-The [static events guide](https://pulsecompute.io/v1.0.0-beta.1/guides/events/) owns the complete frame,
+The [static events guide](https://pulsecompute.io/v1.0.0-beta.3/guides/events/) owns the complete frame,
 queue, target-eligibility, diagnostic, and Native-extension contract. The
-source-bound [event example](https://pulsecompute.io/v1.0.0-beta.1/examples/11-events/) runs the same mixed project
+source-bound [event example](https://pulsecompute.io/v1.0.0-beta.3/examples/11-events/) runs the same mixed project
 on Node JavaScript and Node Native.
 
 ## `ctx.req`
@@ -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 -->
@@ -449,12 +482,12 @@ forms lower into canonical package operations; JavaScript targets execute the
 real package implementation.
 
 Older `/pulsewasm` imports are compatibility-only and are isolated in the
-[migration guide](https://pulsecompute.io/v1.0.0-beta.1/guides/compatibility-imports/). See the
-[GRIP package guide](https://pulsecompute.io/v1.0.0-beta.1/packages/grip/) for the complete current surface.
+[migration guide](https://pulsecompute.io/v1.0.0-beta.3/guides/compatibility-imports/). See the
+[GRIP package guide](https://pulsecompute.io/v1.0.0-beta.3/packages/grip/) for the complete current surface.
 
 ## 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
@@ -516,9 +549,9 @@ Registrations and the terminal binding must use the supported static form. The
 first-party JSON-RPC adapter accepts bounded JSON-RPC 2.0 request objects and
 named params, validates declared schemas, uses stable error framing, and
 acknowledges notifications with HTTP `204`. See the [package
-guide](https://pulsecompute.io/v1.0.0-beta.1/packages/entities/), [entity/adapter
-model](https://pulsecompute.io/v1.0.0-beta.1/concepts/entities-and-adapters/), and [executable
-example](https://pulsecompute.io/v1.0.0-beta.1/examples/10-entities-tools/).
+guide](https://pulsecompute.io/v1.0.0-beta.3/packages/entities/), [entity/adapter
+model](https://pulsecompute.io/v1.0.0-beta.3/concepts/entities-and-adapters/), and [executable
+example](https://pulsecompute.io/v1.0.0-beta.3/examples/10-entities-tools/).
 
 ## Project workflow
 
@@ -535,5 +568,5 @@ selected profile, handler entry, schema declarations, provider bindings, and
 output directory through `.pulse/config.ts`. `pulse inspect` is optional
 observability, and `pulse compile` is the advanced provider-neutral Native
 artifact command; neither is required before `pulse build`. See the [project
-lifecycle guide](https://pulsecompute.io/v1.0.0-beta.1/guides/project-lifecycle/) and [CLI
-reference](https://pulsecompute.io/v1.0.0-beta.1/reference/cli/).
+lifecycle guide](https://pulsecompute.io/v1.0.0-beta.3/guides/project-lifecycle/) and [CLI
+reference](https://pulsecompute.io/v1.0.0-beta.3/reference/cli/).

package/docs/guides/routing.md

@@ -1,6 +1,6 @@
 # Static Router authoring
 
-Use `Router` when an application has several method/path entry points or needs compile-time middleware. It is a static authoring marker from `@pulse-compute/runtime`, not a JavaScript runtime dispatcher. The shared async/static restrictions are defined in [Managed handler TypeScript and JavaScript](https://pulsecompute.io/v1.0.0-beta.1/reference/handler-authoring/); target claims live in the [compatibility matrix](https://pulsecompute.io/v1.0.0-beta.1/reference/compatibility-matrix/).
+Use `Router` when an application has several method/path entry points or needs compile-time middleware. It is a static authoring marker from `@pulse-compute/runtime`, not a JavaScript runtime dispatcher. The shared async/static restrictions are defined in [Managed handler TypeScript and JavaScript](https://pulsecompute.io/v1.0.0-beta.3/reference/handler-authoring/); target claims live in the [compatibility matrix](https://pulsecompute.io/v1.0.0-beta.3/reference/compatibility-matrix/).
 
 <!-- pulse-doc-source: examples/09-router-lowering/src/index.ts -->
 ```ts
@@ -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/preview-scope.md

@@ -1,6 +1,6 @@
 # Beta scope
 
-Pulse `1.0.0-beta.1` is a Beta of one provider-neutral application contract
+Pulse `1.0.0-beta.3` is a Beta of one provider-neutral application contract
 with explicit Native and JavaScript execution targets. The intended 1.0
 surface is present, but deliberate corrections may still occur before the
 stable `1.0.0` release.
@@ -15,7 +15,7 @@ targets.
 - Async-shaped provider-neutral TypeScript handlers; trusted Pulse awaits lower
   into explicit effects and continuations without a Promise runtime.
 - Static Router v2 with terminal middleware, route fallthrough, error
-  middleware, GET/HEAD/POST routes, exact paths, named parameters, trailing
+  middleware, GET/HEAD/POST/PUT/PATCH/DELETE routes, exact paths, named parameters, trailing
   wildcards, and acyclic mounts.
 - Basic branching and structured object, array, and scalar manipulation.
 - Request method, URL, path, headers, text, and JSON access.
@@ -106,13 +106,13 @@ JavaScript-selected project into a Native one.
 ## Compatibility authority
 
 The single source-form, provider-binding, artifact, and deployment-boundary
-table is [Provider and target compatibility](https://pulsecompute.io/v1.0.0-beta.1/reference/compatibility-matrix/).
+table is [Provider and target compatibility](https://pulsecompute.io/v1.0.0-beta.3/reference/compatibility-matrix/).
 It uses one public target order—Node JavaScript, Fastly JavaScript, Node Native,
 and Fastly Native—and links every row to a focused proof or canonical contract.
 
 The exact portable language subset and the JavaScript-only Native eligibility
 boundaries are defined in
-[Managed handler TypeScript and JavaScript](https://pulsecompute.io/v1.0.0-beta.1/reference/handler-authoring/).
+[Managed handler TypeScript and JavaScript](https://pulsecompute.io/v1.0.0-beta.3/reference/handler-authoring/).
 
 ## Body model
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pulse-compute/runtime",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.3",
   "license": "Apache-2.0",
   "engines": {
     "node": "^22.14.0 || ^24.0.0"
@@ -41,7 +41,7 @@
     "url": "git+https://github.com/pulse-compute/pulse.git",
     "directory": "packages/runtime"
   },
-  "homepage": "https://pulsecompute.io/v1.0.0-beta.1/packages/runtime/",
+  "homepage": "https://pulsecompute.io/v1.0.0-beta.3/packages/runtime/",
   "bugs": {
     "url": "https://github.com/pulse-compute/pulse/issues"
   }

package/src/host.d.ts

@@ -1,6 +1,7 @@
 import type {
   Handler,
   PulseEffect,
+  PulseKvGeneration, PulseKvVersionedResult, PulseKvConditionalResult,
   PulseFetchResponse,
   PulseParallelEffect,
   PulseParallelResult,
@@ -14,6 +15,7 @@ export interface PulseJavascriptEffectHostExecution {
   readonly event?: PulseEventFrame;
   readonly application?: unknown;
   readonly signal?: AbortSignal;
+  readonly deadlineMonotonicMs?: number;
   /** Adds execution-owned sensitive text to runtime redaction before provider work continues. */
   registerRedactionValue(value: string | Uint8Array): void;
   /** Applies one project-owned schema codec directly to an in-memory semantic value. */
@@ -35,7 +37,26 @@ export interface PulseJavascriptEffectDescriptor {
   readonly [field: string]: unknown;
 }
 
+/** Host-only preparation hook. Resolving/staging must not dispatch; invoking
+ * the returned primitive is the conservative storage dispatch boundary. */
+export interface PulseConditionalKvExecution {
+  readonly signal?: AbortSignal;
+  readonly deadlineMonotonicMs?: number;
+  registerRedactionValue?(value: string): void;
+  onKvObservation?(value: Readonly<Record<string, unknown>>): void;
+}
+export interface PulseKvClock {
+  now(): number;
+  setTimeout(callback: () => void, delayMs: number): unknown;
+  clearTimeout(handle: unknown): void;
+}
+export type PulseConditionalKvPreparation = (
+  effect: Readonly<Record<string, unknown>>,
+  execution: PulseConditionalKvExecution
+) => Promise<(() => unknown) | undefined> | (() => unknown) | undefined;
+
 export interface PulseJavascriptEffectAdapterInput {
+  prepareConditionalKv?: PulseConditionalKvPreparation;
   readonly id?: string;
   dispatch(
     effect: PulseJavascriptEffectDescriptor,
@@ -46,6 +67,7 @@ export interface PulseJavascriptEffectAdapterInput {
 
 export interface PulseJavascriptEffectAdapter {
   readonly version: 'pulse.javascript-effect-adapter.v1';
+  readonly prepareConditionalKv?: PulseConditionalKvPreparation;
   readonly id: string;
   dispatch(
     effect: PulseJavascriptEffectDescriptor,
@@ -80,12 +102,16 @@ export interface PulseEventRecordingAdapter extends PulseJavascriptEffectAdapter
 }
 
 export interface PulseRuntimeHostKvNamespace<T = unknown> {
+  getVersioned?(key: string): Promise<PulseKvVersionedResult<T>> | PulseKvVersionedResult<T>;
+  insertIfAbsent?(key: string, value: T): Promise<PulseKvConditionalResult> | PulseKvConditionalResult;
+  compareAndSwap?(key: string, generation: PulseKvGeneration, value: T): Promise<PulseKvConditionalResult> | PulseKvConditionalResult;
   get(key: string): Promise<T | undefined> | T | undefined;
   put(key: string, value: T): Promise<boolean> | boolean;
 }
 
 /** Compatibility injection shape retained while providers move to one effect adapter. */
 export interface PulseRuntimeHostCapabilities {
+  prepareConditionalKv?: PulseConditionalKvPreparation;
   fetch?(
     url: string,
     init?: unknown,
@@ -115,7 +141,7 @@ export interface PulseRuntimeHostCapabilities {
 
 export interface PulseJavascriptEffectObservation {
   readonly version: 'pulse.javascript-effect-observation.v1';
-  readonly type: 'effect-dispatched' | 'effect-settled' | 'parallel-dispatched' | 'parallel-settled';
+  readonly type: 'effect-dispatched' | 'effect-settled' | 'parallel-dispatched' | 'parallel-settled' | 'kv-lifecycle';
   readonly [field: string]: unknown;
 }
 
@@ -129,6 +155,7 @@ export interface PulseJavascriptEffectSummary {
   readonly version: 'pulse.javascript-effect-observation.v1';
   readonly adapter: {
     readonly version: 'pulse.javascript-effect-adapter.v1';
+  readonly prepareConditionalKv?: PulseConditionalKvPreparation;
     readonly id: string;
   };
   readonly effectCount: number;
@@ -173,6 +200,10 @@ export interface PulseJavascriptEffectExecution {
 }
 
 export interface PulseRuntimeExecutionOptions {
+  /** Host-only monotonic clock/scheduler injection for deterministic lifecycle evidence. */
+  readonly kvClock?: PulseKvClock;
+  /** Host monotonic deadline; conditional KV uses the earlier of this and 10 seconds. */
+  readonly deadlineMonotonicMs?: number;
   /** Compatibility bridge. New providers should inject one shared effectAdapter instead. */
   readonly capabilities?: PulseRuntimeHostCapabilities;
   readonly effectAdapter?: PulseJavascriptEffectAdapter | PulseJavascriptEffectAdapterInput;
@@ -374,3 +405,16 @@ export declare const EVENT_EMIT_CODES: Readonly<{
   QUEUE_FULL: 'PULSE_RUNTIME_EVENT_EMIT_QUEUE_FULL';
   ADAPTER_INVALID: 'PULSE_RUNTIME_EVENT_ADAPTER_INVALID';
 }>;
+
+/** Shared host-only conditional KV boundary; no provider SDK tokens enter as numbers. */
+export declare const KV_CONDITIONAL_KINDS: readonly string[];
+export declare const KV_CONDITIONAL_LIMITS: Readonly<Record<string, number>>;
+export declare function isConditionalKv(kind: string): boolean;
+export declare function normalizeKvGeneration(value: unknown): PulseKvGeneration;
+export declare function normalizeConditionalKvKey(value: unknown, options?: PulseBindingValueLimits): string;
+export declare function encodeConditionalKvValue(value: unknown, options?: PulseBindingValueLimits): Uint8Array;
+export declare function decodeConditionalKvValue(bytes: Uint8Array, options?: PulseBindingValueLimits): unknown;
+export declare function admitConditionalKv(input: Readonly<Record<string, unknown>>, options?: PulseRuntimeExecutionOptions): Readonly<Record<string, unknown>>;
+export declare function normalizeConditionalKvResult(effect: Readonly<{ kind: string }>, value: unknown, options?: PulseBindingValueLimits): PulseKvVersionedResult<unknown> | PulseKvConditionalResult;
+export declare function executeConditionalKv(effect: Readonly<Record<string, unknown>>, prepare: PulseConditionalKvPreparation, execution?: PulseConditionalKvExecution, options?: PulseRuntimeExecutionOptions): Promise<PulseKvVersionedResult<unknown> | PulseKvConditionalResult>;
+export declare function registerKvRedactions(effect: Readonly<Record<string, unknown>>, register?: (value: string) => void): void;

package/src/host.js

@@ -78,6 +78,7 @@ async function executeApplication(application, request, options = {}) {
 }
 
 module.exports = Object.freeze({
+  ...require('./internal/conditional-kv.js'),
   RUNTIME_HOST_API_VERSION,
   JAVASCRIPT_EFFECT_PROTOCOL_VERSION,
   JAVASCRIPT_EFFECT_ADAPTER_VERSION,

package/src/index.d.ts

@@ -101,7 +101,30 @@ export interface PulseLogger {
   debug(message: string): void;
 }
 
+// Opaque, bounded string. It is neither an application version nor a number.
+export type PulseKvGeneration = string;
+export type PulseKvReadFailureReason =
+  | 'invalid-key' | 'configuration' | 'not-authorized' | 'throttled'
+  | 'unavailable' | 'transport' | 'timeout' | 'protocol' | 'too-large' | 'invalid-value';
+export type PulseKvVersionedResult<T> =
+  | { readonly status: 'found'; readonly value: T; readonly generation: PulseKvGeneration }
+  | { readonly status: 'not-found' }
+  | { readonly status: 'failed'; readonly reason: PulseKvReadFailureReason };
+
+export type PulseKvNotStoredReason =
+  | 'invalid-key' | 'invalid-value' | 'invalid-generation' | 'too-large'
+  | 'configuration' | 'not-authorized' | 'throttled' | 'rejected'
+  | 'unavailable' | 'transport' | 'timeout' | 'protocol';
+export type PulseKvConditionalResult =
+  | { readonly status: 'stored' }
+  | { readonly status: 'conflict' }
+  | { readonly status: 'not-stored'; readonly reason: PulseKvNotStoredReason }
+  | { readonly status: 'unknown'; readonly reason: 'transport' | 'timeout' | 'unavailable' | 'protocol' };
+
 export interface PulseKvNamespace<T = unknown> {
+  getVersioned(key: string): PulseParallelEffect<PulseKvVersionedResult<T>>;
+  insertIfAbsent(key: string, value: T): PulseParallelEffect<PulseKvConditionalResult>;
+  compareAndSwap(key: string, generation: PulseKvGeneration, value: T): PulseParallelEffect<PulseKvConditionalResult>;
   get(key: string): PulseParallelEffect<T | undefined>;
   put(key: string, value: T): PulseParallelEffect<boolean>;
 }
@@ -172,7 +195,7 @@ export type PulseErrorHandler = RouterErrorHandler;
 
 /**
  * Static authoring marker compiled by Pulse. Router instances are not runtime dispatchers.
- * Canonical v2 supports terminal middleware/error transfer, get/head/post routes,
+ * Canonical v2 supports terminal middleware/error transfer, get/head/post/put/patch/delete routes,
  * fallthrough, and acyclic static mounts.
  */
 export declare class Router {
@@ -181,6 +204,9 @@ export declare class Router {
   get(path: string, handler: RouteHandler): this;
   head(path: string, handler: RouteHandler): this;
   post(path: string, handler: RouteHandler): this;
+  put(path: string, handler: RouteHandler): this;
+  patch(path: string, handler: RouteHandler): this;
+  delete(path: string, handler: RouteHandler): this;
   mount(path: string, router: Router): this;
   error(handler: RouterErrorHandler): this;
 }

package/src/internal/bindings.js

@@ -171,7 +171,7 @@ function clonePortableKvValue(value, state, path, depth) {
       }
       const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
       if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
-        throw kvValueError('Pulse KV arrays may not contain accessors.', `${path}[${index}]`, value[index]);
+        throw kvValueError('Pulse KV arrays may not contain accessors.', `${path}[${index}]`, undefined);
       }
       definePortableProperty(output, String(index), clonePortableKvValue(descriptor.value, state, `${path}[${index}]`, depth + 1));
     }

package/src/internal/conditional-kv.js

@@ -0,0 +1,199 @@
+'use strict';
+
+// Shared host contract. Provider preparation must not send a storage operation;
+// the returned primitive is the conservative dispatch boundary (including throws).
+const { cloneKvValue, normalizeKvNamespace } = require('./bindings.js');
+const { PulseRuntimeContractError } = require('./errors.js');
+const KV_CONDITIONAL_KINDS = Object.freeze(['kv.getVersioned', 'kv.insertIfAbsent', 'kv.compareAndSwap']);
+const KV_CONDITIONAL_LIMITS = Object.freeze({ namespaceBytes: 256, keyBytes: 1024, generationBytes: 256,
+  valueBytes: 65536, wireBytes: 65560, depth: 64, entries: 10000, envelopeBytes: 262144, timeoutMs: 10000 });
+const readReasons = new Set(['invalid-key', 'configuration', 'not-authorized', 'throttled', 'unavailable', 'transport', 'timeout', 'protocol', 'too-large', 'invalid-value']);
+const writeReasons = new Set([...readReasons, 'invalid-generation', 'rejected']);
+const unknownReasons = new Set(['transport', 'timeout', 'unavailable', 'protocol']);
+const encoder = new TextEncoder();
+const admissions = new WeakSet();
+// Descriptor copies retain the original admission/deadline. Symbols never enter
+// the serialized effect envelope; only admissions minted by this owner are trusted.
+const admissionSymbol = Symbol('pulse.conditional-kv-admission');
+const isConditionalKv = (kind) => KV_CONDITIONAL_KINDS.includes(kind);
+const isRead = (effect) => effect.kind === 'kv.getVersioned';
+const frozen = (value) => Object.freeze(value);
+function fail(reason) { const error = new Error('Pulse conditional KV boundary rejected data.'); error.kvReason = reason; throw error; }
+function byteLength(value) { return encoder.encode(value).byteLength; }
+function kvClock(options = {}) { return options.kvClock || { now: () => performance.now(), setTimeout, clearTimeout }; }
+function boundedLimits(options = {}) {
+  const limit = (name, max) => options[name] === undefined ? max : Math.min(max, options[name]);
+  return { maxKvValueBytes: limit('maxKvValueBytes', 65536), maxKvValueDepth: limit('maxKvValueDepth', 64), maxKvValueEntries: limit('maxKvValueEntries', 10000) };
+}
+function normalizeKvGeneration(value) {
+  if (typeof value !== 'string' || !/^[\x21-\x7e]{1,256}$/.test(value)) fail('invalid-generation');
+  return value;
+}
+function normalizeConditionalKvKey(value, options = {}) {
+  if (typeof value !== 'string' || value.length === 0 || value.length > 1024 || byteLength(value) > Math.min(1024, options.maxKvKeyBytes ?? 1024)
+    || /[\u0000-\u001f\u007f-\u009f]/u.test(value) || /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(value)) fail('invalid-key');
+  return value;
+}
+function validationReason(error) {
+  if (error && error.kvReason) return error.kvReason;
+  return /TOO_LARGE|DEPTH_EXCEEDED|ENTRIES_EXCEEDED/.test(error && error.code || '') ? 'too-large' : 'invalid-value';
+}
+function encodeConditionalKvValue(value, options = {}) {
+  let detached;
+  try { detached = cloneKvValue(value, boundedLimits(options)); } catch (error) { fail(validationReason(error)); }
+  const wire = encoder.encode('{"__pulseKv":1,"value":' + JSON.stringify(detached) + '}');
+  if (wire.byteLength > KV_CONDITIONAL_LIMITS.wireBytes) fail('too-large');
+  return wire;
+}
+function decodeConditionalKvValue(bytes, options = {}) {
+  if (!(bytes instanceof Uint8Array)) fail('protocol');
+  if (bytes.byteLength > KV_CONDITIONAL_LIMITS.wireBytes) fail('too-large');
+  let text, parsed;
+  try {
+    text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
+    parsed = JSON.parse(text);
+    // JSON.parse validates syntax; this bounded scan rejects last-wins duplicate
+    // members, including escaped aliases, before exposing any parsed value.
+    const tokens = text.match(/"(?:[^"\\]|\\.)*"|[{}\[\],:]|true|false|null|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g);
+    let cursor = 0, entries = 0;
+    function visit(depth) {
+      if (depth > 65 || ++entries > 10002) fail('too-large');
+      const first = tokens[cursor++];
+      if (first !== '{' && first !== '[') return;
+      const end = first === '{' ? '}' : ']', names = new Set();
+      if (tokens[cursor] === end) { cursor++; return; }
+      while (true) {
+        if (first === '{') {
+          const name = JSON.parse(tokens[cursor++]);
+          if (names.has(name)) fail('protocol'); names.add(name);
+          if (tokens[cursor++] !== ':') fail('protocol');
+        }
+        visit(depth + 1);
+        const separator = tokens[cursor++];
+        if (separator === end) return;
+        if (separator !== ',') fail('protocol');
+      }
+    }
+    visit(0);
+    if (cursor !== tokens.length || !parsed || Array.isArray(parsed) || parsed.__pulseKv !== 1
+      || Object.keys(parsed).sort().join(',') !== '__pulseKv,value') fail('protocol');
+  } catch (error) { fail(error.kvReason || 'protocol'); }
+  try { return cloneKvValue(parsed.value, boundedLimits(options)); } catch (error) { fail(validationReason(error)); }
+}
+function kvFailure(effect, reason, dispatched = false) {
+  return frozen(isRead(effect) ? { status: 'failed', reason: readReasons.has(reason) ? reason : 'protocol' }
+    : { status: dispatched ? 'unknown' : 'not-stored', reason: (dispatched ? unknownReasons : writeReasons).has(reason) ? reason : 'protocol' });
+}
+function admitConditionalKv(input, options = {}) {
+  if (admissions.has(input)) return input;
+  if (input && admissions.has(input[admissionSymbol])) return input[admissionSymbol];
+  const clock = kvClock(options);
+  const deadline = Math.min(clock.now() + KV_CONDITIONAL_LIMITS.timeoutMs, options.deadlineMonotonicMs ?? Infinity);
+  const result = { kind: input.kind, deadline };
+  try {
+    try { result.namespace = normalizeKvNamespace(input.namespace ?? input.store, { maxKvNamespaceBytes: Math.min(256, options.maxKvNamespaceBytes ?? 256) }); }
+    catch (_) { fail('configuration'); }
+    result.key = normalizeConditionalKvKey(input.key, options);
+    if (input.kind === 'kv.compareAndSwap') result.generation = normalizeKvGeneration(input.generation);
+    if (!isRead(input)) result.value = decodeConditionalKvValue(encodeConditionalKvValue(input.value, options), options);
+    if (byteLength(JSON.stringify(result)) > KV_CONDITIONAL_LIMITS.envelopeBytes) fail('too-large');
+  } catch (error) { result.validationResult = kvFailure(result, validationReason(error)); }
+  result[admissionSymbol] = result;
+  const admitted = frozen(result); admissions.add(admitted); return admitted;
+}
+function exactRecord(value, fields) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) fail('protocol');
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) fail('protocol');
+  const keys = Reflect.ownKeys(value);
+  if (keys.length !== fields.length || !fields.every((key) => keys.includes(key))) fail('protocol');
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor.enumerable || !Object.prototype.hasOwnProperty.call(descriptor, 'value')) fail('protocol');
+  }
+}
+function normalizeConditionalKvResult(effect, value, options = {}) {
+  try {
+    // Read status without invoking an accessor from a malformed provider result.
+    const status = value && Object.getOwnPropertyDescriptor(value, 'status');
+    const tag = status && status.value;
+    if (isRead(effect)) {
+      if (tag === 'found') {
+        exactRecord(value, ['status', 'value', 'generation']);
+        const generation = normalizeKvGeneration(value.generation);
+        const detached = decodeConditionalKvValue(encodeConditionalKvValue(value.value, options), options);
+        return frozen({ status: 'found', value: detached, generation });
+      }
+      if (tag === 'not-found') { exactRecord(value, ['status']); return frozen({ status: tag }); }
+      exactRecord(value, ['status', 'reason']);
+      if (tag !== 'failed' || !readReasons.has(value.reason)) fail('protocol');
+    } else {
+      if (tag === 'stored' || tag === 'conflict') { exactRecord(value, ['status']); return frozen({ status: tag }); }
+      exactRecord(value, ['status', 'reason']);
+      if (!((tag === 'not-stored' && writeReasons.has(value.reason)) || (tag === 'unknown' && unknownReasons.has(value.reason)))) fail('protocol');
+    }
+    return frozen({ status: tag, reason: value.reason });
+  } catch (error) { return kvFailure(effect, validationReason(error) === 'invalid-generation' ? 'protocol' : validationReason(error), !isRead(effect)); }
+}
+function registerKvRedactions(effect, register) {
+  if (typeof register !== 'function') return;
+  const visit = (value) => {
+    if (typeof value === 'string' && value.length) register(value);
+    else if (value && typeof value === 'object') for (const key of Object.keys(value)) { register(key); visit(value[key]); }
+  };
+  visit(effect.key); visit(effect.generation); visit(effect.value);
+}
+function cancelled() { return new PulseRuntimeContractError('PULSE_RUNTIME_EFFECT_ABORTED', 'Pulse conditional KV execution was cancelled.'); }
+async function executeConditionalKv(effect, prepare, execution = {}, options = {}) {
+  const admitted = admissions.has(effect) ? effect : admitConditionalKv(effect, options);
+  const clock = kvClock(options), controller = new AbortController();
+  let dispatched = false, settled = false, timer, rejectCancellation, resolveTimeout;
+  registerKvRedactions(admitted, execution.registerRedactionValue);
+  const observe = (outcome) => {
+    if (typeof execution.onKvObservation === 'function') execution.onKvObservation(frozen({
+      type: 'kv-lifecycle', kind: admitted.kind, dispatched, mayHaveCommitted: !isRead(admitted) && dispatched && (outcome === 'cancelled' || outcome === 'unknown'), outcome
+    }));
+  };
+  const cancellation = new Promise((_, reject) => { rejectCancellation = reject; });
+  const timeout = new Promise((resolve) => { resolveTimeout = resolve; });
+  const abort = () => { if (!settled) { controller.abort(); rejectCancellation(cancelled()); } };
+  const expire = () => { if (!settled) { controller.abort(); resolveTimeout(kvFailure(admitted, 'timeout', dispatched)); } };
+  const signal = execution.signal;
+  if (signal) signal.addEventListener('abort', abort, { once: true });
+  try {
+    if (signal && signal.aborted) throw cancelled();
+    if (admitted.validationResult) return admitted.validationResult;
+    if (clock.now() >= admitted.deadline) return kvFailure(admitted, 'timeout');
+    timer = clock.setTimeout(expire, admitted.deadline - clock.now());
+    const operationExecution = frozen({ ...execution, signal: controller.signal, deadlineMonotonicMs: admitted.deadline });
+    const work = Promise.resolve().then(async () => {
+      if (controller.signal.aborted) return kvFailure(admitted, 'timeout');
+      try {
+        const primitive = await prepare(admitted, operationExecution);
+        if (controller.signal.aborted || clock.now() >= admitted.deadline) {
+          controller.abort();
+          return kvFailure(admitted, 'timeout');
+        }
+        if (typeof primitive !== 'function') return kvFailure(admitted, 'configuration');
+        dispatched = true;
+        const value = await primitive();
+        if (clock.now() >= admitted.deadline) {
+          controller.abort();
+          return kvFailure(admitted, 'timeout', true);
+        }
+        const normalized = normalizeConditionalKvResult(admitted, value, options);
+        if (normalized.status === 'found') registerKvRedactions(normalized, execution.registerRedactionValue);
+        return normalized;
+      } catch (error) {
+        return kvFailure(admitted, dispatched ? 'transport' : error && writeReasons.has(error.kvReason) ? error.kvReason : 'unavailable', dispatched);
+      }
+    });
+    const result = await Promise.race([work, timeout, cancellation]);
+    if (signal && signal.aborted) throw cancelled();
+    observe(result.status);
+    return result;
+  } catch (error) { if (signal && signal.aborted) observe('cancelled'); throw error; }
+  finally { settled = true; if (timer !== undefined) clock.clearTimeout(timer); if (signal) signal.removeEventListener('abort', abort); }
+}
+module.exports = Object.freeze({ KV_CONDITIONAL_KINDS, KV_CONDITIONAL_LIMITS, isConditionalKv, normalizeKvGeneration, normalizeConditionalKvKey,
+  admitConditionalKv, encodeConditionalKvValue, decodeConditionalKvValue, normalizeConditionalKvResult, executeConditionalKv, registerKvRedactions });

package/src/internal/context.js

@@ -207,6 +207,10 @@ function createContext(frame) {
     kv(name) {
       const namespace = normalizeKvNamespace(name, options);
       return Object.freeze({
+        ...Object.fromEntries(['getVersioned', 'insertIfAbsent', 'compareAndSwap'].map((operation) => [operation, (key, generationOrValue, value) => effects.dispatch({
+          kind: `kv.${operation}`, providerKind: 'kv', operation, capability: `kv.${operation}`, namespace, key,
+          ...(operation === 'compareAndSwap' ? { generation: generationOrValue, value } : operation === 'insertIfAbsent' ? { value: generationOrValue } : {})
+        })])),
         get(key) {
           const normalizedKey = normalizeKvKey(key, options);
           return effects.dispatch({

package/src/internal/effect-adapter.js

@@ -9,6 +9,7 @@ const {
   normalizeKvNamespace,
   normalizeKvPutResult
 } = require('./bindings.js');
+const conditionalKv = require('./conditional-kv.js');
 const { fetchRequestInitForHost } = require('./fetch.js');
 const { createRedactionState } = require('./redaction.js');
 const { validateSchemaValue } = require('./schema.js');
@@ -102,7 +103,6 @@ function createEffectSignal(lifecycleSignal, descriptor) {
 
 function raceWithSignal(promise, signal) {
   if (!signal) return Promise.resolve(promise);
-  if (signal.aborted) return Promise.reject(abortedEffectError(signal.reason));
   return new Promise((resolve, reject) => {
     let settled = false;
     const finish = (callback, value) => {
@@ -117,6 +117,8 @@ function raceWithSignal(promise, signal) {
       (value) => finish(resolve, value),
       (error) => finish(reject, error)
     );
+    // Observe the owned promise even when cancellation preceded the race.
+    if (signal.aborted) onAbort();
   });
 }
 
@@ -167,6 +169,7 @@ function publicEffectDescriptor(effect, redaction) {
   if (effect.kind === 'config.get' || effect.kind === 'secret.get') {
     return Object.freeze({ ...base, name: redactString(effect.name) });
   }
+  if (conditionalKv.isConditionalKv(effect.kind)) return Object.freeze({ ...base, namespace: redactString(effect.namespace), key: '<redacted>', generation: '<redacted>', value: '<redacted>' });
   if (effect.kind === 'kv.get' || effect.kind === 'kv.put') {
     return Object.freeze({
       ...base,
@@ -208,6 +211,7 @@ function createJavascriptEffectAdapter(input) {
     version: JAVASCRIPT_EFFECT_ADAPTER_VERSION,
     id: String(input.id || 'pulse.javascript-effect-adapter.custom'),
     dispatch,
+    prepareConditionalKv: typeof input.prepareConditionalKv === 'function' ? input.prepareConditionalKv : undefined,
     dispose
   });
 }
@@ -225,6 +229,16 @@ function createCapabilityEffectAdapter(capabilities = {}) {
   const namespaces = new Map();
   return createJavascriptEffectAdapter({
     id: 'pulse.javascript-effect-adapter.capabilities',
+    async prepareConditionalKv(effect, execution) {
+      if (typeof value.prepareConditionalKv === 'function') return value.prepareConditionalKv(effect, execution);
+      if (typeof value.kv !== 'function') return undefined;
+      if (!namespaces.has(effect.namespace)) namespaces.set(effect.namespace, await value.kv(effect.namespace, execution));
+      const namespace = namespaces.get(effect.namespace), method = effect.kind.slice(3);
+      if (!namespace || typeof namespace[method] !== 'function') return undefined;
+      return () => method === 'getVersioned' ? namespace[method](effect.key, execution)
+        : method === 'insertIfAbsent' ? namespace[method](effect.key, effect.value, execution)
+        : namespace[method](effect.key, effect.generation, effect.value, execution);
+    },
     async dispatch(effect, execution) {
       if (effect.kind === 'fetch') {
         if (typeof value.fetch !== 'function') return unavailableCapability(effect);
@@ -260,6 +274,7 @@ function createCapabilityEffectAdapter(capabilities = {}) {
 
 function bindingLimits(options = {}) {
   return Object.freeze({
+    kvClock: options.kvClock, deadlineMonotonicMs: options.deadlineMonotonicMs,
     maxBindingNameBytes: options.maxBindingNameBytes,
     maxBindingValueBytes: options.maxBindingValueBytes,
     maxKvNamespaceBytes: options.maxKvNamespaceBytes,
@@ -272,6 +287,7 @@ function bindingLimits(options = {}) {
 
 function normalizeEffectDescriptor(input, limits) {
   const kind = String(input.kind || 'effect');
+  if (conditionalKv.isConditionalKv(kind)) return { ...conditionalKv.admitConditionalKv(input, limits), id: input.id, parallelEligible: input.parallelEligible };
   if (kind === 'config.get' || kind === 'secret.get') {
     const bindingKind = kind === 'secret.get' ? 'secret' : 'config';
     return { ...input, name: normalizeBindingName(bindingKind, input.name, limits) };
@@ -574,6 +590,7 @@ function createJavascriptEffectExecution(options = {}) {
       }
       dispatchedIds.add(descriptor.id);
       totalEffects += 1;
+      if (conditionalKv.isConditionalKv(kind)) conditionalKv.registerKvRedactions(descriptor, (value) => redaction.add(value));
       const publicDescriptor = publicEffectDescriptor(descriptor, redaction);
       observe({ type: 'effect-dispatched', effect: publicDescriptor });
 
@@ -581,6 +598,9 @@ function createJavascriptEffectExecution(options = {}) {
       const operationExecution = Object.freeze({ ...externalExecution, signal: operationSignal.signal });
       const raw = raceWithSignal(Promise.resolve().then(() => {
         if (operationSignal.signal.aborted) throw abortedEffectError(operationSignal.signal.reason);
+        if (conditionalKv.isConditionalKv(kind)) return conditionalKv.executeConditionalKv(descriptor,
+          adapter.prepareConditionalKv || ((_admitted, kvExecution) => () => adapter.dispatch(descriptor, kvExecution)),
+          { ...operationExecution, onKvObservation: observe }, limits);
         return adapter.dispatch(descriptor, operationExecution);
       }), operationSignal.signal).then(
         (value) => {

package/src/internal/event-execution.js

@@ -317,6 +317,7 @@ function effectExecutionOptions(options, application, frame) {
     executionKind: 'event',
     signal: options.signal,
     maxEffects: options.maxEffects,
+    kvClock: options.kvClock, deadlineMonotonicMs: options.deadlineMonotonicMs,
     maxBindingNameBytes: options.maxBindingNameBytes,
     maxBindingValueBytes: options.maxBindingValueBytes,
     maxKvNamespaceBytes: options.maxKvNamespaceBytes,

package/src/internal/package-runtime.js

@@ -16,6 +16,13 @@ const DEFAULT_MAX_PAYLOAD_ENTRIES = 4096;
 const PACKAGE_CONTEXTS = new WeakMap();
 
 const TRUSTED_PACKAGE_EFFECT_CATALOG = Object.freeze({
+  '@pulse-compute/s3': Object.freeze({
+    contractId: 'pulse.s3', providerKind: 's3', operations: Object.freeze({
+      head: Object.freeze({ kind: 's3.head', capability: 's3.head', result: 's3-head-result' }),
+      getText: Object.freeze({ kind: 's3.getText', capability: 's3.getText', result: 's3-get-text-result' }),
+      putText: Object.freeze({ kind: 's3.putText', capability: 's3.putText', result: 's3-put-text-result' })
+    })
+  }),
   '@pulse-compute/assets': Object.freeze({
     contractId: 'pulse.assets',
     providerKind: 'assets',

package/src/internal/router.js

@@ -84,6 +84,33 @@ class Router {
     return this;
   }
 
+  put(path, handler) {
+    ROUTER_STATE.get(this).entries.push(entry('route', {
+      method: 'PUT',
+      path: compileRoutePath(path, { allowWildcard: true }),
+      handler: requireHandler(handler, 'put(path, handler)')
+    }));
+    return this;
+  }
+
+  patch(path, handler) {
+    ROUTER_STATE.get(this).entries.push(entry('route', {
+      method: 'PATCH',
+      path: compileRoutePath(path, { allowWildcard: true }),
+      handler: requireHandler(handler, 'patch(path, handler)')
+    }));
+    return this;
+  }
+
+  delete(path, handler) {
+    ROUTER_STATE.get(this).entries.push(entry('route', {
+      method: 'DELETE',
+      path: compileRoutePath(path, { allowWildcard: true }),
+      handler: requireHandler(handler, 'delete(path, handler)')
+    }));
+    return this;
+  }
+
   mount(path, router) {
     ROUTER_STATE.get(this).entries.push(entry('mount', {
       path: compileRoutePath(path, { scoped: true, allowWildcard: true }),
@@ -391,6 +418,7 @@ async function executeRouter(router, request, options = {}) {
     executionKind: 'request',
     signal: executionSignal,
     maxEffects: options.maxEffects,
+    kvClock: options.kvClock, deadlineMonotonicMs: options.deadlineMonotonicMs,
     maxBindingNameBytes: options.maxBindingNameBytes,
     maxBindingValueBytes: options.maxBindingValueBytes,
     maxKvNamespaceBytes: options.maxKvNamespaceBytes,