posipaki 0.45.0 → 0.46.0

package/dist/remote/index.d.ts

@@ -1,5 +1,5 @@
 import { c as SenderInfo } from "../types-U3NvKgpg.js";
-import { $ as isInit, A as BlobSource, B as isBytesRef, C as Init, D as Blob, E as Spawner, F as Stream, G as StringTransport, H as BAD_PREFIX_LIMIT, I as StreamRef, J as errorFrame, K as badFrame, L as StreamStore, M as RemoteBlob, N as RemoteBytes, O as BlobFacts, P as RemoteStream, Q as isExit, R as StreamStoreOptions, S as serveRemoteActor, T as ServedProcess, U as Channel, V as isStreamRef, W as Frame, X as isBad, Y as errorReason, Z as isError, _ as ServedConnection, a as ClientContext, at as isState, b as oneConnection, c as remoteClient, ct as ProcessRef, d as stderrSink, dt as FrameSink, et as isMsg, f as AnyActorDefinition, ft as RemoteMessage, g as ReactorOptions, h as Reactor, i as CHANNEL_LOST, it as isResume, j as BytesRef, k as BlobRef, l as OutputSink, lt as isRemoteProcess, m as Listener, n as WebSocketLike, nt as isProto, o as ClientSpawner, ot as isStop, p as Connection, pt as RemoteProcess, q as badReason, r as WebSocketTransport, rt as isRelease, s as RemoteClientOptions, st as PROCESS_REF, t as WS_OPEN, tt as isPause, u as pumpOutput, ut as rootIdFor, v as Session, w as Served, x as reactor, y as SessionFactory, z as isBlobRef } from "../websocket-DT8zKD34.js";
+import { $ as isError, A as BlobSource, B as TypedArrayName, C as Init, D as Blob, E as Spawner, F as RemoteStream, G as Channel, H as isBytesRef, I as Stream, J as badFrame, K as Frame, L as StreamRef, M as BytesRef, N as RemoteArray, O as BlobFacts, P as RemoteBlob, Q as isBad, R as StreamStore, S as serveRemoteActor, T as ServedProcess, U as isStreamRef, V as isBlobRef, W as BAD_PREFIX_LIMIT, X as errorFrame, Y as badReason, Z as errorReason, _ as ServedConnection, a as ClientContext, at as isRelease, b as oneConnection, c as remoteClient, ct as isStop, d as stderrSink, dt as isRemoteProcess, et as isExit, f as AnyActorDefinition, ft as rootIdFor, g as ReactorOptions, h as Reactor, ht as RemoteProcess, i as CHANNEL_LOST, it as isProto, j as BytesFacts, k as BlobRef, l as OutputSink, lt as PROCESS_REF, m as Listener, mt as RemoteMessage, n as WebSocketLike, nt as isMsg, o as ClientSpawner, ot as isResume, p as Connection, pt as FrameSink, q as StringTransport, r as WebSocketTransport, rt as isPause, s as RemoteClientOptions, st as isState, t as WS_OPEN, tt as isInit, u as pumpOutput, ut as ProcessRef, v as Session, w as Served, x as reactor, y as SessionFactory, z as StreamStoreOptions } from "../websocket-GFSUt3YC.js";
 //#region src/remote/sender.d.ts
 declare function makeSender(fromName: string, parentName: string | null, parentId: symbol | null): SenderInfo;
 //#endregion
