posipaki 0.49.2 → 0.51.0

package/dist/{actor-B5EJRlY8.js → fetch-D72Xvuoc.js}

@@ -1,5 +1,4 @@
 import { n as defineMessages, t as defineActor } from "./define-actor-DR1P1PA5.js";
-import { StringDecoder } from "node:string_decoder";
 //#region src/port/held.ts
 /**
 * `inner`, with the frames that arrive before anyone is subscribed kept for the readers that follow.
@@ -49,6 +48,8 @@ function held(inner) {
 				readers.delete(handler);
 			};
 		},
+		/** What it kept is handed to whoever subscribes next; what it will *push* is the inner channel's business. */
+		hasFrames: () => inner.hasFrames(),
 		onClose(handler) {
 			if (ending !== null) {
 				handler(ending.reason);
@@ -78,6 +79,17 @@ function held(inner) {
 //#region src/port/split.ts
 const NL = 10;
 const CR = 13;
+const EMPTY = /* @__PURE__ */ new Uint8Array(0);
+const decoder = new TextDecoder();
+/** Two octet strings as one: the one place this file would otherwise reach for `Buffer`. */
+function joined(first, second) {
+	if (first.length === 0) return second;
+	if (second.length === 0) return first;
+	const whole = new Uint8Array(first.length + second.length);
+	whole.set(first, 0);
+	whole.set(second, first.length);
+	return whole;
+}
 const NOTHING = () => null;
 /**
 * One byte channel in, one channel of parts out.
@@ -89,9 +101,8 @@ 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);
+	let buffered = EMPTY;
 	/** The line whose announced octets are still arriving. */
 	let pending = null;
 	let ended = false;
@@ -134,7 +145,7 @@ function splitChannel(inner, announced = NOTHING) {
 			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 text = decoder.decode(line);
 			const count = announced(text);
 			if (count === null) {
 				emit({
@@ -158,9 +169,8 @@ function splitChannel(inner, announced = NOTHING) {
 	};
 	const parts = held({
 		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));
+			const head = new TextEncoder().encode(`${part.line}\n`);
+			await inner.send(part.bytes === null ? head : joined(head, part.bytes));
 		},
 		onFrame: (handler) => {
 			readers.add(handler);
@@ -189,11 +199,12 @@ function splitChannel(inner, announced = NOTHING) {
 			await inner.close(why);
 		},
 		info: inner.info,
-		control: (command) => inner.control(command)
+		control: (command) => inner.control(command),
+		hasFrames: async () => false
 	});
 	inner.onFrame((chunk) => {
 		if (ended) return;
-		buffered = buffered.length === 0 ? Buffer.from(chunk) : Buffer.concat([buffered, Buffer.from(chunk)]);
+		buffered = joined(buffered, chunk);
 		drain();
 	});
 	inner.onError((error) => {
@@ -203,12 +214,12 @@ function splitChannel(inner, announced = NOTHING) {
 		if (ended) return;
 		if (pending === null && buffered.length > 0) {
 			const rest = buffered;
-			buffered = Buffer.alloc(0);
+			buffered = EMPTY;
 			emit({
-				line: decoder.write(rest) + decoder.end(),
+				line: decoder.decode(rest),
 				bytes: null
 			});
-		} else decoder.end();
+		}
 		close(why);
 	});
 	return parts;
@@ -271,6 +282,115 @@ function portActor(spec) {
 	});
 }
 //#endregion
-export { splitChannel as n, held as r, portActor as t };
+//#region src/port/fetch.ts
+/**
+* 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.
+*/
+async function fetchPort(url, options = {}) {
+	const controller = new AbortController();
+	const response = await answered(url, {
+		...options.init,
+		signal: controller.signal
+	}, options.connectMs);
+	const readers = /* @__PURE__ */ new Set();
+	const closers = /* @__PURE__ */ new Set();
+	const failers = /* @__PURE__ */ new Set();
+	const ending = { status: response.status };
+	let ended = false;
+	const end = () => {
+		if (ended) return;
+		ended = true;
+		for (const closer of [...closers]) closer(ending);
+	};
+	const frames = {
+		send: () => Promise.reject(/* @__PURE__ */ new Error("a response body has no input; send on the request instead")),
+		onFrame(handler) {
+			readers.add(handler);
+			return () => {
+				readers.delete(handler);
+			};
+		},
+		onClose(handler) {
+			if (ended) {
+				handler(ending);
+				return () => {};
+			}
+			closers.add(handler);
+			return () => {
+				closers.delete(handler);
+			};
+		},
+		onError(handler) {
+			failers.add(handler);
+			return () => {
+				failers.delete(handler);
+			};
+		},
+		async close() {
+			controller.abort();
+			await reader?.cancel().catch(() => void 0);
+		},
+		info: {
+			url,
+			status: response.status
+		},
+		control: () => {},
+		hasFrames: async () => false
+	};
+	const reader = response.body?.getReader();
+	const port = held(frames);
+	const pump = async () => {
+		if (reader === void 0) {
+			end();
+			return;
+		}
+		try {
+			for (;;) {
+				const chunk = await reader.read();
+				if (chunk.done) {
+					end();
+					return;
+				}
+				for (const target of [...readers]) target(chunk.value);
+			}
+		} catch (error) {
+			for (const failer of [...failers]) failer(error);
+			end();
+		}
+	};
+	pump();
+	return port;
+}
+/** The response head, or a rejection that says why there is none. */
+/**
+* A response that is not a stream: the far end answered, and the answer was a refusal.
+*
+* The status is here as a fact and in the sentence, because a caller that decides what to do next wants the
+* number and a caller reading a log wants the words.
+*/
+var HttpRefusal = class extends Error {
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+		this.name = "HttpRefusal";
+	}
+};
+async function answered(url, init, connectMs) {
+	const attempt = fetch(url, init).catch((error) => Promise.reject(named(url, error)));
+	const response = connectMs === void 0 ? await attempt : await Promise.race([attempt, new Promise((_resolve, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`fetchPort: ${url} answered nothing within ${connectMs}ms`)), connectMs))]);
+	if (!response.ok) {
+		const body = await response.text().catch(() => "");
+		throw new HttpRefusal(response.status, `fetchPort: ${url} answered ${response.status}${body === "" ? "" : `: ${body.slice(0, 200)}`}`);
+	}
+	return response;
+}
+function named(url, error) {
+	return /* @__PURE__ */ new Error(`fetchPort: ${url}: ${error instanceof Error ? error.message : String(error)}`);
+}
+//#endregion
+export { held as a, splitChannel as i, fetchPort as n, portActor as r, HttpRefusal as t };
 
