posipaki 0.45.0 → 0.46.0

package/dist/index.d.ts

@@ -20,7 +20,7 @@ declare function defineActor<Args, InternalState, InMsg extends Message, OutMsg
 //#endregion
 //#region src/version.d.ts
 /** posipaki's release version.  Must equal package.json's `version`. */
-declare const LIB_VERSION = "0.45.0";
+declare const LIB_VERSION = "0.46.0";
 //#endregion
 export { type ActorConfig, type ActorContext, type ActorDecorated, type ActorDefinition, type ActorPlugin, type ActorReflection, type AnyProcess, AsyncProcess, type AsyncProcessFn, type ExitMessage, type HandlerFn, type HandlerOptions, type HookResult, LIB_VERSION, type Message, type MethodOptions, type PluginTransform, Process, type ProcessCtx, type ProcessFn, type SenderInfo, type SenderOrigin, type SpawnedFrom, type StopMessage, type WithSender, type WithoutSender, asyncify, callHook, chainHook, defineActor, defineMessages, mergeConfigs, propagateError, runDispatch, runDispatchAsync, spawn, spawnAsync, stopPropagation };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -2,7 +2,7 @@ import { i as runDispatch } from "./util-Brtfgv68.js";
 import { a as spawnAsync, i as runDispatchAsync, o as asyncify, t as AsyncProcess } from "./process.async-B1FqZyD1.js";
 import { n as chainHook, o as propagateError, r as mergeConfigs, s as stopPropagation, t as callHook } from "./hooks-CgXhmY4r.js";
 import { n as defineMessages, t as defineActor } from "./define-actor-DR1P1PA5.js";
-import { t as LIB_VERSION } from "./version-yonmO5bG.js";
+import { t as LIB_VERSION } from "./version-DAQCfED6.js";
 //#region src/process.ts
 /** @deprecated Use {@link spawnAsync} instead. */
 function spawn(fn, pname, tp) {

package/dist/remote/gateway-cli.js

@@ -146,6 +146,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) => {
@@ -170,6 +178,7 @@ function json1Channel(transport) {
 		}
 		for (const reader of [...segmentReaders]) reader(frame, bytes);
 	});
+	transport.onClose(sayClosed);
 	return {
 		send(frame) {
 			return transport.send(encode(frame));
@@ -191,10 +200,11 @@ function json1Channel(transport) {
 			};
 		},
 		onClose(handler) {
-			transport.onClose(handler);
+			closeReaders.add(handler);
 		},
-		close() {
-			return transport.close();
+		async close() {
+			sayClosed();
+			await transport.close();
 		}
 	};
 }
@@ -438,45 +448,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
@@ -490,6 +461,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;
@@ -532,14 +504,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(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) {
@@ -583,8 +559,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;
@@ -593,6 +583,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();
@@ -649,7 +640,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);
@@ -737,7 +728,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", {
@@ -773,7 +764,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;
@@ -784,8 +774,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) {
@@ -800,10 +789,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;
@@ -961,9 +967,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(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);
@@ -1067,10 +1134,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