@@ -114,5 +114,5 @@ declare function workerClientSpawner<Args = unknown>(url: string | ((args: Args)
 //#region src/remote/spawners/worker-self.d.ts
 declare function workerSelfSpawner(selfScope?: WorkerLike): Spawner;
 //#endregion
-export { type AnyActorDefinition, BAD_PREFIX_LIMIT, type Blob, type BlobFacts, type BlobRef, type BlobSource, type BunServerWebSocketLike, type BytesRef, CHANNEL_LOST, type Channel, type ClientContext, type ClientSpawner, type Connection, type Frame, type FrameSink, type Init, type Listener, type OpenedWebSocket, type OutputSink, PROCESS_REF, type ProcessRef, type Reactor, type ReactorOptions, RemoteBlob, RemoteBytes, type RemoteClientOptions, type RemoteMessage, RemoteProcess, RemoteStream, type Served, type ServedConnection, type ServedProcess, type Session, type SessionFactory, type Spawner, type Stream, type StreamRef, StreamStore, type StreamStoreOptions, type StringTransport, VERSION, WORKER_VERSION, WS_OPEN, type WebSocketClientOptions, type WebSocketCtor, type WebSocketLike, type WebSocketOpener, WebSocketTransport, type WorkerCtor, type WorkerLike, WorkerTransport, badFrame, badReason, bunServerWebSocket, decode, encode, errorFrame, errorReason, isBad, isBlobRef, isBytesRef, isError, isExit, isInit, isMsg, isPause, isProto, isRelease, isRemoteProcess, isResume, isState, isStop, isStreamRef, json1Channel, makeSender, oneConnection, pumpOutput, reactor, readFrame, remoteClient, rootIdFor, serveRemoteActor, stderrSink, workerClientSpawner, workerSelfSpawner, wsClientSpawner, wsServerSpawner };
+export { type AnyActorDefinition, BAD_PREFIX_LIMIT, type Blob, type BlobFacts, type BlobRef, type BlobSource, type BunServerWebSocketLike, type BytesFacts, type BytesRef, CHANNEL_LOST, type Channel, type ClientContext, type ClientSpawner, type Connection, type Frame, type FrameSink, type Init, type Listener, type OpenedWebSocket, type OutputSink, PROCESS_REF, type ProcessRef, type Reactor, type ReactorOptions, type RemoteArray, RemoteBlob, type RemoteClientOptions, type RemoteMessage, RemoteProcess, RemoteStream, type Served, type ServedConnection, type ServedProcess, type Session, type SessionFactory, type Spawner, type Stream, type StreamRef, StreamStore, type StreamStoreOptions, type StringTransport, type TypedArrayName, VERSION, WORKER_VERSION, WS_OPEN, type WebSocketClientOptions, type WebSocketCtor, type WebSocketLike, type WebSocketOpener, WebSocketTransport, type WorkerCtor, type WorkerLike, WorkerTransport, badFrame, badReason, bunServerWebSocket, decode, encode, errorFrame, errorReason, isBad, isBlobRef, isBytesRef, isError, isExit, isInit, isMsg, isPause, isProto, isRelease, isRemoteProcess, isResume, isState, isStop, isStreamRef, json1Channel, makeSender, oneConnection, pumpOutput, reactor, readFrame, remoteClient, rootIdFor, serveRemoteActor, stderrSink, workerClientSpawner, workerSelfSpawner, wsClientSpawner, wsServerSpawner };
 //# sourceMappingURL=index.d.ts.map

package/dist/remote/index.js

@@ -1,4 +1,4 @@
-import { A as errorReason, B as isResume, C as json1Channel, D as badReason, E as badFrame, F as isInit, H as isStop, I as isMsg, K as rootIdFor, L as isPause, M as isBad, N as isError, P as isExit, R as isProto, S as encode, T as BAD_PREFIX_LIMIT, U as PROCESS_REF, V as isState, W as isRemoteProcess, _ as isStreamRef, a as remoteClient, b as VERSION, c as oneConnection, d as RemoteBlob, f as RemoteBytes, g as isBytesRef, h as isBlobRef, i as CHANNEL_LOST, j as frameReaders, k as errorFrame, l as reactor, m as StreamStore, n as WebSocketTransport, o as pumpOutput, p as RemoteStream, s as stderrSink, t as WS_OPEN, u as serveRemoteActor, v as makeSender, w as readFrame, x as decode, y as RemoteProcess, z as isRelease } from "../websocket-DkDAHMFm.js";
+import { A as frameReaders, B as isState, C as readFrame, E as badReason, F as isMsg, G as rootIdFor, H as PROCESS_REF, I as isPause, L as isProto, M as isError, N as isExit, O as errorFrame, P as isInit, R as isRelease, S as json1Channel, T as badFrame, U as isRemoteProcess, V as isStop, _ as makeSender, a as remoteClient, b as decode, c as oneConnection, d as RemoteBlob, f as RemoteStream, g as isStreamRef, h as isBytesRef, i as CHANNEL_LOST, j as isBad, k as errorReason, l as reactor, m as isBlobRef, n as WebSocketTransport, o as pumpOutput, p as StreamStore, s as stderrSink, t as WS_OPEN, u as serveRemoteActor, v as RemoteProcess, w as BAD_PREFIX_LIMIT, x as encode, y as VERSION, z as isResume } from "../websocket-1DAD3oDx.js";
 //#region src/remote/transports/worker.ts
 /** The worker encoding: native structured clone (no JSON). */
 const WORKER_VERSION = "clone.v1";
@@ -152,6 +152,6 @@ function workerSelfSpawner(selfScope = globalThis) {
 	};
 }
 //#endregion
-export { BAD_PREFIX_LIMIT, CHANNEL_LOST, PROCESS_REF, RemoteBlob, RemoteBytes, RemoteProcess, RemoteStream, StreamStore, VERSION, WORKER_VERSION, WS_OPEN, WebSocketTransport, WorkerTransport, badFrame, badReason, bunServerWebSocket, decode, encode, errorFrame, errorReason, isBad, isBlobRef, isBytesRef, isError, isExit, isInit, isMsg, isPause, isProto, isRelease, isRemoteProcess, isResume, isState, isStop, isStreamRef, json1Channel, makeSender, oneConnection, pumpOutput, reactor, readFrame, remoteClient, rootIdFor, serveRemoteActor, stderrSink, workerClientSpawner, workerSelfSpawner, wsClientSpawner, wsServerSpawner };
+export { BAD_PREFIX_LIMIT, CHANNEL_LOST, PROCESS_REF, RemoteBlob, RemoteProcess, RemoteStream, StreamStore, VERSION, WORKER_VERSION, WS_OPEN, WebSocketTransport, WorkerTransport, badFrame, badReason, bunServerWebSocket, decode, encode, errorFrame, errorReason, isBad, isBlobRef, isBytesRef, isError, isExit, isInit, isMsg, isPause, isProto, isRelease, isRemoteProcess, isResume, isState, isStop, isStreamRef, json1Channel, makeSender, oneConnection, pumpOutput, reactor, readFrame, remoteClient, rootIdFor, serveRemoteActor, stderrSink, workerClientSpawner, workerSelfSpawner, wsClientSpawner, wsServerSpawner };
 
 //# sourceMappingURL=index.js.map

package/dist/remote/node.d.ts

@@ -1,6 +1,6 @@
 import { a as Message } from "../types-U3NvKgpg.js";
 import { h as MethodOptions, l as ActorDefinition, p as HandlerOptions, v as ReflectionOptions } from "../hooks-DO-efRM_.js";
-import { G as StringTransport, U as Channel, d as stderrSink, l as OutputSink, m as Listener, n as WebSocketLike, o as ClientSpawner, u as pumpOutput } from "../websocket-DT8zKD34.js";
+import { G as Channel, d as stderrSink, l as OutputSink, m as Listener, n as WebSocketLike, o as ClientSpawner, q as StringTransport, u as pumpOutput } from "../websocket-GFSUt3YC.js";
 import { FileHandle } from "node:fs/promises";
 import { ChildProcess, StdioOptions } from "node:child_process";
 import { Duplex, Readable, Writable } from "node:stream";

package/dist/remote/node.js

@@ -1,5 +1,5 @@
-import { t as LIB_VERSION } from "../version-yonmO5bG.js";
-import { A as errorReason$1, C as json1Channel, G as lowBand, O as channelThrough, R as isProto, a as remoteClient, b as VERSION, k as errorFrame$1, m as StreamStore, n as WebSocketTransport, o as pumpOutput, r as readParts, s as stderrSink, u as serveRemoteActor } from "../websocket-DkDAHMFm.js";
+import { t as LIB_VERSION } from "../version-DAQCfED6.js";
+import { D as channelThrough, L as isProto, O as errorFrame$1, S as json1Channel, W as lowBand, a as remoteClient, k as errorReason$1, n as WebSocketTransport, o as pumpOutput, p as StreamStore, r as readParts, s as stderrSink, u as serveRemoteActor, y as VERSION } from "../websocket-1DAD3oDx.js";
 import { chmod, mkdir, mkdtemp, open, readFile, rm, stat, unlink } from "node:fs/promises";
 import { execFile, spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";

package/dist/{version-yonmO5bG.js → version-DAQCfED6.js}

@@ -1,7 +1,7 @@
 //#region src/version.ts
 /** posipaki's release version.  Must equal package.json's `version`. */
-const LIB_VERSION = "0.45.0";
+const LIB_VERSION = "0.46.0";
 //#endregion
 export { LIB_VERSION as t };
 
-//# sourceMappingURL=version-yonmO5bG.js.map
+//# sourceMappingURL=version-DAQCfED6.js.map

package/dist/{version-yonmO5bG.js.map → version-DAQCfED6.js.map}

@@ -1 +1 @@
-{"version":3,"file":"version-yonmO5bG.js","names":[],"sources":["../src/version.ts"],"sourcesContent":["// ── Library identity ───────────────────────────────────────────────────────\n//\n// posipaki's own release version, as a plain inlined string.  A consumer that\n// stages artifacts onto a host it knows nothing about has to name those\n// artifacts after which posipaki they speak, and the bundle that runs there has\n// no node_modules and no posipaki on disk — it can never read a file to find out.\n//\n// It is not the protocol version: that is `VERSION` in ./remote (`json.v1`), and\n// it does not move between releases.  The two answer different questions.\n//\n// version.test.ts pins this to package.json, so a release that forgets to bump it\n// fails the suite rather than shipping a lie.\n\n/** posipaki's release version.  Must equal package.json's `version`. */\nexport const LIB_VERSION = \"0.45.0\";\n"],"mappings":";;AAcA,MAAa,cAAc"}
+{"version":3,"file":"version-DAQCfED6.js","names":[],"sources":["../src/version.ts"],"sourcesContent":["// ── Library identity ───────────────────────────────────────────────────────\n//\n// posipaki's own release version, as a plain inlined string.  A consumer that\n// stages artifacts onto a host it knows nothing about has to name those\n// artifacts after which posipaki they speak, and the bundle that runs there has\n// no node_modules and no posipaki on disk — it can never read a file to find out.\n//\n// It is not the protocol version: that is `VERSION` in ./remote (`json.v1`), and\n// it does not move between releases.  The two answer different questions.\n//\n// version.test.ts pins this to package.json, so a release that forgets to bump it\n// fails the suite rather than shipping a lie.\n\n/** posipaki's release version.  Must equal package.json's `version`. */\nexport const LIB_VERSION = \"0.46.0\";\n"],"mappings":";;AAcA,MAAa,cAAc"}

package/dist/{websocket-DkDAHMFm.js → websocket-1DAD3oDx.js}

@@ -517,6 +517,14 @@ function announcedOctets(frame) {
 function json1Channel(transport) {
 	const frameReaders = /* @__PURE__ */ new Set();
 	const segmentReaders = /* @__PURE__ */ new Set();
+	const closeReaders = /* @__PURE__ */ new Set();
+	/** The wire goes once, whoever ends it: the peer hanging up, or this side closing it. */
+	let closed = false;
+	const sayClosed = () => {
+		if (closed) return;
+		closed = true;
+		for (const reader of [...closeReaders]) reader();
+	};
 	/** The head whose octets are on their way: set between the line and the run it announced. */
 	let expecting = null;
 	const deliver = (frame) => {
@@ -541,6 +549,7 @@ function json1Channel(transport) {
 		}
 		for (const reader of [...segmentReaders]) reader(frame, bytes);
 	});
+	transport.onClose(sayClosed);
 	return {
 		send(frame) {
 			return transport.send(encode(frame));
@@ -562,10 +571,11 @@ function json1Channel(transport) {
 			};
 		},
 		onClose(handler) {
-			transport.onClose(handler);
+			closeReaders.add(handler);
 		},
-		close() {
-			return transport.close();
+		async close() {
+			sayClosed();
+			await transport.close();
 		}
 	};
 }
@@ -1445,45 +1455,6 @@ var RemoteBlob = class {
 	}
 };
 /**
-* 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
@@ -1497,6 +1468,7 @@ var StreamStore = class {
 		this.pvtRefused = /* @__PURE__ */ new Map();
 		this.pvtNamesOut = /* @__PURE__ */ new Map();
 		this.pvtNamesIn = /* @__PURE__ */ new Map();
+		this.pvtPending = [];
 		this.pvtNamedListeners = /* @__PURE__ */ new Set();
 		this.pvtSegmentOff = null;
 		this.pvtClosed = false;
@@ -1539,14 +1511,18 @@ var StreamStore = class {
 		} };
 	}
 	/**
-	* 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.
+	* Offer bytes this side already holds.  The reference states the length, so the far side can check
+	* it against its bound and make room before the first chunk arrives — and, when the value is a typed
+	* array, the element kind and count too, so the same kind of array is made on the other side.  The
+	* octets are one piece, and the wire carries them as a stream of one.
 	*/
