posipaki 0.47.0 → 0.48.1

package/dist/actor-C8DzeQeT.js

@@ -0,0 +1,258 @@
+import { n as defineMessages, t as defineActor } from "./define-actor-DR1P1PA5.js";
+import { StringDecoder } from "node:string_decoder";
+//#region src/port/split.ts
+const NL = 10;
+const CR = 13;
+const NOTHING = () => null;
+/**
+* One byte channel in, one channel of parts out.
+*
+* The returned channel's `send` is the same rule backwards: a part becomes its line, a terminator, and the
+* octets it carried.
+*/
+function splitChannel(inner, announced = NOTHING) {
+	const readers = /* @__PURE__ */ new Set();
+	const closers = /* @__PURE__ */ new Set();
+	const failers = /* @__PURE__ */ new Set();
+	const decoder = new StringDecoder("utf8");
+	/** Bytes that are not yet a frame: a line, or the octets a line announced. */
+	let buffered = Buffer.alloc(0);
+	/** The line whose announced octets are still arriving. */
+	let pending = null;
+	let ended = false;
+	let reason = null;
+	const emit = (part) => {
+		for (const reader of [...readers]) reader(part);
+	};
+	/** The far end is gone: our own readers hear it. */
+	const close = (why) => {
+		if (ended) return;
+		ended = true;
+		reason = why;
+		for (const closer of [...closers]) closer(why);
+	};
+	/**
+	* End it here: the far end hears a close, our own readers do not, because we are the one who asked.  The
+	* reason stays null: a sentence from this side is not `C`, which is what the other end had to say.
+	*/
+	const shut = () => {
+		if (ended) return;
+		ended = true;
+	};
+	/** Hand over what the buffer holds, as far as the framing allows. */
+	const drain = () => {
+		while (!ended) {
+			if (pending !== null) {
+				if (buffered.length < pending.bytes) return;
+				const bytes = buffered.subarray(0, pending.bytes);
+				buffered = buffered.subarray(pending.bytes);
+				const line = pending.line;
+				pending = null;
+				emit({
+					line,
+					bytes: new Uint8Array(bytes)
+				});
+				continue;
+			}
+			const cut = buffered.indexOf(NL);
+			if (cut === -1) return;
+			const raw = buffered.subarray(0, cut);
+			buffered = buffered.subarray(cut + 1);
+			const line = raw.length > 0 && raw[raw.length - 1] === CR ? raw.subarray(0, raw.length - 1) : raw;
+			const text = decoder.write(line);
+			const count = announced(text);
+			if (count === null) {
+				emit({
+					line: text,
+					bytes: null
+				});
+				continue;
+			}
+			pending = {
+				line: text,
+				bytes: count
+			};
+			if (count === 0) {
+				pending = null;
+				emit({
+					line: text,
+					bytes: /* @__PURE__ */ new Uint8Array(0)
+				});
+			}
+		}
+	};
+	inner.onFrame((chunk) => {
+		if (ended) return;
+		buffered = buffered.length === 0 ? Buffer.from(chunk) : Buffer.concat([buffered, Buffer.from(chunk)]);
+		drain();
+	});
+	inner.onError((error) => {
+		for (const failer of [...failers]) failer(error);
+	});
+	inner.onClose((why) => {
+		if (ended) return;
+		if (pending === null && buffered.length > 0) {
+			const rest = buffered;
+			buffered = Buffer.alloc(0);
+			emit({
+				line: decoder.write(rest) + decoder.end(),
+				bytes: null
+			});
+		} else decoder.end();
+		close(why);
+	});
+	return {
+		send: async (part) => {
+			const head = Buffer.from(`${part.line}\n`, "utf8");
+			const body = part.bytes === null ? head : Buffer.concat([head, Buffer.from(part.bytes)]);
+			await inner.send(new Uint8Array(body));
+		},
+		onFrame: (handler) => {
+			readers.add(handler);
+			return () => {
+				readers.delete(handler);
+			};
+		},
+		onClose: (handler) => {
+			if (ended && reason !== null) {
+				handler(reason);
+				return () => {};
+			}
+			closers.add(handler);
+			return () => {
+				closers.delete(handler);
+			};
+		},
+		onError: (handler) => {
+			failers.add(handler);
+			return () => {
+				failers.delete(handler);
+			};
+		},
+		close: async (why = "closed here") => {
+			shut();
+			await inner.close(why);
+		}
+	};
+}
+//#endregion
+//#region src/port/held.ts
+/**
+* `inner`, with the frames that arrive before anyone is subscribed kept for the readers that follow.
+*
+* The kept frames are not bounded, because a bound depends on what the far end may say before anyone listens,
+* and that is not something this adapter can know.
+*/
+function held(inner) {
+	const readers = /* @__PURE__ */ new Set();
+	const closers = /* @__PURE__ */ new Set();
+	const failers = /* @__PURE__ */ new Set();
+	const kept = [];
+	let live = false;
+	const emit = (frame) => {
+		for (const reader of [...readers]) reader(frame);
+	};
+	inner.onFrame((frame) => {
+		if (live) {
+			emit(frame);
+			return;
+		}
+		if (readers.size === 0) {
+			kept.push(frame);
+			return;
+		}
+		live = true;
+		kept.length = 0;
+		emit(frame);
+	});
+	inner.onClose((reason) => {
+		for (const closer of [...closers]) closer(reason);
+	});
+	inner.onError((error) => {
+		for (const failer of [...failers]) failer(error);
+	});
+	return {
+		send: (frame) => inner.send(frame),
+		onFrame(handler) {
+			readers.add(handler);
+			for (const frame of kept) handler(frame);
+			return () => {
+				readers.delete(handler);
+			};
+		},
+		onClose(handler) {
+			closers.add(handler);
+			return () => {
+				closers.delete(handler);
+			};
+		},
+		onError(handler) {
+			failers.add(handler);
+			return () => {
+				failers.delete(handler);
+			};
+		},
+		close: (reason) => inner.close(reason)
+	};
+}
+//#endregion
+//#region src/port/actor.ts
+/**
+* An actor over one channel.
+*
+* In `SEND {data}` writes to it and `SIGNAL {signal}` asks the medium to act on what is behind it; posipaki's
+* `STOP` ends the actor, which closes the channel.  Out `DATA {data}` for every frame.  The channel's ending is
+* left in `state.end` and the actor stops.
+*/
+function portActor(spec) {
+	return defineActor({
+		name: spec.name,
+		inMessages: /* @__PURE__ */ defineMessages(),
+		outMessages: /* @__PURE__ */ defineMessages(),
+		setup: (args) => ({
+			public: {
+				alive: false,
+				end: null
+			},
+			private: {
+				channel: null,
+				args
+			}
+		}),
+		afterStart() {
+			const { args } = this.state.private;
+			spec.open(args).then((channel) => {
+				this.state.private.channel = channel;
+				this.state.public.alive = true;
+				channel.onFrame((data) => {
+					this.emit({
+						type: "DATA",
+						data
+					});
+				});
+				channel.onClose((reason) => {
+					this.state.public.alive = false;
+					this.state.public.end = reason;
+					this.exit();
+				});
+			});
+		},
+		async beforeEnd() {
+			this.state.public.alive = false;
+			await this.state.private.channel?.close();
+		},
+		handlers: {
+			async SEND(msg) {
+				await this.state.private.channel?.send(msg.data);
+			},
+			SIGNAL(msg) {
+				const channel = this.state.private.channel;
+				if (channel !== null) spec.signal?.(channel, msg.signal);
+			}
+		}
+	});
+}
+//#endregion
+export { held as n, splitChannel as r, portActor as t };
+
+//# sourceMappingURL=actor-C8DzeQeT.js.map