-//# sourceMappingURL=actor-B5EJRlY8.js.map
+//# sourceMappingURL=fetch-D72Xvuoc.js.map

package/dist/fetch-D72Xvuoc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-D72Xvuoc.js","names":[],"sources":["../src/port/held.ts","../src/port/split.ts","../src/port/actor.ts","../src/port/fetch.ts"],"sourcesContent":["// ── 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  /** The ending, kept for a reader that arrives after it: a channel that is over is not one to wait on. */\n  let ending: { reason: C } | null = null;\n  let failed: { error: unknown } | null = null;\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    ending = { reason };\n    for (const closer of [...closers]) closer(reason);\n  });\n  inner.onError((error) => {\n    failed = { 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    /** What it kept is handed to whoever subscribes next; what it will *push* is the inner channel's business. */\n    hasFrames: () => inner.hasFrames(),\n    onClose(handler) {\n      if (ending !== null) {\n        handler(ending.reason);\n        return () => {};\n      }\n      closers.add(handler);\n      return () => {\n        closers.delete(handler);\n      };\n    },\n    onError(handler) {\n      if (failed !== null) {\n        handler(failed.error);\n        return () => {};\n      }\n      failers.add(handler);\n      return () => {\n        failers.delete(handler);\n      };\n    },\n    close: (reason) => inner.close(reason),\n    info: inner.info,\n    control: (command) => inner.control(command),\n  };\n}\n","// ── 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, and a line is decoded only when all of its octets are in hand.  A character that straddles two chunks\n// waits in the buffer, which is why this file needs no decoder of its own — and no `node:` import, because\n// `posipaki/port` is the entry a browser takes.\n\nimport type { Channel, Part } from \"./channel.js\";\nimport { held } from \"./held.js\";\n\nconst NL = 0x0a;\nconst CR = 0x0d;\n\nconst EMPTY = new Uint8Array(0);\nconst decoder = new TextDecoder();\n\n/** Two octet strings as one: the one place this file would otherwise reach for `Buffer`. */\nfunction joined(first: Uint8Array, second: Uint8Array): Uint8Array {\n  if (first.length === 0) return second;\n  if (second.length === 0) return first;\n  const whole = new Uint8Array(first.length + second.length);\n  whole.set(first, 0);\n  whole.set(second, first.length);\n  return whole;\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\n  /** Bytes that are not yet a frame: a line, or the octets a line announced. */\n  let buffered: Uint8Array = EMPTY;\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.decode(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  // Built and wrapped before the inner channel is read: the medium may have kept frames for its first\n  // reader, and subscribing drains them at once — a part produced then must be a reader's to find, not the\n  // wire's to lose.\n  const parts: Channel<Part, C> = held<Part, C>({\n    send: async (part: Part) => {\n      const head = new TextEncoder().encode(`${part.line}\\n`);\n      await inner.send(part.bytes === null ? head : joined(head, part.bytes));\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    info: inner.info,\n    control: (command) => inner.control(command),\n    hasFrames: async () => false,\n  });\n\n  inner.onFrame((chunk) => {\n    if (ended) return;\n    buffered = joined(buffered, 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 = EMPTY;\n      emit({ line: decoder.decode(rest), bytes: null });\n    }\n    close(why);\n  });\n\n  return parts;\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 in `setup`, which the runtime awaits, so an actor that is ready has a channel: a send is\n// never asked to wait for one, and a port that cannot open fails its start rather than looking alive.  What a\n// channel is — a process, a socket, a pair in memory — is `open`'s business; the 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  /** What the medium knows about itself — a process its pid — as the channel reported it. */\n  info: Record<string, unknown>;\n}\n\n/** What a medium's actor is handed: a name, and a way to open the channel it will own. */\nexport interface PortActorSpec<Args, F, C = string> {\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}\n\ntype PortState<F, C> = {\n  public: PortPublic<C>;\n  private: { channel: Channel<F, C>; args: unknown };\n};\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, through\n * the channel's own `control`; posipaki's `STOP` ends the actor, which closes the channel.  Out `DATA {data}`\n * for every frame.  The channel's ending is left in `state.end`, what the medium knows about itself in\n * `state.info`, and then the actor stops.\n */\nexport function portActor<Args, F, C = string>(\n  spec: PortActorSpec<Args, F, C>,\n): ActorDefinition<Args, PortState<F, C>, PortIn<F>, PortOut<F>, {}> {\n  return defineActor({\n    name: spec.name,\n    inMessages: defineMessages<PortIn<F>>(),\n    outMessages: defineMessages<PortOut<F>>(),\n    setup: async (args: Args): Promise<PortState<F, C>> => {\n      const channel = await spec.open(args);\n      return {\n        public: { alive: true, end: null, info: channel.info },\n        private: { channel, args },\n      };\n    },\n    afterStart() {\n      const { channel } = this.state.private;\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    async beforeEnd() {\n      this.state.public.alive = false;\n      await this.state.private.channel.close();\n    },\n    handlers: {\n      async SEND(msg: SendMessage<F>) {\n        await this.state.private.channel.send(msg.data);\n      },\n      SIGNAL(msg: SignalMessage) {\n        this.state.private.channel.control({ signal: msg.signal });\n      },\n    },\n  });\n}\n","// ── an HTTP request as a port ───────────────────────────────────────────────\n//\n// The response body is the channel's frames, `close()` aborts the request, and the ending is what the response\n// said about itself.  A request that never got a response is a rejection, the way a spawner that cannot connect\n// is: a non-2xx, a refused connection, a promise that never settles.\n\nimport type { Channel } from \"./channel.js\";\nimport { held } from \"./held.js\";\n\n/** What a response said when its body was over. */\nexport interface HttpEnd {\n  /** The status the far end answered with.  The frames that came before it are its body. */\n  readonly status: number;\n}\n\nexport interface FetchPortOptions {\n  /** Passed to `fetch`: method, headers, body.  The request's own signal is not read; `close()` aborts. */\n  init?: RequestInit;\n  /** How long to wait for the response head.  No bound by default: a stream may be long. */\n  connectMs?: number;\n}\n\n/**\n * A URL as a channel of the body it answers with.\n *\n * Frames are the chunks of the body as they arrive, so a caller reads a stream rather than waiting for a whole\n * response.  `close()` aborts the request, and the far side hears it.\n */\nexport async function fetchPort(url: string, options: FetchPortOptions = {}): Promise<Channel<Uint8Array, HttpEnd>> {\n  const controller = new AbortController();\n  const response = await answered(url, { ...options.init, signal: controller.signal }, options.connectMs);\n\n  const readers = new Set<(frame: Uint8Array) => void>();\n  const closers = new Set<(reason: HttpEnd) => void>();\n  const failers = new Set<(error: unknown) => void>();\n  const ending: HttpEnd = { status: response.status };\n  let ended = false;\n\n  const end = (): void => {\n    if (ended) return;\n    ended = true;\n    for (const closer of [...closers]) closer(ending);\n  };\n\n  const frames: Channel<Uint8Array, HttpEnd> = {\n    send: () => Promise.reject(new Error(\"a response body has no input; send on the request instead\")),\n    onFrame(handler) {\n      readers.add(handler);\n      return () => {\n        readers.delete(handler);\n      };\n    },\n    onClose(handler) {\n      if (ended) {\n        handler(ending);\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    async close() {\n      controller.abort();\n      await reader?.cancel().catch(() => undefined);\n    },\n    info: { url, status: response.status },\n    control: () => {},\n    hasFrames: async () => false,\n  };\n\n  const reader = response.body?.getReader();\n  // Wrapped before the first read: a body can deliver a chunk in the same turn the port is handed over.\n  const port = held(frames);\n\n  const pump = async (): Promise<void> => {\n    if (reader === undefined) {\n      end();\n      return;\n    }\n    try {\n      for (;;) {\n        const chunk = await reader.read();\n        if (chunk.done) {\n          end();\n          return;\n        }\n        for (const target of [...readers]) target(chunk.value);\n      }\n    } catch (error) {\n      for (const failer of [...failers]) failer(error);\n      end();\n    }\n  };\n  void pump();\n\n  return port;\n}\n\n/** The response head, or a rejection that says why there is none. */\n/**\n * A response that is not a stream: the far end answered, and the answer was a refusal.\n *\n * The status is here as a fact and in the sentence, because a caller that decides what to do next wants the\n * number and a caller reading a log wants the words.\n */\nexport class HttpRefusal extends Error {\n  constructor(\n    readonly status: number,\n    message: string,\n  ) {\n    super(message);\n    this.name = \"HttpRefusal\";\n  }\n}\n\nasync function answered(url: string, init: RequestInit, connectMs: number | undefined): Promise<Response> {\n  const attempt = fetch(url, init).catch((error: unknown) => Promise.reject(named(url, error)));\n  const response =\n    connectMs === undefined\n      ? await attempt\n      : await Promise.race([\n          attempt,\n          new Promise<never>((_resolve, reject) =>\n            setTimeout(() => reject(new Error(`fetchPort: ${url} answered nothing within ${connectMs}ms`)), connectMs),\n          ),\n        ]);\n\n  if (!response.ok) {\n    const body = await response.text().catch(() => \"\");\n    throw new HttpRefusal(\n      response.status,\n      `fetchPort: ${url} answered ${response.status}${body === \"\" ? \"\" : `: ${body.slice(0, 200)}`}`,\n    );\n  }\n  return response;\n}\n\nfunction named(url: string, error: unknown): Error {\n  return new Error(`fetchPort: ${url}: ${error instanceof Error ? error.message : String(error)}`);\n}\n"],"mappings":"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"}