-	offerBytes(bytes) {
+	offerBytes(value) {
+		const { bytes, type, length } = octetsOf$1(value);
 		return { $bytes: {
 			id: this.pvtAnnounce(this.pvtOnePiece(bytes)),
-			size: bytes.length
+			size: bytes.length,
+			...type === void 0 ? {} : { type },
+			...length === void 0 ? {} : { length }
 		} };
 	}
 	pvtAnnounce(source, name) {
@@ -1590,8 +1566,22 @@ var StreamStore = class {
 	}
 	/** A value just read: every reference in it becomes something this side can read. */
 	decode(value) {
+		this.pvtPending = [];
 		return this.pvtDecode(value, /* @__PURE__ */ new Set());
 	}
+	/**
+	* What the octets of a just-decoded value still owe.  A message is handed to its process only once
+	* this has settled, so a typed array in a body is whole when the handler reads it; a stream, a blob
+	* and a plain value carry no octets of their own and settle at once.
+	*/
+	owed() {
+		if (this.pvtPending.length === 0) return null;
+		return Promise.all(this.pvtPending).then(() => void 0);
+	}
+	/** The same question as a promise, for a caller that would rather always await. */
+	settled() {
+		return this.owed() ?? Promise.resolve();
+	}
 	/** Drop every stream of this connection, in both directions.  Called when it ends. */
 	close() {
 		if (this.pvtClosed) return;
@@ -1600,6 +1590,7 @@ var StreamStore = class {
 		this.pvtSegmentOff?.();
 		for (const offered of this.pvtOffers.values()) {
 			offered.dropped = true;
+			Promise.resolve(this.channel.send({ $streamDone: { id: offered.id } })).catch(() => {});
 			offered.source.return?.();
 		}
 		this.pvtOffers.clear();
@@ -1656,7 +1647,7 @@ var StreamStore = class {
 		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 (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return this.offerBytes(value);
 		if (!isPlainObject(value)) return value;
 		const copy = {};
 		for (const [key, item] of Object.entries(value)) copy[key] = this.pvtEncode(item, seen);
@@ -1744,7 +1735,7 @@ var StreamStore = class {
 	}
 	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 (isBytesRef(value)) return this.pvtValueFor(value.$bytes.id, "bytes", value.$bytes);
 		if (isBlobRef(value)) {
 			const { id, size, type, name } = value.$blob;
 			return this.pvtValueFor(id, "blob", {
@@ -1780,7 +1771,6 @@ var StreamStore = class {
 		}
 		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;
@@ -1791,8 +1781,7 @@ var StreamStore = class {
 				reason: "over the reader's bound"
 			} });
 		}
-		if (value instanceof RemoteBytes) value.start();
-		return value;
+		return incoming.value = this.pvtBuild(incoming.reader, form, facts);
 	}
 	/** The value a name the far side announced stands for — or one that says it was never announced. */
 	pvtValueForNamed(name) {
@@ -1807,10 +1796,27 @@ var StreamStore = class {
 		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);
+		if (facts === void 0) return reader;
+		if (form === "blob") return new RemoteBlob(reader, {
+			size: facts.size,
+			type: facts.type,
+			name: "name" in facts ? facts.name : void 0
+		});
+		if (form === "bytes") return this.pvtArray(reader, facts);
 		return reader;
 	}
+	/**
+	* The array the far side is sending: the kind it was, made here at the size its reference stated,
+	* and filled as the octets land.  The fill loop is the stream's one consumer, so the credit
+	* machinery asks for exactly what can be stored and the array is complete before `settled` resolves.
+	*/
+	pvtArray(reader, facts) {
+		const value = facts.size > this.maxBytes ? /* @__PURE__ */ new Uint8Array(0) : allocateBytes(facts.size, facts.type, "length" in facts ? facts.length : void 0);
+		const filling = fillArray(value, reader, facts.size);
+		filling.catch(() => {});
+		this.pvtPending.push(filling);
+		return value;
+	}
 	pvtAsk(incoming) {
 		if (incoming.done || this.pvtClosed) return;
 		const outstanding = incoming.asked - incoming.consumed;
@@ -1968,9 +1974,70 @@ var StreamStore = class {
 	}
 };
 /** 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);
+/** How many octets an element of each kind takes.  A name that came off the wire is looked up here
+*  rather than handed to `globalThis`, so a peer cannot name a constructor this side would run. */
+const TYPED_ARRAY_STRIDE = /* @__PURE__ */ new Map([
+	["Int8Array", 1],
+	["Uint8Array", 1],
+	["Uint8ClampedArray", 1],
+	["Int16Array", 2],
+	["Uint16Array", 2],
+	["Int32Array", 4],
+	["Uint32Array", 4],
+	["Float32Array", 4],
+	["Float64Array", 8],
+	["BigInt64Array", 8],
+	["BigUint64Array", 8]
+]);
+function isTypedArrayName(name) {
+	return TYPED_ARRAY_STRIDE.has(name);
+}
+/** The octets of a value about to cross — and, for a typed array, what they are made of. */
+function octetsOf$1(value) {
+	if (!ArrayBuffer.isView(value)) return { bytes: new Uint8Array(value) };
+	const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+	if (value instanceof DataView) return { bytes };
+	const name = Object.prototype.toString.call(value).slice(8, -1);
+	if (!isTypedArrayName(name)) return { bytes };
+	const stride = TYPED_ARRAY_STRIDE.get(name) ?? 1;
+	if (bytes.length % stride !== 0) return { bytes };
+	return {
+		bytes,
+		type: name,
+		length: bytes.length / stride
+	};
+}
+/** The sender's kind of array, made at the element count its reference stated. */
+function allocateBytes(size, type, length) {
+	if (type === void 0 || !isTypedArrayName(type)) return new Uint8Array(size);
+	const stride = TYPED_ARRAY_STRIDE.get(type) ?? 1;
+	if (size % stride !== 0) return new Uint8Array(size);
+	const count = length !== void 0 && length * stride === size ? length : size / stride;
+	switch (type) {
+		case "Int8Array": return new Int8Array(count);
+		case "Uint8Array": return new Uint8Array(count);
+		case "Uint8ClampedArray": return new Uint8ClampedArray(count);
+		case "Int16Array": return new Int16Array(count);
+		case "Uint16Array": return new Uint16Array(count);
+		case "Int32Array": return new Int32Array(count);
+		case "Uint32Array": return new Uint32Array(count);
+		case "Float32Array": return new Float32Array(count);
+		case "Float64Array": return new Float64Array(count);
+		case "BigInt64Array": return new BigInt64Array(count);
+		case "BigUint64Array": return new BigUint64Array(count);
+	}
+}
+/** Fill the array as its octets arrive.  A view of the same memory is how every element kind is
+*  written the same way, and how a `BigInt64Array` is filled without mixing element types. */
+async function fillArray(value, body, size) {
+	const octets = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+	let at = 0;
+	for await (const chunk of body) {
+		if (at + chunk.length > octets.length) throw new Error(`the array is longer than the ${size} bytes it stated`);
+		octets.set(chunk, at);
+		at += chunk.length;
+	}
+	if (at !== octets.length) throw new Error(`the array is short: ${at} of ${size} octets arrived`);
 }
 function reasonOf(error) {
 	return error instanceof Error ? error.message : String(error);
@@ -2050,6 +2117,7 @@ async function serveChannel(channel, makeProc, onSpawned, streamOptions) {
 		throw new Error(`serveRemoteActor: expected $init (${initProblem})`);
 	}
 	const initFrame = decodeFrame(firstFrame, handleFor, byteStreams);
+	await byteStreams.settled();
 	if (!isInit(initFrame)) throw new Error("serveRemoteActor: expected $init");
 	const init = initFrame.$init;
 	const stated = init.rootName;
@@ -2101,13 +2169,29 @@ async function serveChannel(channel, makeProc, onSpawned, streamOptions) {
 		} catch {}
 		await end();
 	};
-	function dispatch(raw) {
+	/**
+	* Take one frame as far as it goes now.  A frame that carries nothing to wait for is handled
+	* before this returns, as it always was; one that carries a typed array answers with the promise
+	* its octets owe, and the queue below keeps whatever came after it behind it.
+	*/
+	function process(raw) {
 		const wireProblem = badReason(raw) ?? errorReason(raw);
 		if (wireProblem !== null) {
 			endUnreadable(wireProblem);
-			return;
+			return null;
 		}
 		const frame = decodeFrame(raw, handleFor, byteStreams);
+		const owed = byteStreams.owed();
+		if (owed === null) {
+			deliver(frame);
+			return null;
+		}
+		return owed.then(() => {
+			deliver(frame);
+		});
+	}
+	/** What a frame means, and the octets it carried are already there when this runs. */
+	function deliver(frame) {
 		if (calls.settle(frame)) return;
 		const to = frameTo(frame);
 		if (to === null) return;
@@ -2158,8 +2242,42 @@ async function serveChannel(channel, makeProc, onSpawned, streamOptions) {
 		if (call) answerCall(call, mine, write, table, byteStreams);
 	}
 	stopCollecting();
-	channel.onMessage(dispatch);
-	for (const frame of waiting.splice(0)) dispatch(frame);
+	const later = [];
+	let busy = false;
+	const report = (error) => {
+		if (pvtWindDown) return;
+		const message = error instanceof Error ? error.message : String(error);
+		console.warn(`a frame from the far side could not be handled: ${message}`);
+	};
+	const pump = () => {
+		if (busy) return;
+		busy = true;
+		for (;;) {
+			const next = later.shift();
+			if (next === void 0) {
+				busy = false;
+				return;
+			}
+			const outcome = process(next);
+			if (outcome !== null) {
+				outcome.then(() => {
+					busy = false;
+					pump();
+				}, (error) => {
+					busy = false;
+					report(error);
+					pump();
+				});
+				return;
+			}
+		}
+	};
+	const schedule = (raw) => {
+		later.push(raw);
+		pump();
+	};
+	channel.onMessage(schedule);
+	for (const frame of waiting.splice(0)) schedule(frame);
 	let code = 0;
 	const procEnded = proc.wait().then(() => void 0, (err) => {
 		console.error("server actor error:", err);
@@ -2481,13 +2599,29 @@ function remoteClient(name, spawner, options = {}) {
 				pvtWindDown = true;
 				this.exit(CHANNEL_LOST);
 			};
-			channel.onMessage((raw) => {
+			/**
+			* Take one frame as far as it goes now.  A frame that carries nothing to wait for is handled
+			* before this returns, as it always was; one that carries a typed array answers with the
+			* promise its octets owe, and the queue below keeps whatever came after it behind it.
+			*/
+			const process = (raw) => {
 				if ((badReason(raw) ?? errorReason(raw)) !== null) {
 					channel.close();
 					wireGone();
-					return;
+					return null;
 				}
 				const frame = decodeFrame(raw, handleFor, byteStreams);
+				const owed = byteStreams.owed();
+				if (owed === null) {
+					deliver(frame);
+					return null;
+				}
+				return owed.then(() => {
+					deliver(frame);
+				});
+			};
+			/** What a frame means, and the octets it carried are already there when this runs. */
+			const deliver = (frame) => {
 				if (calls.settle(frame)) return;
 				const to = frameTo(frame);
 				if (to === null) return;
@@ -2537,6 +2671,40 @@ function remoteClient(name, spawner, options = {}) {
 				}
 				const call = asReflectionCall(frame);
 				if (call) answerCall(call, mine, write, table, byteStreams);
+			};
+			const later = [];
+			let busy = false;
+			const report = (error) => {
+				if (pvtWindDown) return;
+				const message = error instanceof Error ? error.message : String(error);
+				console.warn(`a frame from the far side could not be handled: ${message}`);
+			};
+			const pump = () => {
+				if (busy) return;
+				busy = true;
+				for (;;) {
+					const next = later.shift();
+					if (next === void 0) {
+						busy = false;
+						return;
+					}
+					const outcome = process(next);
+					if (outcome !== null) {
+						outcome.then(() => {
+							busy = false;
+							pump();
+						}, (error) => {
+							busy = false;
+							report(error);
+							pump();
+						});
+						return;
+					}
+				}
+			};
+			channel.onMessage((raw) => {
+				later.push(raw);
+				pump();
 			});
 			channel.onClose(() => wireGone());
 			await start;
@@ -2660,10 +2828,14 @@ function readChunks(stream, onChunk, onEnd) {
 	};
 	stream.on("data", onData);
 	stream.once("end", finish);
+	stream.once("close", finish);
+	stream.once("error", finish);
 	return { stop() {
 		stopped = true;
 		stream.off("data", onData);
 		stream.off("end", finish);
+		stream.off("close", finish);
+		stream.off("error", finish);
 	} };
 }
 //#endregion
@@ -2745,6 +2917,6 @@ var WebSocketTransport = class {
 	}
 };
 //#endregion
-export { errorReason as A, isResume as B, json1Channel as C, badReason as D, badFrame as E, isInit as F, lowBand as G, isStop as H, isMsg as I, rootIdFor as K, isPause as L, isBad as M, isError as N, channelThrough as O, isExit as P, isProto as R, encode as S, BAD_PREFIX_LIMIT as T, PROCESS_REF as U, isState as V, isRemoteProcess as W, isStreamRef as _, remoteClient as a, VERSION as b, oneConnection as c, RemoteBlob as d, RemoteBytes as f, isBytesRef as g, isBlobRef as h, CHANNEL_LOST as i, frameReaders as j, errorFrame as k, reactor as l, StreamStore as m, WebSocketTransport as n, pumpOutput as o, RemoteStream as p, readParts as r, stderrSink as s, WS_OPEN as t, serveRemoteActor as u, makeSender as v, readFrame as w, decode as x, RemoteProcess as y, isRelease as z };
+export { frameReaders as A, isState as B, readFrame as C, channelThrough as D, badReason as E, isMsg as F, rootIdFor as G, PROCESS_REF as H, isPause as I, isProto as L, isError as M, isExit as N, errorFrame as O, isInit as P, isRelease as R, json1Channel as S, badFrame as T, isRemoteProcess as U, isStop as V, lowBand as W, makeSender as _, remoteClient as a, decode as b, oneConnection as c, RemoteBlob as d, RemoteStream as f, isStreamRef as g, isBytesRef as h, CHANNEL_LOST as i, isBad as j, errorReason as k, reactor as l, isBlobRef as m, WebSocketTransport as n, pumpOutput as o, StreamStore as p, readParts as r, stderrSink as s, WS_OPEN as t, serveRemoteActor as u, RemoteProcess as v, BAD_PREFIX_LIMIT as w, encode as x, VERSION as y, isResume as z };
 
-//# sourceMappingURL=websocket-DkDAHMFm.js.map
+//# sourceMappingURL=websocket-1DAD3oDx.js.map