package/dist/actor-C8DzeQeT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actor-C8DzeQeT.js","names":[],"sources":["../src/port/split.ts","../src/port/held.ts","../src/port/actor.ts"],"sourcesContent":["// ── bytes into parts: the splitter ──────────────────────────────────────────\n//\n// Cuts a stream of bytes on 0x0a; what lies between two cuts is a line.  Every byte medium does this: a stdio pair,\n// a socket, an HTTP body.\n\n// Splitting on the byte is safe for UTF-8: a continuation byte is never 0x0a, so a character cannot be cut in\n// half.  A character that straddles two chunks waits in the buffer until the rest arrives.\n//\n// Text is decoded by a StringDecoder for the same reason: half a character waits rather than becoming two\n// replacement marks.\n//\n// A line may announce octets after it.  The splitter does not know that rule, so it is passed in: given a line,\n// how many raw octets follow it?  The seam answers with `$chunk`; a medium with no such thing answers none.\n\nimport { StringDecoder } from \"node:string_decoder\";\n\nimport type { Channel, Part } from \"./channel.js\";\n\nconst NL = 0x0a;\nconst CR = 0x0d;\n\n/** Given a line, how many raw octets follow it.  Default: none, this is a plain line. */\nexport type Announcement = (line: string) => number | null;\n\nconst NOTHING: Announcement = () => null;\n\n/**\n * One byte channel in, one channel of parts out.\n *\n * The returned channel's `send` is the same rule backwards: a part becomes its line, a terminator, and the\n * octets it carried.\n */\nexport function splitChannel<C = string>(\n  inner: Channel<Uint8Array, C>,\n  announced: Announcement = NOTHING,\n): Channel<Part, C> {\n  const readers = new Set<(part: Part) => void>();\n  const closers = new Set<(reason: C) => void>();\n  const failers = new Set<(error: unknown) => void>();\n  const decoder = new StringDecoder(\"utf8\");\n  /** Bytes that are not yet a frame: a line, or the octets a line announced. */\n  let buffered = Buffer.alloc(0);\n  /** The line whose announced octets are still arriving. */\n  let pending: { line: string; bytes: number } | null = null;\n  let ended = false;\n  let reason: C | null = null;\n\n  const emit = (part: Part): void => {\n    for (const reader of [...readers]) reader(part);\n  };\n\n  /** The far end is gone: our own readers hear it. */\n  const close = (why: C): void => {\n    if (ended) return;\n    ended = true;\n    reason = why;\n    for (const closer of [...closers]) closer(why);\n  };\n\n  /**\n   * End it here: the far end hears a close, our own readers do not, because we are the one who asked.  The\n   * reason stays null: a sentence from this side is not `C`, which is what the other end had to say.\n   */\n  const shut = (): void => {\n    if (ended) return;\n    ended = true;\n  };\n\n  /** Hand over what the buffer holds, as far as the framing allows. */\n  const drain = (): void => {\n    while (!ended) {\n      if (pending !== null) {\n        if (buffered.length < pending.bytes) return;\n        const bytes = buffered.subarray(0, pending.bytes);\n        buffered = buffered.subarray(pending.bytes);\n        const line = pending.line;\n        pending = null;\n        emit({ line, bytes: new Uint8Array(bytes) });\n        continue;\n      }\n      const cut = buffered.indexOf(NL);\n      if (cut === -1) return;\n      const raw = buffered.subarray(0, cut);\n      buffered = buffered.subarray(cut + 1);\n      const line = raw.length > 0 && raw[raw.length - 1] === CR ? raw.subarray(0, raw.length - 1) : raw;\n      const text = decoder.write(line);\n      const count = announced(text);\n      if (count === null) {\n        emit({ line: text, bytes: null });\n        continue;\n      }\n      pending = { line: text, bytes: count };\n      if (count === 0) {\n        pending = null;\n        emit({ line: text, bytes: new Uint8Array(0) });\n      }\n    }\n  };\n\n  inner.onFrame((chunk) => {\n    if (ended) return;\n    buffered = buffered.length === 0 ? Buffer.from(chunk) : Buffer.concat([buffered, Buffer.from(chunk)]);\n    drain();\n  });\n  inner.onError((error) => {\n    for (const failer of [...failers]) failer(error);\n  });\n  inner.onClose((why) => {\n    if (ended) return;\n    // Whatever is left without a terminator is still a line: a peer that hangs up after writing has said\n    // something, and dropping it would be the framing deciding to lose the last word.\n    if (pending === null && buffered.length > 0) {\n      const rest = buffered;\n      buffered = Buffer.alloc(0);\n      emit({ line: decoder.write(rest) + decoder.end(), bytes: null });\n    } else {\n      decoder.end();\n    }\n    close(why);\n  });\n\n  return {\n    send: async (part: Part) => {\n      const head = Buffer.from(`${part.line}\\n`, \"utf8\");\n      const body = part.bytes === null ? head : Buffer.concat([head, Buffer.from(part.bytes)]);\n      await inner.send(new Uint8Array(body));\n    },\n    onFrame: (handler) => {\n      readers.add(handler);\n      return () => {\n        readers.delete(handler);\n      };\n    },\n    onClose: (handler) => {\n      if (ended && reason !== null) {\n        handler(reason);\n        return () => {};\n      }\n      closers.add(handler);\n      return () => {\n        closers.delete(handler);\n      };\n    },\n    onError: (handler) => {\n      failers.add(handler);\n      return () => {\n        failers.delete(handler);\n      };\n    },\n    close: async (why = \"closed here\") => {\n      shut();\n      await inner.close(why);\n    },\n  };\n}\n","// ── a channel that keeps what nobody was reading yet ────────────────────────\n//\n// A medium can deliver a frame in the same turn a reader is being installed, and a channel with no subscriber\n// drops it.  This wraps a channel so nothing is dropped for want of a listener: what arrives while nobody is\n// subscribed is kept, and every subscriber that arrives before the first frame is delivered is given it.\n//\n// The window ends at the first delivery.  After that the channel is live, and a subscriber that comes later has\n// missed what went before it — which is what any live channel means, and the alternative would be an unbounded\n// copy of everything ever said.\n\nimport type { Channel } from \"./channel.js\";\n\n/**\n * `inner`, with the frames that arrive before anyone is subscribed kept for the readers that follow.\n *\n * The kept frames are not bounded, because a bound depends on what the far end may say before anyone listens,\n * and that is not something this adapter can know.\n */\nexport function held<F, C>(inner: Channel<F, C>): Channel<F, C> {\n  const readers = new Set<(frame: F) => void>();\n  const closers = new Set<(reason: C) => void>();\n  const failers = new Set<(error: unknown) => void>();\n  const kept: F[] = [];\n  let live = false;\n\n  const emit = (frame: F): void => {\n    for (const reader of [...readers]) reader(frame);\n  };\n\n  inner.onFrame((frame) => {\n    if (live) {\n      emit(frame);\n      return;\n    }\n    if (readers.size === 0) {\n      kept.push(frame);\n      return;\n    }\n    // Somebody is reading: from here the channel is live, and what was kept has been taken.\n    live = true;\n    kept.length = 0;\n    emit(frame);\n  });\n  inner.onClose((reason) => {\n    for (const closer of [...closers]) closer(reason);\n  });\n  inner.onError((error) => {\n    for (const failer of [...failers]) failer(error);\n  });\n\n  return {\n    send: (frame) => inner.send(frame),\n    onFrame(handler) {\n      readers.add(handler);\n      // Handed to every subscriber that arrives before the first delivery, not only to the first.\n      for (const frame of kept) handler(frame);\n      return () => {\n        readers.delete(handler);\n      };\n    },\n    onClose(handler) {\n      closers.add(handler);\n      return () => {\n        closers.delete(handler);\n      };\n    },\n    onError(handler) {\n      failers.add(handler);\n      return () => {\n        failers.delete(handler);\n      };\n    },\n    close: (reason) => inner.close(reason),\n  };\n}\n","// ── a port as an actor ──────────────────────────────────────────────────────\n//\n// One actor that owns one channel and speaks for it: what it is told to send goes in, what the channel delivers\n// comes out as DATA, and the way the channel ended is left in the actor's state, where a parent reads anyway.\n//\n// The channel is opened when the actor starts and closed when it ends, so the actor's life and the channel's\n// are the same one.  What a channel is — a process, a socket, a pair in memory — is the opener's business; the\n// actor knows only that it has one.\n\nimport type { ActorDefinition } from \"../actor-types.js\";\nimport { defineActor, defineMessages } from \"../define-actor.js\";\nimport type { Message } from \"../types.js\";\nimport type { Channel } from \"./channel.js\";\n\n/** Write this to the channel. */\nexport interface SendMessage<F> extends Message {\n  type: \"SEND\";\n  data: F;\n}\n\n/** Ask the channel's own world to act on what is behind it; a medium without one ignores it. */\nexport interface SignalMessage extends Message {\n  type: \"SIGNAL\";\n  signal: string;\n}\n\n/** A frame the channel delivered. */\nexport interface DataMessage<F> extends Message {\n  type: \"DATA\";\n  data: F;\n}\n\nexport type PortIn<F> = SendMessage<F> | SignalMessage;\nexport type PortOut<F> = DataMessage<F>;\n\n/** What a parent may read of a port.  The ending is here because it is state, not news. */\nexport interface PortPublic<C> {\n  /** The channel is open.  False before it opens and after it has ended. */\n  alive: boolean;\n  /** How it ended, or null while it has not. */\n  end: C | null;\n}\n\nexport interface PortActorSpec<Args, F, C> {\n  name: string;\n  /** Opens the channel this actor owns.  Called once, when the actor starts. */\n  open(args: Args): Promise<Channel<F, C>>;\n  /** How a signal reaches the medium.  A process sends it; a connection with no process behind it has none. */\n  signal?(channel: Channel<F, C>, signal: string): void;\n}\n\ntype PortState<C> = { public: PortPublic<C>; private: { channel: Channel<unknown, C> | null; args: unknown } };\n\n/**\n * An actor over one channel.\n *\n * In `SEND {data}` writes to it and `SIGNAL {signal}` asks the medium to act on what is behind it; posipaki's\n * `STOP` ends the actor, which closes the channel.  Out `DATA {data}` for every frame.  The channel's ending is\n * left in `state.end` and the actor stops.\n */\nexport function portActor<Args, F, C>(\n  spec: PortActorSpec<Args, F, C>,\n): ActorDefinition<Args, PortState<C>, PortIn<F>, PortOut<F>, {}> {\n  return defineActor({\n    name: spec.name,\n    inMessages: defineMessages<PortIn<F>>(),\n    outMessages: defineMessages<PortOut<F>>(),\n    setup: (args: Args) => ({\n      public: { alive: false as boolean, end: null as C | null },\n      private: { channel: null as Channel<unknown, C> | null, args },\n    }),\n    afterStart() {\n      const { args } = this.state.private;\n      void spec.open(args).then((channel) => {\n        this.state.private.channel = channel;\n        this.state.public.alive = true;\n        channel.onFrame((data) => {\n          this.emit({ type: \"DATA\", data });\n        });\n        channel.onClose((reason) => {\n          this.state.public.alive = false;\n          this.state.public.end = reason;\n          this.exit();\n        });\n      });\n    },\n    async beforeEnd() {\n      this.state.public.alive = false;\n      await (this.state.private.channel as Channel<F, C> | null)?.close();\n    },\n    handlers: {\n      async SEND(msg: SendMessage<F>) {\n        await (this.state.private.channel as Channel<F, C> | null)?.send(msg.data);\n      },\n      SIGNAL(msg: SignalMessage) {\n        const channel = this.state.private.channel as Channel<F, C> | null;\n        if (channel !== null) spec.signal?.(channel, msg.signal);\n      },\n    },\n  });\n}\n"],"mappings":"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"}

