@mcp-b/do-runtime 0.1.2 → 0.2.2

package/dist/src/index.d.ts

@@ -52,6 +52,8 @@ export type { Module as SourceModule, ModuleContent, ModulesSource, WorkerSource
  */
 export type { ActorContainer, ActorContainerOptions, ActorEntry, ActorPorts, FacetHandle, FacetHost, FacetId, FacetStartRequest, FacetTree, } from "./server/actor-container.js";
 export { createActorContainer, FACET_ALARM_UNIMPLEMENTED_MESSAGE, noFacets, } from "./server/actor-container.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";
 /**
  * The `ctx.exports` entries, exported where the rest of `api/` is not — for the

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

@@ -169,6 +169,21 @@ export declare const BLOCK_CONCURRENCY_WHILE_TIMEOUT_MESSAGE: string;
  * lost transaction boundary is not.
  */
 export declare function requireInputLock(ctx: IoContext, op: string): void;
+/**
+ * A stack for `noteGateUse`, captured where user frames are still on the stack.
+ *
+ * The invocation stack's own push and pop are scheduler moments — `#runImpl`
+ * runs from a gate resumption and `#exit` from a `MessageChannel` callback — so
+ * a trace taken there names only runtime internals. The moments that still see
+ * the caller are the synchronous entries into the gate machinery: an `awaitIo`
+ * call, an `entry` dispatch, a callback's registration. V8's zero-cost async
+ * traces extend those with the awaiting chain, which is usually the frame the
+ * reader actually wants.
+ *
+ * The first slice drops the `Error` header (absent on SpiderMonkey) and the two
+ * runtime frames: this helper and the gate entry point that called it.
+ */
+export declare function captureGateStack(): string | undefined;
 /**
  * The end of the microtask checkpoint — the moment `runImpl`'s `KJ_DEFER` fires.
  *
@@ -305,6 +320,30 @@ export declare class IoContext {
      * actor's?
      */
     isCurrentSlice(): boolean;
+    /**
+     * Record that user code just engaged this context's gate — an `awaitIo`, an
+     * `entry` dispatch, a re-entry callback firing. No upstream analogue, because
+     * upstream cannot lose the lock; here a continuation that awaits a promise
+     * the runtime does not own comes back lockless, the throw lands at the next
+     * storage call three layers later, and the gap between "where the code last
+     * verifiably ran gated" and the throw site is exactly where the foreign await
+     * hides. This is that first coordinate. Always on: the capture rides calls
+     * that already allocate promise machinery, and a stack costs microseconds
+     * against the diagnosis it replaces.
+     */
+    noteGateUse(what: string, stack: string | undefined): void;
+    /**
+     * The suffix `requireInputLock` appends when the invocation stack is empty:
+     * where this context's gate was last engaged, and how long before the throw.
+     *
+     * "Last engaged" is the honest claim, not "this continuation's ancestor" —
+     * once the offending chain went lockless the gate reopened, so another slice
+     * may have run in between and be the note this reports. In practice the loss
+     * is discovered within the same event storm and the note is the parent; when
+     * it is not, an engagement of this actor moments earlier is still the right
+     * neighbourhood to search.
+     */
+    describeLostLock(): string;
     /**
      * ← `IoContext::getActorOrThrow()`. Upstream's throws when the request is not
      * an actor request; there is no such request here, so it is a plain accessor.

package/dist/src/io/worker.d.ts

@@ -44,9 +44,8 @@ import type { ActorClassChannel } from "./io-channels.js";
  * reentry callback (`actor-state.c++:1044`) — so `api/actor-state.ts` now does
  * the same and this field carries the resolved channel.
  *
- * `id` is upstream's `Worker::Actor::Id` as the string form of a
- * `DurableObjectId`, which is all a `DurableObjectId` is once it leaves this
- * package, since ids never cross the host boundary.
+ * `id` is upstream's `Worker::Actor::Id` as its stable name when present, or
+ * the string form of an unnamed `DurableObjectId`.
  */
 export type FacetStartInfo = {
     readonly actorClass: ActorClassChannel;

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

@@ -66,10 +66,10 @@ export type FacetStartRequest = {
      *
      * The scaffolding called this "the DurableObjectId name". It is not
      * necessarily a name: `FacetStartupOptions.id` is `DurableObjectId | string`
-     * (`actor-state.h:453`), so this carries a 64-hex id string whenever the app
-     * passed a `DurableObjectId`, and whatever the app chose whenever it passed a
-     * string. The host decides what to do with it, exactly as upstream's
-     * `Worker::Actor::Id` leaves that to the supervisor.
+     * (`actor-state.h:453`), so this carries a named id's stable name, an unnamed
+     * id's 64-hex string, or the string the app supplied. The host decides what to
+     * do with it, exactly as upstream's `Worker::Actor::Id` leaves that to the
+     * supervisor.
      */
     routedId?: string;
 };

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

@@ -0,0 +1,3 @@
+import { DurableObjectNamespace, type ActorChannelFactory } from "../api/actor.js";
+/** Assemble the configured namespace binding a host places in `env`. */
+export declare function createDurableObjectNamespace<T extends Rpc.DurableObjectBranded | undefined = undefined>(uniqueKey: string, channel: ActorChannelFactory): DurableObjectNamespace<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-b/do-runtime",
-  "version": "0.1.2",
+  "version": "0.2.2",
   "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",