package/dist/{index-ChSy_Vdu.d.ts → index-BQH-ok2x.d.ts}

@@ -1,4 +1,4 @@
-import { g as Part, m as Channel } from "./reactor-4MaIKVnw.js";
+import { g as Part, m as Channel } from "./reactor-Cl5_rhzB.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. */
@@ -112,5 +112,77 @@ declare function duplexChannel<F, C = void>(pair: {
   readonly outbound: Channel<F, C>;
 }): Channel<F, C>;
 //#endregion
-export { memoryChannelPair as _, fetchPort as a, Sourced as c, StreamPair as d, streamChannel as f, MemoryEnd as g, ChannelPair as h, HttpRefusal as i, all as l, splitChannel as m, FetchPortOptions as n, held as o, Announcement as p, HttpEnd as r, Ended as s, duplexChannel as t, settled as u };
-//# sourceMappingURL=index-ChSy_Vdu.d.ts.map
+//#region src/port/map.d.ts
+/** What a mapper returns when a value has nothing to say in the other vocabulary. */
+declare const SKIP: unique symbol;
+/**
+ * A channel of `I` over a channel of `O`.
+ *
+ * `down` maps what is sent and `up` maps what arrives; either may answer `SKIP`, and then nothing is written
+ * or delivered.  Everything else — close, error, info, control — is the channel below's own, forwarded as it
+ * is, because this layer carries a vocabulary and not a medium.
+ */
+declare function mapChannel<I, O, C>(inner: Channel<O, C>, down: (value: I) => O | typeof SKIP, up: (value: O) => I | typeof SKIP): Channel<I, C>;
+//#endregion
+//#region src/port/lines.d.ts
+/** A channel of octets, read and written as lines. */
+declare function linesChannel<C = string>(inner: Channel<Uint8Array, C>): Channel<string, C>;
+//#endregion
+//#region src/port/testing.d.ts
+declare const encode: (text: string) => Uint8Array;
+declare const decode: (bytes: Uint8Array) => string;
+/** What was written to an outbound port: the head it was told, the frames, and whether it ended. */
+interface Written {
+  head: Record<string, unknown> | null;
+  frames: string[];
+  ended: boolean;
+}
+/** An outbound port that records instead of writing, so a head is asserted as the command it is. */
+declare function recording(): {
+  out: Channel<Uint8Array, void>;
+  written: Written;
+};
+/** An inbound port the test writes into, and then ends. */
+declare function incoming(): {
+  inbound: Channel<Uint8Array, void>;
+  write: (text: string) => void;
+  bytes: (chunk: Uint8Array) => void;
+  end: () => void;
+};
+//#endregion
+//#region src/port/read.d.ts
+/**
+ * The next message on a channel, and no further.
+ *
+ * Reads of one channel are served in order: what arrived while a caller was waiting goes to the next caller
+ * rather than being dropped.  What arrived before the first read is not kept here — a channel whose early
+ * frames matter is wrapped in `held` where it is made.
+ */
+declare function readMessage<T, C>(channel: Channel<T, C>): Promise<T>;
+/**
+ * The next message, or `nothing` when this channel has none and nothing is coming.
+ *
+ * `nothing` is answered once the channel says it is quiet — `hasFrames()` answering `false` — and a channel that
+ * cannot say waits instead, because "no frame now" is not something it can promise.  What is already standing on
+ * this channel is taken first, so a frame that arrived while nobody was waiting is not lost to the question.
+ */
+declare function readMessageMaybe<T, C>(channel: Channel<T, C>): Promise<T | null>;
+declare function readMessageMaybe<T, C, N>(channel: Channel<T, C>, nothing: N): Promise<T | N>;
+//#endregion
+//#region src/port/sse.d.ts
+/** A channel of lines, read as SSE events: one value per event, the empty ones skipped. */
+declare function sseChannel<C>(parts: Channel<Part, C>): Channel<string, C>;
+/**
+ * The other direction: events into a body.
+ *
+ * An event's lines each become a `data:` field and a blank line ends it — the inverse of `sseChannel`, so a
+ * server's answer and a client's reading are one vocabulary over the same bytes.
+ */
+declare function sseWriter<C>(out: Channel<Uint8Array, C>): Channel<string, C>;
+//#endregion
+//#region src/port/node/file/file.d.ts
+/** Where this channel has read up to: every frame it has handed over ends at this offset. */
+declare function fileChannel(path: string): Channel<Uint8Array, string>;
+//#endregion
+export { memoryChannelPair as A, settled as C, splitChannel as D, Announcement as E, ChannelPair as O, all as S, streamChannel as T, HttpRefusal as _, readMessageMaybe as a, Ended as b, encode as c, linesChannel as d, SKIP as f, HttpEnd as g, FetchPortOptions as h, readMessage as i, MemoryEnd as k, incoming as l, duplexChannel as m, sseChannel as n, Written as o, mapChannel as p, sseWriter as r, decode as s, fileChannel as t, recording as u, fetchPort as v, StreamPair as w, Sourced as x, held as y };
+//# sourceMappingURL=index-BQH-ok2x.d.ts.map