package/dist/index-B3FcBNz7.d.ts

@@ -0,0 +1,105 @@
+import { g as Part, m as Channel } from "./reactor-CWPBP7qN.js";
+import { Readable, Writable } from "node:stream";
+//#region src/port/memory.d.ts
+/** One end of a pair.  `fail` is the hook this double adds: it breaks the wire the way a socket would. */
+interface MemoryEnd<F> extends Channel<F> {
+  /** Break the wire: the far end hears an error, and then a close. */
+  fail(error: unknown): void;
+}
+interface ChannelPair<F> {
+  near: MemoryEnd<F>;
+  far: MemoryEnd<F>;
+}
+/** The two halves of one channel. */
+declare function memoryChannelPair<F>(): ChannelPair<F>;
+//#endregion
+//#region src/port/split.d.ts
+/** Given a line, how many raw octets follow it.  Default: none, this is a plain line. */
+type Announcement = (line: string) => number | null;
+/**
+ * One byte channel in, one channel of parts out.
+ *
+ * The returned channel's `send` is the same rule backwards: a part becomes its line, a terminator, and the
+ * octets it carried.
+ */
+declare function splitChannel<C = string>(inner: Channel<Uint8Array, C>, announced?: Announcement): Channel<Part, C>;
+//#endregion
+//#region src/port/stream.d.ts
+/** What the channel talks over: something to read from, something to write to. */
+interface StreamPair {
+  read: Readable;
+  write: Writable;
+}
+/**
+ * A channel of bytes over a stream pair.
+ *
+ * `close()` ends the write side, so the far end hears an end of stream, and destroys the read side, so no
+ * more chunks arrive after this side has said it is done.  A peer that goes away is a close of this side's
+ * own readers, and the reason says which of the two it was.
+ */
+declare function streamChannel(pair: StreamPair): Channel<Uint8Array>;
+//#endregion
+//#region src/port/combine.d.ts
+/** A frame, and which of the combined channels it arrived on. */
+interface Sourced<T, F> {
+  readonly source: T;
+  readonly frame: F;
+}
+/** An ending, and which of the combined channels ended. */
+interface Ended<T, C> {
+  readonly source: T;
+  readonly ending: C;
+}
+/**
+ * Every frame from every source, tagged; the first ending ends it.
+ *
+ * The ending is the first one to arrive, and the others are ignored afterwards.  This is what a process wants
+ * by default: its stdout ending means the process is gone, and that is the news.
+ */
+declare function all<T extends string, F, C>(sources: Record<T, Channel<F, C>>): Channel<Sourced<T, F>, C>;
+/**
+ * Every frame from every source, tagged, and every ending as a frame of its own.
+ *
+ * It closes once all of them have ended, and that close carries nothing: the endings already arrived as frames,
+ * each one saying which source it belongs to.
+ */
+declare function settled<T extends string, F, C>(sources: Record<T, Channel<F, C>>): Channel<Sourced<T, F> | Ended<T, C>, void>;
+//#endregion
+//#region src/port/held.d.ts
+/**
+ * `inner`, with the frames that arrive before anyone is subscribed kept for the readers that follow.
+ *
+ * The kept frames are not bounded, because a bound depends on what the far end may say before anyone listens,
+ * and that is not something this adapter can know.
+ */
+declare function held<F, C>(inner: Channel<F, C>): Channel<F, C>;
+//#endregion
+//#region src/port/fetch.d.ts
+/** What a response said when its body was over. */
+interface HttpEnd {
+  /** The status the far end answered with.  The frames that came before it are its body. */
+  readonly status: number;
+}
+interface FetchPortOptions {
+  /** Passed to `fetch`: method, headers, body.  The request's own signal is not read; `close()` aborts. */
+  init?: RequestInit;
+  /** How long to wait for the response head.  No bound by default: a stream may be long. */
+  connectMs?: number;
+}
+/**
+ * A URL as a channel of the body it answers with.
+ *
+ * Frames are the chunks of the body as they arrive, so a caller reads a stream rather than waiting for a whole
+ * response.  `close()` aborts the request, and the far side hears it.
+ */
+declare function fetchPort(url: string, options?: FetchPortOptions): Promise<Channel<Uint8Array, HttpEnd>>;
+//#endregion
+//#region src/port/duplex.d.ts
+/** A pair whose two sides carry the same frame type, read as one channel. */
+declare function duplexChannel<F, C = void>(pair: {
+  readonly inbound: Channel<F, C>;
+  readonly outbound: Channel<F, C>;
+}): Channel<F, C>;
+//#endregion
+export { held as a, all as c, streamChannel as d, Announcement as f, memoryChannelPair as g, MemoryEnd as h, fetchPort as i, settled as l, ChannelPair as m, FetchPortOptions as n, Ended as o, splitChannel as p, HttpEnd as r, Sourced as s, duplexChannel as t, StreamPair as u };
+//# sourceMappingURL=index-B3FcBNz7.d.ts.map

