@mcp-b/do-runtime 0.1.0

package/dist/cloudflare-workers.js

@@ -0,0 +1,351 @@
+//#region src/api/cloudflare-workers.ts
+/**
+* ← workerd `src/cloudflare/workers.ts` — the built-in `cloudflare:workers`
+* module.
+*
+* Upstream's own header explains the file's shape: "C++ built-in modules do not
+* yet support named exports, so we must define this wrapper module that simply
+* re-exports the classes from the built-in module." The classes come from
+* `cloudflare-internal:workers` (`src/cloudflare/internal/workers.d.ts`); the
+* behaviour this file owns is the two proxies and the three scope functions.
+*
+* **The export surface was re-derived, not inherited.** The extension shim this
+* replaces (`offscreen/worker/host/shims/cloudflare-workers.ts`, 58 lines)
+* documents its surface as the result of grepping `from "cloudflare:workers"`
+* across `vendor/agents/packages/agents/src`. Re-running that grep across all of
+* `vendor/agents` finds six values — `env` (178 imports), `exports` (48),
+* `WorkerEntrypoint` (16), `RpcTarget` (16), `DurableObject` (13),
+* `WorkflowEntrypoint` (3) — and **four types the shim does not have**:
+* `WorkflowEvent` (8), `WorkflowSleepDuration` (4), `WorkflowStep` (3) and
+* `WorkflowStepEvent` (2). `@cloudflare/workers-types` declares only
+* `WorkflowSleepDuration` of those four globally, so the other three are
+* declared here, where the module that exports them lives.
+*
+* Everything else upstream exports is ported too, per the package README's rule
+* that consumer count is not the filter: `RpcStub`, `RpcPromise`, `RpcProperty`,
+* `ServiceStub`, `waitUntil`, `cache`, `tracing` and `abortIsolate`. Each of
+* those is a named throwing boundary, and each throw says which layer owns the
+* thing that is missing rather than that it is missing.
+*
+* **The one thing to know before wiring this in.** `RpcTarget` is declared here,
+* as upstream declares it — capnweb's own documentation says "on Cloudflare
+* Workers, this `RpcTarget` is an alias for the one exported from the
+* `cloudflare:workers` module, so they can be used interchangably." That alias is
+* **unreachable** in capnweb 0.10.0: `let workersModule = globalThis[Symbol("workers-module")]`
+* reads a symbol created fresh inside capnweb's own module and exported nowhere,
+* so it is always `undefined` and capnweb falls back to its private `class {}`.
+* `value instanceof RpcTarget` inside capnweb therefore tests capnweb's class,
+* not this one, which is why today's extension shim re-exports capnweb's. The
+* transport adaptation (`src/transport/`) owns reconciling the two; `api/` may not
+* import a transport library, and inverting the dependency — making the module
+* that defines the base class depend on the library that aliases it — is the
+* layering upstream does not have.
+*
+* Spec: the shim-surface inventory in docs/shim-surface.md and decision 16 in
+* docs/decisions.md.
+*/
+/**
+* `entrypoints.waitUntil` reaches `IoContext::current()`, a thread-local this
+* package deliberately does not port — `io/io-context.ts`'s invocation stack
+* replaces it, and it is reachable only from inside a gated slice rather than
+* from module scope.
+*/
+var MODULE_WAIT_UNTIL_UNIMPLEMENTED_MESSAGE = "The module-level waitUntil() from cloudflare:workers has no current request to attach to in this runtime. Call ctx.waitUntil() on the DurableObjectState or ExecutionContext you were given instead.";
+/**
+* Upstream: "In workerd, the handler aborts the process (unless used on a
+* dynamic worker). In the edge runtime it will condemn and terminate the current
+* isolate." There is no isolate to condemn, which is the same absence
+* `DurableObjectState.abort()` records for `js.terminateExecutionNow()`.
+*/
+var ABORT_ISOLATE_UNIMPLEMENTED_MESSAGE = "abortIsolate() is not available in this runtime: there is no isolate to condemn. Break the actor's output gate instead, which is what DurableObjectState.abort() does.";
+/** The Workers Cache API is an edge facility; `caches` in a browser is a different contract. */
+var CACHE_UNIMPLEMENTED_MESSAGE = "The cloudflare:workers cache context is not available in this runtime: CacheContext.purge() is an edge operation with no browser equivalent.";
+/** The four stub types are the RPC system's, and the RPC system here is the transport adaptation. */
+var RPC_STUB_UNIMPLEMENTED_MESSAGE = "RpcStub, RpcPromise, RpcProperty and ServiceStub belong to the RPC system, which in this runtime is the capnweb transport adaptation rather than this module. Construct one through the transport.";
+/**
+* Upstream's `exports` proxy defines no `set` trap, so an assignment lands on the
+* empty proxy target and is silently lost — its comment says "This proxy is
+* read-only - mutations are not supported." A silent loss is the failure mode
+* this repository's fail-closed tenet exists to prevent, so it throws instead.
+*/
+var EXPORTS_READ_ONLY_MESSAGE = "The cloudflare:workers exports object is read-only. Install worker exports with withExports() or withEnvAndExports().";
+/**
+* Upstream's scopes are `AsyncContext`-propagated, so an `async` callback keeps
+* its bindings across an await. Decision 8's propagation is not built (and Part 4
+* records that this package needs none), so the scope here is the synchronous
+* call — which is exactly what upstream's `fn: () => unknown` signature describes
+* and nothing more. A callback that returns a thenable would silently read the
+* wrong bindings after its first await, so it is refused: the same guard, for the
+* same reason, that `transactionSync` already applies to its callback.
+*/
+var WITH_SCOPE_ASYNC_MESSAGE = "withEnv(), withExports() and withEnvAndExports() take a synchronous callback in this runtime. The returned value is a thenable, and everything after its first await would run outside the scope with the previous bindings installed.";
+/**
+* The scope stacks. Upstream's current env comes from
+* `innerEnv.getCurrentEnv()`, which is `kj::none` before the runtime installs
+* one — the branch every trap below guards with `if (inner)`. Here the bottom of
+* each stack is a real object installed at module load, so that branch is
+* unreachable and the guard collapses.
+*
+* The bottom entry is also what makes `Object.assign(env, bindings)` work, which
+* is how a host installs long-lived bindings: upstream's `set` trap forwards into
+* the current env, and here the current env outside any scope is that object.
+*/
+var envScopes = [{}];
+var exportsScopes = [{}];
+function topOf(scopes) {
+	const top = scopes.at(-1);
+	if (top === void 0) throw new Error("cloudflare:workers scope stack is empty");
+	return top;
+}
+/**
+* ← the `env` proxy (`workers.ts:41-104`). Upstream's comment, which is the whole
+* reason this is a proxy rather than an object: "Since env is imported as a
+* module-level reference, the object identity cannot be changed. The proxy
+* provides indirection, delegating to different underlying env objects based on
+* async context (see withEnv()). Mutations via this proxy modify the current
+* underlying env object in-place - if you're inside a withEnv() scope, mutations
+* affect the override object, not the base environment."
+*/
+var env = new Proxy({}, {
+	get(_target, property) {
+		return Reflect.get(topOf(envScopes), property);
+	},
+	set(_target, property, newValue) {
+		return Reflect.set(topOf(envScopes), property, newValue);
+	},
+	has(_target, property) {
+		return Reflect.has(topOf(envScopes), property);
+	},
+	ownKeys() {
+		return Reflect.ownKeys(topOf(envScopes));
+	},
+	deleteProperty(_target, property) {
+		return Reflect.deleteProperty(topOf(envScopes), property);
+	},
+	defineProperty(_target, property, attributes) {
+		return Reflect.defineProperty(topOf(envScopes), property, attributes);
+	},
+	getOwnPropertyDescriptor(_target, property) {
+		return Reflect.getOwnPropertyDescriptor(topOf(envScopes), property);
+	}
+});
+/**
+* ← the `exports` proxy (`workers.ts:109-147`). Same indirection as `env`, minus
+* the mutating traps — with `set` and `defineProperty` throwing where upstream
+* lets them fall through to the dead proxy target.
+*/
+var exports = new Proxy({}, {
+	get(_target, property) {
+		return Reflect.get(topOf(exportsScopes), property);
+	},
+	set() {
+		throw new TypeError(EXPORTS_READ_ONLY_MESSAGE);
+	},
+	defineProperty() {
+		throw new TypeError(EXPORTS_READ_ONLY_MESSAGE);
+	},
+	deleteProperty() {
+		throw new TypeError(EXPORTS_READ_ONLY_MESSAGE);
+	},
+	has(_target, property) {
+		return Reflect.has(topOf(exportsScopes), property);
+	},
+	ownKeys() {
+		return Reflect.ownKeys(topOf(exportsScopes));
+	},
+	getOwnPropertyDescriptor(_target, property) {
+		return Reflect.getOwnPropertyDescriptor(topOf(exportsScopes), property);
+	}
+});
+/** ← `withEnv` (`workers.ts:21-23`). */
+function withEnv(newEnv, fn) {
+	return runInScopes([{
+		scopes: envScopes,
+		value: newEnv
+	}], fn);
+}
+/** ← `withExports` (`workers.ts:25-27`). */
+function withExports(newExports, fn) {
+	return runInScopes([{
+		scopes: exportsScopes,
+		value: newExports
+	}], fn);
+}
+/** ← `withEnvAndExports` (`workers.ts:29-34`). */
+function withEnvAndExports(newEnv, newExports, fn) {
+	return runInScopes([{
+		scopes: envScopes,
+		value: newEnv
+	}, {
+		scopes: exportsScopes,
+		value: newExports
+	}], fn);
+}
+function runInScopes(pushes, fn) {
+	for (const push of pushes) push.scopes.push(asBindings(push.value));
+	try {
+		const result = fn();
+		if (isThenable(result)) throw new TypeError(WITH_SCOPE_ASYNC_MESSAGE);
+		return result;
+	} finally {
+		for (const push of pushes) push.scopes.pop();
+	}
+}
+function asBindings(value) {
+	if (value !== null && typeof value === "object") return value;
+	throw new TypeError("cloudflare:workers scopes take an object of bindings.");
+}
+function isThenable(value) {
+	if (value === null || typeof value !== "object" && typeof value !== "function") return false;
+	return typeof value.then === "function";
+}
+/**
+* ← `RpcTarget` (`cloudflare/internal/workers.d.ts`: `export class RpcTarget {}`).
+*
+* Upstream's public type declares it `abstract` with one branding member; the
+* implementation declaration has neither, and this follows the implementation so
+* that a marker instance can exist. See this file's header for the identity
+* constraint capnweb imposes on it.
+*/
+var RpcTarget = class {};
+/**
+* ← `DurableObject` (`cloudflare/internal/workers.d.ts`; public shape in
+* `@cloudflare/workers-types`).
+*
+* `extends RpcTarget` is this runtime's, not upstream's: workerd's RPC system
+* knows the three entrypoint classes natively through `Rpc.*Branded`, and
+* capnweb recognises only `RpcTarget`. Same observable behaviour — an instance
+* may be passed by reference over RPC — through the mechanism the substrate has.
+*
+* `ctx` and `env` are `protected` because that is what the published types say,
+* and upstream's comment on `WorkerEntrypoint` says why it matters rather than
+* being style: "`protected` fields don't appear in `keyof`s, so can't be accessed
+* over RPC." The extension shim had them public.
+*/
+var DurableObject = class extends RpcTarget {
+	ctx;
+	env;
+	constructor(ctx, env) {
+		super();
+		this.ctx = ctx;
+		this.env = env;
+	}
+};
+/** ← `WorkerEntrypoint`. */
+var WorkerEntrypoint = class extends RpcTarget {
+	ctx;
+	env;
+	constructor(ctx, env) {
+		super();
+		this.ctx = ctx;
+		this.env = env;
+	}
+};
+/**
+* ← `WorkflowEntrypoint`.
+*
+* The extension shim threw from the constructor. That throw is dropped: the class
+* is a plain base whose `run` a Workflows binding dispatches, and there is no
+* Workflows binding here — so the absent thing is the binding, which nothing in
+* this package offers, rather than the base class. Constructing one and never
+* dispatching it is what happens today either way, and a constructor that throws
+* would take down module evaluation for a consumer that merely declares a
+* subclass.
+*/
+var WorkflowEntrypoint = class extends RpcTarget {
+	ctx;
+	env;
+	constructor(ctx, env) {
+		super();
+		this.ctx = ctx;
+		this.env = env;
+	}
+	run(_event, _step) {
+		throw new Error("WorkflowEntrypoint subclasses must implement run().");
+	}
+};
+/** ← `RpcStub`. */
+var RpcStub = class {
+	constructor(_server) {
+		throw new Error(RPC_STUB_UNIMPLEMENTED_MESSAGE);
+	}
+};
+/** ← `RpcPromise`. */
+var RpcPromise = class {
+	constructor() {
+		throw new Error(RPC_STUB_UNIMPLEMENTED_MESSAGE);
+	}
+};
+/** ← `RpcProperty`. */
+var RpcProperty = class {
+	constructor() {
+		throw new Error(RPC_STUB_UNIMPLEMENTED_MESSAGE);
+	}
+};
+/** ← `ServiceStub`. */
+var ServiceStub = class {
+	constructor() {
+		throw new Error(RPC_STUB_UNIMPLEMENTED_MESSAGE);
+	}
+};
+/** ← `export const waitUntil = entrypoints.waitUntil.bind(entrypoints)`. */
+function waitUntil(_promise) {
+	throw new Error(MODULE_WAIT_UNTIL_UNIMPLEMENTED_MESSAGE);
+}
+/** ← `abortIsolate` (`workers.ts:206-215`). */
+function abortIsolate(_reason) {
+	throw new Error(ABORT_ISOLATE_UNIMPLEMENTED_MESSAGE);
+}
+/**
+* ← the `cache` proxy (`workers.ts:152-198`).
+*
+* Upstream's `cache` answers `undefined` when there is no current context —
+* "Used to enable safe no-op access outside module init" — which here would be
+* every access, and `cache.purge(...)` would fail as "purge is not a function"
+* three frames from the cause. A throwing proxy names the boundary at the access.
+*
+* The one assertion in this file, in one place: no value can be a `CacheContext`
+* here, and the object that stands in for one exists precisely so that touching it
+* fails. Same shape as `io/worker.ts`'s `asFacetStub`.
+*/
+function boundaryObject(message) {
+	const thrower = () => {
+		throw new Error(message);
+	};
+	return new Proxy({}, {
+		get: thrower,
+		has: thrower,
+		ownKeys: thrower,
+		getOwnPropertyDescriptor: thrower
+	});
+}
+var cache = boundaryObject(CACHE_UNIMPLEMENTED_MESSAGE);
+/**
+* ← `export const tracing = innerTracing`.
+*
+* This one is NOT a boundary. The workerd oracle establishes (§1.12) that
+* `tracing` is an
+* object, `startActiveSpan(name, run)` calls `run` and returns its result, and
+* the span it hands over reports `isTraced: false` with working no-op
+* `setAttribute` and `end`. Untraced is workerd's ORDINARY state when nothing is
+* collecting, not an error — so a `Span` here is a permanently untraced one, which
+* is the same observable behaviour through the only mechanism this package has.
+*
+* A throwing proxy was worse than strict, it was wrong: `agents`' tracing runtime
+* feature-detects with `cloudflareWorkers.tracing ?? noopRuntime`, so a present
+* object that throws on use took down every `new Agent(...)` in the extension —
+* where an absent one would have degraded exactly as that code intends.
+*/
+var Span = class {
+	/** Always false: nothing in this package collects spans, so no span is sampled. */
+	isTraced = false;
+	setAttribute(_name, _value) {}
+	end() {}
+};
+var tracing = { startActiveSpan(_name, run) {
+	return run(new Span());
+} };
+//#endregion
+export { ABORT_ISOLATE_UNIMPLEMENTED_MESSAGE, CACHE_UNIMPLEMENTED_MESSAGE, DurableObject, EXPORTS_READ_ONLY_MESSAGE, MODULE_WAIT_UNTIL_UNIMPLEMENTED_MESSAGE, RPC_STUB_UNIMPLEMENTED_MESSAGE, RpcPromise, RpcProperty, RpcStub, RpcTarget, ServiceStub, WITH_SCOPE_ASYNC_MESSAGE, WorkerEntrypoint, WorkflowEntrypoint, abortIsolate, cache, env, exports, tracing, waitUntil, withEnv, withEnvAndExports, withExports };
+
+//# sourceMappingURL=cloudflare-workers.js.map

