@mcp-b/do-runtime 0.1.2 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.2.2
+
+### Patch Changes
+
+- 31cb2a6: Gate the streams `pipeThrough` and `pipeTo` produce. Native pipe machinery reads a gated body through internal spec operations and hands back a brand-new uninstrumented stream, so `res.body.pipeThrough(new TextDecoderStream()).getReader().read()` — the MCP SDK's SSE path — resumed foreign on every chunk and the next storage call threw "no input lock available in this context". `pipeThrough` now re-gates the readable it returns (recursively, so chains stay covered) and `pipeTo`'s settlement resumes gated.
+
+## 0.2.1
+
+### Patch Changes
+
+- 5c91da1: Name the last gated site in the "no input lock available in this context" error. The throw lands at the next storage call, which can be several layers past the foreign await that actually dropped the lock; the error now carries where the gate was last engaged — an `awaitIo` call site with its stack, an `entry` dispatch with its method name, a re-entry callback's registration site — and how many milliseconds before the throw, which brackets the offending await between two coordinates.
+
+## 0.2.0 — 2026-08-21
+
+### Added
+
+- Expose `createDurableObjectNamespace()` and its placement-channel types for standard named Durable Object bindings.
+- Run Agents SDK `routeAgentRequest()`, `getAgentByName()` direct stubs, decorated callables, streaming RPC, email routing, and sub-agents through the MV3 extension host.
+
+### Fixed
+
+- Preserve named facet identities instead of re-hashing serialized Durable Object IDs.
+- Re-enter the calling actor's input gate after outbound namespace-stub calls.
+- Preserve browser WebSocket upgrade requests across PartyServer request clones.
+
 ## 0.1.2
 
 ### Patch Changes

package/README.md

@@ -186,6 +186,15 @@ The lifecycle:
 5. Reach the platform through `container.globals` (or install it with `installActorScope`). For a host-provided promise an actor must await, wrap it once in `container.awaitIo()`.
 6. Watch `container.onBroken`; dispose the placement; recreate it on the next event over the same storage.
 
+For a standard Durable Object binding, call
+`createDurableObjectNamespace(uniqueKey, channel)` and put the result in `env`
+and `ctx.exports`. The channel maps each routed id to a placed `Fetcher`; that
+binding works directly with Agents SDK `routeAgentRequest()` and
+`getAgentByName()`. When an actor uses the binding to call another actor, wrap
+the transport promise with the caller's `container.awaitIo()` so its continuation
+re-enters the owning input gate. The extension example shows both the external
+router binding and the per-container actor binding.
+
 ### Storage
 
 `SqlDatabaseProvider.open(name)` is the runtime execution seam. The runtime owns database names, tables, transactions, reset behaviour, facet metadata, and streaming `sql.ingest()` statement boundaries; the host chooses the physical provider and prefix. Stored KV values use structured-clone semantics across workerd, Node, and the browser; existing JSON rows remain readable. `_cf_` names are reserved to the runtime.

package/dist/index.js

@@ -664,7 +664,28 @@ var INPUT_GATE_BROKEN_PREFIX = "broken.inputGateBroken; ";
 */
 function requireInputLock(ctx, op) {
 	if (ctx.hasCurrent()) return;
-	throw new Error(`${op}: no input lock available in this context`);
+	throw new Error(`${op}: no input lock available in this context${ctx.describeLostLock()}`);
+}
+/**
+* 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.
+*/
+function captureGateStack() {
+	const stack = (/* @__PURE__ */ new Error()).stack;
+	if (stack === void 0) return void 0;
+	const frames = stack.split("\n");
+	const trimmed = frames.slice(frames[0]?.startsWith("Error") ? 3 : 2).join("\n");
+	return trimmed === "" ? void 0 : trimmed;
 }
 /**
 * The end of the microtask checkpoint — the moment `runImpl`'s `KJ_DEFER` fires.
@@ -1014,6 +1035,13 @@ var IoContext = class {
 	* the overlapping slices happen to leave in.
 	*/
 	#currentInputLocks = [];
+	/**
+	* Where this context's gate was last deliberately engaged, for
+	* `describeLostLock`. One slot, overwritten on every engagement — the gate
+	* serialises slices, so the latest note is the best available ancestor of
+	* whatever continuation is running lockless now.
+	*/
+	#lastGateUse;
 	#abortException;
 	#abortPromise;
 	#rejectAbort;
