@mcp-b/do-runtime 0.5.0 → 0.6.1

package/dist/index.js

@@ -1,536 +1,9 @@
-import { a as hasUserErrorDetail, c as setUserErrorDetail, d as tryCurrentSlice, f as CanceledError, i as captureGateStack, m as OutputGate, n as IoContext, o as isExceptionFromInputGateBroken, p as InputGate, r as atCheckpointEnd, s as requireInputLock, t as BrokenActorError, u as tryCurrentIoContext } from "./chunks/io-context-RmmjNtwm.js";
+import { a as hasUserErrorDetail, d as tryCurrentSlice, f as CanceledError, i as captureGateStack, m as OutputGate, n as IoContext, o as isExceptionFromInputGateBroken, p as InputGate, r as atCheckpointEnd, s as requireInputLock, t as BrokenActorError, u as tryCurrentIoContext } from "./chunks/io-context-BBgKEsdR.js";
+import { _ as DurableObjectClass, a as installWebSocketGlobals, c as DurableObjectStorage, d as LoopbackColoLocalActorNamespace, f as LoopbackDurableObjectClass, g as ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE, h as asLoopbackDurableObjectClass, i as acceptWebSocket, l as FACET_NAME_MAX_LENGTH, m as LoopbackServiceStub, n as HibernatableWebSocketRegistry, o as markWebSocketUsed, p as LoopbackDurableObjectNamespace, r as RuntimeWebSocketRequestResponsePair, s as DurableObjectState, t as ALREADY_ACCEPTED_MESSAGE, u as FACET_TREE_MAX_DEPTH, v as DurableObjectId, y as DurableObjectNamespace } from "./chunks/web-socket-W63BdFn5.js";
 import { RpcTarget as RpcTarget$1 } from "./cloudflare-workers.js";
 import { a as SqliteDatabase, c as getText, l as hasCurrentSqliteTable, o as getBlob, s as getInt64, t as ensureRuntimeStorageVersion, u as isNull } from "./chunks/sqlite-migrations-DsWmLP_B.js";
 import { ALARM_RETRY_MAX_TRIES, ALARM_RETRY_START_SECONDS, AlarmScheduler, RETRY_BACKOFF_MAX, RETRY_JITTER_FACTOR, alarmRetryDelayMs } from "./server/alarm-scheduler.js";
-import { deserialize, serialize } from "@ungap/structured-clone";
 import { RpcTarget, newMessagePortRpcSession } from "capnweb";