package/dist/index-BQH-ok2x.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BQH-ok2x.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","../src/port/map.ts","../src/port/lines.ts","../src/port/testing.ts","../src/port/read.ts","../src/port/sse.ts","../src/port/node/file/file.ts"],"mappings":";;;;UAUiB,UAAU,WAAW,QAAQ;;EAE5C,KAAK;;UAGU,YAAY;EAC3B,MAAM,UAAU;EAChB,KAAK,UAAU;;;iBAgBD,kBAAkB,MAAM,YAAY;;;;KCJxC,gBAAgB;;;;;;;iBAUZ,aAAa,YAC3B,OAAO,QAAQ,YAAY,IAC3B,YAAW,eACV,QAAQ,MAAM;;;;UC1BA;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;;;;;;;iBAmEvF,QAAQ,kBAAkB,GAAG,GAC3C,SAAS,OAAO,GAAG,QAAQ,GAAG,MAC7B,QAAQ,QAAQ,GAAG,KAAK,MAAM,GAAG;;;;;;;;;iBCvFpB,KAAK,GAAG,GAAG,OAAO,QAAQ,GAAG,KAAK,QAAQ,GAAG;;;;UCR5C;;WAEN;;UAGM;;EAEf,OAAO;;EAEP;;;;;;;;iBASoB,UAAU,aAAa,UAAS,mBAAwB,QAAQ,QAAQ,YAAY;;;;;;;;cAoF7F,oBAAoB;WAEpB;EADX,YACW,gBACT;;;;;iBCvGY,cAAc,GAAG,UAAU;WAChC,SAAS,QAAQ,GAAG;WACpB,UAAU,QAAQ,GAAG;IAC5B,QAAQ,GAAG;;;;cCNF;;;;;;;;iBASG,WAAW,GAAG,GAAG,GAC/B,OAAO,QAAQ,GAAG,IAClB,OAAO,OAAO,MAAM,WAAW,MAC/B,KAAK,OAAO,MAAM,WAAW,OAC5B,QAAQ,GAAG;;;;iBCTE,aAAa,YAAY,OAAO,QAAQ,YAAY,KAAK,gBAAgB;;;cCN5E,SAAM,iBAAmB;cACzB,SAAM,OAAW;;UAGb;EACf,MAAM;EACN;EACA;;;iBAIc;EAAe,KAAK,QAAQ;EAAmB,SAAS;;;iBAsBxD;EACd,SAAS,QAAQ;EACjB,QAAQ;EACR,QAAQ,OAAO;EACf;;;;;;;;;;;iBCDoB,YAAY,GAAG,GAAG,SAAS,QAAQ,GAAG,KAAK,QAAQ;;;;;;;;iBAcnD,iBAAiB,GAAG,GAAG,SAAS,QAAQ,GAAG,KAAK,QAAQ;iBACxD,iBAAiB,GAAG,GAAG,GAC3C,SAAS,QAAQ,GAAG,IACpB,SAAS,IACR,QAAQ,IAAI;;;;iBClCC,WAAW,GAAG,OAAO,QAAQ,MAAM,KAAK,gBAAgB;;;;;;;iBAwFxD,UAAU,GAAG,KAAK,QAAQ,YAAY,KAAK,gBAAgB;;;;iBCjG3D,YAAY,eAAe,QAAQ"}

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