@@ -1074,6 +1102,42 @@ var IoContext = class {
 		return currentSlice === this;
 	}
 	/**
+	* 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, stack) {
+		this.#lastGateUse = {
+			what,
+			stack,
+			at: this.now()
+		};
+	}
+	/**
+	* 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() {
+		const use = this.#lastGateUse;
+		if (use === void 0) return " (this context has never held its gate: the call arrived from outside any actor invocation)";
+		const age = Math.round(this.now() - use.at);
+		const stackSuffix = use.stack === void 0 ? "" : `, at:\n${use.stack}`;
+		return ` (an await after the last gated point resumed from a promise the runtime does not own; the gate was last engaged by ${use.what} ${age}ms before this call${stackSuffix})`;
+	}
+	/**
 	* ← `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.
 	*/
@@ -1234,13 +1298,16 @@ var IoContext = class {
 	makeReentryCallback(func) {
 		this.#requireCurrent();
 		const criticalSection = this.getCriticalSection();
+		const registrationStack = captureGateStack();
 		return async (...args) => {
+			this.noteGateUse("a re-entry callback registered at the site below", registrationStack);
 			const call = this.run((lock) => func(lock, ...args), criticalSection);
 			this.addTask(call.then(() => {}, () => {}));
 			return await call;
 		};
 	}
 	awaitIo(promise, func = identity) {
+		this.noteGateUse("awaitIo", captureGateStack());
 		return this.#awaitIoImpl(promise, this.getCriticalSection(), func);
 	}
 	awaitIoWithInputLock(promise, func = identity) {
@@ -1250,6 +1317,7 @@ var IoContext = class {
 		} catch (exception) {
 			return Promise.reject(exception);
 		}
+		this.noteGateUse("awaitIoWithInputLock", captureGateStack());
 		return this.#awaitIoImpl(promise, inputLock, func);
 	}
 	/**
@@ -1263,6 +1331,7 @@ var IoContext = class {
 	*/
 	blockConcurrencyWhile(callback) {
 		const lock = this.getInputLock();
+		this.noteGateUse("blockConcurrencyWhile", captureGateStack());
 		const criticalSection = lock.startCriticalSection();
 		const { promise: result, resolve } = Promise.withResolvers();
 		this.addTask((async () => {
@@ -1312,7 +1381,7 @@ var IoContext = class {
 	*/
 	#requireCurrent() {
 		const lock = this.#currentInputLocks.at(-1);
-		if (lock === void 0) throw new Error("no input lock available in this context");
+		if (lock === void 0) throw new Error(`no input lock available in this context${this.describeLostLock()}`);
 		return lock;
 	}
 	/** ← the far side of `runInContextScope`'s `KJ_DEFER`. */
@@ -3419,7 +3488,7 @@ var DurableObjectFacets = class {
 			const id = options.id;
 			return {
 				actorClass: requireFacetClass(options.class).getChannel(),
-				id: id === void 0 ? this.#parentId : typeof id === "string" ? id : id.toString()
+				id: id === void 0 ? this.#parentId : typeof id === "string" ? id : id.name ?? id.toString()
 			};
 		});
 		return facetManager.getFacet(name, getStartInfo);
@@ -3681,6 +3750,8 @@ var BYOB_READER_UNGATABLE_MESSAGE = "getReader({ mode: 'byob' }): a BYOB reader
 function gateReadableStream(ctx, stream) {
 	const getReader = stream.getReader.bind(stream);
 	const tee = stream.tee.bind(stream);
+	const pipeThrough = stream.pipeThrough.bind(stream);
+	const pipeTo = stream.pipeTo.bind(stream);
 	Object.defineProperties(stream, {
 		getReader: {
 			configurable: true,
@@ -3697,6 +3768,20 @@ function gateReadableStream(ctx, stream) {
 				const [a, b] = tee();
 				return [gateReadableStream(ctx, a), gateReadableStream(ctx, b)];
 			}
+		},
+		pipeThrough: {
+			configurable: true,
+			writable: true,
+			value(transform, options) {
+				return gateReadableStream(ctx, pipeThrough(transform, options));
+			}
+		},
+		pipeTo: {
+			configurable: true,
+			writable: true,
+			value(destination, options) {
+				return ctx.awaitIo(pipeTo(destination, options));
+			}
 		}
 	});
 	return stream;
@@ -6944,6 +7029,7 @@ var ActorContainerImpl = class {
 			const cached = bound.get(property);
 			if (cached !== void 0) return cached;
 			const gated = async (...args) => {
+				this.#ctx.noteGateUse(`entry ${String(property)}()`, captureGateStack());
 				const result = await this.#ctx.run(() => this.#withExternalEntry(() => value.apply(subject, args)));
 				await this.#ctx.waitForOutputLocks();
 				return result;
@@ -7132,6 +7218,12 @@ async function createActorContainer(options) {
 	return new ActorContainerImpl(options, db, tree, tree);
 }
 //#endregion
+//#region src/server/actor-namespace.ts
+/** Assemble the configured namespace binding a host places in `env`. */
+function createDurableObjectNamespace(uniqueKey, channel) {
+	return new DurableObjectNamespace(channel, new ActorIdFactoryImpl(uniqueKey));
+}
+//#endregion
 //#region src/transport/rpc-session.ts
 /**
 * ← workerd `NO upstream correspondence (capnweb adaptation)`
@@ -7175,6 +7267,6 @@ function newRpcSession(port, localMain) {
 	return newMessagePortRpcSession(port, localMain);
 }
 //#endregion
-export { ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE, ALARM_RETRY_MAX_TRIES, ALARM_RETRY_START_SECONDS, ALLOW_EXPERIMENTAL_MESSAGE, ALREADY_ACCEPTED_MESSAGE, AlarmInvocationInfo, AlarmScheduler, BYOB_READER_UNGATABLE_MESSAGE, DEAD_LOAD_CONTEXT_MESSAGE, DEFAULT_ALARM_OUTLET, FACET_ALARM_UNIMPLEMENTED_MESSAGE, FACET_NAME_MAX_LENGTH, FACET_TREE_MAX_DEPTH, FOREIGN_SLICE_MESSAGE, HIBERNATION_UNIMPLEMENTED_MESSAGE, LoopbackDurableObjectClass, NOT_BYTES_MESSAGE, NO_GLOBAL_OUTBOUND_MESSAGE, NO_MODULES_MESSAGE, PITR_UNIMPLEMENTED_MESSAGE, REPLICATION_UNIMPLEMENTED_MESSAGE, RETRY_BACKOFF_MAX, RETRY_JITTER_FACTOR, STREAMING_TAILS_EXPERIMENTAL_MESSAGE, WorkerLoader, WorkerStub, actorScopeBindings, alarmRetryDelayMs, asLoopbackDurableObjectClass, createActorContainer, gateRequestBody, installActorScope, jsModuleInPythonWorkerMessage, moduleFieldCountMessage, moduleNameMessage, newRpcSession, noFacets, notSerializableMessage, pythonModuleInJsWorkerMessage, typeScriptModuleNameMessage };
+export { ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE, ALARM_RETRY_MAX_TRIES, ALARM_RETRY_START_SECONDS, ALLOW_EXPERIMENTAL_MESSAGE, ALREADY_ACCEPTED_MESSAGE, AlarmInvocationInfo, AlarmScheduler, BYOB_READER_UNGATABLE_MESSAGE, DEAD_LOAD_CONTEXT_MESSAGE, DEFAULT_ALARM_OUTLET, FACET_ALARM_UNIMPLEMENTED_MESSAGE, FACET_NAME_MAX_LENGTH, FACET_TREE_MAX_DEPTH, FOREIGN_SLICE_MESSAGE, HIBERNATION_UNIMPLEMENTED_MESSAGE, LoopbackDurableObjectClass, NOT_BYTES_MESSAGE, NO_GLOBAL_OUTBOUND_MESSAGE, NO_MODULES_MESSAGE, PITR_UNIMPLEMENTED_MESSAGE, REPLICATION_UNIMPLEMENTED_MESSAGE, RETRY_BACKOFF_MAX, RETRY_JITTER_FACTOR, STREAMING_TAILS_EXPERIMENTAL_MESSAGE, WorkerLoader, WorkerStub, actorScopeBindings, alarmRetryDelayMs, asLoopbackDurableObjectClass, createActorContainer, createDurableObjectNamespace, gateRequestBody, installActorScope, jsModuleInPythonWorkerMessage, moduleFieldCountMessage, moduleNameMessage, newRpcSession, noFacets, notSerializableMessage, pythonModuleInJsWorkerMessage, typeScriptModuleNameMessage };
 
 //# sourceMappingURL=index.js.map