package/dist/index-B3FcBNz7.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-B3FcBNz7.d.ts","names":[],"sources":["../src/port/memory.ts","../src/port/split.ts","../src/port/stream.ts","../src/port/combine.ts","../src/port/held.ts","../src/port/fetch.ts","../src/port/duplex.ts"],"mappings":";;;;UAUiB,UAAU,WAAW,QAAQ;;EAE5C,KAAK;;UAGU,YAAY;EAC3B,MAAM,UAAU;EAChB,KAAK,UAAU;;;iBAgBD,kBAAkB,MAAM,YAAY;;;;KCXxC,gBAAgB;;;;;;;iBAUZ,aAAa,YAC3B,OAAO,QAAQ,YAAY,IAC3B,YAAW,eACV,QAAQ,MAAM;;;;UCnBA;EACf,MAAM;EACN,OAAO;;;;;;;;;iBAyBO,cAAc,MAAM,aAAa,QAAQ;;;;UC5BxC,QAAQ,GAAG;WACjB,QAAQ;WACR,OAAO;;;UAID,MAAM,GAAG;WACf,QAAQ;WACR,QAAQ;;;;;;;;iBAaH,IAAI,kBAAkB,GAAG,GAAG,SAAS,OAAO,GAAG,QAAQ,GAAG,MAAM,QAAQ,QAAQ,GAAG,IAAI;;;;;;;iBAgEvF,QAAQ,kBAAkB,GAAG,GAC3C,SAAS,OAAO,GAAG,QAAQ,GAAG,MAC7B,QAAQ,QAAQ,GAAG,KAAK,MAAM,GAAG;;;;;;;;;iBCpFpB,KAAK,GAAG,GAAG,OAAO,QAAQ,GAAG,KAAK,QAAQ,GAAG;;;;UCR5C;;WAEN;;UAGM;;EAEf,OAAO;;EAEP;;;;;;;;iBASoB,UAAU,aAAa,UAAS,mBAAwB,QAAQ,QAAQ,YAAY;;;;iBChB1F,cAAc,GAAG,UAAU;WAChC,SAAS,QAAQ,GAAG;WACpB,UAAU,QAAQ,GAAG;IAC5B,QAAQ,GAAG"}

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.47.0";
+declare const LIB_VERSION = "0.48.1";
 //#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-DRbb_jh2.js";