package/dist/port/index.d.ts

@@ -1,3 +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-4MaIKVnw.js";
-import { _ as memoryChannelPair, a as fetchPort, c as Sourced, d as StreamPair, f as streamChannel, g as MemoryEnd, h as ChannelPair, i as HttpRefusal, l as all, m as splitChannel, n as FetchPortOptions, o as held, p as Announcement, r as HttpEnd, s as Ended, t as duplexChannel, u as settled } from "../index-ChSy_Vdu.js";
-export { type Announcement, type Channel, ChannelClosed, type ChannelPair, type DataMessage, type Ended, type FetchPortOptions, type HttpEnd, HttpRefusal, 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 };
+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-Cl5_rhzB.js";
+import { A as memoryChannelPair, C as settled, D as splitChannel, E as Announcement, O as ChannelPair, S as all, T as streamChannel, _ as HttpRefusal, a as readMessageMaybe, b as Ended, c as encode, d as linesChannel, f as SKIP, g as HttpEnd, h as FetchPortOptions, i as readMessage, k as MemoryEnd, l as incoming, m as duplexChannel, n as sseChannel, o as Written, p as mapChannel, r as sseWriter, s as decode, t as fileChannel, u as recording, v as fetchPort, w as StreamPair, x as Sourced, y as held } from "../index-BQH-ok2x.js";
+export { type Announcement, type Channel, ChannelClosed, type ChannelPair, type DataMessage, type Ended, type FetchPortOptions, type HttpEnd, HttpRefusal, type MemoryEnd, type Part, type PortActorSpec, type PortIn, type PortListener, type PortOut, type PortPair, type PortPublic, type PortReactor, type PortReactorOptions, SKIP, type SendMessage, type SignalMessage, type Sourced, type StreamPair, type Written, all, decode, duplexChannel, encode, fetchPort, fileChannel, held, incoming, linesChannel, mapChannel, memoryChannelPair, portActor, portReactor, readMessage, readMessageMaybe, recording, settled, splitChannel, sseChannel, sseWriter, streamChannel };

