posipaki 0.49.2 → 0.50.0

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

@@ -271,6 +271,114 @@ 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: () => {}
+	};
+	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-DBJeP47R.js.map

package/dist/fetch-DBJeP47R.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-DBJeP47R.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    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.  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\";\nimport { held } from \"./held.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  // 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 = 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    info: inner.info,\n    control: (command) => inner.control(command),\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 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  };\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.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.50.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-_BGyK0ZQ.js";
 //#region src/process.ts
 /** @deprecated Use {@link spawnAsync} instead. */
 function spawn(fn, pname, tp) {

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";
+import { a as streamChannel, i as settled, n as portReactor, o as memoryChannelPair, r as all, s as ChannelClosed, t as duplexChannel } from "../port-ByBSeVPm.js";
+import { a as held, i as splitChannel, n as fetchPort, r as portActor, t as HttpRefusal } from "../fetch-DBJeP47R.js";
 export { ChannelClosed, HttpRefusal, all, duplexChannel, fetchPort, held, memoryChannelPair, portActor, portReactor, settled, splitChannel, 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 { 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,15 @@ 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;
 }
 /**
  * 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

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;;;;;;;;;iBAgBH,aAAa,gBAAgB,UAAS,oBAAoB,QAAa,aAAa;;;;UC9BnF;EACf;EACA;EACA,MAAM,OAAO;;EAEb;;;cAiDW,YAGX,gBAHqB;;;;;;GAGrB,OAAA,WAAA,mBAAA,QAAA,WAAA;;cAGW,UAGX,gBAHmB;;;;;;mBAGnB"}

package/dist/port/node.js

@@ -1,5 +1,6 @@
-import { n as splitChannel, r as held, t as portActor } from "../actor-B5EJRlY8.js";
+import { a as held, i as splitChannel, r as portActor, t as HttpRefusal } from "../fetch-DBJeP47R.js";
 import { spawn } from "node:child_process";
+import { createServer } from "node:http";
 //#region src/port/node/spawn.ts
 const DEFAULT_KILL_AFTER_MS = 5e3;
 /** A command as a channel of bytes: stdout in, stdin out, and its exit when it closes. */
@@ -154,15 +155,13 @@ async function shutdown(child, killAfterMs) {
 * 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.
 */
 function httpListener(options = {}) {
-	const runtime = globalThis.Bun;
-	if (runtime === void 0) throw new Error("httpListener: this needs Bun's server");
 	const waiting = [];
 	const buffered = [];
 	let closed = false;
-	let server = null;
 	const take = (pair) => {
 		const next = waiting.shift();
 		if (next === void 0) {
@@ -171,29 +170,36 @@ function httpListener(options = {}) {
 		}
 		next.accept(pair);
 	};
-	server = runtime.serve({
-		port: options.port ?? 0,
-		hostname: options.hostname,
-		async fetch(request) {
-			if (closed) return new Response("listener is closed", { status: 503 });
+	const server = createServer((request, response) => {
+		(async () => {
+			if (closed) {
+				response.writeHead(503).end("the listener is closed");
+				return;
+			}
 			let meta;
 			try {
-				meta = options.identify === void 0 ? void 0 : await options.identify(request);
+				meta = options.identify === void 0 ? void 0 : await options.identify(asRequest(request));
 			} catch (error) {
-				return new Response(error instanceof Error ? error.message : String(error), { status: 401 });
+				const status = error instanceof HttpRefusal ? error.status : 401;
+				response.writeHead(status).end(error instanceof Error ? error.message : String(error));
+				return;
 			}
-			const outbound = responsePort();
+			const outbound = responsePort(response);
 			take({
 				inbound: requestPort(request),
-				outbound: outbound.channel,
+				outbound,
 				meta
 			});
-			return new Response(outbound.body);
-		}
+		})();
 	});
+	server.listen(options.port ?? 0, options.hostname);
 	return {
 		get port() {
-			return server === null ? 0 : server.port;
+			const address = server.address();
+			return typeof address === "object" && address !== null ? address.port : 0;
+		},
+		get server() {
+			return server;
 		},
 		accept() {
 			const next = buffered.shift();
@@ -209,11 +215,20 @@ function httpListener(options = {}) {
 		async close() {
 			closed = true;
 			for (const next of waiting.splice(0)) next.refuse(/* @__PURE__ */ new Error("httpListener: closed"));
-			await server?.stop(true);
-			server = null;
+			server.closeAllConnections?.();
+			await new Promise((done) => server.close(() => done()));
 		}
 	};
 }
+/** The request as `identify` sees it: method, url and headers, and no body — the body is the inbound port. */
+function asRequest(request) {
+	const host = request.headers.host ?? "localhost";
+	const method = request.method ?? "GET";
+	return new Request(`http://${host}${request.url ?? "/"}`, {
+		method,
+		headers: Object.entries(request.headers).flatMap(([name, value]) => value === void 0 ? [] : [[name, Array.isArray(value) ? value.join(", ") : value]])
+	});
+}
 /** The request's body as the inbound port: frames as they arrive, ended when the body is. */
 function requestPort(request) {
 	const readers = /* @__PURE__ */ new Set();
@@ -222,7 +237,7 @@ function requestPort(request) {
 	const end = () => {
 		if (ended) return;
 		ended = true;
-		for (const closer of [...closers]) closer(void 0);
+		for (const closer of closers) closer(void 0);
 	};
 	const inbound = {
 		send: () => Promise.reject(/* @__PURE__ */ new Error("a request body has no input; that side is the caller's")),
@@ -246,84 +261,90 @@ function requestPort(request) {
 			return () => {};
 		},
 		close: async () => {
-			await request.body?.cancel().catch(() => void 0);
 			end();
+			request.destroy();
 		},
 		info: {
-			method: request.method,
-			url: request.url
+			method: request.method ?? "GET",
+			url: request.url ?? "/"
 		},
 		control: () => {}
 	};
-	const reader = request.body?.getReader();
 	const port = held(inbound);
-	(async () => {
-		if (reader === void 0) {
-			end();
-			return;
-		}
-		for (;;) {
-			const chunk = await reader.read();
-			if (chunk.done) {
-				end();
-				return;
-			}
-			for (const target of [...readers]) target(chunk.value);
-		}
-	})();
+	request.on("data", (chunk) => {
+		if (ended) return;
+		const bytes = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+		for (const target of readers) target(bytes);
+	});
+	request.on("end", end);
+	request.on("close", end);
+	request.on("error", end);
 	return port;
 }
-/** The response's channel, and the body a `Response` is built from.  One stream, written by the channel. */
-function responsePort() {
+/**
+* The response's channel: the head is one command, the body is what `send` writes, and `close` ends it.
+*
+* `node:http` is told the head separately from the body, which is why a handler states it before the first byte,
+* and why a handler that writes without stating one gets the 200 the wire would have given anyway.
+*/
+function responsePort(response) {
 	const readers = /* @__PURE__ */ new Set();
-	const closers = /* @__PURE__ */ new Set();
+	let stated = false;
 	let ended = false;
+	const state = (head) => {
+		if (stated) return;
+		stated = true;
+		response.writeHead(head.status, head.headers);
+	};
 	const end = () => {
 		if (ended) return;
 		ended = true;
-		for (const closer of [...closers]) closer(void 0);
+		for (const reader of readers) reader(void 0);
 	};
+	response.on("close", end);
 	return {
-		channel: {
-			async send(frame) {
-				if (ended) throw new Error("this response is over");
-				for (const reader of [...readers]) reader(frame);
-			},
-			onFrame() {
-				return () => {};
-			},
-			onClose(handler) {
-				if (ended) {
-					handler(void 0);
-					return () => {};
-				}
-				closers.add(handler);
-				return () => {
-					closers.delete(handler);
-				};
-			},
-			onError() {
-				return () => {};
-			},
-			async close() {
-				end();
-			},
-			info: {},
-			control: () => {}
+		async send(frame) {
+			if (ended) throw new Error("this response is over");
+			if (!stated) state({ status: 200 });
+			await new Promise((done) => {
+				response.write(frame, () => done());
+			});
 		},
-		body: new ReadableStream({
-			start(controller) {
-				readers.add((frame) => controller.enqueue(frame));
-				closers.add(() => {
-					try {
-						controller.close();
-					} catch {}
-				});
-			},
-			cancel() {
-				end();
+		onFrame() {
+			return () => {};
+		},
+		onClose(handler) {
+			if (ended) {
+				handler(void 0);
+				return () => {};
 			}
-		})
+			readers.add(handler);
+			return () => {
+				readers.delete(handler);
+			};
+		},
+		onError() {
+			return () => {};
+		},
+		async close() {
+			if (ended) return;
+			if (!stated) state({ status: 200 });
+			ended = true;
+			await new Promise((done) => {
+				response.end(() => done());
+			});
+		},
+		info: {},
+		control(command) {
+			const head = command.head;
+			if (typeof head !== "object" || head === null) return;
+			const status = head.status;
+			const headers = head.headers;
+			state({
+				status: typeof status === "number" ? status : 200,
+				...typeof headers === "object" && headers !== null ? { headers } : {}
+			});
+		}
 	};
 }
 //#endregion

package/dist/port/node.js.map

@@ -1 +1 @@
-{"version":3,"file":"node.js","names":[],"sources":["../../src/port/node/spawn.ts","../../src/port/node/listener.ts","../../src/port/node/process.ts"],"sourcesContent":["// ── a spawned command as a port ─────────────────────────────────────────────\n//\n// The child's stdout is the channel's frames, its stdin is what `send` writes, and the way it ended is the\n// channel's close reason.  Nothing else crosses: a child's stderr is discarded, because stderr is a stream the\n// child writes while it runs and not a fact about how it ended.  `spawnPorts` is the same process with both of\n// its output streams.\n//\n// Closing is stdin's end of stream first.  A program that reads its input exits on EOF, which is the polite\n// half; the process is killed `killAfterMs` later if it is still there, which is the other half.\nimport { spawn, type ChildProcess } from \"node:child_process\";\nimport type { Readable } from \"node:stream\";\nimport { held } from \"../held.js\";\nimport type { Channel } from \"../channel.js\";\n/** How a process ended: it exited with a code, or a signal terminated it. */\nexport type ProcessEnd =\n  | { readonly kind: \"exit\"; readonly code: number }\n  | { readonly kind: \"signal\"; readonly signal: string };\nexport interface SpawnPortOptions {\n  cwd?: string;\n  env?: NodeJS.ProcessEnv;\n  /** How long the process may live after its stdin is closed.  Default 5000 ms, then SIGKILL. */\n  killAfterMs?: number;\n}\nexport interface ProcessPorts {\n  readonly stdout: Channel<Uint8Array, ProcessEnd>;\n  readonly stderr: Channel<Uint8Array, ProcessEnd>;\n}\nconst DEFAULT_KILL_AFTER_MS = 5_000;\n/** A command as a channel of bytes: stdout in, stdin out, and its exit when it closes. */\nexport function spawnPort(\n  command: string[],\n  options: SpawnPortOptions = {},\n): Promise<Channel<Uint8Array, ProcessEnd>> {\n  return spawnPorts(command, options).then((ports) => ports.stdout);\n}\n/** One process, its stdout and its stderr, each a channel that ends with the same exit. */\nexport async function spawnPorts(\n  command: string[],\n  options: SpawnPortOptions = {},\n): Promise<ProcessPorts> {\n  const [file, ...args] = command;\n  if (file === undefined) throw new Error(\"spawnPort: there is no command to run\");\n  const child = spawn(file, args, { cwd: options.cwd, env: options.env, detached: true });\n  await started(child, file);\n  const out = bytesOf(child.stdout, \"stdout\");\n  const err = bytesOf(child.stderr, \"stderr\");\n  let exit: ProcessEnd | null = null;\n  let ended = false;\n  const closers = new Set<(reason: ProcessEnd) => void>();\n  const failers = new Set<(error: unknown) => void>();\n  const end = (why: ProcessEnd): void => {\n    if (ended) return;\n    ended = true;\n    exit = why;\n    for (const closer of [...closers]) closer(why);\n  };\n  child.on(\"error\", (error) => {\n    for (const failer of [...failers]) failer(error);\n  });\n  // `close` rather than `exit`: it follows the end of both streams, so no frame is lost behind the ending.\n  // Node gives a code or a signal and never both; that is the OS's one status word, split in two.\n  child.on(\"close\", (code, signal) =>\n    end(code !== null ? { kind: \"exit\", code } : { kind: \"signal\", signal: signal ?? \"unknown\" }),\n  );\n  const close = (reason?: string): Promise<void> => {\n    return shutdown(child, options.killAfterMs ?? DEFAULT_KILL_AFTER_MS).catch(() => undefined);\n  };\n  const onClose = (handler: (reason: ProcessEnd) => void): (() => void) => {\n    if (exit !== null) {\n      handler(exit);\n      return () => {};\n    }\n    closers.add(handler);\n    return () => {\n      closers.delete(handler);\n    };\n  };\n  const onError = (handler: (error: unknown) => void): (() => void) => {\n    failers.add(handler);\n    return () => {\n      failers.delete(handler);\n    };\n  };\n  // What only a process knows, and the one command it takes: a signal for the process and its children.\n  const facts = {\n    info: { pid: child.pid },\n    control: (command: Record<string, unknown>): void => {\n      const signal = command.signal;\n      if (typeof signal === \"string\") signalGroup(child, signal as NodeJS.Signals);\n    },\n  };\n  const stderr: Channel<Uint8Array, ProcessEnd> = {\n    send: () => Promise.reject(new Error(\"stderr carries the process's output; it has no input\")),\n    onFrame: err.onFrame,\n    onClose,\n    onError,\n    close,\n    ...facts,\n  };\n  const stdout: Channel<Uint8Array, ProcessEnd> = {\n    send: (frame: Uint8Array) => write(child, frame),\n    onFrame: out.onFrame,\n    onClose,\n    onError,\n    close,\n    ...facts,\n  };\n  return { stdout, stderr };\n}\n/** Resolves once the child exists, rejects when the command could not be started at all. */\nfunction started(child: ChildProcess, file: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    child.once(\"spawn\", () => resolve());\n    child.once(\"error\", (error: Error) =>\n      reject(new Error(`spawnPort: could not start ${file}: ${error.message}`)),\n    );\n  });\n}\n/** One output stream as the frames of a channel, kept until somebody reads them. */\nfunction bytesOf(stream: Readable | null, label: string): Channel<Uint8Array, ProcessEnd> {\n  const readers = new Set<(frame: Uint8Array) => void>();\n  const frames: Channel<Uint8Array, ProcessEnd> = {\n    send: () => Promise.reject(new Error(`${label} carries the process's output; it has no input`)),\n    onFrame(handler) {\n      readers.add(handler);\n      return () => {\n        readers.delete(handler);\n      };\n    },\n    // The stream ending is not the process ending: the port reports that, from the process's own exit.\n    onClose: () => () => {},\n    onError: () => () => {},\n    close: () => Promise.resolve(),\n    info: {},\n    control: () => {},\n  };\n  stream?.on(\"data\", (chunk: Buffer) => {\n    const bytes = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);\n    for (const reader of [...readers]) reader(bytes);\n  });\n  return held(frames);\n}\n/** Writes to the child's stdin, and settles when the write is out. */\nfunction write(child: ChildProcess, frame: Uint8Array): Promise<void> {\n  const stdin = child.stdin;\n  if (stdin === null || stdin.destroyed) return Promise.reject(new Error(\"the process's stdin is closed\"));\n  return new Promise((resolve, reject) => {\n    stdin.write(frame, (error) => (error === null || error === undefined ? resolve() : reject(error)));\n  });\n}\n/** Signal the child's process group, or the child alone when it has none. */\nfunction signalGroup(child: ChildProcess, signal: NodeJS.Signals): void {\n  const pid = child.pid;\n  if (pid === undefined) return;\n  try {\n    // The negative id is the group a detached child leads: its own children are in it too.\n    process.kill(-pid, signal);\n    return;\n  } catch {\n    /* no group of that number: this is one process after all */\n  }\n  try {\n    child.kill(signal);\n  } catch {\n    /* gone */\n  }\n}\n\n/** Ends stdin, and kills what is still there after the grace.  A caller in a hurry sends `signal` first. */\nasync function shutdown(child: ChildProcess, killAfterMs: number): Promise<void> {\n  if (child.exitCode !== null || child.signalCode !== null) return;\n  const closed = new Promise<void>((resolve) => {\n    child.once(\"close\", () => resolve());\n  });\n  child.stdin?.end();\n  const timer = setTimeout(() => {\n    if (child.exitCode === null && child.signalCode === null) signalGroup(child, \"SIGKILL\");\n  }, killAfterMs);\n  timer.unref?.();\n  await closed;\n  clearTimeout(timer);\n}\n","// ── an HTTP server as a port listener ───────────────────────────────────────\n//\n// One request is one pair of ports: the request's body is what the far side sends, the response's body is what we\n// send back, and the `Response` is built here because this is the only place that knows HTTP.  A handler above\n// sees a pair and nothing about the protocol.\n//\n// The body is built before the handler runs, because a server must answer with a `Response` in the same turn it is\n// asked: writes go into the response's stream, and closing the outbound port ends it.\n\nimport type { Channel } from \"../channel.js\";\nimport { held } from \"../held.js\";\nimport type { PortListener, PortPair } from \"../reactor.js\";\n\nexport interface HttpListenerOptions<Meta> {\n  port?: number;\n  hostname?: string;\n  /** Admission before a body is made: what it returns is the pair's meta; throwing refuses the request. */\n  identify?(request: Request): Meta | Promise<Meta>;\n}\n\n/** A port listener that is also an HTTP server: the port it bound, and the pairs it hands out. */\nexport interface HttpListener<Meta> extends PortListener<Uint8Array, Uint8Array, Meta> {\n  readonly port: number;\n}\n\n/** The Bun server this wraps, as little of it as is used here. */\ninterface BunServer {\n  readonly port: number;\n  stop(force?: boolean): void | Promise<void>;\n}\n\ninterface BunRuntime {\n  serve(options: {\n    port: number;\n    hostname?: string;\n    fetch(request: Request): Response | Promise<Response>;\n  }): BunServer;\n}\n\n/**\n * A server whose requests arrive as pairs of ports.\n *\n * `identify` runs before a pair exists, so a refused request costs no stream and the caller reads a status with\n * the reason in it.  The request body is the inbound port; the response body is the outbound one.\n */\nexport function httpListener<Meta = unknown>(options: HttpListenerOptions<Meta> = {}): HttpListener<Meta> {\n  const runtime = (globalThis as { Bun?: BunRuntime }).Bun;\n  if (runtime === undefined) throw new Error(\"httpListener: this needs Bun's server\");\n\n  const waiting: Array<{ accept: (pair: PortPair<Uint8Array, Uint8Array, Meta, void>) => void; refuse: (error: Error) => void }> = [];\n  const buffered: Array<PortPair<Uint8Array, Uint8Array, Meta, void>> = [];\n  let closed = false;\n  let server: BunServer | null = null;\n\n  const take = (pair: PortPair<Uint8Array, Uint8Array, Meta, void>): void => {\n    const next = waiting.shift();\n    if (next === undefined) {\n      buffered.push(pair);\n      return;\n    }\n    next.accept(pair);\n  };\n\n  const bound = runtime.serve({\n    port: options.port ?? 0,\n    hostname: options.hostname,\n    async fetch(request: Request): Promise<Response> {\n      if (closed) return new Response(\"listener is closed\", { status: 503 });\n      let meta: Meta;\n      try {\n        meta = options.identify === undefined ? (undefined as Meta) : await options.identify(request);\n      } catch (error) {\n        return new Response(error instanceof Error ? error.message : String(error), { status: 401 });\n      }\n      const outbound = responsePort();\n      take({ inbound: requestPort(request), outbound: outbound.channel, meta });\n      return new Response(outbound.body);\n    },\n  });\n  server = bound;\n\n  return {\n    get port() {\n      return server === null ? 0 : server.port;\n    },\n    accept(): Promise<PortPair<Uint8Array, Uint8Array, Meta, void>> {\n      const next = buffered.shift();\n      if (next !== undefined) return Promise.resolve(next);\n      if (closed) return Promise.reject(new Error(\"httpListener: closed\"));\n      return new Promise((accept, refuse) => {\n        waiting.push({ accept, refuse });\n      });\n    },\n    async close(): Promise<void> {\n      closed = true;\n      for (const next of waiting.splice(0)) next.refuse(new Error(\"httpListener: closed\"));\n      await server?.stop(true);\n      server = null;\n    },\n  };\n}\n\n/** The request's body as the inbound port: frames as they arrive, ended when the body is. */\nfunction requestPort(request: Request): Channel<Uint8Array, void> {\n  const readers = new Set<(frame: Uint8Array) => void>();\n  const closers = new Set<(reason: void) => void>();\n  let ended = false;\n\n  const end = (): void => {\n    if (ended) return;\n    ended = true;\n    for (const closer of [...closers]) closer(undefined);\n  };\n\n  const inbound: Channel<Uint8Array, void> = {\n    send: () => Promise.reject(new Error(\"a request body has no input; that side is the caller's\")),\n    onFrame(handler) {\n      readers.add(handler);\n      return () => {\n        readers.delete(handler);\n      };\n    },\n    onClose(handler) {\n      if (ended) {\n        handler(undefined);\n        return () => {};\n      }\n      closers.add(handler);\n      return () => {\n        closers.delete(handler);\n      };\n    },\n    onError() {\n      return () => {};\n    },\n    close: async () => {\n      await request.body?.cancel().catch(() => undefined);\n      end();\n    },\n    info: { method: request.method, url: request.url },\n    control: () => {},\n  };\n\n  const reader = request.body?.getReader();\n  // Held before the first read: a body can arrive in the same turn the pair is handed out.\n  const port = held(inbound);\n  void (async () => {\n    if (reader === undefined) {\n      end();\n      return;\n    }\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  })();\n\n  return port;\n}\n\n/** The response's channel, and the body a `Response` is built from.  One stream, written by the channel. */\nfunction responsePort(): { channel: Channel<Uint8Array, void>; body: ReadableStream<Uint8Array> } {\n  const readers = new Set<(frame: Uint8Array) => void>();\n  const closers = new Set<(reason: void) => void>();\n  let ended = false;\n\n  const end = (): void => {\n    if (ended) return;\n    ended = true;\n    for (const closer of [...closers]) closer(undefined);\n  };\n\n  const body = new ReadableStream<Uint8Array>({\n    start(controller) {\n      readers.add((frame) => controller.enqueue(frame));\n      closers.add(() => {\n        try {\n          controller.close();\n        } catch {\n          // Already closed by the platform: nothing here has an opinion about it.\n        }\n      });\n    },\n    cancel() {\n      // The caller stopped reading: the channel is over from this side too.\n      end();\n    },\n  });\n\n  const channel: Channel<Uint8Array, void> = {\n    async send(frame) {\n      if (ended) throw new Error(\"this response is over\");\n      for (const reader of [...readers]) reader(frame);\n    },\n    onFrame() {\n      return () => {};\n    },\n    onClose(handler) {\n      if (ended) {\n        handler(undefined);\n        return () => {};\n      }\n      closers.add(handler);\n      return () => {\n        closers.delete(handler);\n      };\n    },\n    onError() {\n      return () => {};\n    },\n    async close() {\n      end();\n    },\n    info: {},\n    control: () => {},\n  };\n\n  return { channel, body };\n}\n","// ── the two ports that wrap a process ───────────────────────────────────────\n//\n// Both are `portActor` over `spawnPorts`: one carries the child's octets as they are, the other puts the splitter\n// underneath and carries lines.  The names are the contract — an actor definition is spawned by name.\n\nimport type { Message } from \"../../types.js\";\nimport { portActor } from \"../actor.js\";\nimport type { Channel, Part } from \"../channel.js\";\nimport { splitChannel } from \"../split.js\";\nimport { spawnPort, type ProcessEnd } from \"./spawn.js\";\n\n/** How a process port is started. */\nexport interface ProcessPortArgs {\n  command: string[];\n  cwd?: string;\n  env?: NodeJS.ProcessEnv;\n  /** How long the process may live after its stdin is closed.  Default 5000 ms, then SIGKILL. */\n  killAfterMs?: number;\n}\n\n\n\n/** Parts as their text: what a line port carries.  Octets that came with a line are not text and are dropped. */\nfunction lines(parts: Channel<Part, ProcessEnd>): Channel<string, ProcessEnd> {\n  const readers = new Set<(line: string) => void>();\n  const closers = new Set<(reason: ProcessEnd) => void>();\n  const failers = new Set<(error: unknown) => void>();\n\n  parts.onFrame(({ line }) => {\n    for (const reader of [...readers]) reader(line);\n  });\n  parts.onClose((reason) => {\n    for (const closer of [...closers]) closer(reason);\n  });\n  parts.onError((error) => {\n    for (const failer of [...failers]) failer(error);\n  });\n\n  return {\n    send: (line) => parts.send({ line, bytes: null }),\n    onFrame(handler) {\n      readers.add(handler);\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) => parts.close(reason),\n    info: parts.info,\n    control: (command) => parts.control(command),\n  };\n}\n\n\n/** The child's octets, frame for frame. */\nexport const BinaryPort = portActor<ProcessPortArgs, Uint8Array, ProcessEnd>({\n  name: \"binary-port\",\n  open: (args) => spawnPort(args.command, args),\n});\n\n/** The same child cut into lines: the facts come with it, because the medium is the same one. */\nexport const Utf8Port = portActor<ProcessPortArgs, string, ProcessEnd>({\n  name: \"utf8-port\",\n  open: async (args) => lines(splitChannel(await spawnPort(args.command, args))),\n});\n"],"mappings":"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"}
+{"version":3,"file":"node.js","names":[],"sources":["../../src/port/node/spawn.ts","../../src/port/node/listener.ts","../../src/port/node/process.ts"],"sourcesContent":["// ── a spawned command as a port ─────────────────────────────────────────────\n//\n// The child's stdout is the channel's frames, its stdin is what `send` writes, and the way it ended is the\n// channel's close reason.  Nothing else crosses: a child's stderr is discarded, because stderr is a stream the\n// child writes while it runs and not a fact about how it ended.  `spawnPorts` is the same process with both of\n// its output streams.\n//\n// Closing is stdin's end of stream first.  A program that reads its input exits on EOF, which is the polite\n// half; the process is killed `killAfterMs` later if it is still there, which is the other half.\nimport { spawn, type ChildProcess } from \"node:child_process\";\nimport type { Readable } from \"node:stream\";\nimport { held } from \"../held.js\";\nimport type { Channel } from \"../channel.js\";\n/** How a process ended: it exited with a code, or a signal terminated it. */\nexport type ProcessEnd =\n  | { readonly kind: \"exit\"; readonly code: number }\n  | { readonly kind: \"signal\"; readonly signal: string };\nexport interface SpawnPortOptions {\n  cwd?: string;\n  env?: NodeJS.ProcessEnv;\n  /** How long the process may live after its stdin is closed.  Default 5000 ms, then SIGKILL. */\n  killAfterMs?: number;\n}\nexport interface ProcessPorts {\n  readonly stdout: Channel<Uint8Array, ProcessEnd>;\n  readonly stderr: Channel<Uint8Array, ProcessEnd>;\n}\nconst DEFAULT_KILL_AFTER_MS = 5_000;\n/** A command as a channel of bytes: stdout in, stdin out, and its exit when it closes. */\nexport function spawnPort(\n  command: string[],\n  options: SpawnPortOptions = {},\n): Promise<Channel<Uint8Array, ProcessEnd>> {\n  return spawnPorts(command, options).then((ports) => ports.stdout);\n}\n/** One process, its stdout and its stderr, each a channel that ends with the same exit. */\nexport async function spawnPorts(\n  command: string[],\n  options: SpawnPortOptions = {},\n): Promise<ProcessPorts> {\n  const [file, ...args] = command;\n  if (file === undefined) throw new Error(\"spawnPort: there is no command to run\");\n  const child = spawn(file, args, { cwd: options.cwd, env: options.env, detached: true });\n  await started(child, file);\n  const out = bytesOf(child.stdout, \"stdout\");\n  const err = bytesOf(child.stderr, \"stderr\");\n  let exit: ProcessEnd | null = null;\n  let ended = false;\n  const closers = new Set<(reason: ProcessEnd) => void>();\n  const failers = new Set<(error: unknown) => void>();\n  const end = (why: ProcessEnd): void => {\n    if (ended) return;\n    ended = true;\n    exit = why;\n    for (const closer of [...closers]) closer(why);\n  };\n  child.on(\"error\", (error) => {\n    for (const failer of [...failers]) failer(error);\n  });\n  // `close` rather than `exit`: it follows the end of both streams, so no frame is lost behind the ending.\n  // Node gives a code or a signal and never both; that is the OS's one status word, split in two.\n  child.on(\"close\", (code, signal) =>\n    end(code !== null ? { kind: \"exit\", code } : { kind: \"signal\", signal: signal ?? \"unknown\" }),\n  );\n  const close = (reason?: string): Promise<void> => {\n    return shutdown(child, options.killAfterMs ?? DEFAULT_KILL_AFTER_MS).catch(() => undefined);\n  };\n  const onClose = (handler: (reason: ProcessEnd) => void): (() => void) => {\n    if (exit !== null) {\n      handler(exit);\n      return () => {};\n    }\n    closers.add(handler);\n    return () => {\n      closers.delete(handler);\n    };\n  };\n  const onError = (handler: (error: unknown) => void): (() => void) => {\n    failers.add(handler);\n    return () => {\n      failers.delete(handler);\n    };\n  };\n  // What only a process knows, and the one command it takes: a signal for the process and its children.\n  const facts = {\n    info: { pid: child.pid },\n    control: (command: Record<string, unknown>): void => {\n      const signal = command.signal;\n      if (typeof signal === \"string\") signalGroup(child, signal as NodeJS.Signals);\n    },\n  };\n  const stderr: Channel<Uint8Array, ProcessEnd> = {\n    send: () => Promise.reject(new Error(\"stderr carries the process's output; it has no input\")),\n    onFrame: err.onFrame,\n    onClose,\n    onError,\n    close,\n    ...facts,\n  };\n  const stdout: Channel<Uint8Array, ProcessEnd> = {\n    send: (frame: Uint8Array) => write(child, frame),\n    onFrame: out.onFrame,\n    onClose,\n    onError,\n    close,\n    ...facts,\n  };\n  return { stdout, stderr };\n}\n/** Resolves once the child exists, rejects when the command could not be started at all. */\nfunction started(child: ChildProcess, file: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    child.once(\"spawn\", () => resolve());\n    child.once(\"error\", (error: Error) =>\n      reject(new Error(`spawnPort: could not start ${file}: ${error.message}`)),\n    );\n  });\n}\n/** One output stream as the frames of a channel, kept until somebody reads them. */\nfunction bytesOf(stream: Readable | null, label: string): Channel<Uint8Array, ProcessEnd> {\n  const readers = new Set<(frame: Uint8Array) => void>();\n  const frames: Channel<Uint8Array, ProcessEnd> = {\n    send: () => Promise.reject(new Error(`${label} carries the process's output; it has no input`)),\n    onFrame(handler) {\n      readers.add(handler);\n      return () => {\n        readers.delete(handler);\n      };\n    },\n    // The stream ending is not the process ending: the port reports that, from the process's own exit.\n    onClose: () => () => {},\n    onError: () => () => {},\n    close: () => Promise.resolve(),\n    info: {},\n    control: () => {},\n  };\n  stream?.on(\"data\", (chunk: Buffer) => {\n    const bytes = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);\n    for (const reader of [...readers]) reader(bytes);\n  });\n  return held(frames);\n}\n/** Writes to the child's stdin, and settles when the write is out. */\nfunction write(child: ChildProcess, frame: Uint8Array): Promise<void> {\n  const stdin = child.stdin;\n  if (stdin === null || stdin.destroyed) return Promise.reject(new Error(\"the process's stdin is closed\"));\n  return new Promise((resolve, reject) => {\n    stdin.write(frame, (error) => (error === null || error === undefined ? resolve() : reject(error)));\n  });\n}\n/** Signal the child's process group, or the child alone when it has none. */\nfunction signalGroup(child: ChildProcess, signal: NodeJS.Signals): void {\n  const pid = child.pid;\n  if (pid === undefined) return;\n  try {\n    // The negative id is the group a detached child leads: its own children are in it too.\n    process.kill(-pid, signal);\n    return;\n  } catch {\n    /* no group of that number: this is one process after all */\n  }\n  try {\n    child.kill(signal);\n  } catch {\n    /* gone */\n  }\n}\n\n/** Ends stdin, and kills what is still there after the grace.  A caller in a hurry sends `signal` first. */\nasync function shutdown(child: ChildProcess, killAfterMs: number): Promise<void> {\n  if (child.exitCode !== null || child.signalCode !== null) return;\n  const closed = new Promise<void>((resolve) => {\n    child.once(\"close\", () => resolve());\n  });\n  child.stdin?.end();\n  const timer = setTimeout(() => {\n    if (child.exitCode === null && child.signalCode === null) signalGroup(child, \"SIGKILL\");\n  }, killAfterMs);\n  timer.unref?.();\n  await closed;\n  clearTimeout(timer);\n}\n","// ── an HTTP server as a port listener ───────────────────────────────────────\n//\n// One request is one pair of ports: the request's body is what the far side sends, the response's body is what we\n// send back.  A handler above sees a pair and nothing about the protocol; this is the only place that knows HTTP.\n//\n// The runtime is `node:http`, which is the whole of what a listener needs: a request is an async iterable of\n// chunks, a response takes a head and then a body, and an upgrade arrives on the same server.  Nothing here asks\n// what runs it.\n\nimport { createServer, type IncomingMessage, type Server, type ServerResponse } from \"node:http\";\nimport type { Channel } from \"../channel.js\";\nimport { HttpRefusal } from \"../fetch.js\";\nimport { held } from \"../held.js\";\nimport type { PortListener, PortPair } from \"../reactor.js\";\n\nexport interface HttpListenerOptions<Meta> {\n  port?: number;\n  hostname?: string;\n  /** Admission before a body is made: what it returns is the pair's meta; throwing refuses the request. */\n  identify?(request: Request): Meta | Promise<Meta>;\n}\n\n/** A port listener that is also an HTTP server: the port it bound, and the pairs it hands out. */\nexport interface HttpListener<Meta> extends PortListener<Uint8Array, Uint8Array, Meta> {\n  readonly port: number;\n  /** The server itself, for what only a consumer of it can do — a WebSocket upgrade, a second route. */\n  readonly server: Server;\n}\n\n/** What a response says before its body: the status and the headers a handler chose. */\nexport interface ResponseHead {\n  readonly status: number;\n  readonly headers?: HeadersInit;\n}\n\n/**\n * A server whose requests arrive as pairs of ports.\n *\n * `identify` runs before a pair exists, so a refused request costs no stream and the caller reads a status with\n * the reason in it.  The request body is the inbound port; the response body is the outbound one, and the head\n * is one command on it.\n */\nexport function httpListener<Meta = unknown>(options: HttpListenerOptions<Meta> = {}): HttpListener<Meta> {\n  const waiting: Array<{\n    accept: (pair: PortPair<Uint8Array, Uint8Array, Meta, void>) => void;\n    refuse: (error: Error) => void;\n  }> = [];\n  const buffered: Array<PortPair<Uint8Array, Uint8Array, Meta, void>> = [];\n  let closed = false;\n\n  const take = (pair: PortPair<Uint8Array, Uint8Array, Meta, void>): void => {\n    const next = waiting.shift();\n    if (next === undefined) {\n      buffered.push(pair);\n      return;\n    }\n    next.accept(pair);\n  };\n\n  const server = createServer((request: IncomingMessage, response: ServerResponse) => {\n    void (async () => {\n      if (closed) {\n        response.writeHead(503).end(\"the listener is closed\");\n        return;\n      }\n      let meta: Meta;\n      try {\n        meta = options.identify === undefined ? (undefined as Meta) : await options.identify(asRequest(request));\n      } catch (error) {\n        // A refusal is an answer: a `HttpRefusal` says which status, anything else is the listener's own 401.\n        const status = error instanceof HttpRefusal ? error.status : 401;\n        response.writeHead(status).end(error instanceof Error ? error.message : String(error));\n        return;\n      }\n      const outbound = responsePort(response);\n      take({ inbound: requestPort(request), outbound, meta });\n    })();\n  });\n  server.listen(options.port ?? 0, options.hostname);\n\n  return {\n    get port() {\n      const address = server.address();\n      return typeof address === \"object\" && address !== null ? address.port : 0;\n    },\n    get server() {\n      return server;\n    },\n    accept(): Promise<PortPair<Uint8Array, Uint8Array, Meta, void>> {\n      const next = buffered.shift();\n      if (next !== undefined) return Promise.resolve(next);\n      if (closed) return Promise.reject(new Error(\"httpListener: closed\"));\n      return new Promise((accept, refuse) => {\n        waiting.push({ accept, refuse });\n      });\n    },\n    async close(): Promise<void> {\n      closed = true;\n      for (const next of waiting.splice(0)) next.refuse(new Error(\"httpListener: closed\"));\n      server.closeAllConnections?.();\n      await new Promise<void>((done) => server.close(() => done()));\n    },\n  };\n}\n\n/** The request as `identify` sees it: method, url and headers, and no body — the body is the inbound port. */\nfunction asRequest(request: IncomingMessage): Request {\n  const host = request.headers.host ?? \"localhost\";\n  const method = request.method ?? \"GET\";\n  return new Request(`http://${host}${request.url ?? \"/\"}`, {\n    method,\n    headers: Object.entries(request.headers).flatMap(([name, value]) =>\n      value === undefined ? [] : [[name, Array.isArray(value) ? value.join(\", \") : value] as [string, string]],\n    ),\n  });\n}\n\n/** The request's body as the inbound port: frames as they arrive, ended when the body is. */\nfunction requestPort(request: IncomingMessage): Channel<Uint8Array, void> {\n  const readers = new Set<(frame: Uint8Array) => void>();\n  const closers = new Set<(reason: void) => void>();\n  let ended = false;\n\n  const end = (): void => {\n    if (ended) return;\n    ended = true;\n    for (const closer of closers) closer(undefined);\n  };\n\n  const inbound: Channel<Uint8Array, void> = {\n    send: () => Promise.reject(new Error(\"a request body has no input; that side is the caller's\")),\n    onFrame(handler) {\n      readers.add(handler);\n      return () => {\n        readers.delete(handler);\n      };\n    },\n    onClose(handler) {\n      if (ended) {\n        handler(undefined);\n        return () => {};\n      }\n      closers.add(handler);\n      return () => {\n        closers.delete(handler);\n      };\n    },\n    onError() {\n      return () => {};\n    },\n    close: async () => {\n      end();\n      request.destroy();\n    },\n    info: { method: request.method ?? \"GET\", url: request.url ?? \"/\" },\n    control: () => {},\n  };\n\n  // Held before the first read: a body can arrive in the same turn the pair is handed out.\n  const port = held(inbound);\n  request.on(\"data\", (chunk: Buffer) => {\n    if (ended) return;\n    const bytes = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);\n    for (const target of readers) target(bytes);\n  });\n  request.on(\"end\", end);\n  request.on(\"close\", end);\n  request.on(\"error\", end);\n  return port;\n}\n\n/**\n * The response's channel: the head is one command, the body is what `send` writes, and `close` ends it.\n *\n * `node:http` is told the head separately from the body, which is why a handler states it before the first byte,\n * and why a handler that writes without stating one gets the 200 the wire would have given anyway.\n */\nfunction responsePort(response: ServerResponse): Channel<Uint8Array, void> {\n  const readers = new Set<(reason: void) => void>();\n  let stated = false;\n  let ended = false;\n\n  const state = (head: ResponseHead): void => {\n    if (stated) return;\n    stated = true;\n    response.writeHead(head.status, head.headers as Record<string, string> | undefined);\n  };\n\n  const end = (): void => {\n    if (ended) return;\n    ended = true;\n    for (const reader of readers) reader(undefined);\n  };\n  // The client leaving is an ending of this channel too: a handler writing into it learns at once.\n  response.on(\"close\", end);\n\n  return {\n    async send(frame) {\n      if (ended) throw new Error(\"this response is over\");\n      if (!stated) state({ status: 200 });\n      await new Promise<void>((done) => {\n        response.write(frame, () => done());\n      });\n    },\n    onFrame() {\n      return () => {};\n    },\n    onClose(handler) {\n      if (ended) {\n        handler(undefined);\n        return () => {};\n      }\n      readers.add(handler);\n      return () => {\n        readers.delete(handler);\n      };\n    },\n    onError() {\n      return () => {};\n    },\n    async close() {\n      if (ended) return;\n      if (!stated) state({ status: 200 });\n      ended = true;\n      await new Promise<void>((done) => {\n        response.end(() => done());\n      });\n    },\n    info: {},\n    control(command) {\n      const head = command.head;\n      if (typeof head !== \"object\" || head === null) return;\n      const status = (head as { status?: unknown }).status;\n      const headers = (head as { headers?: unknown }).headers;\n      state({\n        status: typeof status === \"number\" ? status : 200,\n        ...(typeof headers === \"object\" && headers !== null ? { headers: headers as HeadersInit } : {}),\n      });\n    },\n  };\n}\n","// ── the two ports that wrap a process ───────────────────────────────────────\n//\n// Both are `portActor` over `spawnPorts`: one carries the child's octets as they are, the other puts the splitter\n// underneath and carries lines.  The names are the contract — an actor definition is spawned by name.\n\nimport type { Message } from \"../../types.js\";\nimport { portActor } from \"../actor.js\";\nimport type { Channel, Part } from \"../channel.js\";\nimport { splitChannel } from \"../split.js\";\nimport { spawnPort, type ProcessEnd } from \"./spawn.js\";\n\n/** How a process port is started. */\nexport interface ProcessPortArgs {\n  command: string[];\n  cwd?: string;\n  env?: NodeJS.ProcessEnv;\n  /** How long the process may live after its stdin is closed.  Default 5000 ms, then SIGKILL. */\n  killAfterMs?: number;\n}\n\n\n\n/** Parts as their text: what a line port carries.  Octets that came with a line are not text and are dropped. */\nfunction lines(parts: Channel<Part, ProcessEnd>): Channel<string, ProcessEnd> {\n  const readers = new Set<(line: string) => void>();\n  const closers = new Set<(reason: ProcessEnd) => void>();\n  const failers = new Set<(error: unknown) => void>();\n\n  parts.onFrame(({ line }) => {\n    for (const reader of [...readers]) reader(line);\n  });\n  parts.onClose((reason) => {\n    for (const closer of [...closers]) closer(reason);\n  });\n  parts.onError((error) => {\n    for (const failer of [...failers]) failer(error);\n  });\n\n  return {\n    send: (line) => parts.send({ line, bytes: null }),\n    onFrame(handler) {\n      readers.add(handler);\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) => parts.close(reason),\n    info: parts.info,\n    control: (command) => parts.control(command),\n  };\n}\n\n\n/** The child's octets, frame for frame. */\nexport const BinaryPort = portActor<ProcessPortArgs, Uint8Array, ProcessEnd>({\n  name: \"binary-port\",\n  open: (args) => spawnPort(args.command, args),\n});\n\n/** The same child cut into lines: the facts come with it, because the medium is the same one. */\nexport const Utf8Port = portActor<ProcessPortArgs, string, ProcessEnd>({\n  name: \"utf8-port\",\n  open: async (args) => lines(splitChannel(await spawnPort(args.command, args))),\n});\n"],"mappings":"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"}