package/dist/cloudflare-workers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-workers.js","names":[],"sources":["../src/api/cloudflare-workers.ts"],"sourcesContent":["/**\n * ← workerd `src/cloudflare/workers.ts` — the built-in `cloudflare:workers`\n * module.\n *\n * Upstream's own header explains the file's shape: \"C++ built-in modules do not\n * yet support named exports, so we must define this wrapper module that simply\n * re-exports the classes from the built-in module.\" The classes come from\n * `cloudflare-internal:workers` (`src/cloudflare/internal/workers.d.ts`); the\n * behaviour this file owns is the two proxies and the three scope functions.\n *\n * **The export surface was re-derived, not inherited.** The extension shim this\n * replaces (`offscreen/worker/host/shims/cloudflare-workers.ts`, 58 lines)\n * documents its surface as the result of grepping `from \"cloudflare:workers\"`\n * across `vendor/agents/packages/agents/src`. Re-running that grep across all of\n * `vendor/agents` finds six values — `env` (178 imports), `exports` (48),\n * `WorkerEntrypoint` (16), `RpcTarget` (16), `DurableObject` (13),\n * `WorkflowEntrypoint` (3) — and **four types the shim does not have**:\n * `WorkflowEvent` (8), `WorkflowSleepDuration` (4), `WorkflowStep` (3) and\n * `WorkflowStepEvent` (2). `@cloudflare/workers-types` declares only\n * `WorkflowSleepDuration` of those four globally, so the other three are\n * declared here, where the module that exports them lives.\n *\n * Everything else upstream exports is ported too, per the package README's rule\n * that consumer count is not the filter: `RpcStub`, `RpcPromise`, `RpcProperty`,\n * `ServiceStub`, `waitUntil`, `cache`, `tracing` and `abortIsolate`. Each of\n * those is a named throwing boundary, and each throw says which layer owns the\n * thing that is missing rather than that it is missing.\n *\n * **The one thing to know before wiring this in.** `RpcTarget` is declared here,\n * as upstream declares it — capnweb's own documentation says \"on Cloudflare\n * Workers, this `RpcTarget` is an alias for the one exported from the\n * `cloudflare:workers` module, so they can be used interchangably.\" That alias is\n * **unreachable** in capnweb 0.10.0: `let workersModule = globalThis[Symbol(\"workers-module\")]`\n * reads a symbol created fresh inside capnweb's own module and exported nowhere,\n * so it is always `undefined` and capnweb falls back to its private `class {}`.\n * `value instanceof RpcTarget` inside capnweb therefore tests capnweb's class,\n * not this one, which is why today's extension shim re-exports capnweb's. The\n * transport adaptation (`src/transport/`) owns reconciling the two; `api/` may not\n * import a transport library, and inverting the dependency — making the module\n * that defines the base class depend on the library that aliases it — is the\n * layering upstream does not have.\n *\n * Spec: the shim-surface inventory in docs/shim-surface.md and decision 16 in\n * docs/decisions.md.\n */\n\n// =======================================================================================\n// Boundary messages\n\n/**\n * `entrypoints.waitUntil` reaches `IoContext::current()`, a thread-local this\n * package deliberately does not port — `io/io-context.ts`'s invocation stack\n * replaces it, and it is reachable only from inside a gated slice rather than\n * from module scope.\n */\nexport const MODULE_WAIT_UNTIL_UNIMPLEMENTED_MESSAGE =\n  \"The module-level waitUntil() from cloudflare:workers has no current request to attach to in \" +\n  \"this runtime. Call ctx.waitUntil() on the DurableObjectState or ExecutionContext you were \" +\n  \"given instead.\";\n\n/**\n * Upstream: \"In workerd, the handler aborts the process (unless used on a\n * dynamic worker). In the edge runtime it will condemn and terminate the current\n * isolate.\" There is no isolate to condemn, which is the same absence\n * `DurableObjectState.abort()` records for `js.terminateExecutionNow()`.\n */\nexport const ABORT_ISOLATE_UNIMPLEMENTED_MESSAGE =\n  \"abortIsolate() is not available in this runtime: there is no isolate to condemn. Break the \" +\n  \"actor's output gate instead, which is what DurableObjectState.abort() does.\";\n\n/** The Workers Cache API is an edge facility; `caches` in a browser is a different contract. */\nexport const CACHE_UNIMPLEMENTED_MESSAGE =\n  \"The cloudflare:workers cache context is not available in this runtime: CacheContext.purge() \" +\n  \"is an edge operation with no browser equivalent.\";\n\n/** The four stub types are the RPC system's, and the RPC system here is the transport adaptation. */\nexport const RPC_STUB_UNIMPLEMENTED_MESSAGE =\n  \"RpcStub, RpcPromise, RpcProperty and ServiceStub belong to the RPC system, which in this \" +\n  \"runtime is the capnweb transport adaptation rather than this module. Construct one through \" +\n  \"the transport.\";\n\n/**\n * Upstream's `exports` proxy defines no `set` trap, so an assignment lands on the\n * empty proxy target and is silently lost — its comment says \"This proxy is\n * read-only - mutations are not supported.\" A silent loss is the failure mode\n * this repository's fail-closed tenet exists to prevent, so it throws instead.\n */\nexport const EXPORTS_READ_ONLY_MESSAGE =\n  \"The cloudflare:workers exports object is read-only. Install worker exports with \" +\n  \"withExports() or withEnvAndExports().\";\n\n/**\n * Upstream's scopes are `AsyncContext`-propagated, so an `async` callback keeps\n * its bindings across an await. Decision 8's propagation is not built (and Part 4\n * records that this package needs none), so the scope here is the synchronous\n * call — which is exactly what upstream's `fn: () => unknown` signature describes\n * and nothing more. A callback that returns a thenable would silently read the\n * wrong bindings after its first await, so it is refused: the same guard, for the\n * same reason, that `transactionSync` already applies to its callback.\n */\nexport const WITH_SCOPE_ASYNC_MESSAGE =\n  \"withEnv(), withExports() and withEnvAndExports() take a synchronous callback in this runtime. \" +\n  \"The returned value is a thenable, and everything after its first await would run outside the \" +\n  \"scope with the previous bindings installed.\";\n\n// =======================================================================================\n// env and exports\n\n/**\n * ← `export const env: Cloudflare.Env`. `Cloudflare.Env` is generated per project\n * from a `wrangler.jsonc`, and this package has neither, so the value type is the\n * open record the extension shim already used.\n */\nexport type Bindings = Record<string, unknown>;\n\n/**\n * The scope stacks. Upstream's current env comes from\n * `innerEnv.getCurrentEnv()`, which is `kj::none` before the runtime installs\n * one — the branch every trap below guards with `if (inner)`. Here the bottom of\n * each stack is a real object installed at module load, so that branch is\n * unreachable and the guard collapses.\n *\n * The bottom entry is also what makes `Object.assign(env, bindings)` work, which\n * is how a host installs long-lived bindings: upstream's `set` trap forwards into\n * the current env, and here the current env outside any scope is that object.\n */\nconst envScopes: Bindings[] = [{}];\nconst exportsScopes: Bindings[] = [{}];\n\nfunction topOf(scopes: Bindings[]): Bindings {\n  const top = scopes.at(-1);\n  if (top === undefined) {\n    // Unreachable: both stacks are seeded at module load and every push has a matching pop in a\n    // `finally`. Written as a throw rather than a `!` because the package has no non-null assertions.\n    throw new Error(\"cloudflare:workers scope stack is empty\");\n  }\n  return top;\n}\n\n/**\n * ← the `env` proxy (`workers.ts:41-104`). Upstream's comment, which is the whole\n * reason this is a proxy rather than an object: \"Since env is imported as a\n * module-level reference, the object identity cannot be changed. The proxy\n * provides indirection, delegating to different underlying env objects based on\n * async context (see withEnv()). Mutations via this proxy modify the current\n * underlying env object in-place - if you're inside a withEnv() scope, mutations\n * affect the override object, not the base environment.\"\n */\nexport const env: Bindings = new Proxy<Bindings>(\n  {},\n  {\n    get(_target, property): unknown {\n      return Reflect.get(topOf(envScopes), property);\n    },\n    set(_target, property, newValue): boolean {\n      return Reflect.set(topOf(envScopes), property, newValue);\n    },\n    has(_target, property): boolean {\n      return Reflect.has(topOf(envScopes), property);\n    },\n    ownKeys(): ArrayLike<string | symbol> {\n      return Reflect.ownKeys(topOf(envScopes));\n    },\n    deleteProperty(_target, property): boolean {\n      return Reflect.deleteProperty(topOf(envScopes), property);\n    },\n    defineProperty(_target, property, attributes): boolean {\n      return Reflect.defineProperty(topOf(envScopes), property, attributes);\n    },\n    getOwnPropertyDescriptor(_target, property): PropertyDescriptor | undefined {\n      return Reflect.getOwnPropertyDescriptor(topOf(envScopes), property);\n    },\n  },\n);\n\n/**\n * ← the `exports` proxy (`workers.ts:109-147`). Same indirection as `env`, minus\n * the mutating traps — with `set` and `defineProperty` throwing where upstream\n * lets them fall through to the dead proxy target.\n */\nexport const exports: Bindings = new Proxy<Bindings>(\n  {},\n  {\n    get(_target, property): unknown {\n      return Reflect.get(topOf(exportsScopes), property);\n    },\n    set(): never {\n      throw new TypeError(EXPORTS_READ_ONLY_MESSAGE);\n    },\n    defineProperty(): never {\n      throw new TypeError(EXPORTS_READ_ONLY_MESSAGE);\n    },\n    deleteProperty(): never {\n      throw new TypeError(EXPORTS_READ_ONLY_MESSAGE);\n    },\n    has(_target, property): boolean {\n      return Reflect.has(topOf(exportsScopes), property);\n    },\n    ownKeys(): ArrayLike<string | symbol> {\n      return Reflect.ownKeys(topOf(exportsScopes));\n    },\n    getOwnPropertyDescriptor(_target, property): PropertyDescriptor | undefined {\n      return Reflect.getOwnPropertyDescriptor(topOf(exportsScopes), property);\n    },\n  },\n);\n\n/** ← `withEnv` (`workers.ts:21-23`). */\nexport function withEnv(newEnv: unknown, fn: () => unknown): unknown {\n  return runInScopes([{ scopes: envScopes, value: newEnv }], fn);\n}\n\n/** ← `withExports` (`workers.ts:25-27`). */\nexport function withExports(newExports: unknown, fn: () => unknown): unknown {\n  return runInScopes([{ scopes: exportsScopes, value: newExports }], fn);\n}\n\n/** ← `withEnvAndExports` (`workers.ts:29-34`). */\nexport function withEnvAndExports(\n  newEnv: unknown,\n  newExports: unknown,\n  fn: () => unknown,\n): unknown {\n  return runInScopes(\n    [\n      { scopes: envScopes, value: newEnv },\n      { scopes: exportsScopes, value: newExports },\n    ],\n    fn,\n  );\n}\n\nfunction runInScopes(\n  pushes: readonly { readonly scopes: Bindings[]; readonly value: unknown }[],\n  fn: () => unknown,\n): unknown {\n  for (const push of pushes) push.scopes.push(asBindings(push.value));\n  try {\n    const result = fn();\n    if (isThenable(result)) throw new TypeError(WITH_SCOPE_ASYNC_MESSAGE);\n    return result;\n  } finally {\n    for (const push of pushes) push.scopes.pop();\n  }\n}\n\nfunction asBindings(value: unknown): Bindings {\n  if (value !== null && typeof value === \"object\") return value as Bindings;\n  throw new TypeError(\"cloudflare:workers scopes take an object of bindings.\");\n}\n\nfunction isThenable(value: unknown): boolean {\n  if (value === null || (typeof value !== \"object\" && typeof value !== \"function\")) return false;\n  return typeof (value as { then?: unknown }).then === \"function\";\n}\n\n// =======================================================================================\n// The entrypoint classes\n\n/**\n * ← `RpcTarget` (`cloudflare/internal/workers.d.ts`: `export class RpcTarget {}`).\n *\n * Upstream's public type declares it `abstract` with one branding member; the\n * implementation declaration has neither, and this follows the implementation so\n * that a marker instance can exist. See this file's header for the identity\n * constraint capnweb imposes on it.\n */\nexport class RpcTarget {}\n\n/**\n * ← `DurableObject` (`cloudflare/internal/workers.d.ts`; public shape in\n * `@cloudflare/workers-types`).\n *\n * `extends RpcTarget` is this runtime's, not upstream's: workerd's RPC system\n * knows the three entrypoint classes natively through `Rpc.*Branded`, and\n * capnweb recognises only `RpcTarget`. Same observable behaviour — an instance\n * may be passed by reference over RPC — through the mechanism the substrate has.\n *\n * `ctx` and `env` are `protected` because that is what the published types say,\n * and upstream's comment on `WorkerEntrypoint` says why it matters rather than\n * being style: \"`protected` fields don't appear in `keyof`s, so can't be accessed\n * over RPC.\" The extension shim had them public.\n */\nexport class DurableObject<Env = unknown, Props = unknown> extends RpcTarget {\n  protected ctx: DurableObjectState<Props>;\n  protected env: Env;\n\n  constructor(ctx: DurableObjectState<Props>, env: Env) {\n    super();\n    this.ctx = ctx;\n    this.env = env;\n  }\n}\n\n/** ← `WorkerEntrypoint`. */\nexport class WorkerEntrypoint<Env = unknown, Props = unknown> extends RpcTarget {\n  protected ctx: ExecutionContext<Props>;\n  protected env: Env;\n\n  constructor(ctx: ExecutionContext<Props>, env: Env) {\n    super();\n    this.ctx = ctx;\n    this.env = env;\n  }\n}\n\n/**\n * ← `WorkflowEntrypoint`.\n *\n * The extension shim threw from the constructor. That throw is dropped: the class\n * is a plain base whose `run` a Workflows binding dispatches, and there is no\n * Workflows binding here — so the absent thing is the binding, which nothing in\n * this package offers, rather than the base class. Constructing one and never\n * dispatching it is what happens today either way, and a constructor that throws\n * would take down module evaluation for a consumer that merely declares a\n * subclass.\n */\nexport class WorkflowEntrypoint<Env = unknown, T = unknown> extends RpcTarget {\n  protected ctx: ExecutionContext;\n  protected env: Env;\n\n  constructor(ctx: ExecutionContext, env: Env) {\n    super();\n    this.ctx = ctx;\n    this.env = env;\n  }\n\n  run(_event: Readonly<WorkflowEvent<T>>, _step: WorkflowStep): Promise<unknown> {\n    throw new Error(\"WorkflowEntrypoint subclasses must implement run().\");\n  }\n}\n\n// =======================================================================================\n// The RPC stub types — the transport adaptation's, not this layer's\n\n/** ← `RpcStub`. */\nexport class RpcStub {\n  constructor(_server: object) {\n    throw new Error(RPC_STUB_UNIMPLEMENTED_MESSAGE);\n  }\n}\n\n/** ← `RpcPromise`. */\nexport class RpcPromise {\n  constructor() {\n    throw new Error(RPC_STUB_UNIMPLEMENTED_MESSAGE);\n  }\n}\n\n/** ← `RpcProperty`. */\nexport class RpcProperty {\n  constructor() {\n    throw new Error(RPC_STUB_UNIMPLEMENTED_MESSAGE);\n  }\n}\n\n/** ← `ServiceStub`. */\nexport class ServiceStub {\n  constructor() {\n    throw new Error(RPC_STUB_UNIMPLEMENTED_MESSAGE);\n  }\n}\n\n// =======================================================================================\n// The boundary exports\n\n/** ← `export const waitUntil = entrypoints.waitUntil.bind(entrypoints)`. */\nexport function waitUntil(_promise: Promise<unknown>): never {\n  throw new Error(MODULE_WAIT_UNTIL_UNIMPLEMENTED_MESSAGE);\n}\n\n/** ← `abortIsolate` (`workers.ts:206-215`). */\nexport function abortIsolate(_reason?: string): never {\n  throw new Error(ABORT_ISOLATE_UNIMPLEMENTED_MESSAGE);\n}\n\n/**\n * ← the `cache` proxy (`workers.ts:152-198`).\n *\n * Upstream's `cache` answers `undefined` when there is no current context —\n * \"Used to enable safe no-op access outside module init\" — which here would be\n * every access, and `cache.purge(...)` would fail as \"purge is not a function\"\n * three frames from the cause. A throwing proxy names the boundary at the access.\n *\n * The one assertion in this file, in one place: no value can be a `CacheContext`\n * here, and the object that stands in for one exists precisely so that touching it\n * fails. Same shape as `io/worker.ts`'s `asFacetStub`.\n */\nfunction boundaryObject<T extends object>(message: string): T {\n  const thrower = (): never => {\n    throw new Error(message);\n  };\n  return new Proxy(\n    {},\n    { get: thrower, has: thrower, ownKeys: thrower, getOwnPropertyDescriptor: thrower },\n  ) as T;\n}\n\nexport const cache: CacheContext = boundaryObject(CACHE_UNIMPLEMENTED_MESSAGE);\n\n/**\n * ← `export const tracing = innerTracing`.\n *\n * This one is NOT a boundary. The workerd oracle establishes (§1.12) that\n * `tracing` is an\n * object, `startActiveSpan(name, run)` calls `run` and returns its result, and\n * the span it hands over reports `isTraced: false` with working no-op\n * `setAttribute` and `end`. Untraced is workerd's ORDINARY state when nothing is\n * collecting, not an error — so a `Span` here is a permanently untraced one, which\n * is the same observable behaviour through the only mechanism this package has.\n *\n * A throwing proxy was worse than strict, it was wrong: `agents`' tracing runtime\n * feature-detects with `cloudflareWorkers.tracing ?? noopRuntime`, so a present\n * object that throws on use took down every `new Agent(...)` in the extension —\n * where an absent one would have degraded exactly as that code intends.\n */\nclass Span {\n  /** Always false: nothing in this package collects spans, so no span is sampled. */\n  readonly isTraced = false;\n  setAttribute(_name: string, _value: unknown): void {}\n  end(): void {}\n}\n\nexport const tracing: Tracing = {\n  startActiveSpan<T>(_name: string, run: (span: Span) => T): T {\n    return run(new Span());\n  },\n} as unknown as Tracing;\n\n// =======================================================================================\n// The Workflow types\n//\n// `@cloudflare/workers-types` declares `WorkflowSleepDuration`, `WorkflowDurationLabel` and\n// `WorkflowRetentionDuration` globally and the rest of the family only inside the\n// `cloudflare:workers` module, so the rest are declared here — the module that exports them.\n// Ported from that module declaration verbatim; they are types and carry no behaviour.\n\n/**\n * `@cloudflare/workers-types` also declares these two globally, and this module\n * declares its own for the reason upstream's module does: `export type {}` needs\n * a local declaration, and the module is where the names belong.\n */\nexport type WorkflowDurationLabel =\n  | \"second\"\n  | \"minute\"\n  | \"hour\"\n  | \"day\"\n  | \"week\"\n  | \"month\"\n  | \"year\";\n\nexport type WorkflowSleepDuration = `${number} ${WorkflowDurationLabel}${\"s\" | \"\"}` | number;\n\nexport type WorkflowRetentionDuration = WorkflowSleepDuration;\nexport type WorkflowDelayDuration = WorkflowSleepDuration;\nexport type WorkflowTimeoutDuration = WorkflowSleepDuration;\nexport type WorkflowBackoff = \"constant\" | \"linear\" | \"exponential\";\nexport type WorkflowStepSensitivity = \"output\";\n\nexport type WorkflowStepConfig = {\n  retries?: {\n    limit: number;\n    delay: WorkflowDelayDuration | number;\n    backoff?: WorkflowBackoff;\n  };\n  timeout?: WorkflowTimeoutDuration | number;\n  sensitive?: WorkflowStepSensitivity;\n};\n\nexport type WorkflowStepRollbackConfig = Pick<WorkflowStepConfig, \"retries\" | \"timeout\">;\n\nexport type WorkflowCronSchedule = {\n  /** Cron expression that triggered this event. */\n  cron: string;\n  /** Timestamp of the scheduled trigger, in milliseconds since the Unix epoch. */\n  scheduledTime: number;\n};\n\nexport type WorkflowEvent<T> = {\n  payload: Readonly<T>;\n  timestamp: Date;\n  instanceId: string;\n  workflowName: string;\n  schedule?: WorkflowCronSchedule;\n};\n\nexport type WorkflowStepEvent<T> = {\n  payload: Readonly<T>;\n  timestamp: Date;\n  type: string;\n  sensitive?: WorkflowStepSensitivity;\n};\n\nexport type WorkflowStepContext = {\n  step: { name: string; count: number };\n  attempt: number;\n  config: WorkflowStepConfig;\n};\n\nexport type WorkflowRollbackContext<T = unknown> = {\n  ctx: WorkflowStepContext;\n  error: Error;\n  output: T | undefined;\n  /** @deprecated Use `ctx.step.name` and `ctx.step.count` instead. */\n  stepName: string;\n};\n\nexport type WorkflowRollbackHandler<T = unknown> = (\n  ctx: WorkflowRollbackContext<T>,\n) => Promise<void>;\n\nexport type WorkflowStepRollbackOptions<T = unknown> = {\n  rollback: WorkflowRollbackHandler<T>;\n  rollbackConfig?: WorkflowStepRollbackConfig;\n};\n\n/**\n * ← `WorkflowStep`, an abstract class in the module declaration. Declared and\n * never implemented here for the same reason `WorkflowEntrypoint.run` throws: a\n * `WorkflowStep` is handed to `run()` by a Workflows binding, and there is none.\n */\nexport declare abstract class WorkflowStep {\n  do<T>(\n    name: string,\n    callback: (ctx: WorkflowStepContext) => Promise<T>,\n    rollbackOptions?: WorkflowStepRollbackOptions<T>,\n  ): Promise<T>;\n  do<T>(\n    name: string,\n    config: WorkflowStepConfig,\n    callback: (ctx: WorkflowStepContext) => Promise<T>,\n    rollbackOptions?: WorkflowStepRollbackOptions<T>,\n  ): Promise<T>;\n  sleep: (name: string, duration: WorkflowSleepDuration) => Promise<void>;\n  sleepUntil: (name: string, timestamp: Date | number) => Promise<void>;\n  waitForEvent<T>(\n    name: string,\n    options: { type: string; timeout?: WorkflowTimeoutDuration | number },\n  ): Promise<WorkflowStepEvent<T>>;\n}\n\nexport type WorkflowInstanceStatus =\n  | \"queued\"\n  | \"running\"\n  | \"paused\"\n  | \"errored\"\n  | \"terminated\"\n  | \"complete\"\n  | \"waiting\"\n  | \"waitingForPause\"\n  | \"unknown\";\n"],"mappings":"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"}