package/dist/port/index.js

@@ -1,3 +1,3 @@
-import { a as all, c as memoryChannelPair, i as fetchPort, l as ChannelClosed, n as portReactor, o as settled, r as HttpRefusal, s as streamChannel, t as duplexChannel } from "../port-DLpNfoyX.js";
-import { n as splitChannel, r as held, t as portActor } from "../actor-B5EJRlY8.js";
-export { ChannelClosed, HttpRefusal, all, duplexChannel, fetchPort, held, memoryChannelPair, portActor, portReactor, settled, splitChannel, streamChannel };
+import { _ as streamChannel, a as readMessageMaybe, c as incoming, d as SKIP, f as mapChannel, g as settled, h as all, i as readMessage, l as recording, m as portReactor, n as sseChannel, o as decode, p as duplexChannel, r as sseWriter, s as encode, t as fileChannel, u as linesChannel, v as memoryChannelPair, y as ChannelClosed } from "../port-CDK2CsXP.js";
+import { a as held, i as splitChannel, n as fetchPort, r as portActor, t as HttpRefusal } from "../fetch-D72Xvuoc.js";
+export { ChannelClosed, HttpRefusal, SKIP, all, decode, duplexChannel, encode, fetchPort, fileChannel, held, incoming, linesChannel, mapChannel, memoryChannelPair, portActor, portReactor, readMessage, readMessageMaybe, recording, settled, splitChannel, sseChannel, sseWriter, streamChannel };