+import { t as LIB_VERSION } from "./version-CjO8pCPA.js";
 //#region src/process.ts
 /** @deprecated Use {@link spawnAsync} instead. */
 function spawn(fn, pname, tp) {

package/dist/port/index.d.ts

@@ -0,0 +1,3 @@
+import { a as portReactor, c as PortIn, d as SendMessage, f as SignalMessage, g as Part, h as ChannelClosed, i as PortReactorOptions, l as PortOut, m as Channel, n as PortPair, o as DataMessage, p as portActor, r as PortReactor, s as PortActorSpec, t as PortListener, u as PortPublic } from "../reactor-CWPBP7qN.js";
+import { a as held, c as all, d as streamChannel, f as Announcement, g as memoryChannelPair, h as MemoryEnd, i as fetchPort, l as settled, m as ChannelPair, n as FetchPortOptions, o as Ended, p as splitChannel, r as HttpEnd, s as Sourced, t as duplexChannel, u as StreamPair } from "../index-B3FcBNz7.js";
+export { type Announcement, type Channel, ChannelClosed, type ChannelPair, type DataMessage, type Ended, type FetchPortOptions, type HttpEnd, type MemoryEnd, type Part, type PortActorSpec, type PortIn, type PortListener, type PortOut, type PortPair, type PortPublic, type PortReactor, type PortReactorOptions, type SendMessage, type SignalMessage, type Sourced, type StreamPair, all, duplexChannel, fetchPort, held, memoryChannelPair, portActor, portReactor, settled, splitChannel, streamChannel };

package/dist/port/index.js

@@ -0,0 +1,3 @@
+import { a as settled, c as ChannelClosed, i as all, n as portReactor, o as streamChannel, r as fetchPort, s as memoryChannelPair, t as duplexChannel } from "../port-DowG9tgl.js";
+import { n as held, r as splitChannel, t as portActor } from "../actor-C8DzeQeT.js";
+export { ChannelClosed, all, duplexChannel, fetchPort, held, memoryChannelPair, portActor, portReactor, settled, splitChannel, streamChannel };

package/dist/port/node.d.ts

@@ -0,0 +1,73 @@
+import { l as ActorDefinition } from "../hooks-DO-efRM_.js";
+import { c as PortIn, l as PortOut, m as Channel, t as PortListener, u as PortPublic } from "../reactor-CWPBP7qN.js";
+//#region src/port/node/spawn.d.ts
+/** How a process ended: it exited with a code, or a signal terminated it. */
+type ProcessEnd = {
+  readonly kind: "exit";
+  readonly code: number;
+} | {
+  readonly kind: "signal";
+  readonly signal: string;
+};
+interface SpawnPortOptions {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  /** How long the process may live after its stdin is closed.  Default 5000 ms, then SIGKILL. */
+  killAfterMs?: number;
+}
+interface ProcessPorts {
+  readonly stdout: Channel<Uint8Array, ProcessEnd>;
+  readonly stderr: Channel<Uint8Array, ProcessEnd>;
+}
+/** A command as a channel of bytes: stdout in, stdin out, and its exit when it closes. */
+declare function spawnPort(command: string[], options?: SpawnPortOptions): Promise<Channel<Uint8Array, ProcessEnd>>;
+/** One process, its stdout and its stderr, each a channel that ends with the same exit. */
+declare function spawnPorts(command: string[], options?: SpawnPortOptions): Promise<ProcessPorts>;
+//#endregion
+//#region src/port/node/process.d.ts
+/** How a process port is started. */
+interface ProcessPortArgs {
+  command: string[];
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  /** How long the process may live after its stdin is closed.  Default 5000 ms, then SIGKILL. */
+  killAfterMs?: number;
+}
+/** The child's octets, frame for frame. */
+declare const BinaryPort: ActorDefinition<ProcessPortArgs, {
+  public: PortPublic<ProcessEnd>;
+  private: {
+    channel: Channel<unknown, ProcessEnd> | null;
+    args: unknown;
+  };
+}, PortIn<Uint8Array<ArrayBufferLike>>, PortOut<Uint8Array<ArrayBufferLike>>, {}>;
+/** The same child, cut into lines. */
+declare const Utf8Port: ActorDefinition<ProcessPortArgs, {
+  public: PortPublic<ProcessEnd>;
+  private: {
+    channel: Channel<unknown, ProcessEnd> | null;
+    args: unknown;
+  };
+}, PortIn<string>, PortOut<string>, {}>;
+//#endregion
+//#region src/port/node/listener.d.ts
+interface HttpListenerOptions<Meta> {
+  port?: number;
+  hostname?: string;
+  /** Admission before a body is made: what it returns is the pair's meta; throwing refuses the request. */
+  identify?(request: Request): Meta | Promise<Meta>;
+}
+/** A port listener that is also an HTTP server: the port it bound, and the pairs it hands out. */
+interface HttpListener<Meta> extends PortListener<Uint8Array, Uint8Array, Meta> {
+  readonly port: number;
+}
+/**
+ * A server whose requests arrive as pairs of ports.
+ *
+ * `identify` runs before a pair exists, so a refused request costs no stream and the caller reads a status with
+ * the reason in it.  The request body is the inbound port; the response body is the outbound one.
+ */
+declare function httpListener<Meta = unknown>(options?: HttpListenerOptions<Meta>): HttpListener<Meta>;
+//#endregion
+export { BinaryPort, type HttpListener, type HttpListenerOptions, type ProcessEnd, type ProcessPortArgs, type ProcessPorts, type SpawnPortOptions, Utf8Port, httpListener, spawnPort, spawnPorts };
+//# sourceMappingURL=node.d.ts.map

package/dist/port/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","names":[],"sources":["../../src/port/node/spawn.ts","../../src/port/node/process.ts","../../src/port/node/listener.ts"],"mappings":";;;;KAcY;WACG;WAAuB;;WACvB;WAAyB;;UACvB;EACf;EACA,MAAM,OAAO;;EAEb;;UAEe;WACN,QAAQ,QAAQ,YAAY;WAC5B,QAAQ,QAAQ,YAAY;;;iBAIvB,UACd,mBACA,UAAS,mBACR,QAAQ,QAAQ,YAAY;;iBAIT,WACpB,mBACA,UAAS,mBACR,QAAQ;;;;UC3BM;EACf;EACA;EACA,MAAM,OAAO;;EAEb;;;cA8CW,YAGX,gBAHqB;;;;;;GAGrB,OAAA,WAAA,mBAAA,QAAA,WAAA;;cAGW,UAGX,gBAHmB;;;;;;mBAGnB;;;UC3De,oBAAoB;EACnC;EACA;;EAEA,UAAU,SAAS,UAAU,OAAO,QAAQ;;;UAI7B,aAAa,cAAc,aAAa,YAAY,YAAY;WACtE;;;;;;;;iBAuBK,aAAa,gBAAgB,UAAS,oBAAoB,QAAa,aAAa"}