@mcp-b/do-runtime 0.5.0 → 0.6.1

package/dist/src/api/actor-state.d.ts

@@ -36,11 +36,9 @@
  * `transformMaybeBackpressure` keeps the branch because
  * `DeleteAllResults.backpressure` is still a promise in `io/actor-cache.ts`.
  *
- * Not ported, because the substrate has no equivalent: Hibernatable WebSockets,
- * which is the whole reason `DurableObjectState`'s eight WebSocket methods are
- * named throwing stubs; V8's private wire bytes, replaced by a browser-safe
- * structured-clone encoding with the same public value semantics; the billing
- * counters
+ * 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`,
@@ -56,6 +54,7 @@ import type { SqliteKv } from "../util/sqlite-kv.js";
 import type { SqliteDatabase } from "../util/sqlite.js";
 import type { ActorScopeBindings } from "./global-scope.js";
 import { SqlStorage } from "./sql.js";
+import type { HibernatableWebSocketRegistry } from "./web-socket.js";
 /**
  * ← `MAX_FACET_NAME_LENGTH` / `MAX_FACET_TREE_DEPTH`
  * (`actor-state.c++:943,947`), in the anonymous namespace beside the facet code
@@ -65,14 +64,6 @@ import { SqlStorage } from "./sql.js";
 export declare const FACET_NAME_MAX_LENGTH = 256;
 /** Root is at depth 0, so the deepest allowed facet is at depth 3. */
 export declare const FACET_TREE_MAX_DEPTH = 4;
-/**
- * The substrate boundary named in the package README: Hibernatable WebSockets
- * exist so the platform can evict an actor while keeping its sockets open, and
- * Chrome exposes no equivalent lifecycle. Under this repo's fail-closed tenet
- * the throw IS the specified behaviour, which is why §2.5 orders the four
- * silent no-op stubs beside it replaced.
- */
-export declare const HIBERNATION_UNIMPLEMENTED_MESSAGE: string;
 /**
  * ← what falls off the end of `DurableObjectFacets::get`'s class switch
  * (`actor-state.c++:1029-1043`).
@@ -88,6 +79,23 @@ export declare const HIBERNATION_UNIMPLEMENTED_MESSAGE: string;
  * which every object satisfies, so nothing refuses it before the method body.
  */
 export declare const FACET_CLASS_UNSUPPORTED_MESSAGE: string;
+/**
+ * ← `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.
+ */
+export declare function serializeValue(value: unknown): Uint8Array;
+/**
+ * ← `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.
+ */
+export declare function deserializeValue<T = unknown>(key: string, buffer: Uint8Array): T;
 /**
  * ← `DurableObjectStorageOperations`. "Common implementation of
  * DurableObjectStorage and DurableObjectTransaction. This class is designed to
@@ -268,6 +276,7 @@ export type DurableObjectStateOptions = {
      * `DurableObjectState.globals`.
      */
     globals: ActorScopeBindings;
+    webSockets: HibernatableWebSocketRegistry;
 };
 /** The type passed as the first parameter to a Durable Object class's constructor. */
 export declare class DurableObjectState implements globalThis.DurableObjectState {
@@ -328,13 +337,13 @@ export declare class DurableObjectState implements globalThis.DurableObjectState
     configureReadReplication(options: {
         mode: string;
     }): Promise<void>;
-    acceptWebSocket(_ws: WebSocket, _tags?: string[]): never;
-    getWebSockets(_tag?: string): never;
-    setWebSocketAutoResponse(_maybeReqResp?: WebSocketRequestResponsePair): never;
-    getWebSocketAutoResponse(): never;
-    getWebSocketAutoResponseTimestamp(_ws: WebSocket): never;
-    setHibernatableWebSocketEventTimeout(_timeoutMs?: number): never;
-    getHibernatableWebSocketEventTimeout(): never;
-    getTags(_ws: WebSocket): never;
+    acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+    getWebSockets(tag?: string): WebSocket[];
+    setWebSocketAutoResponse(maybeReqResp?: WebSocketRequestResponsePair): void;
+    getWebSocketAutoResponse(): WebSocketRequestResponsePair | null;
+    getWebSocketAutoResponseTimestamp(ws: WebSocket): Date | null;
+    setHibernatableWebSocketEventTimeout(timeoutMs?: number): void;
+    getHibernatableWebSocketEventTimeout(): number | null;
+    getTags(ws: WebSocket): string[];
 }
 export {};