package/dist/port/node.d.ts

@@ -1,5 +1,6 @@
 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-4MaIKVnw.js";
+import { c as PortIn, l as PortOut, m as Channel, t as PortListener, u as PortPublic } from "../reactor-Cl5_rhzB.js";
+import { Server } from "node:http";
 //#region src/port/node/spawn.d.ts
 /** How a process ended: it exited with a code, or a signal terminated it. */
 type ProcessEnd = {
@@ -34,12 +35,20 @@ interface HttpListenerOptions<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;
+  /** The server itself, for what only a consumer of it can do — a WebSocket upgrade, a second route. */
+  readonly server: Server;
+}
+/** What a response says before its body: the status and the headers a handler chose. */
+interface ResponseHead {
+  readonly status: number;
+  readonly headers?: HeadersInit;
 }
 /**
  * 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.
+ * the reason in it.  The request body is the inbound port; the response body is the outbound one, and the head
+ * is one command on it.
  */
 declare function httpListener<Meta = unknown>(options?: HttpListenerOptions<Meta>): HttpListener<Meta>;
 //#endregion
@@ -69,5 +78,5 @@ declare const Utf8Port: ActorDefinition<ProcessPortArgs, {
   };
 }, PortIn<string>, PortOut<string>, {}>;
 //#endregion
