posipaki 0.44.0 → 0.45.0

package/dist/remote/gateway-cli.js

@@ -3,38 +3,1075 @@ import { mkdtemp, open, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { promisify } from "node:util";
-import { Writable } from "node:stream";
-import * as readline from "node:readline";
+//#region src/remote/process-ref.ts
+/**
+* The id a side gives its own root: the first id of its parity.  The two ends of a
+* connection therefore number their roots differently, and an id says whose root it is
+* as it says who holds every other process.  A side hands out its next id from two
+* steps further on, the one in between belonging to the root of the side it talks to.
+*/
+function rootIdFor(parity) {
+	return parity === "odd" ? 1 : 0;
+}
+/**
+* The ids one side of a connection hands out: its own parity, from the far side of the low band.
+*
+* Everything numbered on the connection draws from one space — a process reference and a stream alike —
+* so a number names one thing, and the parity says which side made it.  Each side builds its own and
+* hands the same one to whatever allocates.
+*/
+var IdSpace = class {
+	constructor(parity, first = parity === "odd" ? 9 : 10) {
+		this.parity = parity;
+		this.pvtNext = first;
+		this.pvtBand = first <= 8;
+	}
+	/** This side's own end of the connection: the first id of its parity, never handed out. */
+	root() {
+		return rootIdFor(this.parity);
+	}
+	/** The next id of this side's parity, and never the same one twice. */
+	next() {
+		if (this.pvtBand && this.pvtNext > 8) throw new Error("IdSpace: the low band is spent");
+		const id = this.pvtNext;
+		this.pvtNext += 2;
+		return id;
+	}
+};
+/**
+* A space inside the low band, for a party that speaks on a connection it otherwise relays: its ids
+* come from a range no end allocates in, so announcing something of its own cannot take a number
+* either end might mint.
+*/
+function lowBand(parity) {
+	return new IdSpace(parity, parity === "odd" ? 3 : 2);
+}
+//#endregion
 //#region src/remote/channel.ts
+/** Is this something JSON would carry as an object, rather than an instance with behaviour? */
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+/**
+* Is this a stream — a value whose bytes come later, carried by reference?
+*
+* The question every walk that copies containers has to ask: copying a stream keeps the object and
+* loses the behaviour, because its iterator is a symbol-keyed property and `Object.entries` does not
+* see those.  What such a value is belongs to `stream.ts`; that it must be left alone belongs to
+* every layer that walks a message.
+*/
+function isStreamLike(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return typeof value[Symbol.asyncIterator] === "function";
+}
+/**
+* A channel that is `base`, with every incoming frame offered to `onFrame` first — and not handed
+* on when it is claimed.
+*
+* Every wrapper above a protocol wants this one thing, and none of them may lose the octets: a
+* connection that carries segments keeps carrying them through whatever wraps it, or a stream
+* dies one layer above the wire it was written for.
+*/
+function channelThrough(base, onFrame) {
+	const wrapped = {
+		send: (frame) => base.send(frame),
+		onMessage: (handler) => base.onMessage((frame) => {
+			if (onFrame(frame)) return;
+			handler(frame);
+		}),
+		onClose: (handler) => base.onClose(handler),
+		close: () => base.close()
+	};
+	if (base.sendSegment) wrapped.sendSegment = (frame, bytes) => base.sendSegment?.(frame, bytes);
+	if (base.onSegment) wrapped.onSegment = (handler) => base.onSegment?.(handler) ?? (() => {});
+	return wrapped;
+}
+const BAD_KEY = "$bad";
+/** The frame that says a frame could not be read: why, how long it was, and the head of it. */
+function badFrame(reason, raw) {
+	const prefix = raw.length > 32 ? `${raw.slice(0, 32)}…` : raw;
+	return { [BAD_KEY]: {
+		reason,
+		length: raw.length,
+		prefix
+	} };
+}
 const ERROR_KEY = "$error";
 /** The frame that says the wire is over: the reason, and the connection ends with it. */
 function errorFrame$1(reason) {
 	return { [ERROR_KEY]: reason };
 }
-/** A frame of the far end's own output: `data` on the stream `fd`. */
-function outputFrame(fd, data) {
-	return {
-		$fd: fd,
-		data
-	};
-}
 //#endregion
 //#region src/remote/protocols/json1.ts
 function encode(frame) {
 	return JSON.stringify(frame);
 }
+/** The frame a line carries, throwing on a line that is not JSON.  `readFrame` is how the
+*  seam reads a line; this is the primitive underneath it. */
+function decode(str) {
+	return JSON.parse(str);
+}
+/** A line read as a frame: the frame itself, or the frame that says this one could not be
+*  read.  Never throws — see the note at the top of this file. */
+function readFrame(str) {
+	let parsed;
+	try {
+		parsed = decode(str);
+	} catch (err) {
+		return badFrame(err instanceof Error ? err.message : String(err), str);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return badFrame(`a frame is one JSON object, and this was ${kindOf(parsed)}`, str);
+	return parsed;
+}
+function kindOf(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "an array";
+	return `a ${typeof value}`;
+}
+/**
+* The octets a frame announces after it, or null when it announces none.
+*
+* One shape only: a chunk head carries the number of raw octets that follow, and that number
+* is what keeps the reader's framing.  A head without one is not a segment — it goes on as a
+* frame, and whoever reads it refuses it by name.
+*/
+function announcedOctets(frame) {
+	const head = frame.$chunk;
+	if (typeof head !== "object" || head === null) return null;
+	const bytes = head.bytes;
+	return typeof bytes === "number" && Number.isInteger(bytes) && bytes >= 0 ? bytes : null;
+}
+function json1Channel(transport) {
+	const frameReaders = /* @__PURE__ */ new Set();
+	const segmentReaders = /* @__PURE__ */ new Set();
+	/** The head whose octets are on their way: set between the line and the run it announced. */
+	let expecting = null;
+	const deliver = (frame) => {
+		for (const reader of [...frameReaders]) reader(frame);
+	};
+	transport.onMessage((str) => {
+		const frame = readFrame(str);
+		const octets = announcedOctets(frame);
+		if (octets === null) {
+			deliver(frame);
+			return;
+		}
+		expecting = frame;
+		return octets;
+	});
+	transport.onBytes((bytes) => {
+		const frame = expecting;
+		expecting = null;
+		if (frame === null) {
+			deliver(badFrame(`${bytes.length} octets arrived that no frame announced`, ""));
+			return;
+		}
+		for (const reader of [...segmentReaders]) reader(frame, bytes);
+	});
+	return {
+		send(frame) {
+			return transport.send(encode(frame));
+		},
+		onMessage(handler) {
+			frameReaders.add(handler);
+			return () => {
+				frameReaders.delete(handler);
+			};
+		},
+		async sendSegment(frame, bytes) {
+			await transport.send(encode(frame));
+			await transport.sendBytes(bytes);
+		},
+		onSegment(handler) {
+			segmentReaders.add(handler);
+			return () => {
+				segmentReaders.delete(handler);
+			};
+		},
+		onClose(handler) {
+			transport.onClose(handler);
+		},
+		close() {
+			return transport.close();
+		}
+	};
+}
+function isStreamRef(value) {
+	const body = value?.$s;
+	return typeof body?.id === "number" || typeof body?.name === "string";
+}
+function isBytesRef(value) {
+	const body = value?.$bytes;
+	return typeof body?.id === "number" && typeof body?.size === "number";
+}
+function isBlobRef(value) {
+	const body = value?.$blob;
+	return typeof body?.id === "number" && typeof body?.size === "number";
+}
+function isBlob(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	if (typeof candidate.size !== "number") return false;
+	if (typeof candidate.arrayBuffer !== "function") return false;
+	return typeof candidate.slice === "function" || typeof candidate.stream === "function";
+}
+/** Every octet of a stream, in one array. */
+async function bytesOf(stream) {
+	const parts = [];
+	let total = 0;
+	for await (const part of stream) {
+		parts.push(part);
+		total += part.length;
+	}
+	const all = new Uint8Array(total);
+	let at = 0;
+	for (const part of parts) {
+		all.set(part, at);
+		at += part.length;
+	}
+	return all;
+}
+let pvtCrc = null;
+function crcOf() {
+	if (pvtCrc !== null) return pvtCrc;
+	const bun = globalThis.Bun;
+	if (typeof bun?.hash?.crc32 === "function") {
+		const native = bun.hash.crc32;
+		pvtCrc = (bytes) => native(bytes) >>> 0;
+		return pvtCrc;
+	}
+	const builtin = globalThis.process?.getBuiltinModule?.("node:zlib");
+	if (typeof builtin?.crc32 === "function") {
+		const native = builtin.crc32;
+		pvtCrc = (bytes) => native(bytes) >>> 0;
+		return pvtCrc;
+	}
+	pvtCrc = tableCrc;
+	return pvtCrc;
+}
+/** CRC-32 by hand, for a runtime that has none.  Correct, and slow where nothing is a JIT. */
+function tableCrc(bytes) {
+	let crc = 4294967295;
+	for (const byte of bytes) crc = crc >>> 8 ^ pvtTable[(crc ^ byte) & 255];
+	return (crc ^ 4294967295) >>> 0;
+}
+const pvtTable = (() => {
+	const table = [];
+	for (let i = 0; i < 256; i += 1) {
+		let value = i;
+		for (let bit = 0; bit < 8; bit += 1) value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+		table.push(value >>> 0);
+	}
+	return table;
+})();
+/** The checksum a chunk's tail carries. */
+function crc32(bytes) {
+	return crcOf()(bytes);
+}
+/**
+* Bytes the far side offers, read at the consumer's pace.
+*
+* An async iterable of octets, and nothing more: turning it into an array, a `Blob` or a digest
+* is the platform's job — `new Response(stream).arrayBuffer()` where there is a `Response`,
+* `for await` where there is not.
+*/
+var RemoteStream = class {
+	constructor(hooks) {
+		this.hooks = hooks;
+		this.queue = [];
+		this.waiting = [];
+		this.ended = false;
+		this.failure = null;
+		this.stopped = false;
+		this.platform = null;
+	}
+	/** The far side sent more of it. */
+	push(bytes) {
+		if (this.ended || this.failure || this.stopped) return;
+		const waiting = this.waiting.shift();
+		if (!waiting) {
+			this.queue.push(bytes);
+			return;
+		}
+		this.hooks.consumed(bytes.length);
+		waiting.resolve({
+			value: bytes,
+			done: false
+		});
+	}
+	/** The far side has sent all of it. */
+	end() {
+		if (this.ended || this.failure) return;
+		this.ended = true;
+		for (const waiting of this.waiting.splice(0)) waiting.resolve({
+			value: void 0,
+			done: true
+		});
+	}
+	/** The far side gave up on it, or it arrived corrupt. */
+	fail(reason) {
+		if (this.ended || this.failure) return;
+		this.failure = new Error(reason);
+		for (const waiting of this.waiting.splice(0)) waiting.reject(this.failure);
+	}
+	/** Take no more of it.  Said to the far side, so it stops reading its source. */
+	cancel(reason = "the reader stopped") {
+		if (this.stopped || this.ended) return;
+		this.stopped = true;
+		this.queue.length = 0;
+		for (const waiting of this.waiting.splice(0)) waiting.resolve({
+			value: void 0,
+			done: true
+		});
+		this.hooks.cancelled(reason);
+	}
+	async next() {
+		const queued = this.queue.shift();
+		if (queued) {
+			this.hooks.consumed(queued.length);
+			return {
+				value: queued,
+				done: false
+			};
+		}
+		if (this.failure) throw this.failure;
+		if (this.ended || this.stopped) return {
+			value: void 0,
+			done: true
+		};
+		this.hooks.wanted();
+		return new Promise((resolve, reject) => {
+			this.waiting.push({
+				resolve,
+				reject
+			});
+		});
+	}
+	async return() {
+		this.cancel();
+		return {
+			value: void 0,
+			done: true
+		};
+	}
+	/**
+	* The runtime's own stream, built over this one the first time something asks for it.  What a
+	* sender usually hands over is a `ReadableStream`, so what arrives offers the same interface —
+	* `getReader()`, `pipeTo()`, `tee()` — rather than a narrower shape of its own.  A runtime
+	* without `ReadableStream` keeps the iterable, which is the library's own interface.
+	*/
+	asReadableStream() {
+		const ctor = globalThis.ReadableStream;
+		if (typeof ctor !== "function") throw new Error("this runtime has no ReadableStream: read the stream with `for await`");
+		this.platform ??= new ctor({
+			pull: async (controller) => {
+				const next = await this.next();
+				if (next.done) controller.close();
+				else controller.enqueue(next.value);
+			},
+			cancel: (reason) => {
+				this.cancel(typeof reason === "string" ? reason : "the reader stopped");
+			}
+		});
+		return this.platform;
+	}
+	getReader() {
+		return this.asReadableStream().getReader();
+	}
+	pipeTo(destination, options) {
+		return this.asReadableStream().pipeTo(destination, options);
+	}
+	tee() {
+		return this.asReadableStream().tee();
+	}
+	/** One consumer, whichever door it comes through: where the runtime has a platform stream this
+	*  path goes through it, so the lock and the queue are the platform's and not two of ours. */
+	async *[Symbol.asyncIterator]() {
+		if (typeof globalThis.ReadableStream !== "function") for (;;) {
+			const next = await this.next();
+			if (next.done) return;
+			yield next.value;
+		}
+		const reader = this.asReadableStream().getReader();
+		let finished = false;
+		try {
+			for (;;) {
+				const next = await reader.read();
+				if (next.done) {
+					finished = true;
+					return;
+				}
+				yield next.value;
+			}
+		} finally {
+			reader.releaseLock();
+			if (!finished) this.cancel();
+		}
+	}
+};
+/**
+* A blob that came over a connection: the same value the far side offered, with its bytes still
+* over there.  Reading it is what asks for them — and only at the pace the reader takes them, so a
+* file nobody opens costs nothing on the wire.
+*/
+var RemoteBlob = class {
+	constructor(body, facts) {
+		this.facts = facts;
+		this.body = body;
+	}
+	get size() {
+		return this.facts.size;
+	}
+	get type() {
+		return this.facts.type;
+	}
+	get name() {
+		return this.facts.name;
+	}
+	stream() {
+		return this.body;
+	}
+	async arrayBuffer() {
+		return (await bytesOf(this.body)).buffer;
+	}
+};
+/**
+* Bytes that crossed a connection: the sender's array, taken apart into a stream and put back
+* together here as the chunks arrive.  Not lazy — the sender was asked the moment the reference
+* arrived — so awaiting this is waiting for the last chunk, not for a read to start.
+*/
+var RemoteBytes = class {
+	constructor(body, size) {
+		this.filling = null;
+		this.body = body;
+		this.size = size;
+	}
+	/** Start re-assembling.  Called by the store once its record for this stream is in place. */
+	start() {
+		this.bytes().catch(() => {});
+	}
+	/** The octets, once they are all here. */
+	bytes() {
+		this.filling ??= this.pvtFill();
+		return this.filling;
+	}
+	/** The same octets as an array's buffer, for a caller that wants the platform's shape. */
+	async arrayBuffer() {
+		return (await this.bytes()).buffer;
+	}
+	then(onfulfilled, onrejected) {
+		return this.bytes().then(onfulfilled, onrejected);
+	}
+	async pvtFill() {
+		const all = new Uint8Array(this.size);
+		let at = 0;
+		for await (const chunk of this.body) {
+			if (at + chunk.length > all.length) throw new Error(`the array is longer than the ${this.size} bytes it stated`);
+			all.set(chunk, at);
+			at += chunk.length;
+		}
+		if (at !== all.length) throw new Error(`the array is short: ${at} of ${this.size} octets arrived`);
+		return all;
+	}
+};
+/**
+* One connection's streams, as this side sees them.
+*
+* Both directions are in one table, because both are the same numbering: what this side offers
+* (and answers asks for) and what it may read from the far side.  Ids follow the process table's
+* parity, so an id names one stream on one connection and nothing anywhere else.
+*/
+var StreamStore = class {
+	constructor(channel, parity, options = {}) {
+		this.pvtOffers = /* @__PURE__ */ new Map();
+		this.pvtIncoming = /* @__PURE__ */ new Map();
+		this.pvtRefused = /* @__PURE__ */ new Map();
+		this.pvtNamesOut = /* @__PURE__ */ new Map();
+		this.pvtNamesIn = /* @__PURE__ */ new Map();
+		this.pvtNamedListeners = /* @__PURE__ */ new Set();
+		this.pvtSegmentOff = null;
+		this.pvtClosed = false;
+		this.channel = channel;
+		this.chunkBytes = options.chunkBytes ?? 65536;
+		this.windowBytes = options.windowBytes ?? 262144;
+		this.maxBytes = options.maxBytes ?? 67108864;
+		this.ids = options.ids ?? new IdSpace(parity);
+		const attached = options.attach !== false;
+		this.pvtOff = attached ? channel.onMessage((frame) => {
+			this.onFrame(frame);
+		}) : () => {};
+		this.pvtSegmentOff = attached ? channel.onSegment?.((head, bytes) => this.onSegment(head, bytes)) ?? null : null;
+	}
+	/** Whether this connection can carry a stream at all: it must carry octets beside its lines. */
+	get canCarryStreams() {
+		return this.pvtSegmentOff !== null && this.channel.sendSegment !== void 0;
+	}
+	/**
+	* Offer a stream to the connection: the announcement goes out now, and the bytes when the far
+	* side asks for them.  What comes back is what a message carries in their place.
+	*
+	* A `name` makes the stream findable: the far side can reference it by that name instead of the
+	* id, and ask for it with `named()` without waiting for a message to carry a reference.
+	*/
+	offer(stream, name) {
+		return { $s: { id: this.pvtAnnounce(stream[Symbol.asyncIterator](), name) } };
+	}
+	/**
+	* Offer a blob — a whole file, read on demand.  It crosses as a stream over its bytes and arrives
+	* on the far side as a `RemoteBlob`, so nothing of it is read until somebody wants the bytes.
+	*/
+	offerBlob(blob) {
+		const { size, type, name } = blob;
+		return { $blob: {
+			id: this.pvtAnnounce(this.pvtBlobChunks(blob)),
+			size,
+			...type === void 0 ? {} : { type },
+			...name === void 0 ? {} : { name }
+		} };
+	}
+	/**
+	* Offer bytes this side already holds.  The reference states the length, so the far side can
+	* check it against its bound and size the array before the first chunk arrives — a typed array
+	* is one piece, so the wire carries it as a stream of one.
+	*/
+	offerBytes(bytes) {
+		return { $bytes: {
+			id: this.pvtAnnounce(this.pvtOnePiece(bytes)),
+			size: bytes.length
+		} };
+	}
+	pvtAnnounce(source, name) {
+		const id = this.ids.next();
+		this.pvtOffers.set(id, {
+			id,
+			source,
+			pending: null,
+			credit: 0,
+			seq: 0,
+			pumping: false,
+			dropped: false
+		});
+		if (name !== void 0) this.pvtNamesOut.set(name, id);
+		this.channel.send(name === void 0 ? { $stream: { id } } : { $stream: {
+			id,
+			name
+		} });
+		return id;
+	}
+	async *pvtOnePiece(bytes) {
+		if (bytes.length > 0) yield bytes;
+	}
+	/** A blob's octets, a window at a time: sliced where the value can, streamed where it cannot. */
+	async *pvtBlobChunks(blob) {
+		const slice = blob.slice;
+		if (slice) {
+			for (let at = 0; at < blob.size; at += this.chunkBytes) {
+				const end = Math.min(at + this.chunkBytes, blob.size);
+				yield new Uint8Array(await slice.call(blob, at, end).arrayBuffer());
+			}
+			return;
+		}
+		const stream = blob.stream;
+		if (!stream) throw new TypeError("a blob must offer a slice or a stream");
+		yield* stream.call(blob);
+	}
+	/** A value on its way out: every stream in it becomes an announcement and a reference. */
+	encode(value) {
+		return this.pvtEncode(value, /* @__PURE__ */ new Set());
+	}
+	/** A value just read: every reference in it becomes something this side can read. */
+	decode(value) {
+		return this.pvtDecode(value, /* @__PURE__ */ new Set());
+	}
+	/** Drop every stream of this connection, in both directions.  Called when it ends. */
+	close() {
+		if (this.pvtClosed) return;
+		this.pvtClosed = true;
+		this.pvtOff();
+		this.pvtSegmentOff?.();
+		for (const offered of this.pvtOffers.values()) {
+			offered.dropped = true;
+			offered.source.return?.();
+		}
+		this.pvtOffers.clear();
+		for (const incoming of this.pvtIncoming.values()) incoming.reader.fail("the connection ended");
+		this.pvtIncoming.clear();
+	}
+	/** The ids this side is holding, in the order they were offered. */
+	held() {
+		return [...this.pvtOffers.keys()];
+	}
+	/**
+	* Take a frame if it is one this store answers for, and say whether it did.  A party that carries a
+	* connection it does not speak — a first stage, relaying a client to a payload — has to know which
+	* inbound frames are its own and which belong to the far side, and this is the question it asks.
+	* Only frames about a stream this side offered are claimed, so a stream the far side offers passes
+	* through untouched.
+	*/
+	handle(frame) {
+		if (this.pvtClosed) return false;
+		const id = frameId(frame);
+		if (id === null || !this.pvtOffers.has(id)) return false;
+		this.onFrame(frame);
+		return true;
+	}
+	/**
+	* The stream the far side announced under `name`, if it is still live — the way a caller finds a
+	* stream nobody sent it a reference to.  A name that was never announced answers `undefined`, and a
+	* name whose stream is over does too: the sentence lives on the value the reference would give.
+	*/
+	named(name) {
+		const id = this.pvtNamesIn.get(name);
+		if (id === void 0) return void 0;
+		return this.pvtValueFor(id, "stream");
+	}
+	/**
+	* Every named stream the far side announces, now and later.  The listener is called for the names
+	* already live when it is installed and for each new one as it arrives, so a caller that wires a
+	* sink to `stdout` does not have to know whether the far side has printed yet.
+	*/
+	onNamed(listener) {
+		this.pvtNamedListeners.add(listener);
+		for (const [name, id] of this.pvtNamesIn) if (this.pvtIncoming.has(id)) listener(name, this.pvtValueFor(id, "stream"));
+		return () => {
+			this.pvtNamedListeners.delete(listener);
+		};
+	}
+	pvtSend(frame) {
+		return Promise.resolve(this.channel.send(frame));
+	}
+	pvtEncode(value, seen) {
+		if (typeof value !== "object" || value === null) return value;
+		if (isBlob(value)) return this.offerBlob(value);
+		if (isStreamLike(value)) return this.offer(value);
+		if (seen.has(value)) return value;
+		seen.add(value);
+		if (Array.isArray(value)) return value.map((item) => this.pvtEncode(item, seen));
+		if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return this.offerBytes(asOctets(value));
+		if (!isPlainObject(value)) return value;
+		const copy = {};
+		for (const [key, item] of Object.entries(value)) copy[key] = this.pvtEncode(item, seen);
+		return copy;
+	}
+	pvtTake(offered) {
+		if (offered.pending === null) return null;
+		const size = Math.min(offered.pending.length, this.chunkBytes, offered.credit);
+		const piece = offered.pending.subarray(0, size);
+		offered.pending = size === offered.pending.length ? null : offered.pending.subarray(size);
+		return piece;
+	}
+	async pvtPull(offered) {
+		const next = await offered.source.next();
+		if (next.done) return false;
+		const value = next.value;
+		const bytes = value instanceof Uint8Array ? value : ArrayBuffer.isView(value) ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : value instanceof ArrayBuffer ? new Uint8Array(value) : null;
+		if (bytes === null) throw new TypeError("a stream may only yield octets");
+		if (bytes.length === 0) return true;
+		offered.pending = bytes;
+		return true;
+	}
+	async pvtPump(offered) {
+		if (offered.pumping || offered.dropped || this.pvtClosed) return;
+		offered.pumping = true;
+		try {
+			while (!offered.dropped && offered.credit > 0) {
+				if (offered.pending === null && !await this.pvtPull(offered)) {
+					await this.channel.send({ $streamDone: { id: offered.id } });
+					this.pvtDrop(offered);
+					return;
+				}
+				const piece = this.pvtTake(offered);
+				if (piece === null) continue;
+				const seq = offered.seq;
+				offered.seq += 1;
+				offered.credit -= piece.length;
+				await this.channel.sendSegment?.({ $chunk: {
+					id: offered.id,
+					seq,
+					bytes: piece.length
+				} }, piece);
+				await this.channel.send({ $chunkEnd: {
+					id: offered.id,
+					seq,
+					crc32: crc32(piece)
+				} });
+			}
+		} catch (error) {
+			await this.pvtSend({ $streamFail: {
+				id: offered.id,
+				reason: reasonOf(error)
+			} }).catch(() => {});
+			this.pvtDrop(offered);
+		} finally {
+			offered.pumping = false;
+		}
+	}
+	pvtDrop(offered) {
+		if (offered.dropped) return;
+		offered.dropped = true;
+		this.pvtOffers.delete(offered.id);
+		this.pvtRelease(offered.id);
+	}
+	/**
+	* Take a stream out of the live table and remember why it ended, for a reference that arrives
+	* after the fact: "no stream was announced" is the wrong sentence for a stream that was refused.
+	*/
+	pvtRetire(id, reason, form = "stream") {
+		this.pvtIncoming.delete(id);
+		this.pvtRelease(id);
+		this.pvtRefused.set(id, {
+			reason,
+			form
+		});
+		if (this.pvtRefused.size > 64) {
+			const oldest = this.pvtRefused.keys().next();
+			if (!oldest.done) this.pvtRefused.delete(oldest.value);
+		}
+	}
+	/** A stream that is over gives its name back, so the next announcement of it is not a duplicate. */
+	pvtRelease(id) {
+		for (const [name, bound] of this.pvtNamesIn) if (bound === id) this.pvtNamesIn.delete(name);
+		for (const [name, bound] of this.pvtNamesOut) if (bound === id) this.pvtNamesOut.delete(name);
+	}
+	pvtDecode(value, seen) {
+		if (typeof value !== "object" || value === null) return value;
+		if (isBytesRef(value)) return this.pvtValueFor(value.$bytes.id, "bytes", { size: value.$bytes.size });
+		if (isBlobRef(value)) {
+			const { id, size, type, name } = value.$blob;
+			return this.pvtValueFor(id, "blob", {
+				size,
+				type,
+				name
+			});
+		}
+		if (isStreamRef(value)) {
+			const ref = value.$s;
+			return "id" in ref ? this.pvtValueFor(ref.id, "stream") : this.pvtValueForNamed(ref.name);
+		}
+		if (seen.has(value)) return value;
+		seen.add(value);
+		if (Array.isArray(value)) return value.map((item) => this.pvtDecode(item, seen));
+		if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return value;
+		if (!isPlainObject(value)) return value;
+		const copy = {};
+		for (const [key, item] of Object.entries(value)) copy[key] = this.pvtDecode(item, seen);
+		return copy;
+	}
+	pvtValueFor(id, form, facts) {
+		const incoming = this.pvtIncoming.get(id);
+		if (!incoming) {
+			const ended = this.pvtRefused.get(id);
+			const failed = new RemoteStream({
+				consumed() {},
+				cancelled() {},
+				wanted() {}
+			});
+			failed.fail(ended?.reason ?? `no stream was announced with id ${id}`);
+			return this.pvtBuild(failed, ended?.form ?? form, facts);
+		}
+		if (incoming.value) return incoming.value;
+		incoming.form = form;
+		const value = incoming.value = this.pvtBuild(incoming.reader, form, facts);
+		if (facts !== void 0 && facts.size > this.maxBytes) {
+			const reason = `stream ${id} is ${facts.size} bytes, over this side's bound of ${this.maxBytes}`;
+			incoming.done = true;
+			incoming.reader.fail(reason);
+			this.pvtRetire(id, reason, form);
+			this.channel.send({ $streamFail: {
+				id,
+				reason: "over the reader's bound"
+			} });
+		}
+		if (value instanceof RemoteBytes) value.start();
+		return value;
+	}
+	/** The value a name the far side announced stands for — or one that says it was never announced. */
+	pvtValueForNamed(name) {
+		const id = this.pvtNamesIn.get(name);
+		if (id !== void 0 && this.pvtIncoming.has(id)) return this.pvtValueFor(id, "stream");
+		const failed = new RemoteStream({
+			consumed() {},
+			cancelled() {},
+			wanted() {}
+		});
+		failed.fail(`no stream was announced with the name ${name}`);
+		return failed;
+	}
+	pvtBuild(reader, form, facts) {
+		if (form === "blob" && facts !== void 0) return new RemoteBlob(reader, facts);
+		if (form === "bytes" && facts !== void 0) return new RemoteBytes(reader, facts.size);
+		return reader;
+	}
+	pvtAsk(incoming) {
+		if (incoming.done || this.pvtClosed) return;
+		const outstanding = incoming.asked - incoming.consumed;
+		if (outstanding >= this.windowBytes / 2) return;
+		const credit = this.windowBytes - outstanding;
+		incoming.asked += credit;
+		this.channel.send({ $streamAsk: {
+			id: incoming.id,
+			credit
+		} });
+	}
+	pvtAnnounced(id, name) {
+		this.pvtIncoming.get(id)?.reader.fail(`a stream was announced twice with id ${id}`);
+		if (name !== void 0) {
+			const taken = this.pvtNamesIn.get(name);
+			if (taken !== void 0) {
+				const reason = `a stream named ${name} is already live (id ${taken})`;
+				this.pvtRetire(id, reason, "stream");
+				this.channel.send({ $streamFail: {
+					id,
+					reason
+				} });
+				return;
+			}
+			this.pvtNamesIn.set(name, id);
+		}
+		let incoming;
+		incoming = {
+			id,
+			reader: new RemoteStream({
+				consumed: (bytes) => {
+					incoming.consumed += bytes;
+					this.pvtAsk(incoming);
+				},
+				wanted: () => {
+					this.pvtAsk(incoming);
+				},
+				cancelled: (reason) => {
+					incoming.done = true;
+					this.pvtIncoming.delete(id);
+					this.pvtRelease(id);
+					this.channel.send({ $streamCancel: {
+						id,
+						reason
+					} });
+				}
+			}),
+			form: "stream",
+			asked: 0,
+			consumed: 0,
+			received: 0,
+			chunk: null,
+			done: false
+		};
+		this.pvtIncoming.set(id, incoming);
+		if (name !== void 0) {
+			const stream = this.pvtValueFor(id, "stream");
+			for (const listener of this.pvtNamedListeners) listener(name, stream);
+		}
+	}
+	onSegment(head, bytes) {
+		const chunk = head.$chunk;
+		if (typeof chunk?.id !== "number" || typeof chunk.seq !== "number") return;
+		const incoming = this.pvtIncoming.get(chunk.id);
+		if (!incoming || incoming.done) return;
+		incoming.received += bytes.length;
+		if (incoming.received > this.maxBytes) {
+			const reason = `stream ${incoming.id} passed this side's bound of ${this.maxBytes} bytes`;
+			incoming.done = true;
+			incoming.reader.fail(reason);
+			this.pvtRetire(incoming.id, reason, incoming.form);
+			this.channel.send({ $streamFail: {
+				id: incoming.id,
+				reason: "over the reader's bound"
+			} });
+			return;
+		}
+		incoming.chunk = {
+			seq: chunk.seq,
+			bytes
+		};
+	}
+	onFrame(frame) {
+		if (this.pvtClosed) return;
+		if ("$stream" in frame) {
+			const body = frame.$stream;
+			if (typeof body?.id !== "number") return;
+			this.pvtAnnounced(body.id, typeof body.name === "string" ? body.name : void 0);
+			return;
+		}
+		if ("$streamAsk" in frame) {
+			const body = frame.$streamAsk;
+			const offered = typeof body?.id === "number" ? this.pvtOffers.get(body.id) : void 0;
+			if (!offered || typeof body?.credit !== "number" || body.credit <= 0) return;
+			offered.credit += body.credit;
+			this.pvtPump(offered);
+			return;
+		}
+		if ("$chunkEnd" in frame) {
+			const body = frame.$chunkEnd;
+			const incoming = typeof body?.id === "number" ? this.pvtIncoming.get(body.id) : void 0;
+			if (!incoming) return;
+			const chunk = incoming.chunk;
+			incoming.chunk = null;
+			if (chunk === null || chunk.seq !== body?.seq) {
+				incoming.done = true;
+				incoming.reader.fail(`stream ${incoming.id} lost its framing: a chunk ended that never began`);
+				this.pvtRetire(incoming.id, `stream ${incoming.id} lost its framing: a chunk ended that never began`, incoming.form);
+				this.channel.send({ $streamFail: {
+					id: incoming.id,
+					reason: "lost the framing"
+				} });
+				return;
+			}
+			if (typeof body?.crc32 === "number" && crc32(chunk.bytes) !== body.crc32) {
+				incoming.done = true;
+				incoming.reader.fail(`stream ${incoming.id} arrived corrupt: chunk ${chunk.seq} failed its checksum`);
+				this.pvtRetire(incoming.id, `stream ${incoming.id} arrived corrupt: chunk ${chunk.seq} failed its checksum`, incoming.form);
+				this.channel.send({ $streamFail: {
+					id: incoming.id,
+					reason: "a chunk failed its checksum"
+				} });
+				return;
+			}
+			incoming.reader.push(chunk.bytes);
+			return;
+		}
+		if ("$streamDone" in frame) {
+			const body = frame.$streamDone;
+			const incoming = typeof body?.id === "number" ? this.pvtIncoming.get(body.id) : void 0;
+			if (!incoming) return;
+			incoming.done = true;
+			this.pvtIncoming.delete(incoming.id);
+			this.pvtRelease(incoming.id);
+			incoming.reader.end();
+			return;
+		}
+		if ("$streamFail" in frame) {
+			const body = frame.$streamFail;
+			const incoming = typeof body?.id === "number" ? this.pvtIncoming.get(body.id) : void 0;
+			if (!incoming) return;
+			const reason = typeof body?.reason === "string" ? body.reason : `stream ${incoming.id} failed`;
+			incoming.done = true;
+			incoming.reader.fail(reason);
+			this.pvtRetire(incoming.id, reason, incoming.form);
+			return;
+		}
+		if ("$streamCancel" in frame) {
+			const body = frame.$streamCancel;
+			const offered = typeof body?.id === "number" ? this.pvtOffers.get(body.id) : void 0;
+			if (!offered) return;
+			this.pvtDrop(offered);
+			offered.source.return?.();
+		}
+	}
+};
+/** A typed array or an `ArrayBuffer` as the octets the wire carries. */
+function asOctets(value) {
+	if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+	return new Uint8Array(value);
+}
+function reasonOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** The stream id a control frame names, or null when it names none of them. */
+function frameId(frame) {
+	for (const key of [
+		"$streamAsk",
+		"$streamCancel",
+		"$streamDone",
+		"$streamFail"
+	]) {
+		const body = frame[key];
+		if (typeof body?.id === "number") return body.id;
+	}
+	return null;
+}
 //#endregion
-//#region src/remote/streams.ts
+//#region src/remote/lines.ts
+const NL = 10;
+const CR = 13;
+function withoutCr(line) {
+	return line.length > 0 && line[line.length - 1] === CR ? line.subarray(0, line.length - 1) : line;
+}
 /**
-* A writable that writes what is written to it as output frames of one fd: one chunk is one frame.
+* The wire as a sequence of lines, where a line may announce raw octets to follow it.
 *
-* The shape of an output frame lives here rather than at each caller — the gateway relays a payload's
-* own output and holds no channel — and a send that fails is the stream's error, not a lost line.
+* `onLine` gets a line and answers how many octets come next — none, for every frame but
+* one that carries them.  Those octets reach `onBytes` whole, however many reads they
+* arrived in, and the reader goes back to looking for a newline.
 */
-function fdWriter(send, fd) {
-	return new Writable({ write(chunk, _encoding, done) {
-		Promise.resolve(send(outputFrame(fd, String(chunk)))).then(() => done(), (error) => done(error));
-	} });
+var PartReader = class {
+	constructor(onLine, onBytes) {
+		this.onLine = onLine;
+		this.onBytes = onBytes;
+		this.acc = Buffer.alloc(0);
+		this.want = 0;
+		this.done = false;
+	}
+	feed(chunk) {
+		if (this.done) return;
+		this.acc = this.acc.length === 0 ? Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength) : Buffer.concat([this.acc, chunk]);
+		this.pump();
+	}
+	/** The stream is over: whatever is left of a line is still a line, as `readline` said. */
+	end() {
+		if (this.done) return;
+		const rest = this.acc;
+		this.acc = Buffer.alloc(0);
+		this.done = true;
+		if (rest.length > 0 && this.want === 0) this.onLine(withoutCr(rest).toString("utf8"));
+	}
+	pump() {
+		for (;;) {
+			if (this.want > 0) {
+				if (this.acc.length < this.want) return;
+				const bytes = this.acc.subarray(0, this.want);
+				this.acc = this.acc.subarray(this.want);
+				this.want = 0;
+				this.onBytes(bytes);
+				continue;
+			}
+			const at = this.acc.indexOf(NL);
+			if (at < 0) return;
+			const line = this.acc.subarray(0, at);
+			this.acc = this.acc.subarray(at + 1);
+			const asked = this.onLine(withoutCr(line).toString("utf8"));
+			if (typeof asked === "number") {
+				if (asked > 0) this.want = asked;
+				else this.onBytes(/* @__PURE__ */ new Uint8Array(0));
+			}
+		}
+	}
+};
+/**
+* Read `stream` as lines, with the octets a line announces.
+*
+* `onEnd` is called once when the stream is over, after the last line: a stream that
+* ends without its final newline still gives up its last line, because that is what the
+* peer meant to say.
+*/
+function readParts(stream, onLine, onBytes, onEnd) {
+	const reader = new PartReader(onLine, onBytes);
+	return readChunks(stream, (chunk) => reader.feed(chunk), () => {
+		reader.end();
+		onEnd?.();
+	});
+}
+/** The bytes a stream carries, before anything is made of them. */
+function readChunks(stream, onChunk, onEnd) {
+	let stopped = false;
+	const onData = (chunk) => {
+		if (stopped) return;
+		onChunk(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk);
+	};
+	const finish = () => {
+		if (stopped) return;
+		stopped = true;
+		stream.off("data", onData);
+		onEnd?.();
+	};
+	stream.on("data", onData);
+	stream.once("end", finish);
+	return { stop() {
+		stopped = true;
+		stream.off("data", onData);
+		stream.off("end", finish);
+	} };
 }
 //#endregion
 //#region src/remote/stdio.ts
@@ -67,15 +1104,14 @@ function errorText$1(err) {
 var LineTransport = class {
 	constructor(streams) {
 		this.pvtOnMessage = null;
+		this.pvtOnBytes = null;
 		this.pvtOnClose = null;
 		this.pvtClosed = false;
 		this.pvtClosing = null;
 		this.streams = streams;
-		const lines = readline.createInterface({ input: streams.read });
-		lines.on("line", (line) => {
-			if (this.pvtOnMessage && !this.pvtClosed) this.pvtOnMessage(line);
-		});
-		lines.on("close", () => {
+		readParts(streams.read, (line) => this.pvtClosed ? void 0 : this.pvtOnMessage?.(line), (bytes) => {
+			if (!this.pvtClosed) this.pvtOnBytes?.(bytes);
+		}, () => {
 			this.pvtOnClose?.();
 			this.close();
 		});
@@ -97,6 +1133,10 @@ var LineTransport = class {
 		if (this.pvtOnMessage !== null) throw new StdioWireError("stdio transport: handler already set — call removeHandler()");
 		this.pvtOnMessage = handler;
 	}
+	onBytes(handler) {
+		if (this.pvtClosed) throw new StdioWireError("stdio transport: closed");
+		this.pvtOnBytes = handler;
+	}
 	removeHandler() {
 		const previous = this.pvtOnMessage;
 		this.pvtOnMessage = null;
@@ -106,11 +1146,17 @@ var LineTransport = class {
 		this.pvtOnClose = handler;
 	}
 	send(frame) {
-		if (this.pvtClosed) return Promise.resolve();
 		const line = frame.endsWith("\n") ? frame : `${frame}\n`;
+		return this.pvtWrite(line);
+	}
+	sendBytes(bytes) {
+		return this.pvtWrite(bytes);
+	}
+	pvtWrite(data) {
+		if (this.pvtClosed) return Promise.resolve();
 		return new Promise((resolve, reject) => {
 			try {
-				this.streams.write.write(line, (err) => {
+				this.streams.write.write(data, (err) => {
 					if (!err) return resolve();
 					const code = err.code;
 					if (peerGone(code)) return resolve();
@@ -141,6 +1187,7 @@ var LineTransport = class {
 var FifoUtf8NlineTransport = class FifoUtf8NlineTransport {
 	constructor(opts) {
 		this.pvtOnMessage = null;
+		this.pvtOnBytes = null;
 		this.pvtOnClose = null;
 		this.closed = false;
 		this.closingPromise = null;
@@ -148,12 +1195,10 @@ var FifoUtf8NlineTransport = class FifoUtf8NlineTransport {
 		this.readFd = opts.readFd ?? null;
 		this.writeFd = opts.writeFd ?? null;
 		if (this.readFd) {
-			this.rs = this.readFd.createReadStream({ encoding: "utf-8" });
-			this.rl = readline.createInterface({ input: this.rs });
-			this.rl.on("line", (line) => {
-				if (this.pvtOnMessage && !this.closed) this.pvtOnMessage(line);
-			});
-			this.rl.on("close", () => {
+			this.rs = this.readFd.createReadStream();
+			this.reader = readParts(this.rs, (line) => this.closed ? void 0 : this.pvtOnMessage?.(line), (bytes) => {
+				if (!this.closed) this.pvtOnBytes?.(bytes);
+			}, () => {
 				this.pvtOnClose?.();
 				this.close();
 			});
@@ -163,10 +1208,10 @@ var FifoUtf8NlineTransport = class FifoUtf8NlineTransport {
 			});
 		} else {
 			this.rs = null;
-			this.rl = null;
+			this.reader = null;
 		}
 		if (this.writeFd) {
-			this.ws = this.writeFd.createWriteStream({ encoding: "utf-8" });
+			this.ws = this.writeFd.createWriteStream({});
 			this.ws.on("error", (err) => {
 				this.pvtError = err;
 				this.close();
@@ -221,6 +1266,11 @@ var FifoUtf8NlineTransport = class FifoUtf8NlineTransport {
 	get canSend() {
 		return this.writeFd !== null && !this.closed;
 	}
+	onBytes(handler) {
+		if (this.closed) throw new Error("FifoUtf8NlineTransport: closed");
+		if (this.readFd === null) throw new Error("FifoUtf8NlineTransport: not a reader");
+		this.pvtOnBytes = handler;
+	}
 	onMessage(handler) {
 		if (this.closed) throw new Error("FifoUtf8NlineTransport: closed");
 		if (this.readFd === null) throw new Error("FifoUtf8NlineTransport: not a reader");
@@ -247,6 +1297,11 @@ var FifoUtf8NlineTransport = class FifoUtf8NlineTransport {
 		if (!line.endsWith("\n")) line += "\n";
 		await this.ws?.write(line);
 	}
+	async sendBytes(bytes) {
+		if (this.closed) throw new Error("FifoUtf8NlineTransport: closed");
+		if (this.writeFd === null) throw new Error("FifoUtf8NlineTransport: not a writer");
+		await this.ws?.write(bytes);
+	}
 	async close() {
 		this.closingPromise = this.closingPromise || this.pvtClose();
 		await this.closingPromise;
@@ -254,9 +1309,9 @@ var FifoUtf8NlineTransport = class FifoUtf8NlineTransport {
 	}
 	async pvtClose() {
 		await Promise.resolve();
-		if (this.rl) {
-			this.rl.close();
-			this.rl = null;
+		if (this.reader) {
+			this.reader.stop();
+			this.reader = null;
 		}
 		if (this.rs) {
 			this.rs.destroy();
@@ -325,13 +1380,13 @@ async function fail(wire, reason) {
 		await wire.send(errorFrame(reason));
 	} catch {}
 }
-/** Copy everything the payload prints to the client, as output frames of the fd it came in on. */
-function forwardOutput(stream, wire, fd) {
-	stream.setEncoding("utf-8");
-	const out = fdWriter((frame) => wire.send(encode(frame)), fd);
-	out.on("error", () => {});
-	stream.pipe(out, { end: false });
+/** The payload's own prints, as a stream: the pipe's chunks as they arrive. */
+async function* chunksOf(stream, prefix = "") {
+	if (prefix.length > 0) yield new TextEncoder().encode(prefix);
+	for await (const chunk of stream) yield typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk);
 }
+/** Everything a payload printed into its pipes, up to the point they end: what a start that dies
+*  before its channel says about itself.  A stream cannot carry it — there is no connection yet. */
 /**
 * Serve one environment over stdin/stdout.  Returns the exit code; the caller
 * turns it into `process.exitCode`.
@@ -341,6 +1396,11 @@ async function runGateway(argv = process.argv.slice(2)) {
 		read: process.stdin,
 		write: process.stdout
 	});
+	const client = json1Channel(wire);
+	const output = new StreamStore(client, "even", {
+		ids: lowBand("even"),
+		attach: false
+	});
 	let booted;
 	try {
 		booted = gatewayBoot(argv);
@@ -405,8 +1465,39 @@ async function runGateway(argv = process.argv.slice(2)) {
 		"pipe"
 	] });
 	child = workerProc;
-	forwardOutput(workerProc.stdout, wire, 1);
-	forwardOutput(workerProc.stderr, wire, 2);
+	/** What the payload printed before the client spoke: a start that dies that early has no connection
+	*  to announce a stream on, and its words are the only way to say why it went.  Kept per stream, so
+	*  the output that comes after is still attributed to the right one. */
+	const early = {
+		stdout: "",
+		stderr: ""
+	};
+	const keep = (name) => (chunk) => {
+		early[name] = (early[name] + String(chunk)).slice(-4096);
+	};
+	const keepOut = keep("stdout");
+	const keepErr = keep("stderr");
+	workerProc.stdout?.on("data", keepOut);
+	workerProc.stderr?.on("data", keepErr);
+	/** Announce the payload's own output as the two streams a program's prints belong on, with whatever
+	*  it said before the connection could carry it replayed as the first chunk. */
+	const offerOutput = () => {
+		const sides = [{
+			stream: workerProc.stdout,
+			name: "stdout",
+			keep: keepOut
+		}, {
+			stream: workerProc.stderr,
+			name: "stderr",
+			keep: keepErr
+		}];
+		for (const { stream, name, keep: drop } of sides) {
+			if (!stream) continue;
+			stream.off("data", drop);
+			stream.pause();
+			output.offer(chunksOf(stream, early[name]), name);
+		}
+	};
 	const exited = new Promise((settle) => {
 		workerProc.once("exit", (code) => settle(code ?? 0));
 	});
@@ -415,18 +1506,34 @@ async function runGateway(argv = process.argv.slice(2)) {
 			throw new Error(`the payload exited with code ${code} before it opened its channel`);
 		})]);
 	} catch (err) {
-		await fail(wire, errorText(err));
+		const said = `${early.stdout}${early.stderr}`.trim();
+		await fail(wire, `${errorText(err)}${said ? `: ${said}` : ""}`);
 		await teardown();
 		abandon();
 	}
-	const relay = fifo;
-	relay.onMessage((line) => {
-		wire.send(line).catch(() => {});
+	const payload = json1Channel(fifo);
+	const fromClient = channelThrough(client, (frame) => output.handle(frame));
+	const forward = (send, frame) => {
+		Promise.resolve(send(frame)).catch(() => {});
+	};
+	let offered = false;
+	fromClient.onMessage((frame) => {
+		if (!offered) {
+			offered = true;
+			offerOutput();
+		}
+		forward((next) => payload.send(next), frame);
+	});
+	fromClient.onSegment?.((head, bytes) => {
+		payload.sendSegment?.(head, bytes);
+	});
+	payload.onMessage((frame) => {
+		forward((next) => client.send(next), frame);
 	});
-	wire.onMessage((line) => {
-		relay.send(line).catch(() => {});
+	payload.onSegment?.((head, bytes) => {
+		client.sendSegment?.(head, bytes);
 	});
-	wire.onClose(() => {
+	client.onClose(() => {
 		child?.kill();
 	});
 	const code = await exited;