package/dist/conformance/host.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The conformance harness the suite writes against.
+ *
+ * The workerd lane is the ORACLE, not a third implementation — this package is
+ * deliberately absent from it. So a test has exactly one meaning: "workerd does
+ * X" and "our runtime does X" are the same assertion, executed twice.
+ *
+ * Probe classes are dependency-free (see fixtures/probe.ts), which is why the
+ * workerd lane needs no vendored-source aliases and CI's filtered vendor
+ * install never bites. Anything that would need vendored `think` or `agents`
+ * to express is agent-logic testing and belongs in the extension's integration
+ * lanes instead.
+ */
+export type Capability = 
+/** Deterministic clock. Node lane only — a 30s ladder is not assertable on wall time. */
+"fake-time"
+/** Kill without cleanup: worker.terminate() or dropping the container. */
+ | "real-crash"
+/** Substrate boundary: no Chrome equivalent lifecycle. */
+ | "hibernation"
+/** Substrate boundary: sqlite-wasm lacks the storage capability. */
+ | "bookmarks";
+export type LaneName = "workerd" | "node" | "browser";
+export interface ProbeActor {
+    /** Durable identity. `respawn` reopens this same actor. */
+    readonly name: string;
+    call<T = unknown>(method: string, ...args: readonly unknown[]): Promise<T>;
+    /** Launch without awaiting — the gate rows need two overlapping entries. */
+    post(method: string, ...args: readonly unknown[]): {
+        settled: Promise<unknown>;
+    };
+}
+export interface ConformanceHost {
+    readonly lane: LaneName;
+    readonly capabilities: ReadonlySet<Capability>;
+    spawn(name?: string): Promise<ProbeActor>;
+    /** Same identity, fresh instance. Durable state must survive. */
+    respawn(actor: ProbeActor): Promise<ProbeActor>;
+    /** Only where "real-crash". */
+    crash?(actor: ProbeActor): Promise<void>;
+    /** Only where "fake-time". */
+    time?: {
+        advance(ms: number): Promise<void>;
+    };
+}
+/**
+ * Substrate boundaries are ASSERTED, never skipped.
+ *
+ * Where the capability exists, run `native`. Where it does not, run `absent` —
+ * which asserts the exact named throwing-stub message. Under the fail-closed
+ * tenet the throw IS the specified behaviour for that lane, and asserting it is
+ * what stops the stubs regressing to the silent `[]` no-ops the design record
+ * orders replaced.
+ */
+export declare function substrate(host: ConformanceHost, capability: Capability, branches: {
+    native: () => Promise<void>;
+    absent: () => Promise<void>;
+}): Promise<void>;

