@mcp-b/do-runtime 0.5.0 → 0.6.1

package/dist/chunks/web-socket-W63BdFn5.js

@@ -0,0 +1,2574 @@
+import { c as setUserErrorDetail, s as requireInputLock } from "./io-context-BBgKEsdR.js";
+import { deserialize, serialize } from "@ungap/structured-clone";
+//#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 = "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$2 = new TextEncoder();
+/** `kj::String::size()` is bytes; `String.prototype.length` is UTF-16 code units. */
+function utf8Length(value) {
+	return textEncoder$2.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);
+}
+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/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: 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;
+/**
+* ← 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$1 = 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$1.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;
+}
+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`).
+*
+* 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.
+*/
+function requireValidFacetName(name) {
+	if (textEncoder$1.encode(name).length > 256) throw new TypeError(`Facet name is too long (max 256 characters).`);
+}
+/**
+* ← the `KJ_SWITCH_ONEOF(options.$class)` lambda (`actor-state.c++:1029-1043`).
+*
+* 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.
+*
+* 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.
+*/
+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);
+}
+/**
+* ← `DurableObjectFacets`.
+*
+* **`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.
+*/
+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) {
+		this.#options.webSockets.acceptWebSocket(ws, tags);
+	}
+	getWebSockets(tag) {
+		return tag === void 0 ? this.#options.webSockets.getWebSockets() : this.#options.webSockets.getWebSockets(tag);
+	}
+	setWebSocketAutoResponse(maybeReqResp) {
+		this.#options.webSockets.setWebSocketAutoResponse(maybeReqResp);
+	}
+	getWebSocketAutoResponse() {
+		return this.#options.webSockets.getWebSocketAutoResponse();
+	}
+	getWebSocketAutoResponseTimestamp(ws) {
+		return this.#options.webSockets.getWebSocketAutoResponseTimestamp(ws);
+	}
+	setHibernatableWebSocketEventTimeout(timeoutMs) {
+		this.#options.webSockets.setHibernatableWebSocketEventTimeout(timeoutMs);
+	}
+	getHibernatableWebSocketEventTimeout() {
+		return this.#options.webSockets.getHibernatableWebSocketEventTimeout();
+	}
+	getTags(ws) {
+		return this.#options.webSockets.getTags(ws);
+	}
+};
+//#endregion
+//#region src/api/web-socket.ts
+var WebSocketRequestResponsePairImpl = class {
+	#request;
+	#response;
+	constructor(request, response) {
+		this.#request = String(request);
+		this.#response = String(response);
+	}
+	get request() {
+		return this.#request;
+	}
+	get response() {
+		return this.#response;
+	}
+};
+var RuntimeWebSocketRequestResponsePair = new Proxy(WebSocketRequestResponsePairImpl, { apply() {
+	throw new TypeError("Failed to construct 'WebSocketRequestResponsePair': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+} });
+/** ← 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.";
+var HIBERNATION_ALREADY_ACCEPTED_MESSAGE = "Cannot call `acceptWebSocket()` if the WebSocket was already accepted via `accept()`";
+var HIBERNATION_AFTER_ACCEPT_MESSAGE = "Can't accept() WebSocket after enabling hibernation.";
+var HIBERNATION_PAIR_USED_MESSAGE = "Cannot call `acceptWebSocket()` on this WebSocket because its pair has already been accepted or used in a Response.";
+var MAX_HIBERNATABLE_SOCKETS = 32768;
+var MAX_TAGS = 10;
+var MAX_TAG_LENGTH = 256;
+var MAX_ATTACHMENT_BYTES = 16384;
+var MAX_AUTO_RESPONSE_BYTES = 2048;
+var MAX_EVENT_TIMEOUT = 6048e5;
+var MAX_CLOSE_REASON_BYTES = 123;
+var WEB_SOCKET_READY_STATES = {
+	READY_STATE_CONNECTING: 0,
+	READY_STATE_OPEN: 1,
+	READY_STATE_CLOSING: 2,
+	READY_STATE_CLOSED: 3,
+	CONNECTING: 0,
+	OPEN: 1,
+	CLOSING: 2,
+	CLOSED: 3
+};
+var textEncoder = new TextEncoder();
+var SOCKET_EVENTS = [
+	"open",
+	"message",
+	"close",
+	"error"
+];
+var metadata = /* @__PURE__ */ new WeakMap();
+function socketMetadata(socket) {
+	let value = metadata.get(socket);
+	if (value === void 0) {
+		value = {};
+		metadata.set(socket, value);
+	}
+	return value;
+}
+function isRawWebSocket(value) {
+	return typeof value === "object" && value !== null && "addEventListener" in value && typeof value.addEventListener === "function" && "send" in value && typeof value.send === "function" && "close" in value && typeof value.close === "function";
+}
+function requireWebSocket(value, operation) {
+	if (!isRawWebSocket(value)) throw new TypeError(`Failed to execute '${operation}' on 'WebSocket': parameter 1 is not of type 'WebSocket'.`);
+	return value;
+}
+function serializeAttachment(socket, value) {
+	try {
+		structuredClone(value);
+	} catch (error) {
+		if (error instanceof DOMException && error.name === "DataCloneError") throw new DOMException(error.message.replace(/^Failed to execute 'structuredClone' on '[^']+': /, ""), "DataCloneError");
+		throw error;
+	}
+	const bytes = serializeValue(value);
+	const measuredBytes = typeof value === "string" ? textEncoder.encode(value).byteLength + 5 : bytes.byteLength;
+	if (measuredBytes > MAX_ATTACHMENT_BYTES) throw new Error(`A WebSocket 'attachment' cannot be larger than ${MAX_ATTACHMENT_BYTES} bytes.'attachment' was ${measuredBytes} bytes.`);
+	const state = socketMetadata(socket);
+	state.attachment = bytes;
+	if (state.accepted?.mode === "hibernatable") state.accepted.registry.attachmentChanged(socket, bytes);
+}
+function deserializeAttachment(socket) {
+	const attachment = socketMetadata(socket).attachment;
+	if (attachment === void 0) return null;
+	return deserializeValue("WebSocket attachment", attachment);
+}
+function serializeAttachmentMethod(value) {
+	if (arguments.length === 0) throw new TypeError("Failed to execute 'serializeAttachment' on 'WebSocket': parameter 1 is not of type 'Value'.");
+	serializeAttachment(requireWebSocket(this, "serializeAttachment"), value);
+}
+function deserializeAttachmentMethod() {
+	return deserializeAttachment(requireWebSocket(this, "deserializeAttachment"));
+}
+function cloneMessageData(data) {
+	if (typeof data === "string" || data instanceof Blob) return data;
+	if (data instanceof ArrayBuffer) return data.slice(0);
+	if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength).slice().buffer;
+	return String(data);
+}
+var MemoryWebSocketEndpoint = class extends EventTarget {
+	peer;
+	#sentClose = false;
+	send(data) {
+		this.peer.dispatchEvent(new MessageEvent("message", { data: cloneMessageData(data) }));
+	}
+	close(code = 1e3, reason = "") {
+		if (this.#sentClose) return;
+		this.#sentClose = true;
+		this.peer.dispatchEvent(new CloseEvent("close", {
+			code,
+			reason,
+			wasClean: true
+		}));
+	}
+};
+/** One public socket identity, in classic or hibernatable mode after acceptance. */
+var AcceptedWebSocket = class AcceptedWebSocket extends EventTarget {
+	static READY_STATE_CONNECTING = WEB_SOCKET_READY_STATES.READY_STATE_CONNECTING;
+	static READY_STATE_OPEN = WEB_SOCKET_READY_STATES.READY_STATE_OPEN;
+	static READY_STATE_CLOSING = WEB_SOCKET_READY_STATES.READY_STATE_CLOSING;
+	static READY_STATE_CLOSED = WEB_SOCKET_READY_STATES.READY_STATE_CLOSED;
+	static CONNECTING = WEB_SOCKET_READY_STATES.CONNECTING;
+	static OPEN = WEB_SOCKET_READY_STATES.OPEN;
+	static CLOSING = WEB_SOCKET_READY_STATES.CLOSING;
+	static CLOSED = WEB_SOCKET_READY_STATES.CLOSED;
+	bufferedAmount = 0;
+	extensions = "";
+	protocol = "";
+	url = "";
+	#ctx;
+	#socket;
+	#pairState;
+	#delivery = { mode: "pending" };
+	#pump = Promise.resolve();
+	#pending = [];
+	#readyState = AcceptedWebSocket.OPEN;
+	#ownClose = false;
+	#peerClose = false;
+	#binaryType = "blob";
+	onopen = null;
+	onmessage = null;
+	onclose = null;
+	onerror = null;
+	constructor(ctx, socket, pairState) {
+		super();
+		this.#ctx = ctx;
+		this.#socket = socket;
+		this.#pairState = pairState;
+		if (pairState === void 0) this.#enableClassic();
+		for (const type of SOCKET_EVENTS) socket.addEventListener(type, (event) => {
+			this.#receive(type, event);
+		});
+	}
+	get readyState() {
+		return this.#readyState;
+	}
+	get binaryType() {
+		return this.#binaryType;
+	}
+	set binaryType(value) {
+		this.#binaryType = value;
+	}
+	accept() {
+		if (this.#delivery.mode === "hibernatable") throw new TypeError(HIBERNATION_AFTER_ACCEPT_MESSAGE);
+		if (this.#delivery.mode === "classic") throw new Error(ALREADY_ACCEPTED_MESSAGE);
+		if (this.#pairState !== void 0) this.#pairState.used = true;
+		this.#enableClassic();
+	}
+	send(data) {
+		if (this.#delivery.mode === "hibernatable" && this.#ownClose) throw new TypeError("Can't call WebSocket send() after close().");
+		if (this.#peerClose || this.#readyState === AcceptedWebSocket.CLOSED) return;
+		this.#markPairUsed();
+		this.#enqueue(() => this.#socket.send(data));
+	}
+	close(code, reason = "") {
+		if (this.#readyState === AcceptedWebSocket.CLOSED || this.#ownClose) return;
+		if (this.#delivery.mode === "hibernatable" || this.#pairState !== void 0) validateClose(code, reason);
+		this.#markPairUsed();
+		this.#ownClose = true;
+		this.#readyState = this.#peerClose ? AcceptedWebSocket.CLOSED : AcceptedWebSocket.CLOSING;
+		this.#enqueue(() => this.#socket.close(code, reason));
+	}
+	serializeAttachment(value) {
+		if (arguments.length === 0) serializeAttachmentMethod.call(this);
+		else serializeAttachment(this, value);
+	}
+	deserializeAttachment() {
+		return deserializeAttachment(this);
+	}
+	acceptHibernation(registry) {
+		if (this.#delivery.mode !== "pending") throw new Error(HIBERNATION_ALREADY_ACCEPTED_MESSAGE);
+		if (this.#pairState?.used === true && !this.#pairState.hibernationAccepted) throw new Error(HIBERNATION_PAIR_USED_MESSAGE);
+		if (this.#pairState !== void 0) {
+			this.#pairState.used = true;
+			this.#pairState.hibernationAccepted = true;
+		}
+		this.#activateHibernation(registry, this.#ctx);
+	}
+	rehydrateHibernation(registry, ctx) {
+		this.#activateHibernation(registry, ctx);
+	}
+	#activateHibernation(registry, ctx) {
+		this.#ctx = ctx;
+		this.#delivery = {
+			mode: "hibernatable",
+			registry
+		};
+		this.#pending = [];
+	}
+	markPairUsed() {
+		this.#markPairUsed();
+	}
+	#markPairUsed() {
+		if (this.#pairState !== void 0) this.#pairState.used = true;
+	}
+	#enableClassic() {
+		const delivery = {
+			mode: "classic",
+			criticalSection: this.#ctx.getCriticalSection()
+		};
+		this.#delivery = delivery;
+		socketMetadata(this).accepted = { mode: "classic" };
+		const pending = this.#pending;
+		this.#pending = [];
+		for (const item of pending) this.#deliverClassic(item.type, item.event, delivery.criticalSection);
+	}
+	#receive(type, event) {
+		if (type === "close") {
+			this.#receiveClose(event);
+			return;
+		}
+		const delivery = this.#delivery;
+		if (delivery.mode === "pending") this.#pending.push({
+			type,
+			event
+		});
+		else if (delivery.mode === "classic") this.#deliverClassic(type, event, delivery.criticalSection);
+		else delivery.registry.receive(this, type, event);
+	}
+	#receiveClose(event) {
+		if (this.#ownClose) this.#readyState = AcceptedWebSocket.CLOSED;
+		else {
+			this.#peerClose = true;
+			this.#readyState = AcceptedWebSocket.CLOSING;
+			if (this.#delivery.mode === "classic" && this.#pairState !== void 0) {
+				if (event.code === 1005 || event.code === 1006 || event.code === 1015) this.#readyState = AcceptedWebSocket.CLOSED;
+				else this.close(event.code, event.reason);
+			}
+		}
+		const delivery = this.#delivery;
+		if (delivery.mode === "pending") this.#pending.push({
+			type: "close",
+			event
+		});
+		else if (delivery.mode === "classic") this.#deliverClassic("close", event, delivery.criticalSection);
+		else delivery.registry.receive(this, "close", event);
+	}
+	#deliverClassic(type, event, criticalSection) {
+		this.#ctx.addWaitUntil(this.#ctx.run(() => {
+			const delivered = cloneEventFor(type, event);
+			this.dispatchEvent(delivered);
+			const handler = this[`on${type}`];
+			handler?.(delivered);
+		}, { input: criticalSection }));
+	}
+	#enqueue(write) {
+		const outputLock = this.#ctx.waitForOutputLocks();
+		this.#pump = this.#pump.then(async () => {
+			await outputLock;
+			write();
+		});
+		this.#ctx.addWaitUntil(this.#pump);
+	}
+};
+for (const [name, value] of Object.entries(WEB_SOCKET_READY_STATES)) Object.defineProperty(AcceptedWebSocket.prototype, name, {
+	value,
+	enumerable: true
+});
+var HibernatableWebSocketRegistry = class {
+	#ctx;
+	#dispatch;
+	#host;
+	#entries = [];
+	#autoResponse = null;
+	#eventTimeout = null;
+	#pairConstructor;
+	constructor(ctx, dispatch, host, rehydrated = []) {
+		this.#ctx = ctx;
+		this.#dispatch = dispatch;
+		this.#host = host;
+		for (const value of rehydrated) this.#rehydrate(value);
+	}
+	get WebSocketPair() {
+		const registry = this;
+		this.#pairConstructor ??= new Proxy(class WebSocketPair {}, { construct: () => registry.#createPair() });
+		return this.#pairConstructor;
+	}
+	acceptWebSocket(socket, tags) {
+		if (!isRawWebSocket(socket)) throw new TypeError("Failed to execute 'acceptWebSocket' on 'DurableObjectState': parameter 1 is not of type 'WebSocket'.");
+		const state = socketMetadata(socket);
+		if (state.accepted !== void 0) throw new Error(HIBERNATION_ALREADY_ACCEPTED_MESSAGE);
+		if (this.#entries.length >= MAX_HIBERNATABLE_SOCKETS) throw new Error(`only ${MAX_HIBERNATABLE_SOCKETS} websockets can be accepted on a single Durable Object instance`);
+		const normalizedTags = normalizeTags(tags);
+		if (socket instanceof AcceptedWebSocket) socket.acceptHibernation(this);
+		else this.#listenRaw(socket);
+		state.accepted = {
+			mode: "hibernatable",
+			registry: this
+		};
+		this.#entries.push({
+			socket,
+			tags: normalizedTags
+		});
+		this.#host?.accepted(socket, normalizedTags);
+	}
+	getWebSockets(tag) {
+		if (arguments.length > 0) {
+			if (typeof tag !== "string") return [];
+			return this.#entries.filter((entry) => entry.tags.includes(tag)).map((entry) => entry.socket);
+		}
+		return this.#entries.map((entry) => entry.socket).reverse();
+	}
+	getTags(socket) {
+		const state = isRawWebSocket(socket) ? metadata.get(socket) : void 0;
+		if (state?.accepted === void 0) throw new Error("you must call 'acceptWebSocket()' before attempting to access the tags of a WebSocket.");
+		if (state.accepted.mode !== "hibernatable") throw new Error("only hibernatable websockets can have tags.");
+		const entry = this.#entries.find((candidate) => candidate.socket === socket);
+		if (entry === void 0) throw new Error("you must call 'acceptWebSocket()' before attempting to access the tags of a WebSocket.");
+		return [...entry.tags];
+	}
+	setWebSocketAutoResponse(pair) {
+		if (pair === void 0) {
+			this.#autoResponse = null;
+			this.#host?.autoResponse(null);
+			return;
+		}
+		if (!(pair instanceof WebSocketRequestResponsePairImpl)) throw new TypeError("Failed to execute 'setWebSocketAutoResponse' on 'DurableObjectState': parameter 1 is not of type 'WebSocketRequestResponsePair'.");
+		validateAutoResponseSize("Request", pair.request);
+		validateAutoResponseSize("Response", pair.response);
+		this.#autoResponse = pair;
+		this.#host?.autoResponse({
+			request: pair.request,
+			response: pair.response
+		});
+	}
+	getWebSocketAutoResponse() {
+		const pair = this.#autoResponse;
+		return pair === null ? null : new RuntimeWebSocketRequestResponsePair(pair.request, pair.response);
+	}
+	getWebSocketAutoResponseTimestamp(socket) {
+		if (!isRawWebSocket(socket)) throw new TypeError("Failed to execute 'getWebSocketAutoResponseTimestamp' on 'DurableObjectState': parameter 1 is not of type 'WebSocket'.");
+		const timestamp = this.#entries.find((entry) => entry.socket === socket)?.autoResponseTimestamp;
+		return timestamp === void 0 ? null : new Date(timestamp);
+	}
+	setHibernatableWebSocketEventTimeout(value) {
+		if (value === void 0 || Number(value) === 0) {
+			this.#eventTimeout = null;
+			return;
+		}
+		const number = Number(value);
+		if (Number.isNaN(number)) throw new TypeError("The value cannot be converted because it is not an integer.");
+		if (number < 0) throw new TypeError("The value cannot be converted because it is negative and this API expects a positive number.");
+		if (number > 4294967295) throw new TypeError("Value out of range. Must be less than or equal to 4294967295.");
+		const timeout = Math.trunc(number);
+		if (timeout > MAX_EVENT_TIMEOUT) throw new Error(`Event timeout should not exceed ${MAX_EVENT_TIMEOUT} ms.`);
+		this.#eventTimeout = timeout;
+	}
+	getHibernatableWebSocketEventTimeout() {
+		return this.#eventTimeout;
+	}
+	attachmentChanged(socket, bytes) {
+		if (this.#entries.some((entry) => entry.socket === socket)) this.#host?.attachment(socket, bytes);
+	}
+	receive(socket, type, event) {
+		const entry = this.#entries.find((candidate) => candidate.socket === socket);
+		if (entry === void 0) return;
+		if (type === "message") {
+			const data = event.data;
+			if (typeof data === "string" && data === this.#autoResponse?.request) {
+				entry.autoResponseTimestamp = this.#ctx.now();
+				socket.send(this.#autoResponse.response);
+				return;
+			}
+			const message = cloneMessageData(data);
+			if (message instanceof Blob) {
+				this.#ctx.addWaitUntil(message.arrayBuffer().then((buffer) => {
+					this.#schedule(() => this.#dispatch.message(socket, buffer));
+				}));
+				return;
+			}
+			this.#schedule(() => this.#dispatch.message(socket, message));
+			return;
+		}
+		if (type === "close") {
+			this.#remove(entry);
+			const close = event;
+			this.#schedule(() => this.#dispatch.close(socket, close.code, close.reason, close.wasClean));
+			return;
+		}
+		if (type === "error") this.#schedule(() => this.#dispatch.error(socket, event));
+	}
+	#schedule(handler) {
+		this.#ctx.addWaitUntil(this.#ctx.run(handler).then(() => {}));
+	}
+	#remove(entry) {
+		const index = this.#entries.indexOf(entry);
+		if (index === -1) return;
+		this.#entries.splice(index, 1);
+		this.#host?.closed(entry.socket);
+	}
+	#listenRaw(socket) {
+		const state = socketMetadata(socket);
+		if (state.rawListenersInstalled === true) return;
+		state.rawListenersInstalled = true;
+		for (const type of [
+			"message",
+			"close",
+			"error"
+		]) socket.addEventListener(type, (event) => {
+			const accepted = socketMetadata(socket).accepted;
+			if (accepted?.mode === "hibernatable") accepted.registry.receive(socket, type, event);
+		});
+	}
+	#rehydrate(value) {
+		const socket = value.socket;
+		if (!isRawWebSocket(socket)) throw new TypeError("ActorContainerOptions.webSockets contains a non-WebSocket value.");
+		const tags = normalizeTags(value.tags);
+		const state = socketMetadata(socket);
+		state.accepted = {
+			mode: "hibernatable",
+			registry: this
+		};
+		if (value.attachment !== void 0) state.attachment = value.attachment.slice();
+		if (socket instanceof AcceptedWebSocket) socket.rehydrateHibernation(this, this.#ctx);
+		else this.#listenRaw(socket);
+		const entry = {
+			socket,
+			tags
+		};
+		if (value.autoResponseTimestamp !== void 0) entry.autoResponseTimestamp = value.autoResponseTimestamp;
+		this.#entries.push(entry);
+	}
+	#createPair() {
+		const pairState = {
+			used: false,
+			hibernationAccepted: false
+		};
+		const left = new MemoryWebSocketEndpoint();
+		const right = new MemoryWebSocketEndpoint();
+		left.peer = right;
+		right.peer = left;
+		return {
+			0: new AcceptedWebSocket(this.#ctx, left, pairState),
+			1: new AcceptedWebSocket(this.#ctx, right, pairState)
+		};
+	}
+};
+function acceptWebSocket(ctx, socket) {
+	const state = socketMetadata(socket);
+	if (state.accepted !== void 0) throw new Error(ALREADY_ACCEPTED_MESSAGE);
+	if (socket instanceof AcceptedWebSocket) {
+		socket.accept();
+		return socket;
+	}
+	state.accepted = { mode: "classic" };
+	return new AcceptedWebSocket(ctx, socket);
+}
+function markWebSocketUsed(socket) {
+	if (socket instanceof AcceptedWebSocket) socket.markPairUsed();
+}
+function installWebSocketGlobals(target, pairConstructor) {
+	const constructor = globalThis.WebSocket;
+	for (const [name, value] of Object.entries(WEB_SOCKET_READY_STATES)) {
+		defineValue(constructor, name, value);
+		defineValue(constructor.prototype, name, value);
+	}
+	defineValue(constructor.prototype, "serializeAttachment", serializeAttachmentMethod);
+	defineValue(constructor.prototype, "deserializeAttachment", deserializeAttachmentMethod);
+	defineValue(target, "WebSocket", constructor);
+	defineValue(target, "WebSocketPair", pairConstructor);
+	defineValue(target, "WebSocketRequestResponsePair", RuntimeWebSocketRequestResponsePair);
+}
+function defineValue(target, name, value) {
+	if (Object.getOwnPropertyDescriptor(target, name)?.configurable === false) return;
+	Object.defineProperty(target, name, {
+		configurable: true,
+		writable: true,
+		value
+	});
+}
+function normalizeTags(tags) {
+	if (tags === void 0) return [];
+	if (!Array.isArray(tags)) throw new TypeError("Failed to execute 'acceptWebSocket' on 'DurableObjectState': parameter 2 is not of type 'Array'.");
+	if (tags.length > MAX_TAGS) throw new Error(`a Hibernatable WebSocket cannot have more than ${MAX_TAGS} tags`);
+	const normalized = [...new Set(tags.map(String))];
+	for (const tag of normalized) if (tag.length > MAX_TAG_LENGTH) throw new Error(`"${tag}" is longer than the max tag length (${MAX_TAG_LENGTH} characters).`);
+	return normalized;
+}
+function validateAutoResponseSize(side, value) {
+	const bytes = textEncoder.encode(value).byteLength;
+	if (bytes > MAX_AUTO_RESPONSE_BYTES) throw new RangeError(`${side} cannot be larger than ${MAX_AUTO_RESPONSE_BYTES} bytes. A ${side.toLowerCase()} of size ${bytes} was provided.`);
+}
+function validateClose(code, reason) {
+	if (code !== void 0 && code !== 1e3 && (code < 3e3 || code > 4999)) throw new DOMException(`Invalid WebSocket close code: ${code}.`, "InvalidAccessError");
+	if (textEncoder.encode(reason).byteLength > MAX_CLOSE_REASON_BYTES) throw new DOMException(`WebSocket close reason must not be longer than ${MAX_CLOSE_REASON_BYTES} bytes when UTF-8 encoded.`, "SyntaxError");
+}
+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);
+}
+//#endregion
+export { DurableObjectClass as _, installWebSocketGlobals as a, DurableObjectStorage as c, LoopbackColoLocalActorNamespace as d, LoopbackDurableObjectClass as f, ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE as g, asLoopbackDurableObjectClass as h, acceptWebSocket as i, FACET_NAME_MAX_LENGTH as l, LoopbackServiceStub as m, HibernatableWebSocketRegistry as n, markWebSocketUsed as o, LoopbackDurableObjectNamespace as p, RuntimeWebSocketRequestResponsePair as r, DurableObjectState as s, ALREADY_ACCEPTED_MESSAGE as t, FACET_TREE_MAX_DEPTH as u, DurableObjectId as v, DurableObjectNamespace as y };
+
+//# sourceMappingURL=web-socket-W63BdFn5.js.map