@mcp-b/do-runtime 0.2.1 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.2.3
+
+### Patch Changes
+
+- e4b1be6: Close three input-lock laundering paths in HTTP bodies. `ReadableStream` async iteration, second-order `Blob` reads, and reader or stream lifecycle promises could previously resume outside the actor's input gate and make the next storage call throw "no input lock available in this context". They now route every surfaced continuation through the actor's gated I/O seam while preserving native stream cancellation and lock-release behavior.
+
+## 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

package/dist/index.js

@@ -3685,6 +3685,42 @@ var BODY_CONSUMERS = [
 	"json",
 	"text"
 ];
+/** A consumed Blob is a second-order body: every read it produces needs the same gate. */
+function gateBlob(ctx, blob) {
+	const arrayBuffer = blob.arrayBuffer.bind(blob);
+	const bytes = blob.bytes.bind(blob);
+	const slice = blob.slice.bind(blob);
+	const stream = blob.stream.bind(blob);
+	const text = blob.text.bind(blob);
+	Object.defineProperties(blob, {
+		arrayBuffer: {
+			configurable: true,
+			writable: true,
+			value: () => ctx.awaitIo(arrayBuffer())
+		},
+		bytes: {
+			configurable: true,
+			writable: true,
+			value: () => ctx.awaitIo(bytes())
+		},
+		slice: {
+			configurable: true,
+			writable: true,
+			value: (start, end, contentType) => gateBlob(ctx, slice(start, end, contentType))
+		},
+		stream: {
+			configurable: true,
+			writable: true,
+			value: () => gateReadableStream(ctx, stream())
+		},
+		text: {
+			configurable: true,
+			writable: true,
+			value: () => ctx.awaitIo(text())
+		}
+	});
+	return blob;
+}
 /**
 * Wrap a `Request` or `Response` so every asynchronous step of reading it
 * resumes inside a gated slice.
@@ -3718,7 +3754,10 @@ function gateBody(ctx, value) {
 			return clone;
 		}
 		if (BODY_CONSUMERS.includes(property)) {
-			const consume = (...args) => ctx.awaitIo(subject[property].apply(subject, args));
+			const consume = (...args) => {
+				const result = subject[property].apply(subject, args);
+				return ctx.awaitIo(result, (value) => property === "blob" ? gateBlob(ctx, value) : value);
+			};
 			bound.set(property, consume);
 			return consume;
 		}
@@ -3748,9 +3787,45 @@ function gateResponseBody(ctx, response) {
 */
 var BYOB_READER_UNGATABLE_MESSAGE = "getReader({ mode: 'byob' }): a BYOB reader cannot be gated by this runtime, because `ReadableStream.getReader` is the only seam it has and a byte stream's `read(view)` returns the caller's own buffer. Read the body through `arrayBuffer()` or a default reader.";
 function gateReadableStream(ctx, stream) {
+	const cancel = stream.cancel.bind(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);
+	const values = async function* (options) {
+		const reader = gateReader(ctx, getReader());
+		let finished = false;
+		try {
+			for (;;) {
+				let result;
+				try {
+					result = await reader.read();
+				} catch (exception) {
+					finished = true;
+					throw exception;
+				}
+				if (result.done) {
+					finished = true;
+					return;
+				}
+				yield result.value;
+			}
+		} finally {
+			try {
+				if (!finished && options?.preventCancel !== true) await reader.cancel();
+			} finally {
+				reader.releaseLock();
+			}
+		}
+	};
 	Object.defineProperties(stream, {
+		cancel: {
+			configurable: true,
+			writable: true,
+			value(reason) {
+				return ctx.awaitIo(cancel(reason));
+			}
+		},
 		getReader: {
 			configurable: true,
 			writable: true,
@@ -3766,15 +3841,61 @@ 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));
+			}
+		},
+		values: {
+			configurable: true,
+			writable: true,
+			value: values
+		},
+		[Symbol.asyncIterator]: {
+			configurable: true,
+			writable: true,
+			value: values
 		}
 	});
 	return stream;
 }
 function gateReader(ctx, reader) {
+	const bound = /* @__PURE__ */ new Map();
 	return new Proxy(reader, { get(subject, property) {
-		if (property === "read") return () => ctx.awaitIo(subject.read());
+		const cached = bound.get(property);
+		if (cached !== void 0) return cached;
+		if (property === "closed") {
+			const closed = ctx.awaitIo(subject.closed);
+			bound.set(property, closed);
+			return closed;
+		}
+		if (property === "read") {
+			const read = () => ctx.awaitIo(subject.read());
+			bound.set(property, read);
+			return read;
+		}
+		if (property === "cancel") {
+			const cancel = (reason) => ctx.awaitIo(subject.cancel(reason));
+			bound.set(property, cancel);
+			return cancel;
+		}
 		const value = Reflect.get(subject, property, subject);
-		return typeof value === "function" ? value.bind(subject) : value;
+		if (typeof value === "function") {
+			const method = value.bind(subject);
+			bound.set(property, method);
+			return method;
+		}
+		return value;
 	} });
 }
 //#endregion