posipaki 0.47.0 → 0.48.0

package/dist/port/node.js

@@ -0,0 +1,353 @@
+import { n as held, r as splitChannel, t as portActor } from "../actor-C8DzeQeT.js";
+import { spawn } from "node:child_process";
+//#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. */
+function spawnPort(command, options = {}) {
+	return spawnPorts(command, options).then((ports) => ports.stdout);
+}
+/** One process, its stdout and its stderr, each a channel that ends with the same exit. */
+async function spawnPorts(command, options = {}) {
+	const [file, ...args] = command;
+	if (file === void 0) throw new Error("spawnPort: there is no command to run");
+	const child = spawn(file, args, {
+		cwd: options.cwd,
+		env: options.env
+	});
+	await started(child, file);
+	const out = bytesOf(child.stdout, "stdout");
+	const err = bytesOf(child.stderr, "stderr");
+	let exit = null;
+	let ended = false;
+	const closers = /* @__PURE__ */ new Set();
+	const failers = /* @__PURE__ */ new Set();
+	const end = (why) => {
+		if (ended) return;
+		ended = true;
+		exit = why;
+		for (const closer of [...closers]) closer(why);
+	};
+	child.on("error", (error) => {
+		for (const failer of [...failers]) failer(error);
+	});
+	child.on("close", (code, signal) => end(code !== null ? {
+		kind: "exit",
+		code
+	} : {
+		kind: "signal",
+		signal: signal ?? "unknown"
+	}));
+	const close = (reason) => {
+		return shutdown(child, options.killAfterMs ?? DEFAULT_KILL_AFTER_MS).catch(() => void 0);
+	};
+	const onClose = (handler) => {
+		if (exit !== null) {
+			handler(exit);
+			return () => {};
+		}
+		closers.add(handler);
+		return () => {
+			closers.delete(handler);
+		};
+	};
+	const onError = (handler) => {
+		failers.add(handler);
+		return () => {
+			failers.delete(handler);
+		};
+	};
+	const stderr = {
+		send: () => Promise.reject(/* @__PURE__ */ new Error("stderr carries the process's output; it has no input")),
+		onFrame: err.onFrame,
+		onClose,
+		onError,
+		close
+	};
+	return {
+		stdout: {
+			send: (frame) => write(child, frame),
+			onFrame: out.onFrame,
+			onClose,
+			onError,
+			close
+		},
+		stderr
+	};
+}
+/** Resolves once the child exists, rejects when the command could not be started at all. */
+function started(child, file) {
+	return new Promise((resolve, reject) => {
+		child.once("spawn", () => resolve());
+		child.once("error", (error) => reject(/* @__PURE__ */ new Error(`spawnPort: could not start ${file}: ${error.message}`)));
+	});
+}
+/** One output stream as the frames of a channel, kept until somebody reads them. */
+function bytesOf(stream, label) {
+	const readers = /* @__PURE__ */ new Set();
+	const frames = {
+		send: () => Promise.reject(/* @__PURE__ */ new Error(`${label} carries the process's output; it has no input`)),
+		onFrame(handler) {
+			readers.add(handler);
+			return () => {
+				readers.delete(handler);
+			};
+		},
+		onClose: () => () => {},
+		onError: () => () => {},
+		close: () => Promise.resolve()
+	};
+	stream?.on("data", (chunk) => {
+		const bytes = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+		for (const reader of [...readers]) reader(bytes);
+	});
+	return held(frames);
+}
+/** Writes to the child's stdin, and settles when the write is out. */
+function write(child, frame) {
+	const stdin = child.stdin;
+	if (stdin === null || stdin.destroyed) return Promise.reject(/* @__PURE__ */ new Error("the process's stdin is closed"));
+	return new Promise((resolve, reject) => {
+		stdin.write(frame, (error) => error === null || error === void 0 ? resolve() : reject(error));
+	});
+}
+/** Ends stdin, and kills what is still there after the grace. */
+async function shutdown(child, killAfterMs) {
+	if (child.exitCode !== null || child.signalCode !== null) return;
+	const closed = new Promise((resolve) => {
+		child.once("close", () => resolve());
+	});
+	child.stdin?.end();
+	const timer = setTimeout(() => {
+		if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+	}, killAfterMs);
+	timer.unref?.();
+	await closed;
+	clearTimeout(timer);
+}
+//#endregion
+//#region src/port/node/process.ts
+/** Parts as their text: what a line port carries.  Octets that came with a line are not text and are dropped. */
+function lines(parts) {
+	const readers = /* @__PURE__ */ new Set();
+	const closers = /* @__PURE__ */ new Set();
+	const failers = /* @__PURE__ */ new Set();
+	parts.onFrame(({ line }) => {
+		for (const reader of [...readers]) reader(line);
+	});
+	parts.onClose((reason) => {
+		for (const closer of [...closers]) closer(reason);
+	});
+	parts.onError((error) => {
+		for (const failer of [...failers]) failer(error);
+	});
+	return {
+		send: (line) => parts.send({
+			line,
+			bytes: null
+		}),
+		onFrame(handler) {
+			readers.add(handler);
+			return () => {
+				readers.delete(handler);
+			};
+		},
+		onClose(handler) {
+			closers.add(handler);
+			return () => {
+				closers.delete(handler);
+			};
+		},
+		onError(handler) {
+			failers.add(handler);
+			return () => {
+				failers.delete(handler);
+			};
+		},
+		close: (reason) => parts.close(reason)
+	};
+}
+/** The child's octets, frame for frame. */
+const BinaryPort = portActor({
+	name: "binary-port",
+	open: (args) => spawnPort(args.command, args)
+});
+/** The same child, cut into lines. */
+const Utf8Port = portActor({
+	name: "utf8-port",
+	open: async (args) => lines(splitChannel(await spawnPort(args.command, args)))
+});
+//#endregion
+//#region src/port/node/listener.ts
+/**
+* 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.
+*/
+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) {
+			buffered.push(pair);
+			return;
+		}
+		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 });
+			let meta;
+			try {
+				meta = options.identify === void 0 ? void 0 : await options.identify(request);
+			} catch (error) {
+				return new Response(error instanceof Error ? error.message : String(error), { status: 401 });
+			}
+			const outbound = responsePort();
+			take({
+				inbound: requestPort(request),
+				outbound: outbound.channel,
+				meta
+			});
+			return new Response(outbound.body);
+		}
+	});
+	return {
+		get port() {
+			return server === null ? 0 : server.port;
+		},
+		accept() {
+			const next = buffered.shift();
+			if (next !== void 0) return Promise.resolve(next);
+			if (closed) return Promise.reject(/* @__PURE__ */ new Error("httpListener: closed"));
+			return new Promise((accept, refuse) => {
+				waiting.push({
+					accept,
+					refuse
+				});
+			});
+		},
+		async close() {
+			closed = true;
+			for (const next of waiting.splice(0)) next.refuse(/* @__PURE__ */ new Error("httpListener: closed"));
+			await server?.stop(true);
+			server = null;
+		}
+	};
+}
+/** 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();
+	const closers = /* @__PURE__ */ new Set();
+	let ended = false;
+	const end = () => {
+		if (ended) return;
+		ended = true;
+		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")),
+		onFrame(handler) {
+			readers.add(handler);
+			return () => {
+				readers.delete(handler);
+			};
+		},
+		onClose(handler) {
+			if (ended) {
+				handler(void 0);
+				return () => {};
+			}
+			closers.add(handler);
+			return () => {
+				closers.delete(handler);
+			};
+		},
+		onError() {
+			return () => {};
+		},
+		close: async () => {
+			await request.body?.cancel().catch(() => void 0);
+			end();
+		}
+	};
+	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);
+		}
+	})();
+	return port;
+}
+/** The response's channel, and the body a `Response` is built from.  One stream, written by the channel. */
+function responsePort() {
+	const readers = /* @__PURE__ */ new Set();
+	const closers = /* @__PURE__ */ new Set();
+	let ended = false;
+	const end = () => {
+		if (ended) return;
+		ended = true;
+		for (const closer of [...closers]) closer(void 0);
+	};
+	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();
+			}
+		},
+		body: new ReadableStream({
+			start(controller) {
+				readers.add((frame) => controller.enqueue(frame));
+				closers.add(() => {
+					try {
+						controller.close();
+					} catch {}
+				});
+			},
+			cancel() {
+				end();
+			}
+		})
+	};
+}
+//#endregion
+export { BinaryPort, Utf8Port, httpListener, spawnPort, spawnPorts };
+
+//# sourceMappingURL=node.js.map

package/dist/port/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","names":[],"sources":["../../src/port/node/spawn.ts","../../src/port/node/process.ts","../../src/port/node/listener.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 });\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  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  };\n  return {\n    stdout: { send: (frame) => write(child, frame), onFrame: out.onFrame, onClose, onError, close },\n    stderr,\n  };\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  };\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/** Ends stdin, and kills what is still there after the grace. */\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) child.kill(\"SIGKILL\");\n  }, killAfterMs);\n  timer.unref?.();\n  await closed;\n  clearTimeout(timer);\n}\n","// ── the two ports that wrap a process ───────────────────────────────────────\n//\n// Both are `portActor` over `spawnPort`: 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  };\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. */\nexport const Utf8Port = portActor<ProcessPortArgs, string, ProcessEnd>({\n  name: \"utf8-port\",\n  open: async (args) => lines(splitChannel(await spawnPort(args.command, args))),\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  };\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  };\n\n  return { channel, body };\n}\n"],"mappings":"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"}