-export { BinaryPort, type HttpListener, type HttpListenerOptions, type ProcessEnd, type ProcessPortArgs, type ProcessPorts, type SpawnPortOptions, Utf8Port, httpListener, spawnPort, spawnPorts };
+export { BinaryPort, type HttpListener, type HttpListenerOptions, type ProcessEnd, type ProcessPortArgs, type ProcessPorts, type ResponseHead, type SpawnPortOptions, Utf8Port, httpListener, spawnPort, spawnPorts };
 //# sourceMappingURL=node.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","names":[],"sources":["../../src/port/node/spawn.ts","../../src/port/node/listener.ts","../../src/port/node/process.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;;;UC1BM,oBAAoB;EACnC;EACA;;EAEA,UAAU,SAAS,UAAU,OAAO,QAAQ;;;UAI7B,aAAa,cAAc,aAAa,YAAY,YAAY;WACtE;;;;;;;;iBAuBK,aAAa,gBAAgB,UAAS,oBAAoB,QAAa,aAAa;;;;UCjCnF;EACf;EACA;EACA,MAAM,OAAO;;EAEb;;;cAiDW,YAGX,gBAHqB;;;;;;GAGrB,OAAA,WAAA,mBAAA,QAAA,WAAA;;cAGW,UAGX,gBAHmB;;;;;;mBAGnB"}
+{"version":3,"file":"node.d.ts","names":[],"sources":["../../src/port/node/spawn.ts","../../src/port/node/listener.ts","../../src/port/node/process.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;;;UCxBM,oBAAoB;EACnC;EACA;;EAEA,UAAU,SAAS,UAAU,OAAO,QAAQ;;;UAI7B,aAAa,cAAc,aAAa,YAAY,YAAY;WACtE;;WAEA,QAAQ;;;UAIF;WACN;WACA,UAAU;;;;;;;;;iBAUL,aAAa,gBAAgB,UAAS,oBAAoB,QAAa,aAAa;;;;UC9BnF;EACf;EACA;EACA,MAAM,OAAO;;EAEb;;;cAkDW,YAGX,gBAHqB;;;;;;GAGrB,OAAA,WAAA,mBAAA,QAAA,WAAA;;cAGW,UAGX,gBAHmB;;;;;;mBAGnB"}