package/dist/src/api/global-scope.d.ts

@@ -42,6 +42,8 @@
  * docs/decisions.md.
  */
 import { type IoContext } from "../io/io-context.js";
+import { WebSocketRequestResponsePair, type HibernatableWebSocketRegistry } from "./web-socket.js";
+type WebSocketPairConstructor = typeof WebSocketPair;
 /**
  * ← `AlarmInvocationInfo` (`api/global-scope.h:386-412`): "a jsg::Object used to
  * pass alarm invocation info to an alarm handler."
@@ -136,6 +138,7 @@ declare class GatedCrypto {
 /** What the host supplies beneath `ServiceWorkerGlobalScope::fetch`. */
 export type FetchPort = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 export type ActorGlobalScopeOptions = {
+    readonly webSockets: HibernatableWebSocketRegistry;
     /** Opaque identity of the external entry whose synchronous body is running. */
     readonly currentExternalEntry?: (() => object | undefined) | undefined;
     /**
@@ -174,7 +177,10 @@ export declare class ActorGlobalScope {
     #private;
     readonly scheduler: Scheduler;
     readonly crypto: GatedCrypto;
-    constructor(ctx: IoContext, options?: ActorGlobalScopeOptions);
+    readonly WebSocket: typeof globalThis.WebSocket;
+    readonly WebSocketPair: WebSocketPairConstructor;
+    readonly WebSocketRequestResponsePair: typeof WebSocketRequestResponsePair;
+    constructor(ctx: IoContext, options: ActorGlobalScopeOptions);
     /** Opaque identity available only during an external entry's synchronous body. */
     get currentExternalEntry(): object | undefined;
     /** Re-enter this actor after a host promise settles. */
@@ -220,6 +226,9 @@ export type ActorScopeBindings = {
     readonly clearInterval: (id?: number | null) => void;
     readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
     readonly crypto: Crypto;
+    readonly WebSocket: typeof globalThis.WebSocket;
+    readonly WebSocketPair: WebSocketPairConstructor;
+    readonly WebSocketRequestResponsePair: typeof WebSocketRequestResponsePair;
     readonly currentExternalEntry?: object | undefined;
 };
 /**
@@ -238,8 +247,8 @@ export declare function actorScopeBindings(resolve: () => ActorGlobalScope): Act
  * one that is not.
  *
  * **A host should call this rather than assigning the names itself**, and the
- * reason is the failure it prevents: a host that installs five of the six leaves
- * one primitive ungated, and an ungated primitive that WORKS is invisible until
+ * reason is the failure it prevents: a host that installs only a subset leaves a
+ * primitive ungated, and an ungated primitive that WORKS is invisible until
  * a continuation after it touches storage — possibly never, on the path that
  * matters. The set is the package's, so it can grow without every host growing
  * with it.

package/dist/src/api/web-socket.d.ts

@@ -1,93 +1,108 @@
 /**
- * ← workerd `src/workerd/api/web-socket.{h,c++}` — the gating, and nothing else.
+ * ← workerd `src/workerd/api/web-socket.{h,c++}` — classic and hibernatable
+ * socket delivery over the actor's input/output gates.
  *
- * A socket is the one primitive that is neither of the other two, and §1.8 says
- * why in three lines: incoming frames "each take a fresh input lock via
- * `context.run(...)`", the read loop "captures the critical section at
- * `accept()` time", and outbound messages "each carry their own output-gate
- * promise captured at `send()` time". Upstream states the first outright, on the
- * line that does it (`web-socket.c++:1056-1059`):
- *
- * > "Re-enter the context with context.run(). This is arguably a bit unusual
- * > compared to other I/O which is delivered by return from context.awaitIo(),
- * > but the difference here is that we have a long stream of events over time.
- * > It makes sense to use context.run() each time a new event arrives."
- *
- * So a socket cannot be `awaitIo`: there is no single result to resume from.
- * `accept()` starts a loop, and the loop is the gate's caller.
- *
- * **What is ported and what is not.** The frame protocol, the hibernation
- * states, auto-response, `WebSocketPair` and the byte accounting are all
- * absent — the substrate ships a `WebSocket`, and hibernation is a recorded
- * substrate boundary with no Chrome lifecycle to be faithful to. What is here is
- * `WebSocket::Accepted`: the three gate properties above, over whatever socket
- * the host hands in. That is the same division `api/http.ts` makes and for the
- * same reason.
- *
- * **The accept contract, and the hole it leaves.** After `acceptWebSocket`, the
- * gated view owns the raw socket's events. A consumer that keeps a reference to
- * the raw socket and registers a listener on it directly gets that listener
- * called ungated, and nothing here can prevent it — upstream cannot be reached
- * that way because `accept()` moves the `kj::WebSocket` into `Accepted` and the
- * JS object never had it. The refusal below covers the case that is detectable
- * (accepting the same socket twice); the rest is the accept contract, stated.
- *
- * Spec: §1.1, §1.8 and decision 5 in
- * docs/decisions.md.
+ * The runtime owns the WebSocket object produced by `WebSocketPair`; embedders
+ * still own network transports supplied as `RawWebSocket`s. Hibernation state is
+ * per container and can be mirrored through `HibernationHost` for reconstruction.
  */
 import type { IoContext } from "../io/io-context.js";
-/**
- * The socket beneath. Deliberately structural and minimal: a real `WebSocket`,
- * the extension's `WebSocketFacade` over capnweb, and a test double all satisfy
- * it, and none of them is a type this package should name.
- */
 export interface RawWebSocket {
     addEventListener(type: string, listener: (event: Event) => void): void;
     send(data: string | ArrayBufferLike | ArrayBufferView | Blob): void;
     close(code?: number, reason?: string): void;
+    readonly readyState?: number;
+    binaryType?: string;
+}
+export interface HibernationHost {
+    accepted(socket: RawWebSocket, tags: readonly string[]): void;
+    attachment(socket: RawWebSocket, bytes: Uint8Array | null): void;
+    autoResponse(pair: {
+        request: string;
+        response: string;
+    } | null): void;
+    closed(socket: RawWebSocket): void;
 }
+export type RehydratedWebSocket = {
+    socket: RawWebSocket;
+    tags?: readonly string[];
+    attachment?: Uint8Array;
+    autoResponseTimestamp?: number;
+};
+type WebSocketPairConstructor = typeof WebSocketPair;
+declare const RuntimeWebSocketRequestResponsePair: typeof WebSocketRequestResponsePair;
+export { RuntimeWebSocketRequestResponsePair as WebSocketRequestResponsePair };
 /** ← the `JSG_REQUIRE(!native.state.is<Accepted>(), ...)` at the head of `accept()`. */
 export declare const ALREADY_ACCEPTED_MESSAGE: string;
-/**
- * ← `WebSocket::Accepted` (`web-socket.h:~300-360`), reached through
- * `accept()` → `internalAccept(js, IoContext::current().getCriticalSection())`
- * → `startReadLoop` (`web-socket.c++:133`, `:426`, `:429-433`, `:507`).
- *
- * An `EventTarget`, so a consumer registers listeners the way it would on a real
- * socket — but on THIS object rather than on the raw one, because this is what
- * runs them inside a gated slice.
- */
-export declare class AcceptedWebSocket extends EventTarget {
+export declare const HIBERNATION_ALREADY_ACCEPTED_MESSAGE = "Cannot call `acceptWebSocket()` if the WebSocket was already accepted via `accept()`";
+export declare const HIBERNATION_AFTER_ACCEPT_MESSAGE = "Can't accept() WebSocket after enabling hibernation.";
+export declare const HIBERNATION_PAIR_USED_MESSAGE = "Cannot call `acceptWebSocket()` on this WebSocket because its pair has already been accepted or used in a Response.";
+declare const SOCKET_EVENTS: readonly ["open", "message", "close", "error"];
+type SocketEvent = (typeof SOCKET_EVENTS)[number];
+type PairState = {
+    used: boolean;
+    hibernationAccepted: boolean;
+};
+/** One public socket identity, in classic or hibernatable mode after acceptance. */
+export declare class AcceptedWebSocket extends EventTarget implements RawWebSocket, WebSocket {
     #private;
+    static readonly READY_STATE_CONNECTING: 0;
+    static readonly READY_STATE_OPEN: 1;
+    static readonly READY_STATE_CLOSING: 2;
+    static readonly READY_STATE_CLOSED: 3;
+    static readonly CONNECTING: 0;
+    static readonly OPEN: 1;
+    static readonly CLOSING: 2;
+    static readonly CLOSED: 3;
+    readonly READY_STATE_CONNECTING: 0;
+    readonly READY_STATE_OPEN: 1;
+    readonly READY_STATE_CLOSING: 2;
+    readonly READY_STATE_CLOSED: 3;
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+    readonly bufferedAmount = 0;
+    readonly extensions = "";
+    readonly protocol = "";
+    readonly url = "";
     onopen: ((event: Event) => void) | null;
     onmessage: ((event: MessageEvent) => void) | null;
     onclose: ((event: CloseEvent) => void) | null;
     onerror: ((event: Event) => void) | null;
-    constructor(ctx: IoContext, socket: RawWebSocket);
-    /**
-     * ← `WebSocket::send` (`web-socket.c++:~640`), which inserts a
-     * `GatedMessage{IoContext::current().waitForOutputLocksIfNecessary(), …}`.
-     *
-     * Synchronous, as upstream's is: the wait is the pump's, not the caller's. The
-     * output gate is what "blocks all outgoing messages from an actor that would
-     * allow the rest of the world to observe the actor's state" (§1.1), and a
-     * socket frame is exactly such a message.
-     *
-     * `waitForOutputLocksIfNecessary()` collapses to `waitForOutputLocks()` here
-     * for the reason the whole file collapses `kj::Maybe<Worker::Actor&>`: its
-     * body is `actor.map(…)` (`io-context.c++:383-386`) and every context in this
-     * runtime is an actor context.
-     */
+    constructor(ctx: IoContext, socket: RawWebSocket, pairState?: PairState);
+    get readyState(): number;
+    get binaryType(): "blob" | "arraybuffer";
+    set binaryType(value: "blob" | "arraybuffer");
+    accept(): void;
     send(data: string | ArrayBufferLike | ArrayBufferView | Blob): void;
-    /** ← `WebSocket::close`, which enqueues a `Close` through the same gate. */
     close(code?: number, reason?: string): void;
+    serializeAttachment(value: unknown): void;
+    deserializeAttachment(): unknown;
+    acceptHibernation(registry: HibernatableWebSocketRegistry): void;
+    rehydrateHibernation(registry: HibernatableWebSocketRegistry, ctx: IoContext): void;
+    markPairUsed(): void;
+}
+type HandlerDispatch = {
+    message(socket: RawWebSocket, message: string | ArrayBuffer): unknown;
+    close(socket: RawWebSocket, code: number, reason: string, wasClean: boolean): unknown;
+    error(socket: RawWebSocket, error: unknown): unknown;
+};
+export declare class HibernatableWebSocketRegistry {
+    #private;
+    constructor(ctx: IoContext, dispatch: HandlerDispatch, host?: HibernationHost, rehydrated?: readonly RehydratedWebSocket[]);
+    get WebSocketPair(): WebSocketPairConstructor;
+    acceptWebSocket(socket: RawWebSocket, tags?: string[]): void;
+    getWebSockets(tag?: string): WebSocket[];
+    getTags(socket: RawWebSocket): string[];
+    setWebSocketAutoResponse(pair?: WebSocketRequestResponsePair): void;
+    getWebSocketAutoResponse(): WebSocketRequestResponsePair | null;
+    getWebSocketAutoResponseTimestamp(socket: RawWebSocket): Date | null;
+    setHibernatableWebSocketEventTimeout(value?: number): void;
+    getHibernatableWebSocketEventTimeout(): number | null;
+    attachmentChanged(socket: RawWebSocket, bytes: Uint8Array): void;
+    receive(socket: RawWebSocket, type: SocketEvent, event: Event): void;
 }
-/**
- * ← `accept()` / `state.acceptWebSocket()`, as the one verb.
- *
- * Named for what upstream names it, because the critical-section capture is a
- * property of accepting rather than of constructing: "a socket accepted inside a
- * `blockConcurrencyWhile` delivers its messages inside that critical section"
- * (§1.8).
- */
 export declare function acceptWebSocket(ctx: IoContext, socket: RawWebSocket): AcceptedWebSocket;
+export declare function markWebSocketUsed(socket: RawWebSocket): void;
+export declare function installWebSocketGlobals(target: object, pairConstructor: WebSocketPairConstructor): void;

package/dist/src/browser.d.ts

@@ -0,0 +1,15 @@
+import { type RawWebSocket } from "./api/web-socket.js";
+export type UpgradeWebSocket = EventTarget & RawWebSocket & {
+    accept(): void;
+    readonly readyState: number;
+};
+type CloneableRequest = {
+    readonly headers: Headers;
+    clone(): CloneableRequest;
+};
+/** Install the Request/Response half of browser-hosted WebSocket upgrades. */
+export declare function installWebSocketUpgradeGlobals(): void;
+export declare function upgradeWebSocket(response: Response): UpgradeWebSocket | undefined;
+/** Preserve the upgrade signal across browser `Request.clone()` calls. */
+export declare function withWebSocketUpgrade<T extends CloneableRequest>(request: T): T;
+export {};

package/dist/src/index.d.ts

@@ -51,8 +51,10 @@ export type { Module as SourceModule, ModuleContent, ModulesSource, WorkerSource
  * `src/` references `src/server/`, so a declaration in this file is one
  * `server/` may not import.
  */
-export type { ActorContainer, ActorContainerOptions, ActorEntry, ActorPorts, FacetHandle, FacetHost, FacetId, FacetStartRequest, FacetTree, } from "./server/actor-container.js";
+export type { ActorContainer, ActorContainerOptions, ActorEntry, ActorPorts, HibernationHost, FacetHandle, FacetHost, FacetId, FacetStartRequest, FacetTree, } from "./server/actor-container.js";
 export { createActorContainer, FACET_ALARM_UNIMPLEMENTED_MESSAGE, noFacets, } from "./server/actor-container.js";
+export type { HibernationAutoResponse } from "./server/hibernation-mirror.js";
+export { HibernationMirror } from "./server/hibernation-mirror.js";
 export type { ActorChannelFactory, GlobalActorRequest } from "./api/actor.js";
 export { createDurableObjectNamespace } from "./server/actor-namespace.js";
 export { ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE } from "./api/actor.js";
@@ -74,7 +76,7 @@ export { ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE } from "./api/actor.js"
  */
 export type { LoopbackDurableObjectClassOptions, LoopbackDurableObjectClassValue, ActorClassChannelFactory, } from "./api/export-loopback.js";
 export { asLoopbackDurableObjectClass, LoopbackDurableObjectClass } from "./api/export-loopback.js";
-export { FACET_NAME_MAX_LENGTH, FACET_TREE_MAX_DEPTH, HIBERNATION_UNIMPLEMENTED_MESSAGE, } from "./api/actor-state.js";
+export { FACET_NAME_MAX_LENGTH, FACET_TREE_MAX_DEPTH, } from "./api/actor-state.js";
 export { PITR_UNIMPLEMENTED_MESSAGE, REPLICATION_UNIMPLEMENTED_MESSAGE } from "./io/actor-cache.js";
 /**
  * The alarm scheduler is exported where the gate is not, and the difference is
@@ -114,8 +116,8 @@ export { AlarmInvocationInfo } from "./api/global-scope.js";
  */
 export type { ActorGlobalScope, ActorGlobalScopeOptions, ActorScopeBindings, FetchPort, Scheduler, SchedulerWaitOptions, } from "./api/global-scope.js";
 export { actorScopeBindings, FOREIGN_SLICE_MESSAGE, installActorScope, NO_GLOBAL_OUTBOUND_MESSAGE, } from "./api/global-scope.js";
-export type { AcceptedWebSocket, RawWebSocket } from "./api/web-socket.js";
-export { ALREADY_ACCEPTED_MESSAGE } from "./api/web-socket.js";
+export type { AcceptedWebSocket, RawWebSocket, RehydratedWebSocket } from "./api/web-socket.js";
+export { ALREADY_ACCEPTED_MESSAGE, WebSocketRequestResponsePair, installWebSocketGlobals, markWebSocketUsed, } from "./api/web-socket.js";
 export { BYOB_READER_UNGATABLE_MESSAGE, gateRequestBody } from "./api/http.js";
 /**
  * The transport, for the same reason the loader binding and the scheduler are

package/dist/src/io/io-context.d.ts

@@ -424,6 +424,7 @@ export declare class IoContext {
      * upstream's other half of `taskFailed()` is a log this package has no port for.
      */
     waitUntilStatus(): unknown;
+    waitUntilTaskCount(): number;
     /**
      * ← `IncomingRequest::drain()`, actor branch. "For actors, all promises are canceled on
      * actor shutdown, not on a fixed timeout, because work doesn't necessarily happen on a

package/dist/src/server/actor-container.d.ts

@@ -41,12 +41,13 @@
 import { DurableObjectState } from "../api/actor-state.js";
 import type { FetchPort } from "../api/global-scope.js";
 import { ActorGlobalScope } from "../api/global-scope.js";
-import type { AcceptedWebSocket, RawWebSocket } from "../api/web-socket.js";
+import type { AcceptedWebSocket, HibernationHost, RawWebSocket, RehydratedWebSocket } from "../api/web-socket.js";
 import type { IsolateChannelFactory, WorkerLoaderOptions } from "../api/worker-loader.js";
 import { WorkerLoader } from "../api/worker-loader.js";
 import type { AlarmOutlet } from "../io/actor-sqlite.js";
 import type { AlarmResult } from "./alarm-scheduler.js";
 import type { Timer } from "../io/io-context.js";
+import type { InputGateHooks, OutputGateHooks } from "../io/io-gate.js";
 import type { SqlDatabase, SqlDatabaseProvider } from "../util/sqlite.js";
 import type { IndexFile } from "./facet-tree-index.js";
 import { FacetReferenceEpochs } from "./facet-deletion.js";
@@ -190,7 +191,7 @@ export interface FacetHost {
  */
 export declare const noFacets: FacetHost;
 /**
- * The four ports. Each one is a seam workerd itself takes as a constructor
+ * The five ports. Each one is a seam workerd itself takes as a constructor
  * input; a port that would exist only because our code is currently shaped
  * badly is an invented seam and was rejected. Rejected, for the record:
  * a transport port (one implementation per substrate, forever), a logger port
@@ -232,7 +233,9 @@ export type ActorPorts = {
      * prevent.
      */
     fetch?: FetchPort;
+    hibernation?: HibernationHost;
 };
+export type { HibernationHost } from "../api/web-socket.js";
 /**
  * The whole-tree facet state, which belongs to the root container and is shared
  * by every container in one actor tree.
@@ -311,6 +314,11 @@ export type ActorContainerOptions = {
     exports: Record<string, unknown>;
     env: unknown;
     ports: ActorPorts;
+    webSockets?: readonly RehydratedWebSocket[];
+    gateHooks?: {
+        input?: InputGateHooks;
+        output?: OutputGateHooks;
+    };
     /** Present when this container hosts a facet rather than a root. */
     facet?: {
         /** Root is 0, a direct child of the root is 1. `getDepth()` answers with it. */
@@ -483,6 +491,12 @@ export interface ActorContainer {
     waitOutputLocks(): Promise<void>;
     /** For the host's idle check — today's `drainWaitUntil`. */
     drainWaitUntil(): Promise<void>;
+    quiescence(): {
+        armedTimers: number;
+        pendingWaitUntil: number;
+        inputLockHeld: boolean;
+        outputGateBroken: boolean;
+    };
     /**
      * ← `WorkerdApi::compileGlobals`'s `Global::WorkerLoader` arm
      * (`server/workerd-api.c++:748-752`), which is the step that turns a configured

package/dist/src/server/hibernation-mirror.d.ts

@@ -0,0 +1,16 @@
+import type { HibernationHost, RawWebSocket, RehydratedWebSocket } from "../api/web-socket.js";
+export type HibernationAutoResponse = {
+    request: string;
+    response: string;
+};
+/** In-memory socket state shared by embedders that replace live actor containers. */
+export declare class HibernationMirror implements HibernationHost {
+    #private;
+    constructor(rehydrated?: readonly RehydratedWebSocket[], autoResponsePair?: HibernationAutoResponse | null);
+    get autoResponsePair(): HibernationAutoResponse | null;
+    accepted(socket: RawWebSocket, tags: readonly string[]): void;
+    attachment(socket: RawWebSocket, bytes: Uint8Array | null): void;
+    autoResponse(pair: HibernationAutoResponse | null): void;
+    closed(socket: RawWebSocket): void;
+    snapshot(): RehydratedWebSocket[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-b/do-runtime",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Cloudflare's Durable Object runtime (workerd), ported to TypeScript: actors with input/output gates, SQLite storage, facets and alarms, running in the browser and in Node.",
   "keywords": [
     "actors",
@@ -41,6 +41,10 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./browser": {
+      "types": "./dist/src/browser.d.ts",
+      "import": "./dist/browser.js"
+    },
     "./server/alarm-scheduler": {
       "types": "./dist/src/server/alarm-scheduler.d.ts",
       "import": "./dist/server/alarm-scheduler.js"