package/dist/conformance.js

@@ -0,0 +1,18 @@
+//#region conformance/host.ts
+/**
+* Substrate boundaries are ASSERTED, never skipped.
+*
+* Where the capability exists, run `native`. Where it does not, run `absent` —
+* which asserts the exact named throwing-stub message. Under the fail-closed
+* tenet the throw IS the specified behaviour for that lane, and asserting it is
+* what stops the stubs regressing to the silent `[]` no-ops the design record
+* orders replaced.
+*/
+async function substrate(host, capability, branches) {
+	if (host.capabilities.has(capability)) await branches.native();
+	else await branches.absent();
+}
+//#endregion
+export { substrate };
+
+//# sourceMappingURL=conformance.js.map

package/dist/conformance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conformance.js","names":[],"sources":["../conformance/host.ts"],"sourcesContent":["/**\n * The conformance harness the suite writes against.\n *\n * The workerd lane is the ORACLE, not a third implementation — this package is\n * deliberately absent from it. So a test has exactly one meaning: \"workerd does\n * X\" and \"our runtime does X\" are the same assertion, executed twice.\n *\n * Probe classes are dependency-free (see fixtures/probe.ts), which is why the\n * workerd lane needs no vendored-source aliases and CI's filtered vendor\n * install never bites. Anything that would need vendored `think` or `agents`\n * to express is agent-logic testing and belongs in the extension's integration\n * lanes instead.\n */\n\nexport type Capability =\n  /** Deterministic clock. Node lane only — a 30s ladder is not assertable on wall time. */\n  | \"fake-time\"\n  /** Kill without cleanup: worker.terminate() or dropping the container. */\n  | \"real-crash\"\n  /** Substrate boundary: no Chrome equivalent lifecycle. */\n  | \"hibernation\"\n  /** Substrate boundary: sqlite-wasm lacks the storage capability. */\n  | \"bookmarks\";\n\nexport type LaneName = \"workerd\" | \"node\" | \"browser\";\n\nexport interface ProbeActor {\n  /** Durable identity. `respawn` reopens this same actor. */\n  readonly name: string;\n  call<T = unknown>(method: string, ...args: readonly unknown[]): Promise<T>;\n  /** Launch without awaiting — the gate rows need two overlapping entries. */\n  post(method: string, ...args: readonly unknown[]): { settled: Promise<unknown> };\n}\n\nexport interface ConformanceHost {\n  readonly lane: LaneName;\n  readonly capabilities: ReadonlySet<Capability>;\n  spawn(name?: string): Promise<ProbeActor>;\n  /** Same identity, fresh instance. Durable state must survive. */\n  respawn(actor: ProbeActor): Promise<ProbeActor>;\n  /** Only where \"real-crash\". */\n  crash?(actor: ProbeActor): Promise<void>;\n  /** Only where \"fake-time\". */\n  time?: { advance(ms: number): Promise<void> };\n}\n\n/**\n * Substrate boundaries are ASSERTED, never skipped.\n *\n * Where the capability exists, run `native`. Where it does not, run `absent` —\n * which asserts the exact named throwing-stub message. Under the fail-closed\n * tenet the throw IS the specified behaviour for that lane, and asserting it is\n * what stops the stubs regressing to the silent `[]` no-ops the design record\n * orders replaced.\n */\nexport async function substrate(\n  host: ConformanceHost,\n  capability: Capability,\n  branches: { native: () => Promise<void>; absent: () => Promise<void> },\n): Promise<void> {\n  if (host.capabilities.has(capability)) await branches.native();\n  else await branches.absent();\n}\n"],"mappings":";;;;;;;;;;AAuDA,eAAsB,UACpB,MACA,YACA,UACe;CACf,IAAI,KAAK,aAAa,IAAI,UAAU,GAAG,MAAM,SAAS,OAAO;MACxD,MAAM,SAAS,OAAO;AAC7B"}