-//#region src/api/actor.ts
-/**
-* ← the `[1, 2048]` bound in `ColoLocalActorNamespace::get`.
-*
-* Upstream compares `actorId.size()`, which for a `kj::String` is **bytes**, so
-* this is measured in UTF-8 bytes rather than in UTF-16 code units. That costs
-* one `TextEncoder` pass and buys an exact match on a bound a caller can hit.
-*/
-var MAX_COLO_LOCAL_ACTOR_ID_BYTES = 2048;
-/**
-* Upstream never faces this: JSG unwraps a `jsg::Ref<DurableObjectId>` parameter
-* and throws a `TypeError` before the method body runs, so `getInner()` cannot be
-* reached on something that is not one. Here the parameter type is
-* workers-types' structural `DurableObjectId` interface, which any object with a
-* `toString` and an `equals` satisfies — so the unwrap has to be written, and it
-* fails closed rather than guessing at the string form.
-*/
-var FOREIGN_ACTOR_ID_MESSAGE$1 = "This DurableObjectId was not created by this runtime, so its underlying actor id cannot be read. Ids must come from newUniqueId(), idFromName() or idFromString() on a DurableObjectNamespace.";
-/** Substrate boundary: `jsg::Serializer`, `Frankenvalue` and channel tokens have no port. */
-var ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE = "DurableObjectClass cannot be serialized in this runtime: upstream writes a channel token through jsg::Serializer and Frankenvalue, and neither the token nor the serializer has an equivalent here.";
-/**
-* Replication is a named substrate boundary (`io/actor-cache.ts`), so no request
-* this file builds asks for replica routing. Upstream reads
-* `FeatureFlags::get(js).getReplicaRouting()` here.
-*/
-var ENABLE_REPLICA_ROUTING = false;
-/**
-* ← `ColoLocalActorNamespace` (`actor.h:25-37`). "A capability to an ephemeral
-* Actor namespace."
-*/
-var ColoLocalActorNamespace = class {
-	#channel;
-	constructor(channel) {
-		this.#channel = channel;
-	}
-	/** ← `ColoLocalActorNamespace::get` (`actor.c++:116-129`). */
-	get(actorId) {
-		const bytes = utf8Length(actorId);
-		if (!(bytes > 0 && bytes <= 2048)) throw new TypeError(`Actor ID length must be in the range [1, ${MAX_COLO_LOCAL_ACTOR_ID_BYTES}].`);
-		return this.#channel.getColoLocalActor({ actorId });
-	}
-};
-var textEncoder$1 = new TextEncoder();
-/** `kj::String::size()` is bytes; `String.prototype.length` is UTF-16 code units. */
-function utf8Length(value) {
-	return textEncoder$1.encode(value).length;
-}
-/**
-* ← `DurableObjectId` (`actor.h:42-84`). "DurableObjectId type seen by
-* JavaScript."
-*
-* `name` and `jurisdiction` are read from the inner id **once, at construction**,
-* where upstream's are `JSG_READONLY_INSTANCE_PROPERTY`s that re-read it on every
-* access. That is not a preference: `@cloudflare/workers-types` declares both
-* `readonly name?: string`, and under `exactOptionalPropertyTypes` a getter
-* returning `string | undefined` does not satisfy an optional `string`. An own
-* property assigned only when the value exists does, and it is what keeps this
-* class assignable to the interface with no cast (§2.4). The one behaviour lost
-* is `ActorIdImpl::clearName()` (`server/actor-id-impl.h`) taking effect on an
-* already-wrapped id — a `server/`-internal that runs before the id reaches JS.
-*/
-var DurableObjectId = class {
-	#id;
-	name;
-	jurisdiction;
-	constructor(id) {
-		this.#id = id;
-		const name = id.getName();
-		if (name !== void 0) this.name = name;
-		const jurisdiction = id.getJurisdiction();
-		if (jurisdiction !== void 0) this.jurisdiction = jurisdiction;
-	}
-	/** ← `getInner()`. Not JS-visible upstream either; the outgoing factories take it. */
-	getInner() {
-		return this.#id;
-	}
-	/** "Converts to a string which can be passed back to the constructor to reproduce the same ID." */
-	toString() {
-		return this.#id.toString();
-	}
-	equals(other) {
-		return this.#id.equals(innerIdOf(other));
-	}
-};
-/** The unwrap JSG performs for a `jsg::Ref<DurableObjectId>` parameter. */
-function requireDurableObjectId(id) {
-	if (id instanceof DurableObjectId) return id;
-	throw new TypeError(FOREIGN_ACTOR_ID_MESSAGE$1);
-}
-function innerIdOf(id) {
-	return requireDurableObjectId(id).getInner();
-}
-/**
-* ← `DurableObject` (`actor.h:87-139`). "Stub object used to send messages to a
-* remote durable object."
-*
-* Upstream's carries its whole behaviour by `JSG_INHERIT(Fetcher)` and adds
-* exactly two readonly properties. So does this: the `Fetcher` is the transport's
-* and everything except `id` and `name` belongs to it. `asDurableObjectStub`
-* below is where the inheritance goes.
-*/
-var DurableObject = class {
-	#id;
-	#fetcher;
-	constructor(id, fetcher) {
-		this.#id = id;
-		this.#fetcher = fetcher;
-	}
-	/** ← `JSG_READONLY_INSTANCE_PROPERTY(id, getId)`. */
-	getId() {
-		return this.#id;
-	}
-	/** ← `JSG_READONLY_INSTANCE_PROPERTY(name, getName)`. */
-	getName() {
-		return this.#id.name;
-	}
-	/** The `Fetcher` upstream inherits from rather than holds. */
-	getFetcher() {
-		return this.#fetcher;
-	}
-};
-/**
-* ← `js.alloc<DurableObject>(...)` plus `JSG_INHERIT(Fetcher)` plus the
-* `JSG_TS_OVERRIDE` that renames the resource type to `DurableObjectStub`.
-*
-* The named assertion is the same one `io/worker.ts`'s `asFacetStub` makes and
-* for the same reason: `DurableObjectStub<T>` is `Fetcher<T, …> & { id, name }`,
-* and `Fetcher<T>` for an unresolved `T` is `Rpc.Provider<T, …>`, a conditional
-* type TypeScript defers until `T` is known — where `T` is the caller's claim
-* about a class it named, which no value can confirm. Upstream is in the same
-* position and answers it the same way, with the parameter living only inside a
-* `JSG_TS_OVERRIDE`.
-*
-* The `Proxy` is what JSG inheritance costs in JS. Two properties have to answer
-* from the id and every other property — `fetch`, `connect`, and every RPC method
-* name, which are the whole point of a stub — has to reach the transport with
-* `this` still bound to it. Bound methods are memoised so `stub.foo === stub.foo`,
-* which upstream gets for free by there being one object rather than two.
-*/
-function asDurableObjectStub(object) {
-	const fetcher = object.getFetcher();
-	const bound = /* @__PURE__ */ new Map();
-	return new Proxy(fetcher, {
-		get(target, property) {
-			if (property === "id") return object.getId();
-			if (property === "name") return object.getName();
-			const cached = bound.get(property);
-			if (cached !== void 0) return cached;
-			const value = Reflect.get(target, property, target);
-			if (typeof value !== "function") return value;
-			const method = value.bind(target);
-			bound.set(property, method);
-			return method;
-		},
-		has(target, property) {
-			if (property === "id" || property === "name") return true;
-			return Reflect.has(target, property);
-		},
-		ownKeys(target) {
-			return [
-				"id",
-				"name",
-				...Reflect.ownKeys(target).filter((key) => key !== "id" && key !== "name")
-			];
-		},
-		getOwnPropertyDescriptor(target, property) {
-			if (property === "id" || property === "name") return {
-				value: property === "id" ? object.getId() : object.getName(),
-				writable: false,
-				enumerable: true,
-				configurable: true
-			};
-			return Reflect.getOwnPropertyDescriptor(target, property);
-		}
-	});
-}
-/**
-* ← `DurableObjectNamespace` (`actor.h:142-291`). "Global durable object class
-* binding type."
-*/
-var DurableObjectNamespace = class DurableObjectNamespace {
-	#channel;
-	#idFactory;
-	constructor(channel, idFactory) {
-		this.#channel = channel;
-		this.#idFactory = idFactory;
-	}
-	/**
-	* "Create a new unique ID for a durable object that will be allocated nearby
-	* the calling colo."
-	*/
-	newUniqueId(options) {
-		return new DurableObjectId(this.#idFactory.newUniqueId(options?.jurisdiction ?? void 0));
-	}
-	/**
-	* "Create a name-derived ID. Passing in the same `name` (to the same class)
-	* will always produce the same ID."
-	*/
-	idFromName(name) {
-		return new DurableObjectId(this.#idFactory.idFromName(name));
-	}
-	/**
-	* "Create a DurableObjectId from the stringified form of the ID (as produced by
-	* calling `toString()` on a durable object ID). Throws if the ID is not a
-	* 64-digit hex number, or if the ID was not originally created for this class."
-	*/
-	idFromString(id) {
-		return new DurableObjectId(this.#idFactory.idFromString(id));
-	}
-	/** "Gets a durable object by ID or creates it if it doesn't already exist." */
-	get(id, options) {
-		return this.#getImpl("GET_OR_CREATE", id, options);
-	}
-	/**
-	* "Gets a durable object by name or creates it if it doesn't already exist.
-	* Short for `idFromName()` followed by `get()`."
-	*/
-	getByName(name, options) {
-		return this.#getImpl("GET_OR_CREATE", this.idFromName(name), options);
-	}
-	/**
-	* "Experimental. Gets a durable object by ID if it already exists. Currently,
-	* gated for use by cloudflare only."
-	*
-	* Upstream exposes it only when the `durableObjectGetExisting` compat flag is
-	* on, and `@cloudflare/workers-types` 4.20260702.1 does not declare it. It is
-	* exposed unconditionally here, which is the current-behaviour reading every
-	* other compat flag in this file gets.
-	*/
-	getExisting(id, options) {
-		return this.#getImpl("GET_EXISTING", id, options);
-	}
-	/**
-	* "Creates a subnamespace with the jurisdiction hardcoded."
-	*
-	* The argument is optional because upstream's is a
-	* `jsg::Optional<kj::Maybe<kj::String>>`, so both "omitted" and "null" mean the
-	* same thing — `cloneWithJurisdiction(kj::none)`, a subnamespace with none.
-	*/
-	jurisdiction(jurisdiction) {
-		return new DurableObjectNamespace(this.#channel, this.#idFactory.cloneWithJurisdiction(jurisdiction ?? void 0));
-	}
-	/** ← `DurableObjectNamespace::getImpl` (`actor.c++:167-213`). */
-	#getImpl(mode, id, options) {
-		const durableObjectId = requireDurableObjectId(id);
-		const inner = durableObjectId.getInner();
-		if (!this.#idFactory.matchesJurisdiction(inner)) throw new TypeError("get called on jurisdictional subnamespace with an ID from a different jurisdiction");
-		let routingMode = "DEFAULT";
-		const requestedRoutingMode = options?.routingMode;
-		if (requestedRoutingMode !== void 0) {
-			if (requestedRoutingMode !== "primary-only") throw new RangeError(`unknown routingMode: ${requestedRoutingMode}`);
-			routingMode = "PRIMARY_ONLY";
-		}
-		return asDurableObjectStub(new DurableObject(durableObjectId, this.#channel.getGlobalActor({
-			id: inner,
-			locationHint: options?.locationHint,
-			mode,
-			enableReplicaRouting: ENABLE_REPLICA_ROUTING,
-			routingMode,
-			version: actorVersionOf(options?.version)
-		})));
-	}
-};
-/**
-* ← `version = ActorVersion{.cohort = kj::mv(v.cohort)}` (`actor.c++:186-190`),
-* behind `FeatureFlags::get(js).getEnableVersionApi()` which this file reads as
-* on. A version with no cohort is still a version, which is why the empty object
-* is not collapsed to `undefined`.
-*/
-function actorVersionOf(version) {
-	if (version === void 0) return void 0;
-	return version.cohort === void 0 ? {} : { cohort: version.cohort };
-}
-/**
-* ← `DurableObjectClass` (`actor.h:367-393`). "DurableObjectClass represents a
-* binding to a Durable Object class that can be used as a facet. The only use of
-* this type is to pass to `ctx.facets.get()`."
-*
-* `getChannel()` takes no `IoContext` because the parameter existed to resolve the
-* numbered-channel arm, and there is no numbered-channel arm here.
-*/
-var DurableObjectClass = class {
-	#channel;
-	constructor(channel) {
-		this.#channel = channel;
-	}
-	/** ← `DurableObjectClass::getChannel` (`actor.c++:232-242`). */
-	getChannel() {
-		return this.#channel;
-	}
-	/**
-	* ← `DurableObjectClass::serialize` (`actor.c++:244-306`). Substrate boundary.
-	*
-	* `requireAllowsTransfer()` runs first, exactly as upstream's does, so a class
-	* that refuses transfer reports that rather than the boundary — the refusal is
-	* the more specific answer and it is the one upstream would give too.
-	*/
-	serialize() {
-		this.#channel.requireAllowsTransfer();
-		throw new Error(ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE);
-	}
-	/** ← `DurableObjectClass::deserialize` (`actor.c++:308-359`). Substrate boundary. */
-	static deserialize() {
-		throw new Error(ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE);
-	}
-};
-//#endregion
-//#region src/api/export-loopback.ts
-/**
-* ← what JSG's struct unwrapper does with a value that is not an object
-* (`jsg/struct.h:246`). Undefined and null are **not** in that set: a struct
-* whose every field is optional — which both option structs here are — unwraps
-* from either as an empty struct (`jsg/struct.h:236-243`), so `ctx.exports.Foo()`
-* is upstream's own empty-options call and not an error.
-*/
-var LOOPBACK_OPTIONS_NOT_AN_OBJECT_MESSAGE = "A ctx.exports binding is invoked with an options object: pass { props }, or nothing at all.";
-/** ← what JSG does unwrapping a `jsg::JsRef<jsg::JsObject>` from a non-object. */
-var LOOPBACK_PROPS_NOT_AN_OBJECT_MESSAGE = "`props` must be an object. Upstream unwraps it as a jsg::JsObject, which refuses anything else.";
-/**
-* ← `LoopbackServiceStub` (`export-loopback.h:18-109`).
-*
-* Upstream is a `Fetcher` on the loopback channel and holds the channel number a
-* second time so `callImpl` can re-specialize it. Here the `Fetcher` is the
-* transport's — `api/http.{h,c++}` is not ported — so the unspecialized stub is
-* what the factory returns for a request with no props and no version, and the
-* factory is the thing held twice over.
-*/
-var LoopbackServiceStub = class {
-	#channel;
-	#fetcher;
-	constructor(channel) {
-		this.#channel = channel;
-		this.#fetcher = channel.getSubrequestChannel({
-			props: void 0,
-			version: void 0
-		});
-	}
-	/** The `Fetcher` upstream inherits from rather than holds, as `DurableObject`'s is. */
-	getFetcher() {
-		return this.#fetcher;
-	}
-	/**
-	* ← `LoopbackServiceStub::callImpl` (`export-loopback.c++:11-29`) reached
-	* through `callWithVersion` (`export-loopback.h:53-55`), which is the callable
-	* when `enableVersionApi` is on. "Create a specialized Fetcher which can be
-	* passed over RPC."
-	*/
-	callWithVersion(options) {
-		return this.#channel.getSubrequestChannel({
-			props: requireProps(options.props),
-			version: versionRequestOf(options.version)
-		});
-	}
-};
-/**
-* ← `LoopbackDurableObjectClass` (`export-loopback.h:116-148`). "Similar to
-* LoopbackServiceStub, but for actor classes … this is used for actor classes
-* that do *not* have any storage configured. If you simply export a class
-* extending `DurableObject` but you don't configure storage for it, it shows up
-* in `ctx.exports` as this type. This can be used to create a Durable Object
-* facet."
-*
-* Upstream's base `DurableObjectClass` holds the channel *number*, and
-* `getChannel(ioctx)` resolves it lazily. There is no numbered arm here, so the
-* unspecialized channel is requested once, in the constructor — which is the same
-* value `getActorClass(channel)` with default props would have produced.
-*/
-var LoopbackDurableObjectClass = class extends DurableObjectClass {
-	#channel;
-	constructor(channel) {
-		super(channel.getActorClass({ props: void 0 }));
-		this.#channel = channel;
-	}
-	/**
-	* ← `LoopbackDurableObjectClass::call` (`export-loopback.c++:31-40`). "Create a
-	* specialized DurableObjectClass which can be passed over RPC."
-	*
-	* The result is a plain `DurableObjectClass`, as `js.alloc<DurableObjectClass>`
-	* is: specializing a loopback class does not produce another loopback class.
-	*/
-	call(options) {
-		return new DurableObjectClass(this.#channel.getActorClass({ props: requireProps(options.props) }));
-	}
-};
-function asLoopbackDurableObjectClass(actorClass) {
-	return asCallable({
-		properties: actorClass,
-		prototype: Object.getPrototypeOf(actorClass),
-		call: (options) => actorClass.call(requireOptions(options))
-	});
-}
-/**
-* ← `LoopbackDurableObjectNamespace` (`export-loopback.h:155-189`).
-*
-* Upstream: "used when the class has storage configured. In this case, we want a
-* binding that behaves *both* like a LoopbackDurableObjectClass *and* like a
-* DurableObjectNamespace binding. Easy enough, we'll inherit
-* DurableObjectNamespace, but also make the binding invokable as a function like
-* LoopbackDurableObjectClass."
-*/
-var LoopbackDurableObjectNamespace = class extends DurableObjectNamespace {
-	#loopbackClass;
-	constructor(channel, idFactory, loopbackClass) {
-		super(channel, idFactory);
-		this.#loopbackClass = loopbackClass;
-	}
-	/** ← `getClass()`. "getClass() accessor for use from C++ only." */
-	getClass() {
-		return this.#loopbackClass;
-	}
-	/** ← `call`. "Invoking the binding creates a specialization of the class -- not the namespace." */
-	call(options) {
-		return this.#loopbackClass.call(options);
-	}
-};
-/**
-* ← `LoopbackColoLocalActorNamespace` (`export-loopback.h:192-220`). "Like
-* LoopbackDurableObjectNamespace, but for colo-local (ephemeral) actor
-* namespaces."
-*/
-var LoopbackColoLocalActorNamespace = class extends ColoLocalActorNamespace {
-	#loopbackClass;
-	constructor(channel, loopbackClass) {
-		super(channel);
-		this.#loopbackClass = loopbackClass;
-	}
-	/** ← `getClass()`. "getClass() accessor for use from C++ only." */
-	getClass() {
-		return this.#loopbackClass;
-	}
-	/** ← `call`. "Invoking the binding creates a specialization of the class -- not the namespace." */
-	call(options) {
-		return this.#loopbackClass.call(options);
-	}
-};
-/**
-* ← `JSG_CALLABLE`, which makes a JSG resource object invocable while leaving
-* every other property answering from the resource type.
-*
-* `properties` is where reads land, with `this` bound to it so a method reaching
-* a private field still finds one — the same binding, memoised the same way,
-* that `asDurableObjectStub` performs for `JSG_INHERIT`. `prototype` is what
-* `instanceof` sees, and it is separate from `properties` because
-* `LoopbackServiceStub` is one object with two halves: upstream's identity is the
-* resource type while its behaviour is the inherited `Fetcher`'s.
-*
-* The target is an arrow function rather than a plain one because a plain
-* function has a non-configurable own `prototype` property, which a Proxy may not
-* hide from `ownKeys`.
-*
-* This is the one assertion the four producers above need, made once here. It is
-* `asDurableObjectStub`'s, for `asDurableObjectStub`'s reason: the declared value
-* is a `Fetcher<T>` or a `DurableObjectClass<T>` intersected with a call
-* signature, and `T` is the caller's claim about a class it named, which no value
-* can confirm. Upstream states the same shapes the same way, in a
-* `JSG_TS_OVERRIDE` that no C++ value is checked against either.
-*/
-var INVOCATION_METHODS = /* @__PURE__ */ new Set([
-	"call",
-	"apply",
-	"bind"
-]);
-function asCallable(facade) {
-	const bound = /* @__PURE__ */ new Map();
-	const target = () => {
-		throw new Error("unreachable: the apply trap answers every invocation");
-	};
-	return new Proxy(target, {
-		apply(_target, _thisArg, args) {
-			return facade.call(args[0]);
-		},
-		get(target, property, receiver) {
-			if (INVOCATION_METHODS.has(property)) return Reflect.get(target, property, receiver);
-			const cached = bound.get(property);
-			if (cached !== void 0) return cached;
-			const value = Reflect.get(facade.properties, property, facade.properties);
-			if (typeof value !== "function") return value;
-			const method = value.bind(facade.properties);
-			bound.set(property, method);
-			return method;
-		},
-		has(_target, property) {
-			return Reflect.has(facade.properties, property);
-		},
-		ownKeys() {
-			return Reflect.ownKeys(facade.properties);
-		},
-		getOwnPropertyDescriptor(_target, property) {
-			const descriptor = Reflect.getOwnPropertyDescriptor(facade.properties, property);
-			if (descriptor === void 0) return void 0;
-			return {
-				...descriptor,
-				configurable: true
-			};
-		},
-		getPrototypeOf() {
-			return facade.prototype;
-		}
-	});
-}
-/**
-* ← JSG's struct unwrapper (`jsg/struct.h:236-246`), for the two option structs
-* here: every field of both is optional, so undefined and null yield an empty
-* struct and anything that is not an object is a `TypeError`. V8's `IsObject()`
-* is true for functions, which is why one is not refused here either.
-*
-* `cohort` is not checked, because upstream does not check it: JSG's `kj::String`
-* unwrapper calls `ToString` on whatever it is given (`jsg/value.h:501-506`), so
-* refusing a non-string here would refuse what workerd coerces. That is the same
-* reading `api/actor.ts`'s `actorVersionOf` already takes of the same field.
-*/
-function requireOptions(options) {
-	if (options !== void 0 && options !== null && typeof options !== "object" && typeof options !== "function") throw new TypeError(LOOPBACK_OPTIONS_NOT_AN_OBJECT_MESSAGE);
-	return options ?? {};
-}
-/** ← `jsg::Optional<jsg::JsRef<jsg::JsObject>> props` — present means an object. */
-function requireProps(props) {
-	if (props === void 0) return void 0;
-	if (props === null || typeof props !== "object" && typeof props !== "function") throw new TypeError(LOOPBACK_PROPS_NOT_AN_OBJECT_MESSAGE);
-	return props;
-}
-/** ← `.cohort = kj::mv(version.cohort).orDefault(kj::none)` (`export-loopback.c++:19-23`). */
-function versionRequestOf(version) {
-	if (version === void 0) return void 0;
-	return { cohort: version.cohort ?? void 0 };
-}
-//#endregion
 //#region src/api/worker-loader.ts
 /** ← `JSG_REQUIRE(code.modules.fields.size() > 0, …)` (`worker-loader.c++:175-176`). */
 var NO_MODULES_MESSAGE = "Dynamic Worker code must contain at least one module.";
@@ -851,7 +324,7 @@ function objectModuleContentOf(name, module) {
 	};
 	if (module.data !== void 0) return {
 		type: "dataModule",
-		body: copyBytes$1(module.data)
+		body: copyBytes(module.data)
 	};
 	if (module.json !== void 0) return {
 		type: "jsonModule",
@@ -863,1642 +336,112 @@ function objectModuleContentOf(name, module) {
 	};
 	if (module.wasm !== void 0) return {
 		type: "wasmModule",
-		body: copyBytes$1(module.wasm)
-	};
-	throw new Error("unreachable: exactly one module field is set");
-}
-/**
-* ← `jsg::asBytes()` followed by `kj::heapArray<const kj::byte>(data.asPtr())`
-* (`worker-loader.c++:231`, `:244`). The copy is the whole point — see the caller.
-*/
-function copyBytes$1(value) {
-	if (value instanceof ArrayBuffer) return new Uint8Array(value.slice(0));
-	if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
-	throw new TypeError(NOT_BYTES_MESSAGE);
-}
-/**
-* ← `Fetcher::getSubrequestChannel(ioctx)` followed by
-* `channel->requireAllowsTransfer()` (`worker-loader.c++:125-126`, `:144-145`,
-* `:157-158`).
-*
-* **The check has nothing to call, and that is a recorded divergence rather than
-* an omission.** Upstream's `SubrequestChannel` carries `requireAllowsTransfer()`;
-* here a `SubrequestChannel` and the `Fetcher` built over it are one object
-* (`io/io-channels.ts`'s header, and the same collapse `api/actor.ts` and
-* `api/export-loopback.ts` already made), and a `Fetcher` is
-* `@cloudflare/workers-types`' interface with no such member. The one refusal it
-* produces in the open-source runtime is `throwDynamicEntrypointTransferError`
-* (`server.c++:167-173`), raised by `WorkerService::requireAllowsTransfer` when
-* `isDynamic` — an isolate-host fact here, exactly as it is a `server/` fact there.
-*
-* Kept as a named function rather than inlined so the three call sites read as
-* upstream's do, and so there is one place to put the check if a `Fetcher` seam
-* ever grows one.
-*/
-function requireTransferableChannel(fetcher) {
-	return fetcher;
-}
-/**
-* ← `Frankenvalue::fromJs(js, …)`, whose serializer refuses any object whose JSG
-* resource type declares no `JSG_SERIALIZABLE` (`jsg/ser.c++:175-183`).
-*
-* Four types reachable from this package are in that set, and all four for one
-* reason: `JSG_INHERIT` does not carry serializability. Upstream says so twice — in
-* `export-loopback.h:57-58` ("Note that `LoopbackServiceStub` is intentionally NOT
-* serializable, unlike its parent class Fetcher") and in the test that pins it,
-* whose comment reads "it's more testing LoopbackServiceStub and that
-* serializability is not inherited" (`worker-loader-test.js:91-92`). None of
-* `LoopbackServiceStub`, `LoopbackDurableObjectClass`,
-* `LoopbackDurableObjectNamespace` or `LoopbackColoLocalActorNamespace` declares
-* `JSG_SERIALIZABLE`; every one of them *invoked* produces something that does — a
-* `Fetcher` or a plain `DurableObjectClass` — which is exactly the distinction
-* `worker-loader-test.js:62-107` measures, accepting the invoked form in `props`
-* and refusing the bare binding.
-*
-* **This discharges the obligation the README left open on Section 7.** That row
-* says the refusal would have to come from `src/transport/` if a `Fetcher` ever
-* became serializable; the layer upstream refuses at is this one, because
-* `Frankenvalue::fromJs` runs inside `getEntrypoint`, `getDurableObjectClass` and
-* `toDynamicWorkerSource`. Putting it here makes it reachable today rather than
-* conditional on a transport change that has not happened, and it depends on no
-* transport fact — so `api/` still imports no transport library.
-*
-* The walk descends into plain objects and arrays only. Everything else is a host
-* object: either one the substrate knows how to carry (a `Fetcher`, a
-* `DurableObjectClass`, an `RpcTarget`) or one of the four above. Walking a host
-* object's own keys would drive proxy traps — a stub's `get` mints an RPC import —
-* which is a cost upstream's serializer never pays, because it asks the type rather
-* than the value.
-*/
-function requireSerializableProps(root, field) {
-	const seen = /* @__PURE__ */ new Set();
-	const visit = (value, path) => {
-		if (value === null || typeof value !== "object" && typeof value !== "function") return;
-		const subject = value;
-		const refused = notSerializableType(subject);
-		if (refused !== void 0) throw new DOMException(`${notSerializableMessage(refused)} At ${path}.`, "DataCloneError");
-		if (seen.has(subject)) return;
-		seen.add(subject);
-		if (Array.isArray(subject)) {
-			subject.forEach((entry, index) => {
-				visit(entry, `${path}[${index}]`);
-			});
-			return;
-		}
-		const prototype = Object.getPrototypeOf(subject);
-		if (prototype !== Object.prototype && prototype !== null) return;
-		for (const [name, entry] of Object.entries(subject)) visit(entry, `${path}.${name}`);
+		body: copyBytes(module.wasm)
 	};
-	visit(root, `<${field}>`);
-	return root;
-}
-/**
-* The four `ctx.exports` binding types, named by the class whose name
-* `GetConstructorName()` would report.
-*
-* The four are mutually exclusive — each extends a different base
-* (`api/export-loopback.ts`) — so the order is presentational. What the order does
-* NOT do is reach a base class: `DurableObjectClass`, `DurableObjectNamespace`,
-* `ColoLocalActorNamespace` and `Fetcher` are all serializable upstream
-* (`actor.h:389`), and it is exactly `JSG_INHERIT`'s failure to carry
-* serializability that makes the four subclasses refuse where their bases accept.
-*/
-function notSerializableType(value) {
-	if (value instanceof LoopbackServiceStub) return "LoopbackServiceStub";
-	if (value instanceof LoopbackDurableObjectNamespace) return "LoopbackDurableObjectNamespace";
-	if (value instanceof LoopbackColoLocalActorNamespace) return "LoopbackColoLocalActorNamespace";
-	if (value instanceof LoopbackDurableObjectClass) return "LoopbackDurableObjectClass";
-}
-//#endregion
-//#region src/api/sql.ts
-/**
-* ← workerd `src/workerd/api/sql.{h,c++}`
-*
-* `SqlStorage` and its two nested types. ~330 call sites depend on this — it is
-* the real storage layer, not KV.
-*
-* Four things about the translation, in descending order of how much they cost:
-*
-*  1. **The cursor is materialised, not live.** Upstream's `Cursor` owns a
-*     running `SqliteDatabase::Query` and pulls one row at a time; the backend
-*     seam this package chose (`SqlDatabase.exec` → `SqlResult`) has already
-*     collected every row before a cursor exists. Everything downstream of that
-*     follows: there is no statement cache, so `CachedStatement`, the 1 MiB LRU
-*     and `reusedCachedQueryForTest` are absent with it; there is no live
-*     statement to cancel, so `Cursor::canceled` and `selfRef` — both already
-*     dead upstream, written but never assigned — have nothing to guard; and
-*     `endQuery`'s job of returning a statement to the cache is nothing here, so
-*     the counters it saves off are simply the counters. What is kept is every
-*     observable: the position is shared across `next`/`toArray`/`one`/`raw`,
-*     and a drained cursor keeps yielding done.
-*  2. **`Cursor` and `Statement` must be constructible with no arguments**, or
-*     `SqlStorage` cannot satisfy workers-types without a cast: the interface
-*     types them `typeof SqlStorageCursor` / `typeof SqlStorageStatement`, and
-*     both are `abstract` there, so their construct signatures take none.
-*     Upstream's are unconstructible from JS for the same reason they are
-*     `abstract` in the types — JSG nested types have no JS constructor — so the
-*     faithful shape is a constructor that refuses. `sql.Cursor` exists for
-*     `instanceof`, which is all upstream exposes it for.
-*  3. **The regulator is ported whole, and that is not the whole authorizer.**
-*     Four of its five members are here as callbacks, and none needed the
-*     authorizer to compute anything — `isAllowedName` is a prefix test,
-*     `isAllowedTrigger` is `return true`, `allowTransactions` throws,
-*     `shouldAddQueryStats` is a constant. The fifth, `onError`, is not a
-*     callback at all in this port: it is every `throw new Error(message)`
-*     below, which is all its upstream body does with a refusal message.
-*     For those, what the authorizer supplied was the *identifiers*:
-*     with none, the statement text is the only source, so `exec` tokenizes it
-*     and runs `isAllowedName` over every identifier-shaped token. That is
-*     deliberately STRICTER than upstream — see `SQL_RESERVED_PREFIX_MESSAGE`.
-*
-*     But the authorizer also makes decisions no callback ever sees, and those
-*     do NOT arrive with the regulator: `SQLITE_ATTACH` / `SQLITE_DETACH`, the
-*     `SQLITE_CREATE_TEMP_*` family and the `temp` schema, `SQLITE_PRAGMA`, and
-*     the `SQLITE_CREATE_VTABLE` module list. Each is refused from the text in
-*     `refuseUnauthorizedForms` and `requireAllowedPragmas`. `SQLITE_FUNCTION`
-*     is the one still unported — see the README divergence row.
-*  4. **`ingest` stays at upstream's SQLite seam.** `SqliteDatabase.ingest()`
-*     executes every complete statement and returns the partial tail, using the
-*     same compiled boundaries and regulator as `exec`.
-*
-* Spec: §1.4, §2.4 in docs/decisions.md.
-*/
-/**
-* ← `SqlStorageRegulator::allowTransactions()`, copied verbatim. Users match on
-* it and it is the one regulator callback our substrate can still answer.
-*/
-var SQL_TRANSACTION_REFUSED_MESSAGE = "To execute a transaction, please use the state.storage.transaction() or state.storage.transactionSync() APIs instead of the SQL BEGIN TRANSACTION or SAVEPOINT statements. The JavaScript API is safer because it will automatically roll back on exceptions, and because it interacts correctly with Durable Objects' automatic atomic write coalescing.";
-/** See translation 2 in the header: the class is exposed for `instanceof` only. */
-var CURSOR_NOT_CONSTRUCTIBLE_MESSAGE = "Illegal invocation: SqlStorage.Cursor cannot be constructed directly. Use sql.exec().";
-/** Same, for the prepared-statement compatibility shim. */
-var STATEMENT_NOT_CONSTRUCTIBLE_MESSAGE = "Illegal invocation: SqlStorage.Statement cannot be constructed directly. Use sql.prepare().";
-/**
-* ← SQLite's own denial text, with the reason appended.
-*
-* There is no upstream string to copy here: `SqlStorageRegulator::onError` just
-* rethrows whatever SQLite produced, and SQLite produces `not authorized` for an
-* authorizer denial (`access to X.Y is prohibited` for the column-read case,
-* which needs a resolved identifier we do not have). The prefix is kept so that
-* anything matching upstream still matches; the rest is here because a bare
-* `not authorized` is not debuggable.
-*/
-var SQL_RESERVED_PREFIX_MESSAGE = "not authorized: a SQL statement may not name the reserved _cf_ prefix, which is where this Durable Object keeps its own KV and metadata tables.";
-/**
-* ← the five transaction-control forms `sqlite3_stmt_readonly()` reports
-* read-only and the authorizer reports as `SQLITE_TRANSACTION` /
-* `SQLITE_SAVEPOINT`. The same set `util/sqlite.ts` classifies, read here from
-* the leading keyword because the untrusted path has to refuse them before the
-* trusted one applies them.
-*
-* `;` counts as leading trivia here and in every other leading-keyword refusal
-* below. A statement boundary comes from the backend, and `node:sqlite` reports
-* an empty leading statement as part of the span it compiled: the `sourceSQL`
-* for `;ATTACH ...` is the whole string, so an anchor of `^\s*` would read the
-* keyword as `;` and let the compiled ATTACH through. The browser backend cuts
-* the same input at the first `;` and refuses the empty statement instead.
-*/
-var TRANSACTION_CONTROL = /^[\s;]*(?:BEGIN|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i;
-/** Cheap pre-test, so the tokenizer below runs only on a statement that could fail it. */
-var RESERVED_PREFIX_HINT = /_cf_/i;
-/** A SQL identifier. Double-quoted and bracketed forms are still identifiers, so only the
-* delimiters are stripped and the word inside is scanned like any other. */
-var IDENTIFIER = /[A-Za-z_][A-Za-z0-9_$]*/g;
-/**
-* Everything in a statement an identifier cannot come from: single-quoted string
-* literals (SQLite escapes an embedded quote by doubling it), `--` line comments,
-* and `/* *\/` block comments. Replaced with a space before tokenizing, so what is
-* left is code.
-*
-* Backtick-quoted names are NOT here: MySQL-compatible quoting produces an
-* identifier, exactly as the double-quoted form does.
-*/
-var NOT_CODE = /'(?:[^']|'')*'|--[^\n]*|\/\*[\s\S]*?\*\//g;
-/**
-* Comments are never code. String literals STAY, for both of this regex's callers: pragma
-* arguments may be quoted, and SQLite's misquoting feature reads a single-quoted string as an
-* identifier — `CREATE TABLE 'temp'.t(x)` really creates a temp-schema table — so the checks
-* that read identifier positions must still see it. `NOT_CODE` blanks literals, which is right
-* for the token scans and would be a bypass for these callers.
-*/
-var NOT_COMMENT = /--[^\n]*|\/\*[\s\S]*?\*\//g;
-/**
-* ← `SqlStorageRegulator` (`sql.h:15-22`, `sql.c++:141-165`), whole.
-*
-* Upstream reaches these through the SQLite authorizer while a statement is
-* being compiled. `exec` calls them from the statement text instead, which is
-* the same translation Section 3 made for the write classifier and for
-* transaction state.
-*/
-var SqlStorageRegulator = {
-	/**
-	* Upstream's body is `return !name.startsWith("_cf_")`, with an autogate that
-	* makes the comparison case-insensitive and logs a warning until it lands. The
-	* case-insensitive form is taken here: it is the direction upstream is moving,
-	* and there is no logger for the warning half.
-	*/
-	isAllowedName(name) {
-		return name.length < 4 || name.slice(0, 4).toLowerCase() !== "_cf_";
-	},
-	/** Upstream's body is `return true`. */
-	isAllowedTrigger(_name) {
-		return true;
-	},
-	/** Upstream's body is a `JSG_FAIL_REQUIRE` with this message. */
-	allowTransactions() {
-		throw new Error(SQL_TRANSACTION_REFUSED_MESSAGE);
-	},
-	/** "Bill for queries executed from JavaScript." Nothing reads it — `SqliteObserver` has no port. */
-	shouldAddQueryStats() {
-		return true;
-	}
-};
-/**
-* The text-level stand-in for the authorizer's `isAllowedName` calls — see
-* `SQL_RESERVED_PREFIX_MESSAGE` and the README row.
-*
-* Upstream refuses a *resolved identifier* that starts with `_cf_`, because it
-* reaches `isAllowedName` through the SQLite authorizer while the statement is
-* being compiled. There is no authorizer here, so this tokenizes the statement
-* text instead, over everything that is not a string literal or a comment —
-* which is the same set of characters an identifier can come from.
-*
-* **The literals were once refused too, and that was wrong.** The first draft
-* scanned the whole statement on the reasoning that no legitimate consumer
-* statement contains the token, so being stricter than upstream was the safe
-* direction. A retained conformance case uses `_cf_keepAliveHeartbeat` as a
-* bound value: real workerd accepts it, so this parser must distinguish data
-* from identifiers. `conformance/suite/sql.spec.ts` pins the rule: refused as a
-* table name and as a quoted identifier, allowed as data.
-*
-* A name that merely CONTAINS the token — `my_cf_thing` — stays allowed, because
-* `isAllowedName` tests a prefix.
-*/
-function requireAllowedNames(query) {
-	if (!RESERVED_PREFIX_HINT.test(query)) return;
-	const code = query.replace(NOT_CODE, " ");
-	for (const [token] of code.matchAll(IDENTIFIER)) if (!SqlStorageRegulator.isAllowedName(token)) throw new Error(SQL_RESERVED_PREFIX_MESSAGE);
-}
-/** Refuse transaction control against one SQLite-decided statement boundary. */
-function refuseTransactionControl(statement) {
-	const code = statement.replace(NOT_CODE, " ");
-	if (TRANSACTION_CONTROL.test(code)) SqlStorageRegulator.allowTransactions();
-}
-/**
-* ← the message a `SQLITE_DENY` from the authorizer surfaces to JavaScript,
-* byte-identical so a caller matching on it ports unchanged.
-*/
-var SQL_NOT_AUTHORIZED_MESSAGE = "not authorized: SQLITE_AUTH";
-/**
-* The forms neither the regulator nor any callback sees: the authorizer's own
-* action codes, plus `VACUUM`, which SQLite itself refuses by precondition.
-*
-* Porting `SqlStorageRegulator` whole (point 3 in the file header) carried over its members, but
-* not the authorizer's own action codes: `SQLITE_ATTACH`, `SQLITE_DETACH`, `SQLITE_CREATE_TEMP_*`
-* and `SQLITE_CREATE_VTABLE` consult no callback, so nothing here refused them. Every form below
-* was measured on real workerd through the conformance oracle, not inferred.
-*
-* `ATTACH` and `DETACH` are also the isolation boundary rather than a fidelity detail: both
-* backends open a real file, so on `node:sqlite` an `ATTACH` reads another actor's database and
-* a `VACUUM INTO` writes anywhere the process can. The reserved-name scan does not cover it,
-* because that scan tokenizes the SUBMITTED statement — `other._cf_KV` is caught, and every
-* application table in the same attached database is not.
-*/
-var DATABASE_ATTACHMENT = /^[\s;]*(?:ATTACH|DETACH)\b/i;
-/**
-* ← the `SQLITE_CREATE_TEMP_*` denials (`sqlite.c++:1323`) and the `dbName == temp` rule
-* (`sqlite.c++:1073`), which permits a temp-schema database name only `READ` and `UPDATE`.
-* Upstream's own reason to deny them applies here unchanged: a temporary table makes SQLite
-* open a separate temporary file that the storage engine knows nothing about.
-*
-* Two spellings, one refusal each by its own upstream path: `CREATE TEMP TABLE t(x)` is the
-* keyword and hits the action codes; `CREATE TABLE temp.t(x)` is the schema qualifier and hits
-* the `dbName` rule — and the qualifier was the live gap, where the table was created, written
-* and read back here while workerd refused it outright. The qualifier accepts every quoting
-* SQLite does, single quotes included, with or without whitespace after the keyword (measured:
-* workerd refuses `CREATE TABLE 'temp'.t(x)` and `CREATE TABLE"temp".t(x)` the same way), and
-* is matched only in the object-name position, so an application table merely NAMED `tempest`
-* or `temporary_log` is untouched. The keyword spelling needs no qualifier arm of its own here:
-* `TEMP_SCHEMA` already refuses every `CREATE TEMP…` before this pattern is consulted.
-*
-* The rest of the `dbName` rule goes unported on purpose: with no way to create a temp-schema
-* object, `INSERT`/`DELETE`/`DROP` against one die in SQLite as `no such table`, and the one
-* silent form measures identically — workerd allows `DROP TABLE IF EXISTS temp.ghost` too.
-*/
-var TEMP_SCHEMA = /^[\s;]*CREATE\s+(?:TEMP|TEMPORARY)\b/i;
-var TEMP_QUALIFIED = /^[\s;]*CREATE\s+(?:UNIQUE\s+|VIRTUAL\s+)?(?:TABLE|VIEW|TRIGGER|INDEX)\s*(?:IF\s+NOT\s+EXISTS\s*)?(?:"temp"|'temp'|`temp`|\[temp\]|temp)\s*\./i;
-/**
-* ← `SQLITE_CREATE_VTABLE` (`sqlite.c++:1298-1316`): a virtual table is native-code callbacks, so
-* upstream allows exactly four modules — FTS5 and its `fts5vocab` companion, R*Tree and its
-* `rtree_i32` variant — and denies every other module SQLite was compiled with.
-*
-* `dbstat` is why this is not only fidelity: it reports a row per table with page counts and
-* byte sizes, so `SELECT name FROM d` enumerates `_cf_KV` and the rest of the runtime's own
-* tables without the statement ever naming them — around `requireAllowedNames`, which can only
-* see the text it was given.
-*
-* The table name and the module accept every quoting SQLite does — double quotes, backticks,
-* brackets, and the misquoting feature's single-quoted string, with or without whitespace
-* before them — because the module has to be read from PAST the name, and a guessed name
-* boundary is a bypass in both directions: an unparseable name skipped the check, and
-* `"a USING fts5 b" USING dbstat` read its module out of the quoted name. Measured: workerd
-* refuses both, refuses `CREATE VIRTUAL TABLE"d"USING dbstat`, resolves `USING "dbstat"` to
-* the same denial, and allows `USING 'fts5'`. A `CREATE VIRTUAL TABLE` whose module the
-* pattern cannot read is refused outright — the deliberately stricter direction the
-* unparseable-PRAGMA fallback below already takes.
-*/
-var SQL_IDENTIFIER_SOURCE = /"(?:[^"]|"")*"|'(?:[^']|'')*'|`(?:[^`]|``)*`|\[[^\]]*\]|[A-Za-z_\u0080-\uffff][A-Za-z0-9_$\u0080-\uffff]*/.source;
-var VIRTUAL_TABLE = /^[\s;]*CREATE\s+VIRTUAL\s+TABLE\b/i;
-var VIRTUAL_TABLE_MODULE = new RegExp(String.raw`^[\s;]*CREATE\s+VIRTUAL\s+TABLE\s*(?:IF\s+NOT\s+EXISTS\s*)?(?:${SQL_IDENTIFIER_SOURCE})\s*(?:\.\s*(?:${SQL_IDENTIFIER_SOURCE})\s*)?USING\s*(${SQL_IDENTIFIER_SOURCE})`, "i");
-var ALLOWED_VIRTUAL_TABLE_MODULES = /* @__PURE__ */ new Set([
-	"fts5",
-	"fts5vocab",
-	"rtree",
-	"rtree_i32"
-]);
-/**
-* `VACUUM` has no action code of its own, so the authorizer never sees it. What refuses it
-* upstream is SQLite's own `cannot VACUUM from within a transaction` precondition, against the
-* transaction a Durable Object always has open — and that message is what the oracle returned,
-* for `VACUUM`, `VACUUM main` and `VACUUM INTO` alike. Byte-identical for the same reason
-* `SQL_NOT_AUTHORIZED_MESSAGE` is: a caller matching on it ports unchanged.
-*
-* Refused here unconditionally rather than by transaction state, which is a divergence only in
-* mechanism: this runtime never runs a statement where upstream would have allowed it.
-*/
-var VACUUM_STATEMENT = /^[\s;]*VACUUM\b/i;
-var SQL_VACUUM_REFUSED_MESSAGE = "cannot VACUUM from within a transaction: SQLITE_ERROR";
-/** Refuse the authorizer-only forms against one SQLite-decided statement boundary. */
-function refuseUnauthorizedForms(statement) {
-	const code = statement.replace(NOT_COMMENT, " ");
-	if (VACUUM_STATEMENT.test(code)) throw new Error(SQL_VACUUM_REFUSED_MESSAGE);
-	if (DATABASE_ATTACHMENT.test(code) || TEMP_SCHEMA.test(code) || TEMP_QUALIFIED.test(code)) throw new Error(SQL_NOT_AUTHORIZED_MESSAGE);
-	if (VIRTUAL_TABLE.test(code)) {
-		const moduleName = VIRTUAL_TABLE_MODULE.exec(code)?.[1];
-		if (moduleName === void 0 || !ALLOWED_VIRTUAL_TABLE_MODULES.has(unquoted(moduleName).toLowerCase())) throw new Error(SQL_NOT_AUTHORIZED_MESSAGE);
-	}
-}
-/** Cheap pre-test; `PRAGMA` and the `pragma_` functions both contain it. */
-var PRAGMA_HINT = /pragma/i;
-/** `PRAGMA [schema.]name`, then `= value`, `(argument)`, or nothing. */
-var PRAGMA_STATEMENT = /^[\s;]*PRAGMA\s+(?:[A-Za-z_][A-Za-z0-9_$]*\s*\.\s*)?([A-Za-z_][A-Za-z0-9_$]*)(?:\s*=\s*([\s\S]+?)|\s*\(\s*([\s\S]*?)\s*\))?\s*;?\s*$/i;
-/**
-* ← `ALLOWED_PRAGMAS` (`util/sqlite.c++:543-571`) and `PragmaSignature` (`:528-535`),
-* verbatim. `table_list`, `table_info`, and `table_xinfo` are special-cased
-* ahead of the table in the authorizer, exactly as upstream's `SQLITE_PRAGMA`
-* case does (`util/sqlite.c++:1194-1273`).
-*/
-var ALLOWED_PRAGMAS = /* @__PURE__ */ new Map([
-	["data_version", "NO_ARG"],
-	["page_size", "NO_ARG"],
-	["case_sensitive_like", "BOOLEAN"],
-	["foreign_keys", "BOOLEAN"],
-	["defer_foreign_keys", "BOOLEAN"],
-	["ignore_check_constraints", "BOOLEAN"],
-	["legacy_alter_table", "BOOLEAN"],
-	["recursive_triggers", "BOOLEAN"],
-	["reverse_unordered_selects", "BOOLEAN"],
-	["foreign_key_check", "OPTIONAL_OBJECT_NAME"],
-	["foreign_key_list", "OBJECT_NAME"],
-	["index_info", "OBJECT_NAME"],
-	["index_list", "OBJECT_NAME"],
-	["index_xinfo", "OBJECT_NAME"],
-	["quick_check", "NULL_NUMBER_OR_OBJECT_NAME"],
-	["optimize", "NULL_OR_NUMBER"]
-]);
-/** Upstream compares the eight literal forms as PREFIXES, case-insensitively. */
-var BOOLEAN_PRAGMA_VALUE = /^(?:true|false|yes|no|on|off|1|0)/i;
-/**
-* The pragmas SQLite ships (https://www.sqlite.org/pragma.html), so a
-* `pragma_X` identifier can be told apart: `X` here means the table-valued
-* pragma function and follows the allowlist; any other `pragma_`-prefixed
-* identifier is an ordinary application name, which upstream's authorizer
-* distinguishes by resolution and the conformance suite pins.
-*/
-var SQLITE_PRAGMA_NAMES = /* @__PURE__ */ new Set([
-	"analysis_limit",
-	"application_id",
-	"auto_vacuum",
-	"automatic_index",
-	"busy_timeout",
-	"cache_size",
-	"cache_spill",
-	"case_sensitive_like",
-	"cell_size_check",
-	"checkpoint_fullfsync",
-	"collation_list",
-	"compile_options",
-	"data_version",
-	"database_list",
-	"defer_foreign_keys",
-	"encoding",
-	"foreign_key_check",
-	"foreign_key_list",
-	"foreign_keys",
-	"freelist_count",
-	"full_column_names",
-	"fullfsync",
-	"function_list",
-	"hard_heap_limit",
-	"ignore_check_constraints",
-	"incremental_vacuum",
-	"index_info",
-	"index_list",
-	"index_xinfo",
-	"integrity_check",
-	"journal_mode",
-	"journal_size_limit",
-	"legacy_alter_table",
-	"legacy_file_format",
-	"locking_mode",
-	"max_page_count",
-	"mmap_size",
-	"module_list",
-	"optimize",
-	"page_count",
-	"page_size",
-	"pragma_list",
-	"query_only",
-	"quick_check",
-	"read_uncommitted",
-	"recursive_triggers",
-	"reverse_unordered_selects",
-	"schema_version",
-	"secure_delete",
-	"short_column_names",
-	"shrink_memory",
-	"soft_heap_limit",
-	"synchronous",
-	"table_info",
-	"table_list",
-	"table_xinfo",
-	"temp_store",
-	"threads",
-	"trusted_schema",
-	"user_version",
-	"wal_autocheckpoint",
-	"wal_checkpoint",
-	"writable_schema"
-]);
-/** kj's `tryParseAs` is decimal; keep the same acceptance. */
-var DECIMAL = /^[+-]?\d+$/;
-/**
-* One layer of SQL quoting, any of the four forms — a pragma argument, or the module token
-* `VIRTUAL_TABLE_MODULE` captured. Doubled inner quotes stay doubled, which cannot change a
-* verdict here: no allowlisted comparison target contains a quote character.
-*/
-function unquoted(argument) {
-	const first = argument[0];
-	const last = argument[argument.length - 1];
-	if (argument.length >= 2) {
-		if ((first === "'" || first === "\"" || first === "`") && last === first) return argument.slice(1, -1);
-		if (first === "[" && last === "]") return argument.slice(1, -1);
-	}
-	return argument;
-}
-/** ← the `SQLITE_PRAGMA` authorizer case (`util/sqlite.c++:1194-1273`), whole. */
-function isAllowedPragma(name, argument) {
-	const pragma = name.toLowerCase();
-	if (pragma === "table_list") return true;
-	if (pragma === "table_info" || pragma === "table_xinfo") {
-		if (argument === void 0) return false;
-		return SqlStorageRegulator.isAllowedName(unquoted(argument));
-	}
-	const signature = ALLOWED_PRAGMAS.get(pragma);
-	if (signature === void 0) return false;
-	switch (signature) {
-		case "NO_ARG": return argument === void 0;
-		case "BOOLEAN": return argument === void 0 || BOOLEAN_PRAGMA_VALUE.test(unquoted(argument));
-		case "OBJECT_NAME": return argument !== void 0 && SqlStorageRegulator.isAllowedName(unquoted(argument));
-		case "OPTIONAL_OBJECT_NAME": return argument === void 0 || SqlStorageRegulator.isAllowedName(unquoted(argument));
-		case "NULL_OR_NUMBER": return argument === void 0 || DECIMAL.test(argument);
-		case "NULL_NUMBER_OR_OBJECT_NAME": return argument === void 0 || DECIMAL.test(argument) || SqlStorageRegulator.isAllowedName(unquoted(argument));
-	}
-}
-/**
-* The text-level stand-in for the authorizer's `SQLITE_PRAGMA` case, against
-* one SQLite-decided statement boundary. Load-bearing beyond fidelity:
-* `user_version` is where runtime storage versioning keeps its per-file stamp
-* (`util/sqlite-migrations.ts`), and `writable_schema` would let application
-* SQL rewrite `sqlite_master` out from under the `_cf_` reservation.
-*
-* The `pragma_` table-valued functions reach the same authorizer path
-* upstream, so they follow the same allowlist here — by pragma NAME only. An
-* argument the text cannot see (a string literal or a binding) goes unchecked
-* where upstream's authorizer sees the resolved value; a `_cf_` name smuggled
-* that way reads schema whose shape is public source anyway, while identifier
-* arguments stay covered by `requireAllowedNames`. The README divergence row
-* records this.
-*/
-function requireAllowedPragmas(statement) {
-	if (!PRAGMA_HINT.test(statement)) return;
-	const code = statement.replace(NOT_COMMENT, " ");
-	const direct = code.match(PRAGMA_STATEMENT);
-	if (direct !== null) {
-		const [, name = "", assigned, called] = direct;
-		const argument = (assigned ?? called)?.trim();
-		if (!isAllowedPragma(name, argument === "" ? void 0 : argument)) throw new Error(SQL_NOT_AUTHORIZED_MESSAGE);
-		return;
-	}
-	if (/^[\s;]*PRAGMA\b/i.test(code)) throw new Error(SQL_NOT_AUTHORIZED_MESSAGE);
-	const literalFree = code.replace(NOT_CODE, " ");
-	for (const [token] of literalFree.matchAll(IDENTIFIER)) {
-		if (token.length <= 7 || token.slice(0, 7).toLowerCase() !== "pragma_") continue;
-		const name = token.slice(7).toLowerCase();
-		if (!SQLITE_PRAGMA_NAMES.has(name)) continue;
-		if (name !== "table_list" && name !== "table_info" && name !== "table_xinfo" && !ALLOWED_PRAGMAS.has(name)) throw new Error(SQL_NOT_AUTHORIZED_MESSAGE);
-	}
-}
-/** Everything the untrusted path refuses at one statement boundary. */
-function regulateUntrustedStatement(statement) {
-	refuseTransactionControl(statement);
-	refuseUnauthorizedForms(statement);
-	requireAllowedPragmas(statement);
-}
-/** ← `JSG_INHERIT_INTRINSIC(v8::kIteratorPrototype)` (`jsg/iterator.h:1044`). */
-var IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
-/**
-* ← the `JSG_ITERATOR` types (`jsg/iterator.h:1036-1050`): `next` and
-* self-iterability on `%IteratorPrototype%` — which is what carries the ES
-* iterator helpers; `raw().toArray()` is what Drizzle's durable-sqlite driver
-* calls — and NOTHING else. No `return`, no `throw` (only the async variant
-* registers `return_`, `:1069-1085`), so `IteratorClose` after a `break`, a
-* partial destructuring, or a `take()` is a no-op and a retained iterator
-* resumes. Results are `JSG_STRUCT(done, value)` in that key order
-* (`jsg/iterator.h:706-710`).
-*/
-var RawIterator = class {
-	#pull;
-	constructor(pull) {
-		this.#pull = pull;
-	}
-	next() {
-		const raw = this.#pull();
-		if (raw === void 0) return {
-			done: true,
-			value: void 0
-		};
-		return {
-			done: false,
-			value: asRawRow([...raw])
-		};
-	}
-	[Symbol.iterator]() {
-		return this;
-	}
-};
-Object.setPrototypeOf(RawIterator.prototype, IteratorPrototype);
-Object.defineProperty(RawIterator.prototype, Symbol.toStringTag, {
-	value: "RawIterator",
-	configurable: true
-});
-/** ← `RowIterator`, shaped exactly as `RawIterator` above. */
-var RowIterator = class {
-	#pull;
-	constructor(pull) {
-		this.#pull = pull;
-	}
-	next() {
-		const row = this.#pull();
-		if (row === void 0) return {
-			done: true,
-			value: void 0
-		};
-		return {
-			done: false,
-			value: row
-		};
-	}
-	[Symbol.iterator]() {
-		return this;
-	}
-};
-Object.setPrototypeOf(RowIterator.prototype, IteratorPrototype);
-Object.defineProperty(RowIterator.prototype, Symbol.toStringTag, {
-	value: "RowIterator",
-	configurable: true
-});
-/**
-* ← `SqlStorage::Cursor`.
-*
-* `rowsRead` is the one counter that is not upstream's. Upstream reads
-* `Query::getRowsRead()`, a billing counter sourced from libsql's
-* `STMTSTATUS_ROWS_READ` that counts index rows and that neither backend
-* exposes — the same absence the README already records for `SqlResult`. The
-* interface requires a number, so this returns the rows the cursor has yielded,
-* which is what today's browser host returns and what its tests assert. It
-* undercounts any query that scans more rows than it returns.
-*/
-var Cursor = class {
-	#columnNames;
-	#rawRows;
-	#rowsWritten;
-	#position = 0;
-	constructor(state) {
-		if (state === void 0) throw new Error(CURSOR_NOT_CONSTRUCTIBLE_MESSAGE);
-		this.#columnNames = state.columnNames;
-		this.#rawRows = state.rawRows;
-		this.#rowsWritten = state.rowsWritten;
-	}
-	/**
-	* ← `JSG_READONLY_PROTOTYPE_PROPERTY(columnNames)` (`sql.h:210`): a
-	* prototype accessor, not an own field, so a cursor JSON-stringifies to `{}`.
-	*/
-	get columnNames() {
-		return this.#columnNames;
-	}
-	/** ← `Cursor::next`, whose `RowIterator::Next` is this exact shape. */
-	next() {
-		const row = this.#nextRow();
-		if (row === void 0) return {
-			done: true,
-			value: void 0
-		};
-		return {
-			done: false,
-			value: row
-		};
-	}
-	/** ← `Cursor::toArray`, which drains from the current position. */
-	toArray() {
-		const rows = [];
-		for (;;) {
-			const row = this.#nextRow();
-			if (row === void 0) return rows;
-			rows.push(row);
-		}
-	}
-	/** ← `Cursor::one`. Both messages are upstream's, verbatim. */
-	one() {
-		const row = this.#nextRow();
-		if (row === void 0) throw new Error("Expected exactly one result from SQL query, but got no results.");
-		if (this.#position < this.#rawRows.length) {
-			this.#position = this.#rawRows.length;
-			throw new Error("Expected exactly one result from SQL query, but got multiple results.");
-		}
-		return row;
-	}
-	/**
-	* ← `Cursor::raw`, which shares this cursor's position rather than
-	* restarting. The iterator's shape is `RawIterator`'s whole doc comment.
-	*/
-	raw() {
-		return new RawIterator(() => this.#nextRaw());
-	}
-	/** ← `JSG_ITERABLE(rows)`, yielding through the same shared position. */
-	[Symbol.iterator]() {
-		return new RowIterator(() => this.#nextRow());
-	}
-	get rowsRead() {
-		return this.#position;
-	}
-	/** ← `Cursor::getRowsWritten`, which is `SqlResult.rowsWritten` here. */
-	get rowsWritten() {
-		return this.#rowsWritten;
-	}
-	#nextRaw() {
-		const raw = this.#rawRows[this.#position];
-		if (raw === void 0) return void 0;
-		this.#position += 1;
-		return raw;
-	}
-	/** ← `Cursor::rowIteratorNext`: zip the column names onto the row. */
-	#nextRow() {
-		const raw = this.#nextRaw();
-		if (raw === void 0) return void 0;
-		const row = {};
-		this.#columnNames.forEach((name, index) => {
-			row[name] = raw[index] ?? null;
-		});
-		return asRow(row);
-	}
-};
-/** ← the jsg resource-type tag every workerd API object carries (`resource.h`). */
-Object.defineProperty(Cursor.prototype, Symbol.toStringTag, {
-	value: "Cursor",
-	configurable: true
-});
-/**
-* ← `SqlStorage::Statement`, which upstream describes as "supported only for
-* backwards compatibility ... it is actually just a wrapper around `exec()`".
-* `JSG_CALLABLE(run)` makes the object itself callable, so `prepare()` returns a
-* function wearing this prototype rather than an object with a `run` method.
-*/
-var Statement = class {
-	constructor() {
-		throw new Error(STATEMENT_NOT_CONSTRUCTIBLE_MESSAGE);
-	}
-};
-var SqlStorage = class {
-	#ctx;
-	#owner;
-	/** ← `kj::Maybe<uint> pageSize`, memoized for the same reason. */
-	#pageSize;
-	constructor(ctx, owner) {
-		this.#ctx = ctx;
-		this.#owner = owner;
-	}
-	/** ← `JSG_NESTED_TYPE(Cursor)`. Exposed so `instanceof` works, as upstream's is. */
-	Cursor = Cursor;
-	/** ← `JSG_NESTED_TYPE(Statement)`. */
-	Statement = Statement;
-	exec(query, ...bindings) {
-		requireInputLock(this.#ctx, "sql.exec()");
-		const db = this.#owner.getSqliteDb();
-		const sqlBindings = bindings.map(toSqlBindingValue);
-		requireAllowedNames(query);
-		const result = db.run({ regulate: regulateUntrustedStatement }, query, ...sqlBindings);
-		return new Cursor({
-			columnNames: [...result.columnNames],
-			rawRows: result.rawRows.map((row) => row.map(toSqlStorageValue)),
-			rowsWritten: result.rowsWritten
-		});
-	}
-	/**
-	* ← `SqlStorage::getDatabaseSize`.
-	*
-	* Upstream's second query is `PRAGMA page_size;`, which `sqlite3_stmt_readonly()`
-	* reports read-only. With no such call the text is the only source and §1.7.1's
-	* rule is write-unless-provably-a-read, so a bare `PRAGMA` would open a
-	* transaction and take an output-gate lock to answer a size question. The
-	* `pragma_page_size` table-valued function is the same value read through the
-	* `SELECT` upstream already uses for the page count.
-	*/
-	get databaseSize() {
-		requireInputLock(this.#ctx, "sql.databaseSize");
-		const db = this.#owner.getSqliteDb();
-		return readNumber(db.run("select (select * from pragma_page_count) - (select * from pragma_freelist_count);"), "page count") * this.#getPageSize(db);
-	}
-	/** ← `SqlStorage::prepare`. Experimental and deprecated upstream; `exec` caches for you. */
-	prepare(query) {
-		requireInputLock(this.#ctx, "sql.prepare()");
-		const run = (...bindings) => this.exec(query, ...bindings);
-		Object.setPrototypeOf(run, Statement.prototype);
-		return run;
-	}
-	/** ← `SqlStorage::ingest`. */
-	ingest(query) {
-		requireInputLock(this.#ctx, "sql.ingest()");
-		requireAllowedNames(query);
-		return this.#owner.getSqliteDb().ingest(query, regulateUntrustedStatement);
-	}
-	/** ← `SqlStorage::setMaxPageCountForTest`, which is what its name says. */
-	setMaxPageCountForTest(count) {
-		requireInputLock(this.#ctx, "sql.setMaxPageCountForTest()");
-		this.#owner.getSqliteDb().run(`PRAGMA max_page_count = ${count}`);
-	}
-	/** ← `SqlStorage::getPageSize`. */
-	#getPageSize(db) {
-		const cached = this.#pageSize;
-		if (cached !== void 0) return cached;
-		const size = readNumber(db.run("select * from pragma_page_size;"), "page size");
-		this.#pageSize = size;
-		return size;
-	}
-};
-function readNumber(result, what) {
-	const value = result.rawRows[0]?.[0];
-	if (typeof value === "number") return value;
-	if (typeof value === "bigint") return Number(value);
-	throw new Error(`Expected a number for the database's ${what}.`);
-}
-/** ← JSG's conversion from JavaScript arguments to `SqlStorage::BindingValue`. */
-function toSqlBindingValue(value) {
-	if (value === null || value === void 0) return null;
-	if (typeof value === "string" || typeof value === "number") return value;
-	if (typeof value === "boolean") return String(value);
-	if (typeof value === "bigint") throw new TypeError("Cannot convert a BigInt value to a number");
-	if (value instanceof ArrayBuffer) return copyBytes(new Uint8Array(value));
-	if (ArrayBuffer.isView(value)) return copyBytes(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
-	throw new TypeError(`Cannot convert ${Object.prototype.toString.call(value)} to a SQL value`);
-}
-function copyBytes(bytes) {
-	const copy = new Uint8Array(bytes.byteLength);
-	copy.set(bytes);
-	return copy;
-}
-/**
-* ← `SqlStorage::wrapSqlValue` plus the `Query::getValue` switch above it.
-*
-* Upstream's int64 arm carries its own comment: "int64 will become BigInt, but
-* most applications won't want all their integers to be BigInt. We will coerce
-* to a double here." That coercion is kept rather than refused, because it is
-* the documented behaviour of `sql.exec` and a caller storing an id larger than
-* 2^53 has already lost on workerd.
-*/
-function toSqlStorageValue(value) {
-	if (value === null || value === void 0) return null;
-	if (typeof value === "string" || typeof value === "number") return value;
-	if (typeof value === "bigint") return Number(value);
-	if (typeof value === "boolean") return value ? 1 : 0;
-	if (value instanceof Uint8Array) {
-		const copy = new ArrayBuffer(value.byteLength);
-		new Uint8Array(copy).set(value);
-		return copy;
-	}
-	throw new Error(`SQL returned a ${typeof value}, which is not a SqlStorageValue.`);
-}
-/**
-* The two narrowings a generic row type needs. `T` is the caller's claim about
-* the shape of a row SQLite produced at runtime, so no check can confirm it and
-* upstream does not try — its `Cursor<T>` is the same claim written in a
-* `JSG_TS_OVERRIDE`. Confined to these two functions so the claim is one place
-* rather than sprinkled through the cursor.
-*/
-function asRow(row) {
-	return row;
-}
-function asRawRow(values) {
-	return values;
-}
-//#endregion
-//#region src/api/actor-state.ts
-/**
-* ← workerd `src/workerd/api/actor-state.{h,c++}`
-*
-* The JS-facing storage objects: `DurableObjectStorageOperations` and its two
-* subclasses, `DurableObjectFacets`, and `DurableObjectState`. Everything below
-* this file is reached through one of them.
-*
-* **`DurableObjectStorage` satisfies workers-types with no cast (§2.4).** That
-* was checked rather than asserted, and two shapes here exist only because it
-* has to: `sql.Cursor` and `sql.Statement` must be constructible with no
-* arguments (see `sql.ts`), and `storage.kv` is required. The narrowings that
-* remain are all one thing —
-* `get<T>` returns the caller's claim about the shape of a value SQLite handed
-* back as bytes, which no check can confirm and which upstream states the same
-* way, as a `jsg::JsRef<jsg::JsValue>` behind a `JSG_TS_OVERRIDE`'d
-* `Promise<T>`. There is no `as unknown as` anywhere in this layer.
-*
-* **Every throw is synchronous, including from the promise-returning methods.**
-* That is upstream's: a `JSG_REQUIRE` inside a method returning `jsg::Promise`
-* throws into the isolate before the promise exists, so `put(k, undefined)`
-* throws rather than rejecting. The same goes for a value that will not decode,
-* because §1.4 makes the SQLite path run the decoder before `Promise.resolve`.
-*
-* **What the input gate does and does not do here.** Every entry point calls
-* `requireInputLock` — see its comment in `io/io-context.ts`, which is the one
-* place this package decides what an empty invocation stack means. Nothing else
-* takes a lock: a read returns a value, a write returns a resolved promise, and
-* `atCheckpointEnd` is what keeps the whole chain inside one transaction
-* (§1.7.1). The two exceptions are upstream's own — `sync()` and the bookmark
-* pair release the gate via `awaitIo`, and `transaction()` takes a critical
-* section.
-*
-* **Decision 2's branch has one reachable site**, and it is not where upstream's
-* is. §1.4 measures that SQLite cache operations are immediate, so their
-* `kj::OneOf<T, kj::Promise<T>>` branch has nothing to select between.
-* `transformMaybeBackpressure` keeps the branch because
-* `DeleteAllResults.backpressure` is still a promise in `io/actor-cache.ts`.
-*
-* Not ported, because the substrate has no equivalent: Hibernatable WebSockets,
-* which is the whole reason `DurableObjectState`'s eight WebSocket methods are
-* named throwing stubs; V8's private wire bytes, replaced by a browser-safe
-* structured-clone encoding with the same public value semantics; the billing
-* counters
-* (`billingUnits`, `ActorObserver`, `updateStorageWriteUnit`) and the trace
-* spans, both already absent throughout; `enableSql`, a workerd namespace option
-* that exists to simulate a non-SQLite Durable Object; and `ReplicaActorOutgoingFactory`,
-* whose replication half is a named boundary in `io/actor-cache.ts`.
-*
-* Spec: §1.4, §1.5, §1.10, §2.4, §2.5, decisions 2, 4 and 14 in
-* docs/decisions.md.
-*/
-/**
-* ← `MAX_FACET_NAME_LENGTH` / `MAX_FACET_TREE_DEPTH`
-* (`actor-state.c++:943,947`), in the anonymous namespace beside the facet code
-* that enforces them. The scaffolding had them in `server/`, which is neither
-* where upstream puts them nor where they are checked.
-*/
-var FACET_NAME_MAX_LENGTH = 256;
-/** Root is at depth 0, so the deepest allowed facet is at depth 3. */
-var FACET_TREE_MAX_DEPTH = 4;
-/**
-* The substrate boundary named in the package README: Hibernatable WebSockets
-* exist so the platform can evict an actor while keeping its sockets open, and
-* Chrome exposes no equivalent lifecycle. Under this repo's fail-closed tenet
-* the throw IS the specified behaviour, which is why §2.5 orders the four
-* silent no-op stubs beside it replaced.
-*/
-var HIBERNATION_UNIMPLEMENTED_MESSAGE = "Hibernatable WebSockets are not available in this runtime: they exist so the platform can evict a Durable Object while keeping its sockets open, and there is no equivalent lifecycle to be faithful to.";
-/**
-* ← what falls off the end of `DurableObjectFacets::get`'s class switch
-* (`actor-state.c++:1029-1043`).
-*
-* Upstream accepts three things as `FacetStartupOptions.class`: a bare
-* `DurableObjectClass`, a `LoopbackDurableObjectNamespace`, or a
-* `LoopbackColoLocalActorNamespace`, unwrapping the last two through
-* `getClass()`. All three are ported — the loopback pair by
-* `api/export-loopback.ts` — and `KJ_UNREACHABLE` is the fourth case there
-* because JSG has already refused anything else while unwrapping the
-* `kj::OneOf`. The check has to be written here because
-* `@cloudflare/workers-types` declares `interface DurableObjectClass<_T> {}`,
-* which every object satisfies, so nothing refuses it before the method body.
-*/
-var FACET_CLASS_UNSUPPORTED_MESSAGE = "facets.get() was given a class this runtime cannot resolve. `class` must be a DurableObjectClass, a LoopbackDurableObjectNamespace or a LoopbackColoLocalActorNamespace — which is what a ctx.exports entry for a Durable Object class is.";
-/** ← `DurableObjectStorageOperations::OpName`. Named only where an error quotes them. */
-var OP_GET = "get()";
-var OP_GET_ALARM = "getAlarm()";
-var OP_LIST = "list()";
-var OP_PUT = "put()";
-var OP_PUT_ALARM = "setAlarm()";
-var OP_DELETE = "delete()";
-var OP_DELETE_ALARM = "deleteAlarm()";
-var OP_ROLLBACK = "rollback()";
-/** ← `actor-state.c++:455`, verbatim: the one message both overloads' misuse produces. */
-var PUT_OVERLOAD_MESSAGE = "put() may only be called with a single key-value pair and optional options as put(key, value, options) or with multiple key-value pairs and optional options as put(entries, options)";
-/**
-* ← the `kj::OneOf<kj::String, jsg::Dict<…>>` unwrap on put()'s first parameter: `jsg::Dict`
-* takes any JS object except an Array — functions and Maps included — and `kj::String` takes
-* everything else by coercion. A type predicate, so the overload split narrows without a cast.
-*/
-function isEntriesArgument(value) {
-	return (typeof value === "object" || typeof value === "function") && value !== null && !Array.isArray(value);
-}
-/**
-* ← the struct wrapper (`jsg/struct.h:246-258`), which is NOT the Dict wrapper: `PutOptions` is
-* all-optional fields, so `null` unwraps to default options, and any object does — arrays and
-* functions included, because the wrapper checks `IsObject()` with no Array exclusion. Only a
-* non-null primitive fails to unwrap. Measured on real workerd: `put({k: 1}, null)`, `…, [])`
-* and `…, function () {})` all write, and `put({k: 1}, "v")` alone is the overload error.
-*/
-function isPutOptions(value) {
-	return value === null || typeof value === "object" || typeof value === "function";
-}
-/** The key immediately after `k` in byte order is `k` plus this. */
-var NULL_CHARACTER = "\0";
-/** ← the `0xff` upstream strips from the tail of a prefix, in UTF-16 code units. */
-var MAX_CODE_UNIT = 65535;
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder();
-/** A byte JSON could never begin with, `DO`, and the local codec version. */
-var VALUE_CODEC_HEADER = new Uint8Array([
-	0,
-	68,
-	79,
-	1
-]);
-/**
-* ← `serializeV8Value`. The wire bytes differ because V8's serializer is not
-* available in browsers; the public structured-clone value semantics do not.
-* The short header keeps the new representation unambiguous while old JSON rows
-* remain readable.
-*/
-function serializeValue(value) {
-	const body = textEncoder.encode(JSON.stringify(serialize(value)));
-	const encoded = new Uint8Array(VALUE_CODEC_HEADER.byteLength + body.byteLength);
-	encoded.set(VALUE_CODEC_HEADER);
-	encoded.set(body, VALUE_CODEC_HEADER.byteLength);
-	return encoded;
-}
-/**
-* ← `deserializeV8Value`.
-*
-* Upstream logs "the key (to help find the data in the database if it hasn't
-* been deleted), the length of the value, and the first three bytes of the value
-* (which is just the v8-internal version header and the tag that indicates the
-* type of the value, but not its contents)". Our four-byte header carries only
-* a marker and version for the same reason.
-*/
-function deserializeValue(key, buffer) {
-	if (buffer.byteLength === 0) throw new Error(`unexpectedly empty value buffer; key = ${key}`);
-	try {
-		const structured = VALUE_CODEC_HEADER.every((byte, index) => buffer[index] === byte);
-		const bytes = structured ? buffer.subarray(VALUE_CODEC_HEADER.byteLength) : buffer;
-		const parsed = JSON.parse(textDecoder.decode(bytes));
-		return structured ? deserialize(parsed) : parsed;
-	} catch (exception) {
-		throw new Error(`actor storage deserialization failed: failed to deserialize stored value; key = ${key}; size = ${buffer.byteLength}`, { cause: exception });
-	}
-}
-/**
-* ← `transformMaybeBackpressure` (`actor-state.c++:103-119`). THIS is decision
-* 2's live site: `DeleteAllResults.backpressure` is still `Promise<void> |
-* undefined`, so the branch has something to select between.
-*
-* Upstream's own note, kept because it is the reason the flag is threaded here
-* at all: "In practice `allowConcurrency` will have no effect on a backpressure
-* promise since backpressure blocks everything anyway, but we pass the option
-* through for consistency in case of future changes."
-*/
-function transformMaybeBackpressure(ctx, options, maybeBackpressure) {
-	if (maybeBackpressure === void 0) return Promise.resolve();
-	if (options.allowConcurrency === true) return ctx.awaitIo(maybeBackpressure);
-	return ctx.awaitIoWithInputLock(maybeBackpressure, () => {});
-}
-/**
-* ← `DurableObjectStorageOperations::compileListOptions`
-* (`actor-state.c++:314-417`). Returns undefined if the list operation would
-* provably return no results. `SyncKvStorage` reuses it, exactly as upstream's
-* comment says it must.
-*
-* Two translations. `startAfter` gains ONE null character where upstream's
-* `kj::String` gains two, because the second of upstream's is the terminator and
-* a JS string has none. And every comparison here is on UTF-16 code units where
-* upstream's is on UTF-8 bytes, while the range the database actually applies is
-* SQLite's `BINARY` collation over UTF-8 — the two orders agree for every key
-* outside the astral planes, and a key that mixes astral characters with a
-* prefix can land on the wrong side of a clamp this function computes.
-*/
-function compileListOptions(options) {
-	let start = "";
-	let end;
-	let reverse = false;
-	let limit;
-	if (options !== void 0) {
-		if (options.start !== void 0) {
-			if (options.startAfter !== void 0) throw new TypeError("list() cannot be called with both start and startAfter values.");
-			start = options.start;
-		}
-		if (options.startAfter !== void 0) start = options.startAfter + NULL_CHARACTER;
-		if (options.end !== void 0) end = options.end;
-		if (options.reverse !== void 0) reverse = options.reverse;
-		if (options.limit !== void 0) {
-			if (!(options.limit > 0)) throw new TypeError("List limit must be positive.");
-			limit = options.limit;
-		}
-		const prefix = options.prefix;
-		if (prefix !== void 0 && prefix.length > 0) {
-			if (start < prefix) start = prefix;
-			else if (start.startsWith(prefix)) {} else return;
-			const keyAfterPrefix = firstKeyAfterPrefix(prefix);
-			if (keyAfterPrefix === void 0) {} else if (end === void 0) end = keyAfterPrefix;
-			else if (end <= prefix) return;
-			else if (end.startsWith(prefix)) {} else end = keyAfterPrefix;
-		}
-	}
-	if (end !== void 0 && end <= start) return;
-	return {
-		start,
-		end,
-		reverse,
-		limit
-	};
-}
-/**
-* ← the `keyAfterPrefix` vector: strip maximal trailing units, then increment.
-*
-* Returns undefined when the prefix is nothing but maximal units, which is
-* upstream's "the prefix is a string of some number of 0xff bytes, so includes
-* the entire key space up through the last possible key".
-*/
-function firstKeyAfterPrefix(prefix) {
-	let head = prefix;
-	while (head.length > 0 && head.charCodeAt(head.length - 1) === MAX_CODE_UNIT) head = head.slice(0, -1);
-	if (head.length === 0) return void 0;
-	return head.slice(0, -1) + String.fromCharCode(head.charCodeAt(head.length - 1) + 1);
-}
-/**
-* ← workerd `src/workerd/api/sync-kv.{h,c++}`. The synchronous surface lives
-* beside the asynchronous storage owner because both share the same codec and
-* list-option compiler over one `SqliteKv`.
-*/
-var SyncKvStorage = class {
-	#ctx;
-	#kv;
-	constructor(ctx, kv) {
-		this.#ctx = ctx;
-		this.#kv = kv;
-	}
-	get(key) {
-		requireInputLock(this.#ctx, "kv.get()");
-		const value = this.#kv.get(key);
-		if (value === void 0) return void 0;
-		return deserializeValue(key, value);
-	}
-	list(options) {
-		requireInputLock(this.#ctx, "kv.list()");
-		const compiled = compileListOptions(options);
-		if (compiled === void 0) return [];
-		return listIterator(this.#kv.list(compiled.start, compiled.end, compiled.limit, compiled.reverse ? "REVERSE" : "FORWARD"));
-	}
-	put(key, value) {
-		requireInputLock(this.#ctx, "kv.put()");
-		this.#kv.put(key, serializeValue(value));
-	}
-	delete(key) {
-		requireInputLock(this.#ctx, "kv.delete()");
-		return this.#kv.delete(key);
-	}
-};
-/** ← `SyncKvStorage::listNext`, whose cancellation branch is the reason it is not a plain loop. */
-function* listIterator(cursor) {
-	for (;;) {
-		const pair = cursor.next();
-		if (pair !== void 0) {
-			yield [pair.key, deserializeValue(pair.key, pair.value)];
-			continue;
-		}
-		if (cursor.wasCanceled()) throw new Error("kv.list() iterator was invalidated because a new call to kv.list() was started. Only one kv.list() iterator can exist at a time.");
-		return;
-	}
-}
-/**
-* ← `DurableObjectStorageOperations`. "Common implementation of
-* DurableObjectStorage and DurableObjectTransaction. This class is designed to
-* be used as a mixin."
-*/
-var DurableObjectStorageOperations = class {
-	ctx;
-	constructor(ctx) {
-		this.ctx = ctx;
-	}
-	get(keyOrKeys, maybeOptions) {
-		requireInputLock(this.ctx, OP_GET);
-		const options = { ...maybeOptions };
-		if (typeof keyOrKeys === "string") return this.#getOne(keyOrKeys, options);
-		return this.#getMultiple(keyOrKeys, options);
-	}
-	getAlarm(maybeOptions) {
-		requireInputLock(this.ctx, OP_GET_ALARM);
-		const options = {
-			...maybeOptions,
-			noCache: false
-		};
-		return Promise.resolve(this.getCache(OP_GET_ALARM).getAlarm(options));
-	}
-	list(maybeOptions) {
-		requireInputLock(this.ctx, OP_LIST);
-		const compiled = compileListOptions(maybeOptions);
-		if (compiled === void 0) return Promise.resolve(/* @__PURE__ */ new Map());
-		const options = { ...maybeOptions };
-		const cache = this.getCache(OP_LIST);
-		const result = compiled.reverse ? cache.listReverse(compiled.start, compiled.end, compiled.limit, options) : cache.list(compiled.start, compiled.end, compiled.limit, options);
-		return Promise.resolve(listResultsToMap(result));
-	}
-	put(keyOrEntries, valueOrOptions, maybeOptions) {
-		requireInputLock(this.ctx, OP_PUT);
-		if (!isEntriesArgument(keyOrEntries)) {
-			if (valueOrOptions === void 0) throw new TypeError("put() called with undefined value.");
-			return this.#putOne(`${keyOrEntries}`, valueOrOptions, { ...maybeOptions });
-		}
-		if (valueOrOptions !== void 0 && !isPutOptions(valueOrOptions)) throw new TypeError(PUT_OVERLOAD_MESSAGE);
-		return this.#putMultiple(keyOrEntries, { ...valueOrOptions });
-	}
-	delete(keyOrKeys, maybeOptions) {
-		requireInputLock(this.ctx, OP_DELETE);
-		const options = { ...maybeOptions };
-		if (typeof keyOrKeys === "string") return Promise.resolve(this.getCache(OP_DELETE).delete(keyOrKeys, options));
-		return Promise.resolve(this.getCache(OP_DELETE).deleteMultiple(keyOrKeys, options));
-	}
-	setAlarm(scheduledTime, maybeOptions) {
-		requireInputLock(this.ctx, OP_PUT_ALARM);
-		const when = scheduledTime instanceof Date ? scheduledTime.getTime() : scheduledTime;
-		if (!(when > 0)) throw new TypeError("setAlarm() cannot be called with an alarm time <= 0");
-		this.ctx.getActorOrThrow().assertCanSetAlarm();
-		const options = {
-			...maybeOptions,
-			noCache: false
-		};
-		this.getCache(OP_PUT_ALARM).setAlarm(Math.max(when, this.ctx.now()), options);
-		return Promise.resolve();
-	}
-	deleteAlarm(maybeOptions) {
-		requireInputLock(this.ctx, OP_DELETE_ALARM);
-		const options = {
-			...maybeOptions,
-			noCache: false
-		};
-		this.getCache(OP_DELETE_ALARM).setAlarm(null, options);
-		return Promise.resolve();
-	}
-	#getOne(key, options) {
-		const value = this.getCache(OP_GET).get(key, options);
-		return Promise.resolve(value === void 0 ? void 0 : deserializeValue(key, value));
-	}
-	#getMultiple(keys, options) {
-		const result = this.getCache(OP_GET).getMultiple(keys, options);
-		return Promise.resolve(listResultsToMap(result));
-	}
-	#putOne(key, value, options) {
-		this.getCache(OP_PUT).put(key, serializeValue(value), options);
-		return Promise.resolve();
-	}
-	#putMultiple(entries, options) {
-		const pairs = [];
-		for (const [key, value] of Object.entries(entries)) {
-			if (value === void 0) continue;
-			pairs.push({
-				key,
-				value: serializeValue(value)
-			});
-		}
-		this.getCache(OP_PUT).putMultiple(pairs, options);
-		return Promise.resolve();
-	}
-};
-/** ← `listResultsToMap` and `getMultipleResultsToMap`, minus the billing halves. */
-function listResultsToMap(rows) {
-	const map = /* @__PURE__ */ new Map();
-	for (const entry of rows) map.set(entry.key, deserializeValue(entry.key, entry.value));
-	return map;
+	throw new Error("unreachable: exactly one module field is set");
+}
+/**
+* ← `jsg::asBytes()` followed by `kj::heapArray<const kj::byte>(data.asPtr())`
+* (`worker-loader.c++:231`, `:244`). The copy is the whole point — see the caller.
+*/
+function copyBytes(value) {
+	if (value instanceof ArrayBuffer) return new Uint8Array(value.slice(0));
+	if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+	throw new TypeError(NOT_BYTES_MESSAGE);
 }
-var DurableObjectStorage = class extends DurableObjectStorageOperations {
-	#cache;
-	#sql;
-	#kv;
-	constructor(ctx, cache) {
-		super(ctx);
-		this.#cache = cache;
-	}
-	/** ← `DurableObjectStorage::getActorCacheInterface`, which `DurableObjectState::abort` needs. */
-	getActorCacheInterface() {
-		return this.#cache;
-	}
-	/** ← `DurableObjectStorage::getSqliteDb`. Always SQLite-backed here; see the header. */
-	getSqliteDb() {
-		return this.#cache.getSqliteDatabase();
-	}
-	getCache() {
-		return this.#cache;
-	}
-	/** ← `JSG_LAZY_INSTANCE_PROPERTY(sql, getSql)`. */
-	get sql() {
-		this.#sql ??= new SqlStorage(this.ctx, this);
-		return this.#sql;
-	}
-	/** ← `JSG_LAZY_INSTANCE_PROPERTY(kv, getKv)`. */
-	get kv() {
-		this.#kv ??= new SyncKvStorage(this.ctx, this.#cache.getSqliteKv());
-		return this.#kv;
-	}
-	/**
-	* ← `DurableObjectStorage::deleteAll`.
-	*
-	* `deleteAlarm` is upstream's `FeatureFlags::get(js).getDeleteAllDeletesAlarm()`,
-	* a compatibility flag that exists so Workers published before it keep the old
-	* behaviour. A runtime with no deployed history takes the current behaviour.
-	*/
-	deleteAll(maybeOptions) {
-		requireInputLock(this.ctx, "deleteAll()");
-		const options = { ...maybeOptions };
-		const result = this.#cache.deleteAll(options, { deleteAlarm: true });
-		return transformMaybeBackpressure(this.ctx, options, result.backpressure);
-	}
-	/**
-	* ← `DurableObjectStorage::transaction`.
-	*
-	* The critical section is load bearing and upstream says why: "the call to
-	* `startTransaction()` is when the SQLite-backed implementation will actually
-	* invoke `BEGIN TRANSACTION`, so it's important that we're inside the
-	* blockConcurrencyWhile block before that point so we don't accidentally catch
-	* some other asynchronous event in our transaction."
-	*
-	* The exception is packed into the result rather than thrown out of the
-	* section, and then rethrown outside it. Upstream's reason: "We don't actually
-	* want to reset the object, we only want to roll back the transaction and
-	* propagate the exception." A throw out of a critical section permanently
-	* breaks the input gate (§1.5), so a failing transaction callback would
-	* destroy the actor.
-	*/
-	transaction(closure) {
-		requireInputLock(this.ctx, "transaction()");
-		return this.ctx.blockConcurrencyWhile(async () => {
-			const txn = new DurableObjectTransaction(this.ctx, this.#cache.startTransaction());
-			try {
-				const value = await closure(txn);
-				txn.maybeCommit();
-				return {
-					isError: false,
-					value
-				};
-			} catch (exception) {
-				txn.maybeRollback();
-				return {
-					isError: true,
-					exception
-				};
-			}
-		}).then((result) => {
-			if (result.isError) throw result.exception;
-			return result.value;
-		});
-	}
-	/** ← `DurableObjectStorage::transactionSync`, a forward for the reason above. */
-	transactionSync(callback) {
-		requireInputLock(this.ctx, "transactionSync()");
-		return this.#cache.transactionSync(callback);
-	}
-	/**
-	* ← `DurableObjectStorage::sync`.
-	*
-	* Upstream's `awaitIo` rather than `awaitIoWithInputLock`, which is the one
-	* storage method that deliberately opens the gate: "we're merely checking if
-	* we have any pending or in-flight operations, and providing a promise that
-	* resolves when they succeed."
-	*/
-	sync() {
-		requireInputLock(this.ctx, "sync()");
-		return this.ctx.awaitIo(this.#cache.onNoPendingFlush());
-	}
-	/**
-	* Real, not a boundary: `ActorSqlite`'s is "an ersatz implementation that's
-	* good enough for local dev with D1's Session API", built on the metadata
-	* table's local-development bookmark. Anything above this package that
-	* surfaces it to an application should know it is a counter and not a
-	* recovery point — as it is on workerd.
-	*/
-	getCurrentBookmark() {
-		requireInputLock(this.ctx, "getCurrentBookmark()");
-		return this.ctx.awaitIo(this.#cache.getCurrentBookmark());
-	}
-	waitForBookmark(bookmark) {
-		requireInputLock(this.ctx, "waitForBookmark()");
-		return this.ctx.awaitIo(this.#cache.waitForBookmark(bookmark));
-	}
-	/** Substrate boundary: point-in-time recovery. Upstream reaches the cache directly, as this does. */
-	getBookmarkForTime(timestamp) {
-		return this.#cache.getBookmarkForTime(timestamp instanceof Date ? timestamp.getTime() : timestamp);
-	}
-	/** Substrate boundary: point-in-time recovery. */
-	onNextSessionRestoreBookmark(bookmark) {
-		return this.#cache.onNextSessionRestoreBookmark(bookmark);
-	}
-	/** Substrate boundary: replication. */
-	ensureReplicas() {
-		this.#cache.ensureReplicas();
-	}
-	/** Substrate boundary: replication. */
-	disableReplicas() {
-		this.#cache.disableReplicas();
-	}
-	/**
-	* ← `DurableObjectStorage::getPrimary` / `isReplica`. `maybePrimary` is set
-	* only by the replica constructor, and nothing constructs a replica here, so
-	* these answer upstream's own non-replica case rather than a stubbed one.
-	*/
-	getPrimary() {}
-	isReplica() {
-		return false;
-	}
-};
-var DurableObjectTransaction = class extends DurableObjectStorageOperations {
-	/** Becomes undefined when committed or rolled back. */
-	#cacheTxn;
-	#rolledBack = false;
-	constructor(ctx, cacheTxn) {
-		super(ctx);
-		this.#cacheTxn = cacheTxn;
-	}
-	getCache(op) {
-		if (this.#rolledBack) throw new Error(`Cannot ${op} on rolled back transaction`);
-		const txn = this.#cacheTxn;
-		if (txn === void 0) throw new Error(`Cannot call ${op} on transaction that has already committed: did you move \`txn\` outside of the closure?`);
-		return txn;
-	}
-	/** Called from JS. */
-	rollback() {
-		if (this.#rolledBack) return;
-		this.getCache(OP_ROLLBACK);
-		const txn = this.#cacheTxn;
-		if (txn !== void 0) {
-			txn.rollback();
-			txn.drop();
-			this.#cacheTxn = void 0;
-		}
-		this.#rolledBack = true;
-	}
-	/** Just throws an exception saying this isn't supported. */
-	deleteAll() {
-		throw new Error("Cannot call deleteAll() within a transaction");
-	}
-	/**
-	* Called from the runtime, not JS, after the transaction callback has
-	* completed. Does nothing if the transaction is already committed or rolled
-	* back. Synchronous, because `ActorCacheTransaction::commit` is (§1.4).
-	*/
-	maybeCommit() {
-		const txn = this.#cacheTxn;
-		if (txn === void 0) return;
-		this.#cacheTxn = void 0;
-		txn.commit();
-		txn.drop();
-	}
-	/** Same, for the failure path. Upstream's drops the transaction, whose destructor rolls back. */
-	maybeRollback() {
-		const txn = this.#cacheTxn;
-		this.#cacheTxn = void 0;
-		this.#rolledBack = true;
-		txn?.drop();
-	}
-};
 /**
-* ← `requireValidFacetName` (`actor-state.c++:949-952`).
+* ← `Fetcher::getSubrequestChannel(ioctx)` followed by
+* `channel->requireAllowsTransfer()` (`worker-loader.c++:125-126`, `:144-145`,
+* `:157-158`).
+*
+* **The check has nothing to call, and that is a recorded divergence rather than
+* an omission.** Upstream's `SubrequestChannel` carries `requireAllowsTransfer()`;
+* here a `SubrequestChannel` and the `Fetcher` built over it are one object
+* (`io/io-channels.ts`'s header, and the same collapse `api/actor.ts` and
+* `api/export-loopback.ts` already made), and a `Fetcher` is
+* `@cloudflare/workers-types`' interface with no such member. The one refusal it
+* produces in the open-source runtime is `throwDynamicEntrypointTransferError`
+* (`server.c++:167-173`), raised by `WorkerService::requireAllowsTransfer` when
+* `isDynamic` — an isolate-host fact here, exactly as it is a `server/` fact there.
 *
-* The comparison is `name.size()` on a `kj::StringPtr`, which is **UTF-8 bytes**,
-* so it is measured in bytes here too — the same `TextEncoder` pass, for the same
-* reason, that `ColoLocalActorNamespace.get`'s `[1, 2048]` bound already costs.
-* Comparing `name.length` accepts a 256-character non-ASCII name that upstream
-* refuses, which is a bound a caller can hit.
+* Kept as a named function rather than inlined so the three call sites read as
+* upstream's do, and so there is one place to put the check if a `Fetcher` seam
+* ever grows one.
 */
-function requireValidFacetName(name) {
-	if (textEncoder.encode(name).length > 256) throw new TypeError(`Facet name is too long (max 256 characters).`);
+function requireTransferableChannel(fetcher) {
+	return fetcher;
 }
 /**
-* ← the `KJ_SWITCH_ONEOF(options.$class)` lambda (`actor-state.c++:1029-1043`).
+* ← `Frankenvalue::fromJs(js, …)`, whose serializer refuses any object whose JSG
+* resource type declares no `JSG_SERIALIZABLE` (`jsg/ser.c++:175-183`).
+*
+* Four types reachable from this package are in that set, and all four for one
+* reason: `JSG_INHERIT` does not carry serializability. Upstream says so twice — in
+* `export-loopback.h:57-58` ("Note that `LoopbackServiceStub` is intentionally NOT
+* serializable, unlike its parent class Fetcher") and in the test that pins it,
+* whose comment reads "it's more testing LoopbackServiceStub and that
+* serializability is not inherited" (`worker-loader-test.js:91-92`). None of
+* `LoopbackServiceStub`, `LoopbackDurableObjectClass`,
+* `LoopbackDurableObjectNamespace` or `LoopbackColoLocalActorNamespace` declares
+* `JSG_SERIALIZABLE`; every one of them *invoked* produces something that does — a
+* `Fetcher` or a plain `DurableObjectClass` — which is exactly the distinction
+* `worker-loader-test.js:62-107` measures, accepting the invoked form in `props`
+* and refusing the bare binding.
 *
-* Three arms, and the order matters for the same reason it does upstream: a
-* `LoopbackDurableObjectClass` *is* a `DurableObjectClass`, so it takes the bare
-* arm here exactly as JSG's `kj::OneOf` unwraps it into the first alternative.
-* The two loopback namespaces are not classes and carry one, which `getClass()`
-* hands back.
+* **This discharges the obligation the README left open on Section 7.** That row
+* says the refusal would have to come from `src/transport/` if a `Fetcher` ever
+* became serializable; the layer upstream refuses at is this one, because
+* `Frankenvalue::fromJs` runs inside `getEntrypoint`, `getDurableObjectClass` and
+* `toDynamicWorkerSource`. Putting it here makes it reachable today rather than
+* conditional on a transport change that has not happened, and it depends on no
+* transport fact — so `api/` still imports no transport library.
 *
-* A `ctx.exports` entry is the callable façade `api/export-loopback.ts` produces
-* rather than the instance itself, and every check below is an `instanceof` that
-* the façade's `getPrototypeOf` answers — which is why that trap exists.
+* The walk descends into plain objects and arrays only. Everything else is a host
+* object: either one the substrate knows how to carry (a `Fetcher`, a
+* `DurableObjectClass`, an `RpcTarget`) or one of the four above. Walking a host
+* object's own keys would drive proxy traps — a stub's `get` mints an RPC import —
+* which is a cost upstream's serializer never pays, because it asks the type rather
+* than the value.
 */
-function requireFacetClass(actorClass) {
-	if (actorClass instanceof DurableObjectClass) return actorClass;
-	if (actorClass instanceof LoopbackDurableObjectNamespace) return actorClass.getClass();
-	if (actorClass instanceof LoopbackColoLocalActorNamespace) return actorClass.getClass();
-	throw new TypeError(FACET_CLASS_UNSUPPORTED_MESSAGE);
+function requireSerializableProps(root, field) {
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (value, path) => {
+		if (value === null || typeof value !== "object" && typeof value !== "function") return;
+		const subject = value;
+		const refused = notSerializableType(subject);
+		if (refused !== void 0) throw new DOMException(`${notSerializableMessage(refused)} At ${path}.`, "DataCloneError");
+		if (seen.has(subject)) return;
+		seen.add(subject);
+		if (Array.isArray(subject)) {
+			subject.forEach((entry, index) => {
+				visit(entry, `${path}[${index}]`);
+			});
+			return;
+		}
+		const prototype = Object.getPrototypeOf(subject);
+		if (prototype !== Object.prototype && prototype !== null) return;
+		for (const [name, entry] of Object.entries(subject)) visit(entry, `${path}.${name}`);
+	};
+	visit(root, `<${field}>`);
+	return root;
 }
 /**
-* ← `DurableObjectFacets`.
+* The four `ctx.exports` binding types, named by the class whose name
+* `GetConstructorName()` would report.
 *
-* **`clone` is the fourth method, and the vendored C++ snapshot does not have
-* it.** The design record cites `actor-state.h:431-497` and
-* `server.c++:721-749`; neither line range contains it, `DurableObjectFacets`
-* there exposes exactly `get`, `abort` and `delete`, and
-* `Worker::Actor::FacetManager` has exactly `getDepth`, `getFacet`, `abortFacet`
-* and `deleteFacet`. It is real all the same: `@cloudflare/workers-types`
-* 4.20260702.1 — a month newer than the snapshot — declares
-* `clone(src: string, dst: string): void` on `DurableObjectFacets`. So the
-* signature comes from the types and the semantics from §1.10 (abort dst, delete
-* dst storage, recursive copy of the src subtree), and the orchestration is
-* `server/`'s `cloneFacet`. There is nothing upstream to check the body against,
-* which makes it the one method here with no reference — worth knowing when it
-* is wrong.
+* The four are mutually exclusive — each extends a different base
+* (`api/export-loopback.ts`) — so the order is presentational. What the order does
+* NOT do is reach a base class: `DurableObjectClass`, `DurableObjectNamespace`,
+* `ColoLocalActorNamespace` and `Fetcher` are all serializable upstream
+* (`actor.h:389`), and it is exactly `JSG_INHERIT`'s failure to carry
+* serializability that makes the four subclasses refuse where their bases accept.
 */
-var DurableObjectFacets = class {
-	#ctx;
-	#facetManager;
-	#parentId;
-	constructor(ctx, facetManager, parentId) {
-		this.#ctx = ctx;
-		this.#facetManager = facetManager;
-		this.#parentId = parentId;
-	}
-	/**
-	* Get a facet by name, starting it if it isn't already running.
-	* `getStartupOptions` is invoked only if the facet wasn't already running.
-	*
-	* Returns a `Fetcher` instead of a `DurableObject` because the returned stub
-	* does not have the `id` or `name` methods that a DO stub normally has.
-	*/
-	get(name, getStartupOptions) {
-		requireValidFacetName(name);
-		const facetManager = this.#getFacetManager();
-		if (facetManager.getDepth() + 1 >= 4) throw new Error(`Facet nesting depth limit exceeded. The maximum depth including the root Durable Object is 4.`);
-		requireInputLock(this.#ctx, "facets.get()");
-		const getStartInfo = this.#ctx.makeReentryCallback(async () => {
-			const options = await getStartupOptions();
-			const id = options.id;
-			return {
-				actorClass: requireFacetClass(options.class).getChannel(),
-				id: id === void 0 ? this.#parentId : typeof id === "string" ? id : id.name ?? id.toString()
-			};
-		});
-		return facetManager.getFacet(name, getStartInfo);
-	}
-	abort(name, reason) {
-		requireValidFacetName(name);
-		this.#getFacetManager().abortFacet(name, reason);
-	}
-	delete(name) {
-		requireValidFacetName(name);
-		this.#getFacetManager().deleteFacet(name);
-	}
-	clone(src, dst) {
-		requireValidFacetName(src);
-		requireValidFacetName(dst);
-		this.#getFacetManager().cloneFacet(src, dst);
-	}
-	#getFacetManager() {
-		const facetManager = this.#facetManager;
-		if (facetManager === void 0) throw new Error("This Durable Object does not support creating facets.");
-		return facetManager;
-	}
-};
-/** The type passed as the first parameter to a Durable Object class's constructor. */
-var DurableObjectState = class {
-	#ctx;
-	#options;
-	#facets;
-	constructor(ctx, options) {
-		this.#ctx = ctx;
-		this.#options = options;
-	}
-	get id() {
-		return this.#options.id;
-	}
-	get props() {
-		return this.#options.props;
-	}
-	/** ← `JSG_LAZY_INSTANCE_PROPERTY(exports, getExports)`, behind `enableCtxExports` upstream. */
-	get exports() {
-		return this.#options.exports;
-	}
-	get version() {
-		return this.#options.version;
-	}
-	/**
-	* NO upstream correspondence, because upstream needs none: a
-	* `ServiceWorkerGlobalScope` IS the isolate's global object there, so an
-	* actor's class reaches its gated `setTimeout` by writing `setTimeout`.
-	*
-	* Here one realm hosts several actors, so the names on `globalThis` can only
-	* be bound to one of them and a continuation cannot be asked which one it
-	* belongs to. `ctx` is the one reference every Durable Object class already
-	* holds and that already means exactly one actor — the constructor was handed
-	* it — so it is where the scope goes. An actor's method writes
-	* `this.ctx.globals.setTimeout(…)`; a free function it calls takes the scope
-	* as a parameter.
-	*
-	* `installActorScope` still exists and is still what a host uses for a
-	* dynamically-loaded Worker source, which has no `ctx` to reach through and
-	* its own module scope to destructure into. The two are the same object.
-	*/
-	get globals() {
-		return this.#options.globals;
-	}
-	get storage() {
-		const storage = this.#options.storage;
-		if (storage === void 0) throw new Error("This Durable Object does not have storage.");
-		return storage;
-	}
-	/** ← `JSG_LAZY_INSTANCE_PROPERTY(facets, getFacets)`. */
-	get facets() {
-		this.#facets ??= new DurableObjectFacets(this.#ctx, this.#options.facets, this.#options.id.toString());
-		return this.#facets;
-	}
-	waitUntil(promise) {
-		this.#ctx.addWaitUntil(promise.then(() => {}));
-	}
-	/**
-	* ← `DurableObjectState::blockConcurrencyWhile` (`actor-state.c++:1128-1131`),
-	* which is a one-line forward and nothing else. The 30-second deadline, the
-	* brokenness annotation and the never-settled promise on failure all live in
-	* `IoContext::blockConcurrencyWhile`, which Section 2 already implements.
-	*
-	* Its precondition comes with it: `IoContext::blockConcurrencyWhile` calls
-	* `getInputLock()`, which asserts, so this is reachable only from inside a
-	* gated slice.
-	*/
-	blockConcurrencyWhile(callback) {
-		return this.#ctx.blockConcurrencyWhile(callback);
-	}
-	/**
-	* ← `DurableObjectState::abort`. Reset the object, including breaking the
-	* output gate and canceling any writes that haven't been committed yet.
-	*
-	* `js.terminateExecutionNow()` has no port — there is no isolate to terminate —
-	* so the caller's own slice keeps running to its next await, where `IoContext`
-	* refuses to re-enter.
-	*/
-	abort(reason) {
-		const description = reason === void 0 ? "broken.outputGateBroken; jsg.Error: Application called abort() to reset Durable Object." : `broken.outputGateBroken; jsg.Error: ${reason}`;
-		const error = new Error(description);
-		setUserErrorDetail(error);
-		this.#options.storage?.getActorCacheInterface().shutdown(error);
-		this.#ctx.abort(error);
-	}
-	/** ← `DurableObjectState::getPrimaryStub`. Non-null only for a replica; see the storage note. */
-	get primaryStub() {
-		return this.#options.storage?.getPrimary();
-	}
-	/** Substrate boundary: replication. */
-	configureReadReplication(options) {
-		const storage = this.#options.storage;
-		if (storage === void 0) throw new TypeError("This actor does not support read replication.");
-		if (storage.isReplica()) throw new Error("Replica Durable Objects cannot call configureReadReplication().");
-		if (options.mode !== "auto" && options.mode !== "disabled") throw new TypeError(`configureReadReplication() called with unknown mode setting: ${options.mode}.`);
-		return this.#ctx.awaitIo(storage.getActorCacheInterface().configureReadReplication(options.mode === "auto"));
-	}
-	acceptWebSocket(_ws, _tags) {
-		throw new Error(HIBERNATION_UNIMPLEMENTED_MESSAGE);
-	}
-	getWebSockets(_tag) {
-		throw new Error(HIBERNATION_UNIMPLEMENTED_MESSAGE);
-	}
-	setWebSocketAutoResponse(_maybeReqResp) {
-		throw new Error(HIBERNATION_UNIMPLEMENTED_MESSAGE);
-	}
-	getWebSocketAutoResponse() {
-		throw new Error(HIBERNATION_UNIMPLEMENTED_MESSAGE);
-	}
-	getWebSocketAutoResponseTimestamp(_ws) {
-		throw new Error(HIBERNATION_UNIMPLEMENTED_MESSAGE);
-	}
-	setHibernatableWebSocketEventTimeout(_timeoutMs) {
-		throw new Error(HIBERNATION_UNIMPLEMENTED_MESSAGE);
-	}
-	getHibernatableWebSocketEventTimeout() {
-		throw new Error(HIBERNATION_UNIMPLEMENTED_MESSAGE);
-	}
-	getTags(_ws) {
-		throw new Error(HIBERNATION_UNIMPLEMENTED_MESSAGE);
-	}
-};
+function notSerializableType(value) {
+	if (value instanceof LoopbackServiceStub) return "LoopbackServiceStub";
+	if (value instanceof LoopbackDurableObjectNamespace) return "LoopbackDurableObjectNamespace";
+	if (value instanceof LoopbackColoLocalActorNamespace) return "LoopbackColoLocalActorNamespace";
+	if (value instanceof LoopbackDurableObjectClass) return "LoopbackDurableObjectClass";
+}
 //#endregion
 //#region src/api/http.ts
 /**
@@ -3019,10 +962,11 @@ var ActorGlobalScope = class {
 	#readCurrentExternalEntry;
 	scheduler;
 	crypto;
-	constructor(ctx, options = {}) {
+	constructor(ctx, options) {
 		this.#ctx = ctx;
 		this.#fetch = options.fetch;
 		this.#readCurrentExternalEntry = options.currentExternalEntry;
+		installWebSocketGlobals(this, options.webSockets.WebSocketPair);
 		this.scheduler = new Scheduler(this);
 		this.crypto = new GatedCrypto((op) => {
 			this.#requireOwnSlice(op);
@@ -3127,6 +1071,7 @@ var ActorGlobalScope = class {
 * scope instead. A single-actor host simply writes `() => scope`.
 */
 function actorScopeBindings(resolve) {
+	const BoundWebSocketPair = new Proxy(class WebSocketPair {}, { construct: () => new (resolve()).WebSocketPair() });
 	return {
 		awaitIo: (promise) => resolve().awaitIo(promise),
 		scheduler: {
@@ -3143,6 +1088,9 @@ function actorScopeBindings(resolve) {
 		},
 		fetch: (input, init) => resolve().fetch(input, init),
 		crypto: scopeCrypto(resolve),
+		WebSocket: globalThis.WebSocket,
+		WebSocketPair: BoundWebSocketPair,
+		WebSocketRequestResponsePair: RuntimeWebSocketRequestResponsePair,
 		get currentExternalEntry() {
 			return resolve().currentExternalEntry;
 		}
@@ -3153,7 +1101,7 @@ function actorScopeBindings(resolve) {
 * an operation actually runs.
 *
 * That laziness is required rather than tidy, and both lanes proved it. A facet's
-* module destructures its seven names at module scope, which is BEFORE its container
+* module destructures its actor globals at module scope, which is BEFORE its container
 * exists — so a `crypto` that resolved on read threw at import. And on the root
 * path `globalThis.crypto` is read by things that are not the actor at all: capnweb,
 * the sqlite driver, the test runner. So the binding is a pair of plain objects
@@ -3199,8 +1147,8 @@ var ASYNC_SUBTLE_METHODS = [
 * one that is not.
 *
 * **A host should call this rather than assigning the names itself**, and the
-* reason is the failure it prevents: a host that installs five of the six leaves
-* one primitive ungated, and an ungated primitive that WORKS is invisible until
+* reason is the failure it prevents: a host that installs only a subset leaves a
+* primitive ungated, and an ungated primitive that WORKS is invisible until
 * a continuation after it touches storage — possibly never, on the path that
 * matters. The set is the package's, so it can grow without every host growing
 * with it.
@@ -3229,153 +1177,6 @@ function installActorScope(target, resolve) {
 		});
 	}
 }
-//#endregion
-//#region src/api/web-socket.ts
-/** ← the `JSG_REQUIRE(!native.state.is<Accepted>(), ...)` at the head of `accept()`. */
-var ALREADY_ACCEPTED_MESSAGE = "acceptWebSocket(): this socket has already been accepted by an actor. A socket's frames are delivered by exactly one read loop, and a second accept would deliver them under two gates.";
-/** Sockets this runtime has accepted, so the refusal above is answerable. */
-var accepted = /* @__PURE__ */ new WeakSet();
-/** The four events a `WebSocket` dispatches, which `readLoop` and its `.then` cover upstream. */
-var SOCKET_EVENTS = [
-	"open",
-	"message",
-	"close",
-	"error"
-];
-/**
-* ← `WebSocket::Accepted` (`web-socket.h:~300-360`), reached through
-* `accept()` → `internalAccept(js, IoContext::current().getCriticalSection())`
-* → `startReadLoop` (`web-socket.c++:133`, `:426`, `:429-433`, `:507`).
-*
-* An `EventTarget`, so a consumer registers listeners the way it would on a real
-* socket — but on THIS object rather than on the raw one, because this is what
-* runs them inside a gated slice.
-*/
-var AcceptedWebSocket = class extends EventTarget {
-	#ctx;
-	#socket;
-	/**
-	* ← `readLoop`'s `cs` parameter, captured at accept and replayed for every
-	* frame via `mapAddRef(cs)` (`web-socket.c++:1110`). A socket accepted inside
-	* `blockConcurrencyWhile` therefore delivers its messages inside that critical
-	* section — §1.8's second bullet, and the reason this is captured here rather
-	* than read when a frame arrives.
-	*/
-	#criticalSection;
-	/**
-	* ← `OutgoingMessagesMap outgoingMessages` plus `ensurePumping`
-	* (`web-socket.h:582-590`, `web-socket.c++:948-975`), as a chain.
-	*
-	* The table is insertion-ordered and the pump awaits each entry's own
-	* `outputLock` before sending it, so messages leave in order and message N
-	* waits only for the writes outstanding when IT was enqueued. A promise chain
-	* is the same two properties with nothing to schedule.
-	*/
-	#pump = Promise.resolve();
-	onopen = null;
-	onmessage = null;
-	onclose = null;
-	onerror = null;
-	constructor(ctx, socket) {
-		super();
-		this.#ctx = ctx;
-		this.#socket = socket;
-		this.#criticalSection = ctx.getCriticalSection();
-		for (const type of SOCKET_EVENTS) socket.addEventListener(type, (event) => {
-			this.#deliver(type, event);
-		});
-	}
-	/**
-	* ← `co_await context.run([...](auto& wLock) { dispatchEventImpl(...) }, mapAddRef(cs))`
-	* (`web-socket.c++:1065-1110`).
-	*
-	* The run rides `addWaitUntil`, as upstream's read loop does ("We put the read
-	* loop in a `waitUntil`, since there would otherwise be a race condition
-	* between delivering the final close message and the request being canceled",
-	* `web-socket.c++:537-541`). That is also what stops a listener's throw
-	* becoming an unhandled rejection: it lands in `waitUntilStatus()`.
-	*/
-	#deliver(type, event) {
-		this.#ctx.addWaitUntil(this.#ctx.run(() => {
-			const delivered = cloneEventFor(type, event);
-			this.dispatchEvent(delivered);
-			const handler = this[`on${type}`];
-			handler?.(delivered);
-		}, { input: this.#criticalSection }));
-	}
-	/**
-	* ← `WebSocket::send` (`web-socket.c++:~640`), which inserts a
-	* `GatedMessage{IoContext::current().waitForOutputLocksIfNecessary(), …}`.
-	*
-	* Synchronous, as upstream's is: the wait is the pump's, not the caller's. The
-	* output gate is what "blocks all outgoing messages from an actor that would
-	* allow the rest of the world to observe the actor's state" (§1.1), and a
-	* socket frame is exactly such a message.
-	*
-	* `waitForOutputLocksIfNecessary()` collapses to `waitForOutputLocks()` here
-	* for the reason the whole file collapses `kj::Maybe<Worker::Actor&>`: its
-	* body is `actor.map(…)` (`io-context.c++:383-386`) and every context in this
-	* runtime is an actor context.
-	*/
-	send(data) {
-		this.#enqueue(() => {
-			this.#socket.send(data);
-		});
-	}
-	/** ← `WebSocket::close`, which enqueues a `Close` through the same gate. */
-	close(code, reason) {
-		this.#enqueue(() => {
-			this.#socket.close(code, reason);
-		});
-	}
-	#enqueue(write) {
-		const outputLock = this.#ctx.waitForOutputLocks();
-		this.#pump = this.#pump.then(async () => {
-			await outputLock;
-			write();
-		});
-		this.#ctx.addWaitUntil(this.#pump);
-	}
-};
-/**
-* ← `accept()` / `state.acceptWebSocket()`, as the one verb.
-*
-* Named for what upstream names it, because the critical-section capture is a
-* property of accepting rather than of constructing: "a socket accepted inside a
-* `blockConcurrencyWhile` delivers its messages inside that critical section"
-* (§1.8).
-*/
-function acceptWebSocket(ctx, socket) {
-	if (accepted.has(socket)) throw new Error(ALREADY_ACCEPTED_MESSAGE);
-	accepted.add(socket);
-	return new AcceptedWebSocket(ctx, socket);
-}
-/**
-* An `Event` may be dispatched by exactly one target at a time, so the raw
-* socket's event object cannot be re-dispatched: `dispatchEvent` on an event
-* that is already dispatched throws `InvalidStateError`, and one that has
-* finished carries the raw socket as its `target`. Rebuilding it is what makes
-* `event.target` the accepted socket, which is what a listener expects.
-*/
-function cloneEventFor(type, event) {
-	if (type === "message") {
-		const source = event;
-		return new MessageEvent("message", {
-			data: source.data,
-			origin: source.origin,
-			lastEventId: source.lastEventId
-		});
-	}
-	if (type === "close") {
-		const source = event;
-		return new CloseEvent("close", {
-			code: source.code,
-			reason: source.reason,
-			wasClean: source.wasClean
-		});
-	}
-	return new Event(type);
-}
 /**
 * ← the message every unimplemented `ActorCacheInterface` PITR method throws.
 * `ActorSqlite` overrides two of the four; the other two keep this.
@@ -5608,14 +3409,16 @@ var ActorTree = class {
 * which is the whole mechanism behind §1.10's parent↔child re-entrancy.
 */
 var ActorImpl = class {
-	#inputGate = new InputGate();
-	#outputGate = new OutputGate();
+	#inputGate;
+	#outputGate;
 	#isFacet;
 	/** Assigned after construction; `storage` is a WXT auto-import in extension bundles. */
 	actorStorage;
 	classInstance = { kind: "before-ctor" };
-	constructor(isFacet) {
+	constructor(isFacet, hooks = {}) {
 		this.#isFacet = isFacet;
+		this.#inputGate = new InputGate(hooks.input);
+		this.#outputGate = new OutputGate(hooks.output);
 	}
 	getInputGate() {
 		return this.#inputGate;
@@ -5925,6 +3728,7 @@ var ActorContainerImpl = class {
 	#facets;
 	#tree;
 	#env;
+	#webSockets;
 	state;
 	facetTree;
 	globals;
@@ -5932,16 +3736,22 @@ var ActorContainerImpl = class {
 	#alarmTail = Promise.resolve();
 	constructor(options, db, tree, facetTree) {
 		const facet = options.facet;
-		this.#actor = new ActorImpl(facet !== void 0);
+		this.#actor = new ActorImpl(facet !== void 0, options.gateHooks);
 		this.#ctx = new IoContext(this.#actor, options.ports.timer);
 		this.#env = options.env;
 		this.#tree = tree;
 		this.#cache = new ActorSqlite(db, this.#actor.getOutputGate(), async () => {}, facet === void 0 ? options.ports.alarms : DEFAULT_ALARM_OUTLET);
 		this.#actor.actorStorage = this.#cache;
 		this.#durableStorage = new DurableObjectStorage(this.#ctx, this.#cache);
+		this.#webSockets = new HibernatableWebSocketRegistry(this.#ctx, {
+			message: (socket, message) => this.#runWebSocketHandler("webSocketMessage", socket, message),
+			close: (socket, code, reason, wasClean) => this.#runWebSocketHandler("webSocketClose", socket, code, reason, wasClean),
+			error: (socket, error) => this.#runWebSocketHandler("webSocketError", socket, error)
+		}, options.ports.hibernation, options.webSockets);
 		this.globals = new ActorGlobalScope(this.#ctx, {
 			fetch: options.ports.fetch,
-			currentExternalEntry: () => this.#currentExternalEntry
+			currentExternalEntry: () => this.#currentExternalEntry,
+			webSockets: this.#webSockets
 		});
 		this.facetTree = facetTree;
 		this.#facets = new FacetManagerImpl(this, options.ports.facets, facet?.id ?? 0, facet?.depth ?? 0, this.facetTree);
@@ -5955,7 +3765,8 @@ var ActorContainerImpl = class {
 			props: void 0,
 			storage: this.#durableStorage,
 			facets: this.#facets,
-			globals: actorScopeBindings(() => this.globals)
+			globals: actorScopeBindings(() => this.globals),
+			webSockets: this.#webSockets
 		});
 	}
 	get onBroken() {
@@ -6089,6 +3900,14 @@ var ActorContainerImpl = class {
 	drainWaitUntil() {
 		return this.#ctx.drainWaitUntil();
 	}
+	quiescence() {
+		return {
+			armedTimers: this.#ctx.getTimeoutCount(),
+			pendingWaitUntil: this.#ctx.waitUntilTaskCount(),
+			inputLockHeld: this.#ctx.hasCurrent(),
+			outputGateBroken: this.#ctx.isOutputGateBroken()
+		};
+	}
 	/** ← `WorkerdApi::compileGlobals`'s `Global::WorkerLoader` arm. */
 	workerLoader(channel, options) {
 		return new WorkerLoader(this.#ctx, channel, options);
@@ -6182,6 +4001,13 @@ var ActorContainerImpl = class {
 		if (!hasAlarmHandler(instance.instance)) throw new TypeError("Your Durable Object class must have an alarm() handler.");
 		return instance.instance.alarm(new AlarmInvocationInfo(scheduledTime, retryCount));
 	}
+	#runWebSocketHandler(name, socket, ...args) {
+		const instance = this.#actor.classInstance;
+		if (instance.kind !== "running") return void 0;
+		const handler = Reflect.get(instance.instance, name);
+		if (typeof handler !== "function") return void 0;
+		return Reflect.apply(handler, instance.instance, [socket, ...args]);
+	}
 };
 /**
 * Builds one actor: the two gates, the `IoContext` over them, the storage engine
@@ -6203,6 +4029,53 @@ async function createActorContainer(options) {
 	return new ActorContainerImpl(options, db, tree, tree);
 }
 //#endregion
+//#region src/server/hibernation-mirror.ts
+/** In-memory socket state shared by embedders that replace live actor containers. */
+var HibernationMirror = class {
+	#entries = /* @__PURE__ */ new Map();
+	#autoResponsePair;
+	constructor(rehydrated = [], autoResponsePair = null) {
+		for (const value of rehydrated) this.#entries.set(value.socket, cloneEntry(value));
+		this.#autoResponsePair = cloneAutoResponse(autoResponsePair);
+	}
+	get autoResponsePair() {
+		return cloneAutoResponse(this.#autoResponsePair);
+	}
+	accepted(socket, tags) {
+		this.#entries.set(socket, {
+			socket,
+			tags: [...tags]
+		});
+	}
+	attachment(socket, bytes) {
+		const entry = this.#entries.get(socket);
+		if (entry === void 0) throw new Error("Hibernation mirror: attachment preceded socket acceptance.");
+		if (bytes === null) delete entry.attachment;
+		else entry.attachment = bytes.slice();
+	}
+	autoResponse(pair) {
+		this.#autoResponsePair = cloneAutoResponse(pair);
+	}
+	closed(socket) {
+		this.#entries.delete(socket);
+	}
+	snapshot() {
+		return [...this.#entries.values()].map(cloneEntry);
+	}
+};
+function cloneEntry(value) {
+	const entry = {
+		socket: value.socket,
+		tags: [...value.tags ?? []]
+	};
+	if (value.attachment !== void 0) entry.attachment = value.attachment.slice();
+	if (value.autoResponseTimestamp !== void 0) entry.autoResponseTimestamp = value.autoResponseTimestamp;
+	return entry;
+}
+function cloneAutoResponse(pair) {
+	return pair === null ? null : { ...pair };
+}
+//#endregion
 //#region src/server/actor-namespace.ts
 /** Assemble the configured namespace binding a host places in `env`. */
 function createDurableObjectNamespace(uniqueKey, channel) {
@@ -6252,6 +4125,6 @@ function newRpcSession(port, localMain) {
 	return newMessagePortRpcSession(port, localMain);
 }
 //#endregion
-export { ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE, ALARM_RETRY_MAX_TRIES, ALARM_RETRY_START_SECONDS, ALLOW_EXPERIMENTAL_MESSAGE, ALREADY_ACCEPTED_MESSAGE, AlarmInvocationInfo, AlarmScheduler, BYOB_READER_UNGATABLE_MESSAGE, BrokenActorError, CanceledError, DEAD_LOAD_CONTEXT_MESSAGE, DEFAULT_ALARM_OUTLET, FACET_ALARM_UNIMPLEMENTED_MESSAGE, FACET_NAME_MAX_LENGTH, FACET_TREE_MAX_DEPTH, FOREIGN_SLICE_MESSAGE, HIBERNATION_UNIMPLEMENTED_MESSAGE, LoopbackDurableObjectClass, NOT_BYTES_MESSAGE, NO_GLOBAL_OUTBOUND_MESSAGE, NO_MODULES_MESSAGE, PITR_UNIMPLEMENTED_MESSAGE, REPLICATION_UNIMPLEMENTED_MESSAGE, RETRY_BACKOFF_MAX, RETRY_JITTER_FACTOR, STREAMING_TAILS_EXPERIMENTAL_MESSAGE, WorkerLoader, WorkerStub, actorScopeBindings, alarmRetryDelayMs, asLoopbackDurableObjectClass, createActorContainer, createDurableObjectNamespace, gateRequestBody, installActorScope, jsModuleInPythonWorkerMessage, moduleFieldCountMessage, moduleNameMessage, newRpcSession, noFacets, notSerializableMessage, pythonModuleInJsWorkerMessage, typeScriptModuleNameMessage };
+export { ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE, ALARM_RETRY_MAX_TRIES, ALARM_RETRY_START_SECONDS, ALLOW_EXPERIMENTAL_MESSAGE, ALREADY_ACCEPTED_MESSAGE, AlarmInvocationInfo, AlarmScheduler, BYOB_READER_UNGATABLE_MESSAGE, BrokenActorError, CanceledError, DEAD_LOAD_CONTEXT_MESSAGE, DEFAULT_ALARM_OUTLET, FACET_ALARM_UNIMPLEMENTED_MESSAGE, FACET_NAME_MAX_LENGTH, FACET_TREE_MAX_DEPTH, FOREIGN_SLICE_MESSAGE, HibernationMirror, LoopbackDurableObjectClass, NOT_BYTES_MESSAGE, NO_GLOBAL_OUTBOUND_MESSAGE, NO_MODULES_MESSAGE, PITR_UNIMPLEMENTED_MESSAGE, REPLICATION_UNIMPLEMENTED_MESSAGE, RETRY_BACKOFF_MAX, RETRY_JITTER_FACTOR, STREAMING_TAILS_EXPERIMENTAL_MESSAGE, RuntimeWebSocketRequestResponsePair as WebSocketRequestResponsePair, WorkerLoader, WorkerStub, actorScopeBindings, alarmRetryDelayMs, asLoopbackDurableObjectClass, createActorContainer, createDurableObjectNamespace, gateRequestBody, installActorScope, installWebSocketGlobals, jsModuleInPythonWorkerMessage, markWebSocketUsed, moduleFieldCountMessage, moduleNameMessage, newRpcSession, noFacets, notSerializableMessage, pythonModuleInJsWorkerMessage, typeScriptModuleNameMessage };
 
 //# sourceMappingURL=index.js.map