posipaki 0.34.0 → 0.35.1

package/dist/{channel-HCjngMq_.d.ts → client-DHI-6XPF.d.ts}

@@ -1,4 +1,5 @@
 import { r as Message } from "./types-CsE8xK3a.js";
+import { h as MethodOptions, l as ActorDefinition, p as HandlerOptions, v as ReflectionOptions } from "./hooks-CfQ8EhKW.js";
 //#region src/remote/channel.d.ts
 interface StringTransport {
   send(frame: string): void | Promise<void>;
@@ -38,5 +39,9 @@ declare function isExit(msg: Record<string, unknown>): msg is {
   };
 };
 //#endregion
-export { isMsg as a, isInit as i, StringTransport as n, isProto as o, isExit as r, isState as s, Channel as t };
-//# sourceMappingURL=channel-HCjngMq_.d.ts.map
+//#region src/remote/client.d.ts
+type ClientSpawner<Args> = (args: Args) => Promise<Channel>;
+declare function remoteClient<Args, State, InMsg extends Message, OutMsg extends Message, Methods extends MethodOptions = MethodOptions, Handlers extends HandlerOptions<InMsg> = HandlerOptions<InMsg>, R extends ReflectionOptions = ReflectionOptions>(name: string, spawner: ClientSpawner<Args>): ActorDefinition<Args, State, InMsg, OutMsg, R>;
+//#endregion
+export { isExit as a, isProto as c, StringTransport as i, isState as l, remoteClient as n, isInit as o, Channel as r, isMsg as s, ClientSpawner as t };
+//# sourceMappingURL=client-DHI-6XPF.d.ts.map

package/dist/client-DHI-6XPF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-DHI-6XPF.d.ts","names":[],"sources":["../src/remote/channel.ts","../src/remote/client.ts"],"mappings":";;;UAUiB;EACf,KAAK,uBAAuB;EAC5B,UAAU,UAAU;EACpB;;EAEA,QAAQ;EACR,SAAS;;UAGM;EACf,KAAK,OAAO,iCAAiC;EAC7C,UAAU,UAAU,OAAO;EAC3B;;EAEA,QAAQ;EACR,SAAS;;iBAKK,QAAQ,KAAK,0BAA0B;EAAS;;iBAGhD,OAAO,KAAK,0BAA0B;EAAS,OAAO;;iBAGtD,QAAQ,KAAK,0BAA0B;EAAS,QAAQ;;iBAGxD,MACd,KAAK,0BACJ;EAAS;IAAQ;IAAkB,MAAM;;;iBAG5B,OACd,KAAK,0BACJ;EAAS;IAAS;IAAc;;;;;KC/BvB,cAAc,SAAS,MAAM,SAAS,QAAQ;iBAE1C,aACd,MACA,OACA,cAAc,SACd,eAAe,SACf,gBAAgB,gBAAgB,eAChC,iBAAiB,eAAe,SAAS,eAAe,QACxD,UAAU,oBAAoB,mBAE9B,cACA,SAAS,cAAc,QACtB,gBAAgB,MAAM,OAAO,OAAO,QAAQ"}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/{client-D23TlXPf.js → json1-DzPx9oX3.js}

@@ -1,6 +1,22 @@
 import { t as defineActor } from "./define-actor-DqOW2StX.js";
 import { s as stopPropagation } from "./hooks-CgXhmY4r.js";
-import { a as isExit, l as isState, o as isInit, s as isMsg } from "./json1-DS3xxg13.js";
+//#region src/remote/channel.ts
+function isProto(msg) {
+	return "$proto" in msg;
+}
+function isInit(msg) {
+	return "$init" in msg;
+}
+function isState(msg) {
+	return "$state" in msg;
+}
+function isMsg(msg) {
+	return "$msg" in msg;
+}
+function isExit(msg) {
+	return "$exit" in msg;
+}
+//#endregion
 //#region src/remote/server.ts
 function makeSender(fromName, parentName, parentId) {
 	if (parentId && fromName === parentName) return {
@@ -151,6 +167,34 @@ function remoteClient(name, spawner) {
 	});
 }
 //#endregion
-export { makeSender as n, serveRemoteActor as r, remoteClient as t };
+//#region src/remote/protocols/json1.ts
+const VERSION = "json.v1";
+function encode(frame) {
+	return JSON.stringify(frame);
+}
+function decode(str) {
+	return JSON.parse(str);
+}
+function json1Channel(transport) {
+	return {
+		send(frame) {
+			return transport.send(encode(frame));
+		},
+		onMessage(handler) {
+			transport.onMessage((str) => handler(decode(str)));
+		},
+		removeHandler() {
+			transport.removeHandler();
+		},
+		onClose(handler) {
+			transport.onClose(handler);
+		},
+		close() {
+			return transport.close();
+		}
+	};
+}
+//#endregion
+export { remoteClient as a, isExit as c, isProto as d, isState as f, json1Channel as i, isInit as l, decode as n, makeSender as o, encode as r, serveRemoteActor as s, VERSION as t, isMsg as u };
 
-//# sourceMappingURL=client-D23TlXPf.js.map
+//# sourceMappingURL=json1-DzPx9oX3.js.map

package/dist/json1-DzPx9oX3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json1-DzPx9oX3.js","names":[],"sources":["../src/remote/channel.ts","../src/remote/server.ts","../src/remote/client.ts","../src/remote/protocols/json1.ts"],"sourcesContent":["// ── Frame channel ──────────────────────────────────────────────────────────\n//\n// The seam's shared vocabulary. A StringTransport moves encoded frames\n// (strings); a Channel moves decoded frame objects. The frame guards narrow a\n// decoded frame to one of the `$`-key shapes. server.ts / client.ts speak only\n// in Channels and these guards — they never see a specific protocol or\n// transport.\n\nimport type { Message } from \"../types.js\";\n\nexport interface StringTransport {\n  send(frame: string): void | Promise<void>;\n  onMessage(handler: (frame: string) => void): void;\n  removeHandler(): void;\n  /** Fires when the peer disconnects (transport closes from the other side). */\n  onClose(handler: () => void): void;\n  close(): Promise<void>;\n}\n\nexport interface Channel {\n  send(frame: Record<string, unknown>): void | Promise<void>;\n  onMessage(handler: (frame: Record<string, unknown>) => void): void;\n  removeHandler(): void;\n  /** Fires when the peer disconnects (transport closes from the other side). */\n  onClose(handler: () => void): void;\n  close(): Promise<void>;\n}\n\n// ── frame guards ──────────────────────────────────────────────────────────\n\nexport function isProto(msg: Record<string, unknown>): msg is { $proto: string } {\n  return \"$proto\" in msg;\n}\nexport function isInit(msg: Record<string, unknown>): msg is { $init: Record<string, unknown> } {\n  return \"$init\" in msg;\n}\nexport function isState(msg: Record<string, unknown>): msg is { $state: Record<string, unknown> } {\n  return \"$state\" in msg;\n}\nexport function isMsg(\n  msg: Record<string, unknown>,\n): msg is { $msg: { fromName: string; body: Message } } {\n  return \"$msg\" in msg;\n}\nexport function isExit(\n  msg: Record<string, unknown>,\n): msg is { $exit: { code: number; state: unknown } } {\n  return \"$exit\" in msg;\n}\n","// ── Server side of the seam ────────────────────────────────────────────────\n//\n// serveRemoteActor serves a posipaki actor over a frame Channel produced by a\n// spawner. It knows only the frame vocabulary (channel.ts) — no protocol, no\n// transport, no spawner. The spawner has already done the $proto handshake.\n\nimport type { ActorDefinition, ReflectionOptions } from \"../actor-types.js\";\nimport type { Message } from \"../types.js\";\nimport type { Channel } from \"./channel.js\";\nimport { isInit, isMsg } from \"./channel.js\";\n\nexport type Spawner = () => Promise<Channel>;\n\nexport function makeSender(\n  fromName: string,\n  parentName: string | null,\n  parentId: symbol | null,\n): { fromName: string; fromId: symbol } {\n  if (parentId && fromName === parentName) {\n    return { fromName, fromId: parentId };\n  }\n  return { fromName, fromId: Symbol() };\n}\n\nexport async function serveRemoteActor<\n  Args,\n  State,\n  InMsg extends Message,\n  OutMsg extends Message,\n  R extends ReflectionOptions,\n>(actor: ActorDefinition<Args, State, InMsg, OutMsg, R>, spawner: Spawner): Promise<void> {\n  const channel = await spawner();\n\n  // await $init\n  const initFrame = await new Promise<Record<string, unknown>>((resolve) => {\n    channel.onMessage((frame) => resolve(frame));\n  });\n  channel.removeHandler();\n  if (!isInit(initFrame)) {\n    throw new Error(\"serveRemoteActor: expected $init\");\n  }\n\n  const init = initFrame.$init;\n  const parentName = (init.parentName as string) ?? null;\n  const parentIdName = (init.parentIdName as string) ?? null;\n  const parentId = parentIdName ? Symbol.for(parentIdName) : null;\n  const { parentName: _pn, parentIdName: _pid, ...initArgs } = init;\n\n  const proc = await actor.spawn(initArgs as unknown as Args, {\n    name: \"remote\",\n    parentName,\n    parentId,\n  });\n\n  // bridge actor output → channel\n  proc.subscribe(\"message\", async (msg, sender) => {\n    try {\n      await channel.send({ $msg: { fromName: sender.fromName, body: msg } });\n    } catch {\n      console.error(\"Error sending out the message\");\n    }\n  });\n  proc.subscribe(\"state\", async () => {\n    try {\n      await channel.send({ $state: proc.state as Record<string, unknown> });\n    } catch (e) {\n      console.error(\"Error sending out the message\", e);\n    }\n  });\n\n  await proc.ready();\n  await channel.send({ $state: proc.state as Record<string, unknown> });\n\n  // bridge channel input → actor\n  channel.onMessage((frame) => {\n    if (isMsg(frame)) {\n      const { fromName, body } = frame.$msg;\n      proc.send(body as InMsg, makeSender(fromName, parentName, parentId));\n    }\n  });\n\n  // await actor exit, announce it, close\n  let code = 0;\n  try {\n    await proc.wait();\n  } catch (err) {\n    console.error(\"server actor error:\", err);\n    code = 1;\n  }\n  await channel.send({ $exit: { code, state: proc.state } });\n  await channel.close();\n}\n","// ── Client side of the seam ────────────────────────────────────────────────\n//\n// remoteClient builds a posipaki actor that talks to a remote server through a\n// frame Channel produced by a spawner. It knows only the frame vocabulary\n// (channel.ts) — no protocol, no transport, no spawner. The spawner has\n// already done the $proto handshake.\n\nimport { defineActor } from \"../define-actor.js\";\nimport { stopPropagation } from \"../hooks.js\";\nimport type { HookResult } from \"../hooks.js\";\nimport type { ActorDefinition, HandlerOptions, MethodOptions, ReflectionOptions } from \"../actor-types.js\";\nimport type { Message } from \"../types.js\";\nimport type { Channel } from \"./channel.js\";\nimport { isState, isMsg, isExit } from \"./channel.js\";\n\nexport type ClientSpawner<Args> = (args: Args) => Promise<Channel>;\n\nexport function remoteClient<\n  Args,\n  State,\n  InMsg extends Message,\n  OutMsg extends Message,\n  Methods extends MethodOptions = MethodOptions,\n  Handlers extends HandlerOptions<InMsg> = HandlerOptions<InMsg>,\n  R extends ReflectionOptions = ReflectionOptions,\n>(\n  name: string,\n  spawner: ClientSpawner<Args>,\n): ActorDefinition<Args, State, InMsg, OutMsg, R> {\n  const proxyDef = defineActor<\n    Args,\n    { public: State; private: { channel: Channel; exitPromise: Promise<{ code: number | null; state: State }>; fromName: string } },\n    InMsg,\n    OutMsg,\n    Methods,\n    Handlers,\n    R\n  >({\n    name,\n    handlers: {} as unknown as Handlers,\n    async setup(args: Args) {\n      const channel = await spawner(args);\n      const fromName = name;\n      await channel.send({\n        $init: { ...(args as unknown as Record<string, unknown>), parentName: fromName, parentIdName: fromName },\n      });\n\n      let currentState: Record<string, unknown> = {};\n      await new Promise<void>((resolve) => {\n        channel.onMessage((frame) => {\n          if (isState(frame)) {\n            Object.assign(currentState, frame.$state);\n            resolve();\n          }\n        });\n      });\n      channel.removeHandler();\n\n      let exitResolver: ((v: { code: number | null; state: State }) => void) | null = null;\n      const exitPromise = new Promise<{ code: number | null; state: State }>((resolve) => {\n        exitResolver = resolve;\n      });\n\n      channel.onMessage((frame) => {\n        if (isState(frame)) {\n          Object.assign(currentState, frame.$state);\n          // $state frames arrive outside this actor's dispatch loop; notify\n          // state subscribers so observers (Vue, nextState, …) see the change.\n          this.ctx.notify();\n        } else if (isMsg(frame)) {\n          this.emit(frame.$msg.body as OutMsg);\n        } else if (isExit(frame)) {\n          if (exitResolver) {\n            exitResolver({ code: frame.$exit.code, state: frame.$exit.state as State });\n            exitResolver = null;\n          }\n        }\n      });\n      channel.onClose(() => {\n        if (exitResolver) {\n          exitResolver({ code: null, state: currentState as State });\n          exitResolver = null;\n        }\n      });\n\n      return {\n        public: currentState as State,\n        private: { channel, exitPromise, fromName },\n      };\n    },\n    async onMessage(msg: InMsg): Promise<HookResult> {\n      this.state.private.channel?.send({ $msg: { fromName: this.state.private.fromName, body: msg } });\n      return stopPropagation();\n    },\n    async onStopRequested() {\n      if (this.state.private.channel) {\n        this.state.private.channel.send({ $msg: { fromName: this.state.private.fromName, body: { type: \"STOP\" } } });\n        await this.state.private.exitPromise;\n      }\n      this.agreeToStop();\n    },\n    async afterEnd() {\n      if (this.state.private.channel) {\n        await this.state.private.channel.close();\n      }\n    },\n  });\n\n  return proxyDef as unknown as ActorDefinition<Args, State, InMsg, OutMsg, R>;\n}\n","// ── json1 wire protocol ────────────────────────────────────────────────────\n//\n// One JSON object per frame: `{\"$key\": value}`. encode/decode turn a decoded\n// frame object into a string and back. json1Channel wraps a StringTransport so\n// it moves frame objects instead of strings.\n\nimport type { Channel, StringTransport } from \"../channel.js\";\n\nexport const VERSION = \"json.v1\";\n\nexport function encode(frame: Record<string, unknown>): string {\n  return JSON.stringify(frame);\n}\n\nexport function decode(str: string): Record<string, unknown> {\n  return JSON.parse(str);\n}\n\nexport function json1Channel(transport: StringTransport): Channel {\n  return {\n    send(frame) {\n      return transport.send(encode(frame));\n    },\n    onMessage(handler) {\n      transport.onMessage((str) => handler(decode(str)));\n    },\n    removeHandler() {\n      transport.removeHandler();\n    },\n    onClose(handler) {\n      transport.onClose(handler);\n    },\n    close() {\n      return transport.close();\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/remote/gateway-cli.js

@@ -1,4 +1,412 @@
-import { i as runGateway } from "../gateway-BytuRl_6.js";
+import { execFile, spawn } from "node:child_process";
+import { mkdtemp, open, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { promisify } from "node:util";
+import * as readline from "node:readline";
+//#region src/remote/stdio.ts
+const OUTPUT_KEY = "$fd";
+const ERROR_KEY = "$error";
+/** Raised when the wire itself fails: no frame, the wrong protocol, a peer that went away. */
+var StdioWireError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "StdioWireError";
+	}
+};
+function outputFrame(fd, data) {
+	return JSON.stringify({
+		[OUTPUT_KEY]: fd,
+		data
+	});
+}
+function errorFrame(reason) {
+	return JSON.stringify({ [ERROR_KEY]: reason });
+}
+/** Is this write error just a peer that already left? */
+function peerGone(code) {
+	return code === "EPIPE" || code === "ERR_STREAM_DESTROYED" || code === "ERR_STREAM_WRITE_AFTER_END" || code === "ERR_STREAM_ALREADY_FINISHED";
+}
+function errorText$1(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/**
+* A `StringTransport` over a read/write stream pair, one JSON frame per line.
+*
+* `close()` is idempotent and never throws: teardown races are normal here —
+* the peer exits, the read side ends, and a write arrives a moment later.
+*/
+var LineTransport = class {
+	constructor(streams) {
+		this.pvtOnMessage = null;
+		this.pvtOnClose = null;
+		this.pvtClosed = false;
+		this.pvtClosing = null;
+		this.streams = streams;
+		const lines = readline.createInterface({ input: streams.read });
+		lines.on("line", (line) => {
+			if (this.pvtOnMessage && !this.pvtClosed) this.pvtOnMessage(line);
+		});
+		lines.on("close", () => {
+			this.pvtOnClose?.();
+			this.close();
+		});
+		streams.read.on("error", () => {
+			this.close();
+		});
+		streams.write.on("error", () => {
+			this.close();
+		});
+	}
+	get closed() {
+		return this.pvtClosed;
+	}
+	get hasHandler() {
+		return this.pvtOnMessage !== null;
+	}
+	onMessage(handler) {
+		if (this.pvtClosed) throw new StdioWireError("stdio transport: closed");
+		if (this.pvtOnMessage !== null) throw new StdioWireError("stdio transport: handler already set — call removeHandler()");
+		this.pvtOnMessage = handler;
+	}
+	removeHandler() {
+		const previous = this.pvtOnMessage;
+		this.pvtOnMessage = null;
+		return previous;
+	}
+	onClose(handler) {
+		this.pvtOnClose = handler;
+	}
+	send(frame) {
+		if (this.pvtClosed) return Promise.resolve();
+		const line = frame.endsWith("\n") ? frame : `${frame}\n`;
+		return new Promise((resolve, reject) => {
+			try {
+				this.streams.write.write(line, (err) => {
+					if (!err) return resolve();
+					const code = err.code;
+					if (peerGone(code)) return resolve();
+					reject(new StdioWireError(`stdio transport: ${err.message}`));
+				});
+			} catch (err) {
+				reject(new StdioWireError(`stdio transport: ${errorText$1(err)}`));
+			}
+		});
+	}
+	async close() {
+		this.pvtClosing ??= this.pvtClose();
+		await this.pvtClosing;
+	}
+	async pvtClose() {
+		await Promise.resolve();
+		this.pvtClosed = true;
+		try {
+			this.streams.read.destroy?.();
+		} catch {}
+		try {
+			if (!this.streams.write.writableEnded) this.streams.write.end();
+		} catch {}
+	}
+};
+//#endregion
+//#region src/remote/transports/fifo.ts
+var FifoUtf8NlineTransport = class FifoUtf8NlineTransport {
+	constructor(opts) {
+		this.pvtOnMessage = null;
+		this.pvtOnClose = null;
+		this.closed = false;
+		this.closingPromise = null;
+		this.pvtError = null;
+		this.readFd = opts.readFd ?? null;
+		this.writeFd = opts.writeFd ?? null;
+		if (this.readFd) {
+			this.rs = this.readFd.createReadStream({ encoding: "utf-8" });
+			this.rl = readline.createInterface({ input: this.rs });
+			this.rl.on("line", (line) => {
+				if (this.pvtOnMessage && !this.closed) this.pvtOnMessage(line);
+			});
+			this.rl.on("close", () => {
+				this.pvtOnClose?.();
+				this.close();
+			});
+			this.rs.on("error", (err) => {
+				this.pvtError = err;
+				this.close();
+			});
+		} else {
+			this.rs = null;
+			this.rl = null;
+		}
+		if (this.writeFd) {
+			this.ws = this.writeFd.createWriteStream({ encoding: "utf-8" });
+			this.ws.on("error", (err) => {
+				this.pvtError = err;
+				this.close();
+			});
+		} else this.ws = null;
+	}
+	static openReaderFd(readFd) {
+		return new FifoUtf8NlineTransport({ readFd });
+	}
+	static openWriterFd(writeFd) {
+		return new FifoUtf8NlineTransport({ writeFd });
+	}
+	static fromFds(readFd, writeFd) {
+		return new FifoUtf8NlineTransport({
+			readFd,
+			writeFd
+		});
+	}
+	/**
+	* Start opening a bidirectional connection.  Opens readPath for reading
+	* in the background, returns a promise.  The caller should do whatever
+	* setup is needed to unblock the read (e.g. spawn a process that opens
+	* readPath for writing), then await the returned transport.
+	*
+	* The transport itself is built only once both directions are open.  A read
+	* stream created while no writer exists on its fifo is handed an immediate
+	* end-of-stream by some runtimes (bun), which closes a channel that has not
+	* carried a byte yet — so the writes side is opened before the reader exists.
+	*/
+	static beginConnect(readPath, writePath) {
+		return { transport: open(readPath, "r").then(async (readFd) => {
+			const writeFd = await open(writePath, "w");
+			return FifoUtf8NlineTransport.fromFds(readFd, writeFd);
+		}) };
+	}
+	/**
+	* Open a bidirectional connection.  Opens writePath for writing first
+	* (unblocking the peer's read), starts reading readPath in the
+	* background, then awaits both.
+	*
+	* Use this when you are the side that responds to the peer's beginConnect
+	* (i.e. you don't need to interleave any setup between the read and write
+	* opens).  Built like `beginConnect`: the transport exists only after both
+	* directions do.
+	*/
+	static async connect(readPath, writePath) {
+		const readFdPromise = open(readPath, "r");
+		const writeFd = await open(writePath, "w");
+		const readFd = await readFdPromise;
+		return FifoUtf8NlineTransport.fromFds(readFd, writeFd);
+	}
+	get canSend() {
+		return this.writeFd !== null && !this.closed;
+	}
+	onMessage(handler) {
+		if (this.closed) throw new Error("FifoUtf8NlineTransport: closed");
+		if (this.readFd === null) throw new Error("FifoUtf8NlineTransport: not a reader");
+		if (this.pvtOnMessage !== null) throw new Error("FifoUtf8NlineTransport: handler already set — call removeHandler() first");
+		this.pvtOnMessage = handler;
+	}
+	removeHandler() {
+		const prev = this.pvtOnMessage;
+		this.pvtOnMessage = null;
+		return prev;
+	}
+	onClose(handler) {
+		this.pvtOnClose = handler;
+	}
+	get hasHandler() {
+		return this.pvtOnMessage !== null;
+	}
+	get lastError() {
+		return this.pvtError;
+	}
+	async send(line) {
+		if (this.closed) throw new Error("FifoUtf8NlineTransport: closed");
+		if (this.writeFd === null) throw new Error("FifoUtf8NlineTransport: not a writer");
+		if (!line.endsWith("\n")) line += "\n";
+		await this.ws?.write(line);
+	}
+	async close() {
+		this.closingPromise = this.closingPromise || this.pvtClose();
+		await this.closingPromise;
+		this.closed = true;
+	}
+	async pvtClose() {
+		await Promise.resolve();
+		if (this.rl) {
+			this.rl.close();
+			this.rl = null;
+		}
+		if (this.rs) {
+			this.rs.destroy();
+			this.rs = null;
+		}
+		if (this.ws) {
+			await new Promise((resolve) => {
+				try {
+					this.ws?.end("", resolve);
+				} catch {
+					resolve();
+				}
+			});
+			this.ws = null;
+		}
+		if (this.readFd) {
+			try {
+				await this.readFd.close();
+			} catch {}
+			this.readFd = null;
+		}
+		if (this.writeFd) {
+			try {
+				await this.writeFd.close();
+			} catch {}
+			this.writeFd = null;
+		}
+	}
+};
+//#endregion
+//#region src/remote/gateway.ts
+const run = promisify(execFile);
+function errorText(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/**
+* A label for the gateway's own temp directory: the program this environment was made for.
+* It is the gateway's business alone — the payload is not told which label it is.
+*/
+function label(worker) {
+	const name = basename(worker).replace(/[^A-Za-z0-9.+@_-]/g, "-").slice(0, 60);
+	return name === "" ? "payload" : name;
+}
+/** The boot a gateway was started with, or the reason it cannot start. */
+function gatewayBoot(argv) {
+	const [worker, ...passthrough] = argv;
+	if (worker === void 0 || worker.startsWith("--")) throw new Error("no <payload>: the gateway relays to a payload, named as its first argument");
+	return {
+		passthrough,
+		worker
+	};
+}
+/**
+* End a start that failed.  The reason has already gone out on the wire, and
+* returning is not enough: the `open()` on a fifo no payload will ever write sits
+* in the threadpool forever, so the loop never drains and the gateway would linger
+* with a dead payload on its books.
+*/
+function abandon() {
+	process.exit(1);
+}
+/** Carry a failed start to the client, then let the caller exit non-zero. */
+async function fail(wire, reason) {
+	process.stderr.write(`gateway: ${reason}\n`);
+	try {
+		await wire.send(errorFrame(reason));
+	} catch {}
+}
+/** Copy everything the payload prints onto the wire as output frames. */
+function forwardOutput(stream, wire, fd) {
+	stream.setEncoding("utf-8");
+	stream.on("data", (chunk) => {
+		wire.send(outputFrame(fd, chunk)).catch(() => {});
+	});
+}
+/**
+* Serve one environment over stdin/stdout.  Returns the exit code; the caller
+* turns it into `process.exitCode`.
+*/
+async function runGateway(argv = process.argv.slice(2)) {
+	const wire = new LineTransport({
+		read: process.stdin,
+		write: process.stdout
+	});
+	let booted;
+	try {
+		booted = gatewayBoot(argv);
+	} catch (err) {
+		await fail(wire, errorText(err));
+		abandon();
+	}
+	const { passthrough, worker } = booted;
+	const dir = await mkdtemp(join(tmpdir(), `posipaki-${label(worker)}-`));
+	const fifoIn = join(dir, "in");
+	const fifoOut = join(dir, "out");
+	let child = null;
+	let fifo = null;
+	/**
+	* Everything this gateway owns, undone.  All of it is idempotent, because the
+	* exit path and the signal path can both arrive.
+	*/
+	const teardown = async () => {
+		child?.kill();
+		await fifo?.close().catch(() => {});
+		await rm(dir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+	};
+	/**
+	* A client that gives up stops us with a signal, and a gateway that died on the
+	* spot would leave its payload behind in the environment — a process holding a
+	* fifo nobody will ever write, which is a leak the environment cannot clean up
+	* for us.  So the signals do what the exit path does.
+	*/
+	const onTerminate = () => {
+		teardown().catch(() => {}).then(() => process.exit(1));
+	};
+	for (const signal of [
+		"SIGTERM",
+		"SIGINT",
+		"SIGHUP"
+	]) process.on(signal, onTerminate);
+	try {
+		await run("mkfifo", [
+			"-m",
+			"600",
+			fifoIn,
+			fifoOut
+		]);
+	} catch (err) {
+		await fail(wire, `cannot create the environment's fifos: ${errorText(err)}`);
+		await teardown();
+		abandon();
+	}
+	const connection = FifoUtf8NlineTransport.beginConnect(fifoIn, fifoOut);
+	const workerArgs = [
+		worker,
+		...passthrough,
+		`--fifo-in=${fifoIn}`,
+		`--fifo-out=${fifoOut}`
+	];
+	const workerProc = spawn(workerArgs[0], workerArgs.slice(1), { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] });
+	child = workerProc;
+	forwardOutput(workerProc.stdout, wire, 1);
+	forwardOutput(workerProc.stderr, wire, 2);
+	const exited = new Promise((settle) => {
+		workerProc.once("exit", (code) => settle(code ?? 0));
+	});
+	try {
+		fifo = await Promise.race([connection.transport, exited.then((code) => {
+			throw new Error(`the payload exited with code ${code} before it opened its channel`);
+		})]);
+	} catch (err) {
+		await fail(wire, errorText(err));
+		await teardown();
+		abandon();
+	}
+	const relay = fifo;
+	relay.onMessage((line) => {
+		wire.send(line).catch(() => {});
+	});
+	wire.onMessage((line) => {
+		relay.send(line).catch(() => {});
+	});
+	wire.onClose(() => {
+		child?.kill();
+	});
+	const code = await exited;
+	await teardown();
+	await wire.close();
+	return code;
+}
+//#endregion
 //#region src/remote/gateway-cli.ts
 (async () => {
 	try {

package/dist/remote/gateway-cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"gateway-cli.js","names":[],"sources":["../../src/remote/gateway-cli.ts"],"sourcesContent":["// ── The gateway, as a program ──────────────────────────────────────────────\n//\n// A gateway is something a client runs: the first-stage command that makes a fifo\n// inside a foreign environment and relays frames between its own stdin/stdout and\n// the payload.  That is this file's whole job — it always serves, and it exits with\n// the code the run ended in.\n//\n// Serving lives in ./gateway.js and starts nothing by itself.  A file cannot decide\n// \"am I the program?\" from where it is: a consumer that bundles the node surface\n// into its own program carries this code along, and there the bundle *is* the\n// program — a payload would find a gateway booting on its wire.  So the decision is\n// in the layout instead: importing a module never starts anything, and running this\n// one always does.\n//\n// The client names it either way: `posipaki/remote/gateway-cli.js` is a published\n// specifier, so `import.meta.resolve` answers with the built file, and a consumer\n// with a program of its own stages that instead.  Nothing here works out its own\n// location — a path derived from `import.meta.url` is a guess about a layout the\n// bundler owns, and the guess is wrong the moment the module moves into a chunk.\n\nimport { GATEWAY_FAILED, runGateway } from \"./gateway.js\";\n\nvoid (async () => {\n  try {\n    process.exitCode = await runGateway();\n  } catch (err) {\n    process.stderr.write(`gateway: ${err instanceof Error ? err.message : String(err)}\\n`);\n    process.exitCode = GATEWAY_FAILED;\n  }\n})();\n"],"mappings":";;CAsBM,YAAY;CAChB,IAAI;EACF,QAAQ,WAAW,MAAM,WAAW;CACtC,SAAS,KAAK;EACZ,QAAQ,OAAO,MAAM,YAAY,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,EAAE,GAAG;EACrF,QAAQ,WAAA;CACV;AACF,EAAA,CAAG"}
+{"version":3,"file":"gateway-cli.js","names":["errorText","Lines"],"sources":["../../src/remote/stdio.ts","../../src/remote/transports/fifo.ts","../../src/remote/gateway.ts","../../src/remote/gateway-cli.ts"],"sourcesContent":["// ── stdio wire ─────────────────────────────────────────────────────────────\n//\n// A newline-delimited JSON channel over a pair of streams: the one wire every\n// way into a foreign execution context can carry.  Two callers rely on it, and\n// they are two halves of the same thing:\n//\n//   * the client of a spawn we make ourselves, on fds handed to the child (see\n//     `fdStreams`) — private fds, so the child's own stdout stays free;\n//   * a first-stage command on its own stdin/stdout, over ssh, under `sudo`, in\n//     a container — where stdio is the only channel there is.\n//\n// Frames are one JSON object per line.  Whatever the far end prints is carried\n// as an *output frame* (`$fd`), so it can never be mistaken for a frame of the\n// protocol itself; a failed start is carried as an `$error` frame.\n//\n// Why the client filters output frames before handing the transport to the\n// seam: `json1Channel` decodes every line it sees, and the first frame of a\n// session is the peer's `$proto`.  Stripping output frames in the transport\n// keeps the protocol view clean without the seam knowing anything about them.\n\nimport { createReadStream, createWriteStream } from \"node:fs\";\nimport * as readline from \"node:readline\";\nimport type { Readable, Writable } from \"node:stream\";\nimport { isProto, type Channel, type StringTransport } from \"./channel.js\";\nimport { VERSION, json1Channel } from \"./protocols/json1.js\";\n\n/** The stream pair a line transport talks over. */\nexport interface LineStreams {\n  read: Readable;\n  write: Writable;\n}\n\n/** A stream of the far end's process: its stdout or its stderr. */\nexport type OutputFd = 1 | 2;\n\n/** Where the far end's own output goes. */\nexport type OutputSink = (fd: OutputFd, data: string) => void;\n\n/** How long to wait for the far end's first protocol frame. */\nexport const HANDSHAKE_TIMEOUT_MS = 15_000;\n\nconst OUTPUT_KEY = \"$fd\";\n\nconst ERROR_KEY = \"$error\";\n\n/** Raised when the wire itself fails: no frame, the wrong protocol, a peer that went away. */\nexport class StdioWireError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"StdioWireError\";\n  }\n}\n\n// ── output frames ──────────────────────────────────────────────────────────\n\n/** One frame of the far end's own output. */\nexport interface OutputFrame {\n  fd: OutputFd;\n  data: string;\n}\n\nexport function outputFrame(fd: OutputFd, data: string): string {\n  return JSON.stringify({ [OUTPUT_KEY]: fd, data });\n}\n\n/** The output frame a line carries, or null when it carries something else. */\nexport function parseOutputFrame(line: string): OutputFrame | null {\n  // Cheap reject first: almost every line of a session is protocol traffic.\n  if (!line.startsWith('{\"$fd\"')) return null;\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(line);\n  } catch {\n    return null;\n  }\n  if (typeof parsed !== \"object\" || parsed === null) return null;\n  const frame = parsed as Record<string, unknown>;\n  const fd = frame[OUTPUT_KEY];\n  const data = frame.data;\n  if (fd !== 1 && fd !== 2) return null;\n  return { fd, data: typeof data === \"string\" ? data : JSON.stringify(data) };\n}\n\nexport function errorFrame(reason: string): string {\n  return JSON.stringify({ [ERROR_KEY]: reason });\n}\n\n/** The reason an `$error` frame carries, or null when it is not one. */\nexport function errorReason(frame: Record<string, unknown>): string | null {\n  const reason = frame[ERROR_KEY];\n  return typeof reason === \"string\" ? reason : null;\n}\n\n// ── transports ─────────────────────────────────────────────────────────────\n\n/** Is this write error just a peer that already left? */\nfunction peerGone(code: unknown): boolean {\n  return (\n    code === \"EPIPE\" ||\n    code === \"ERR_STREAM_DESTROYED\" ||\n    code === \"ERR_STREAM_WRITE_AFTER_END\" ||\n    code === \"ERR_STREAM_ALREADY_FINISHED\"\n  );\n}\n\nfunction errorText(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\n/**\n * A `StringTransport` over a read/write stream pair, one JSON frame per line.\n *\n * `close()` is idempotent and never throws: teardown races are normal here —\n * the peer exits, the read side ends, and a write arrives a moment later.\n */\nexport class LineTransport implements StringTransport {\n  private readonly streams: LineStreams;\n  private pvtOnMessage: ((line: string) => void) | null = null;\n  private pvtOnClose: (() => void) | null = null;\n  private pvtClosed = false;\n  private pvtClosing: Promise<void> | null = null;\n\n  constructor(streams: LineStreams) {\n    this.streams = streams;\n    const lines = readline.createInterface({ input: streams.read });\n    lines.on(\"line\", (line) => {\n      if (this.pvtOnMessage && !this.pvtClosed) this.pvtOnMessage(line);\n    });\n    lines.on(\"close\", () => {\n      this.pvtOnClose?.();\n      void this.close();\n    });\n    // A stream error is a peer that went away, not a reason to take the process\n    // down with an unhandled 'error' event.\n    streams.read.on(\"error\", () => {\n      void this.close();\n    });\n    streams.write.on(\"error\", () => {\n      void this.close();\n    });\n  }\n\n  get closed(): boolean {\n    return this.pvtClosed;\n  }\n\n  get hasHandler(): boolean {\n    return this.pvtOnMessage !== null;\n  }\n\n  onMessage(handler: (line: string) => void): void {\n    if (this.pvtClosed) throw new StdioWireError(\"stdio transport: closed\");\n    if (this.pvtOnMessage !== null) {\n      throw new StdioWireError(\"stdio transport: handler already set — call removeHandler()\");\n    }\n    this.pvtOnMessage = handler;\n  }\n\n  removeHandler(): ((line: string) => void) | null {\n    const previous = this.pvtOnMessage;\n    this.pvtOnMessage = null;\n    return previous;\n  }\n\n  onClose(handler: () => void): void {\n    this.pvtOnClose = handler;\n  }\n\n  send(frame: string): Promise<void> {\n    if (this.pvtClosed) {\n      return Promise.resolve();\n    }\n    const line = frame.endsWith(\"\\n\") ? frame : `${frame}\\n`;\n    return new Promise<void>((resolve, reject) => {\n      try {\n        this.streams.write.write(line, (err?: Error | null) => {\n          if (!err) return resolve();\n          const code = (err as { code?: unknown }).code;\n          // A peer that has hung up cannot be told anything; the write that\n          // races its exit is not an error in this transport.\n          if (peerGone(code)) {\n            return resolve();\n          }\n          reject(new StdioWireError(`stdio transport: ${err.message}`));\n        });\n      } catch (err) {\n        reject(new StdioWireError(`stdio transport: ${errorText(err)}`));\n      }\n    });\n  }\n\n  async close(): Promise<void> {\n    this.pvtClosing ??= this.pvtClose();\n    await this.pvtClosing;\n  }\n\n  private async pvtClose(): Promise<void> {\n    await Promise.resolve();\n\n    this.pvtClosed = true;\n    // Best effort: a half-open stream (the peer is already gone) must not turn\n    // teardown into an exception.\n    try {\n      this.streams.read.destroy?.();\n    } catch {\n      /* already gone */\n    }\n    try {\n      if (!this.streams.write.writableEnded) this.streams.write.end();\n    } catch {\n      /* already gone */\n    }\n  }\n}\n\n/** Streams over two fds of *our own* process — the child side of an fd wire. */\nexport function fdStreams(readFd: number, writeFd: number): LineStreams {\n  const read = createReadStream(\"\", { fd: readFd, encoding: \"utf-8\", autoClose: false });\n  const write = createWriteStream(\"\", { fd: writeFd, encoding: \"utf-8\", autoClose: false });\n  return { read, write };\n}\n\n/**\n * A transport that lifts output frames out of the stream: everything else is\n * passed through untouched, so the protocol sees frames and only frames.\n */\nexport class OutputFilter implements StringTransport {\n  private readonly inner: StringTransport;\n  private readonly sink: OutputSink;\n\n  constructor(inner: StringTransport, sink: OutputSink) {\n    this.inner = inner;\n    this.sink = sink;\n  }\n\n  send(frame: string): void | Promise<void> {\n    return this.inner.send(frame);\n  }\n\n  onMessage(handler: (frame: string) => void): void {\n    this.inner.onMessage((line) => {\n      const output = parseOutputFrame(line);\n      if (output) this.sink(output.fd, output.data);\n      else handler(line);\n    });\n  }\n\n  removeHandler(): void {\n    this.inner.removeHandler();\n  }\n\n  onClose(handler: () => void): void {\n    this.inner.onClose(handler);\n  }\n\n  close(): Promise<void> {\n    return this.inner.close();\n  }\n}\n\n// ── sinks ──────────────────────────────────────────────────────────────────\n\n/** Write the far end's output to our stderr, tagged with its name. */\nexport function stderrSink(name = \"\"): OutputSink {\n  const tag = name ? `[${name}] ` : \"\";\n  return (fd, data) => {\n    const lead = fd === 1 ? tag : `${tag}err: `;\n    for (const line of data.split(\"\\n\")) {\n      if (line.length > 0) process.stderr.write(`${lead}${line}\\n`);\n    }\n  };\n}\n\n// ── handshakes ─────────────────────────────────────────────────────────────\n\n/** The next frame that arrives, or a timeout. */\nasync function nextFrame(channel: Channel, timeoutMs: number): Promise<Record<string, unknown>> {\n  return await new Promise((resolve, reject) => {\n    const timer = setTimeout(\n      () => reject(new StdioWireError(`no protocol frame within ${timeoutMs}ms`)),\n      timeoutMs,\n    );\n    timer.unref?.();\n    channel.onMessage((frame) => {\n      clearTimeout(timer);\n      resolve(frame);\n    });\n  });\n}\n\nexport interface ClientChannelOptions {\n  /** Where the far end's own output goes.  Defaults to our stderr. */\n  onOutput?: OutputSink;\n  /** How long to wait for the peer's protocol frame.  Defaults to {@link HANDSHAKE_TIMEOUT_MS}. */\n  timeoutMs?: number;\n}\n\n/**\n * The client end of the wire: hand the streams to the seam (minus output\n * frames) and wait for the peer's `$proto`.  A first stage reports a failed\n * start as an `$error` frame instead.\n */\nexport async function clientChannel(\n  streams: LineStreams,\n  opts: ClientChannelOptions = {},\n): Promise<Channel> {\n  const transport = new LineTransport(streams);\n  const channel = json1Channel(new OutputFilter(transport, opts.onOutput ?? stderrSink()));\n  const frame = await nextFrame(channel, opts.timeoutMs ?? HANDSHAKE_TIMEOUT_MS);\n  channel.removeHandler();\n\n  const reason = errorReason(frame);\n  if (reason) throw new StdioWireError(reason);\n  if (!isProto(frame)) {\n    throw new StdioWireError(`unexpected first frame: ${JSON.stringify(frame).slice(0, 120)}`);\n  }\n  if (frame.$proto !== VERSION) {\n    throw new StdioWireError(`unsupported protocol ${String(frame.$proto)}, expected ${VERSION}`);\n  }\n  return channel;\n}\n\n/** The server end of the wire — a payload speaking stdio itself. */\nexport async function serverChannel(streams: LineStreams): Promise<Channel> {\n  const channel = json1Channel(new LineTransport(streams));\n  await channel.send({ $proto: VERSION });\n  return channel;\n}\n","// ── FIFO transport ─────────────────────────────────────────────────────────\n//\n// Newline-delimited UTF-8 over named fifos.  Strict handler lifecycle:\n// onMessage() throws if a handler is already set; call removeHandler() first.\n\nimport { open, type FileHandle } from \"node:fs/promises\";\nimport type { ReadStream, WriteStream } from \"node:fs\";\nimport * as readline from \"node:readline\";\nimport type { StringTransport } from \"../channel.js\";\n\nexport class FifoUtf8NlineTransport implements StringTransport {\n  private readFd: FileHandle | null;\n  private writeFd: FileHandle | null;\n  private rl: readline.Interface | null;\n  private rs: ReadStream | null;\n  private ws: WriteStream | null;\n  private pvtOnMessage: ((line: string) => void) | null = null;\n  private pvtOnClose: (() => void) | null = null;\n  private closed = false;\n  private closingPromise: Promise<void> | null = null;\n  private pvtError: Error | null = null;\n\n  private constructor(opts: { readFd?: FileHandle; writeFd?: FileHandle }) {\n    this.readFd = opts.readFd ?? null;\n    this.writeFd = opts.writeFd ?? null;\n\n    if (this.readFd) {\n      this.rs = this.readFd.createReadStream({ encoding: \"utf-8\" });\n      this.rl = readline.createInterface({ input: this.rs });\n\n      this.rl.on(\"line\", (line) => {\n        if (this.pvtOnMessage && !this.closed) this.pvtOnMessage(line);\n      });\n\n      this.rl.on(\"close\", () => {\n        this.pvtOnClose?.();\n        this.close();\n      });\n\n      this.rs.on(\"error\", (err: Error) => {\n        this.pvtError = err;\n        this.close();\n      });\n    } else {\n      this.rs = null;\n      this.rl = null;\n    }\n\n    if (this.writeFd) {\n      this.ws = this.writeFd.createWriteStream({ encoding: \"utf-8\" });\n      this.ws.on(\"error\", (err: Error) => {\n        this.pvtError = err;\n        this.close();\n      });\n    } else {\n      this.ws = null;\n    }\n  }\n\n  // ── factories ──────────────────────────────────────────────────────────\n\n  static openReaderFd(readFd: FileHandle): FifoUtf8NlineTransport {\n    return new FifoUtf8NlineTransport({ readFd });\n  }\n\n  static openWriterFd(writeFd: FileHandle): FifoUtf8NlineTransport {\n    return new FifoUtf8NlineTransport({ writeFd });\n  }\n\n  static fromFds(readFd: FileHandle, writeFd: FileHandle): FifoUtf8NlineTransport {\n    return new FifoUtf8NlineTransport({ readFd, writeFd });\n  }\n\n  // ── bidirectional connection ───────────────────────────────────────────\n\n  /**\n   * Start opening a bidirectional connection.  Opens readPath for reading\n   * in the background, returns a promise.  The caller should do whatever\n   * setup is needed to unblock the read (e.g. spawn a process that opens\n   * readPath for writing), then await the returned transport.\n   *\n   * The transport itself is built only once both directions are open.  A read\n   * stream created while no writer exists on its fifo is handed an immediate\n   * end-of-stream by some runtimes (bun), which closes a channel that has not\n   * carried a byte yet — so the writes side is opened before the reader exists.\n   */\n  static beginConnect(\n    readPath: string,\n    writePath: string,\n  ): { transport: Promise<FifoUtf8NlineTransport> } {\n    const readFdPromise = open(readPath, \"r\");\n\n    const transport = readFdPromise.then(async (readFd) => {\n      const writeFd = await open(writePath, \"w\");\n      return FifoUtf8NlineTransport.fromFds(readFd, writeFd);\n    });\n\n    return { transport };\n  }\n\n  /**\n   * Open a bidirectional connection.  Opens writePath for writing first\n   * (unblocking the peer's read), starts reading readPath in the\n   * background, then awaits both.\n   *\n   * Use this when you are the side that responds to the peer's beginConnect\n   * (i.e. you don't need to interleave any setup between the read and write\n   * opens).  Built like `beginConnect`: the transport exists only after both\n   * directions do.\n   */\n  static async connect(readPath: string, writePath: string): Promise<FifoUtf8NlineTransport> {\n    const readFdPromise = open(readPath, \"r\");\n    const writeFd = await open(writePath, \"w\");\n    const readFd = await readFdPromise;\n    return FifoUtf8NlineTransport.fromFds(readFd, writeFd);\n  }\n\n  // ── public API ─────────────────────────────────────────────────────────\n\n  get canSend(): boolean {\n    return this.writeFd !== null && !this.closed;\n  }\n\n  onMessage(handler: (line: string) => void): void {\n    if (this.closed) throw new Error(\"FifoUtf8NlineTransport: closed\");\n    if (this.readFd === null) throw new Error(\"FifoUtf8NlineTransport: not a reader\");\n    if (this.pvtOnMessage !== null) {\n      throw new Error(\"FifoUtf8NlineTransport: handler already set — call removeHandler() first\");\n    }\n    this.pvtOnMessage = handler;\n  }\n\n  removeHandler(): ((line: string) => void) | null {\n    const prev = this.pvtOnMessage;\n    this.pvtOnMessage = null;\n    return prev;\n  }\n\n  onClose(handler: () => void): void {\n    this.pvtOnClose = handler;\n  }\n\n  get hasHandler(): boolean {\n    return this.pvtOnMessage !== null;\n  }\n\n  get lastError(): Error | null {\n    return this.pvtError;\n  }\n\n  async send(line: string): Promise<void> {\n    if (this.closed) throw new Error(\"FifoUtf8NlineTransport: closed\");\n    if (this.writeFd === null) throw new Error(\"FifoUtf8NlineTransport: not a writer\");\n    if (!line.endsWith(\"\\n\")) line += \"\\n\";\n    await this.ws?.write(line);\n  }\n\n  async close(): Promise<void> {\n    this.closingPromise = this.closingPromise || this.pvtClose();\n    await this.closingPromise;\n    this.closed = true;\n  }\n\n  private async pvtClose(): Promise<void> {\n    // tranfser control back to caller\n    // so they can capture the promise reference\n    // and prevent reentry\n    await Promise.resolve();\n\n    if (this.rl) {\n      this.rl.close();\n      this.rl = null;\n    }\n    if (this.rs) {\n      this.rs.destroy();\n      this.rs = null;\n    }\n    if (this.ws) {\n      await new Promise<void>((resolve) => {\n        try {\n          this.ws?.end(\"\", resolve);\n        } catch {\n          resolve();\n        }\n      });\n      this.ws = null;\n    }\n\n    if (this.readFd) {\n      try {\n        await this.readFd.close();\n      } catch {}\n      this.readFd = null;\n    }\n    if (this.writeFd) {\n      try {\n        await this.writeFd.close();\n      } catch {}\n      this.writeFd = null;\n    }\n  }\n}\n","// ── Gateway ────────────────────────────────────────────────────────────────\n//\n// The first-stage command.  Run this *inside* a foreign environment — directly,\n// under `sudo`, over ssh, in a container — and it:\n//\n//   1. creates the channel to the payload (fifo paths it makes itself, in a\n//      private temp dir, so they belong to the uid that will open them),\n//   2. starts the payload — the first argument, required — hands it everything else it was\n//      given (the host version among it) and relays frames between stdin/stdout,\n//   3. carries whatever the payload prints to the client as output frames\n//      (`$fd`), so the payload's own stdout can never be mistaken for protocol.\n//\n// Why a gateway at all: a fifo path created on the client side is useless when the\n// payload runs as another uid (it cannot open it) or on another host (the path is\n// not there).  stdio is the one channel every way into an environment gives us, so\n// the wire is stdio and the fifo stays inside the environment.\n//\n// The gateway reads nothing out of what it carries and owns no flag: the payload's path and\n// every argument after it go through verbatim, in order.  The payload is the one who refuses a\n// host version it is not, and a relay that judged would be a second place for that decision.\n//\n// Directories and processes are cleaned up on every exit path, which is also why\n// the client never sees a transport being closed twice.\n//\n// It imports nothing but node builtins and this package, so the payload behind it\n// can be anything the runtime there can start.\n\nimport { execFile, spawn } from \"node:child_process\";\nimport type { ChildProcess } from \"node:child_process\";\nimport { mkdtemp, rm } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { basename, join } from \"node:path\";\nimport { promisify } from \"node:util\";\nimport { errorFrame, outputFrame } from \"./stdio.js\";\nimport type { LineTransport, OutputFd } from \"./stdio.js\";\nimport { LineTransport as Lines } from \"./stdio.js\";\nimport { FifoUtf8NlineTransport } from \"./transports/fifo.js\";\n\nconst run = promisify(execFile);\n\n/** Exit code for \"this environment could not be set up\". */\nexport const GATEWAY_FAILED = 1;\n\nexport interface GatewayBoot {\n  /**\n   * The program to start for the payload: the first word of the command the client composed —\n   * a runtime, or a program that runs itself.  Required, and first, and the gateway has no\n   * opinion of its own about which it is.\n   */\n  worker: string;\n  /**\n   * Everything after the payload, carried to it **as is** and in order: the consumer's own\n   * arguments, and posipaki's own facts among them (the host version travels this way).  The\n   * gateway reads nothing by name and owns no flag, so nothing of the caller's is interpreted,\n   * eaten, re-ordered or re-spelled — and the next fact added to that line needs no new\n   * vocabulary here.\n   */\n  passthrough: string[];\n}\n\nfunction errorText(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\n/**\n * A label for the gateway's own temp directory: the program this environment was made for.\n * It is the gateway's business alone — the payload is not told which label it is.\n */\nfunction label(worker: string): string {\n  const name = basename(worker).replace(/[^A-Za-z0-9.+@_-]/g, \"-\").slice(0, 60);\n  return name === \"\" ? \"payload\" : name;\n}\n\n/**\n * The argv that boots this gateway — built by the client, read by\n * {@link gatewayBoot}, so the two halves cannot drift apart.\n *\n * The payload comes first and its arguments after it, so a positional argument of the\n * payload's own can never be mistaken for the payload.\n */\nexport function gatewayArgs(boot: GatewayBoot): string[] {\n  return [boot.worker, ...boot.passthrough];\n}\n\n/** The boot a gateway was started with, or the reason it cannot start. */\nexport function gatewayBoot(argv: string[]): GatewayBoot {\n  const [worker, ...passthrough] = argv;\n  if (worker === undefined || worker.startsWith(\"--\")) {\n    throw new Error(\"no <payload>: the gateway relays to a payload, named as its first argument\");\n  }\n  return { passthrough, worker };\n}\n\n/**\n * End a start that failed.  The reason has already gone out on the wire, and\n * returning is not enough: the `open()` on a fifo no payload will ever write sits\n * in the threadpool forever, so the loop never drains and the gateway would linger\n * with a dead payload on its books.\n */\nfunction abandon(): never {\n  process.exit(GATEWAY_FAILED);\n}\n\n/** Carry a failed start to the client, then let the caller exit non-zero. */\nasync function fail(wire: LineTransport, reason: string): Promise<void> {\n  process.stderr.write(`gateway: ${reason}\\n`);\n  try {\n    await wire.send(errorFrame(reason));\n  } catch {\n    /* the client is gone too — the exit code still says what happened */\n  }\n}\n\n/** Copy everything the payload prints onto the wire as output frames. */\nfunction forwardOutput(stream: NodeJS.ReadableStream, wire: LineTransport, fd: OutputFd): void {\n  stream.setEncoding(\"utf-8\");\n  stream.on(\"data\", (chunk: string) => {\n    void wire.send(outputFrame(fd, chunk)).catch(() => {\n      /* the client hung up: the payload's exit is what matters now */\n    });\n  });\n}\n\n/**\n * Serve one environment over stdin/stdout.  Returns the exit code; the caller\n * turns it into `process.exitCode`.\n */\nexport async function runGateway(argv: string[] = process.argv.slice(2)): Promise<number> {\n  const wire = new Lines({ read: process.stdin, write: process.stdout });\n\n  let booted: GatewayBoot;\n  try {\n    booted = gatewayBoot(argv);\n  } catch (err) {\n    // Nothing has been started yet, so there is nothing to tear down — but the\n    // client still deserves the reason rather than a channel that closes on it,\n    // and the loop can outlive us: an open stdin nobody will close keeps the\n    // process alive, so this is an exit, not a return.\n    await fail(wire, errorText(err));\n    abandon();\n  }\n  const { passthrough, worker } = booted;\n\n  const dir = await mkdtemp(join(tmpdir(), `posipaki-${label(worker)}-`));\n  const fifoIn = join(dir, \"in\"); // the payload writes, we read\n  const fifoOut = join(dir, \"out\"); // we write, the payload reads\n\n  let child: ChildProcess | null = null;\n  let fifo: FifoUtf8NlineTransport | null = null;\n\n  /**\n   * Everything this gateway owns, undone.  All of it is idempotent, because the\n   * exit path and the signal path can both arrive.\n   */\n  const teardown = async (): Promise<void> => {\n    child?.kill();\n    await fifo?.close().catch(() => {});\n    await rm(dir, { recursive: true, force: true }).catch(() => {});\n  };\n\n  /**\n   * A client that gives up stops us with a signal, and a gateway that died on the\n   * spot would leave its payload behind in the environment — a process holding a\n   * fifo nobody will ever write, which is a leak the environment cannot clean up\n   * for us.  So the signals do what the exit path does.\n   */\n  const onTerminate = () => {\n    void teardown()\n      .catch(() => {})\n      .then(() => process.exit(GATEWAY_FAILED));\n  };\n  for (const signal of [\"SIGTERM\", \"SIGINT\", \"SIGHUP\"] as const) process.on(signal, onTerminate);\n\n  try {\n    await run(\"mkfifo\", [\"-m\", \"600\", fifoIn, fifoOut]);\n  } catch (err) {\n    await fail(wire, `cannot create the environment's fifos: ${errorText(err)}`);\n    await teardown();\n    abandon();\n  }\n\n  // Open the read side in the background, then start the payload that unblocks\n  // it — the order the fifo handshake requires.\n  const connection = FifoUtf8NlineTransport.beginConnect(fifoIn, fifoOut);\n  const workerArgs = [worker, ...passthrough, `--fifo-in=${fifoIn}`, `--fifo-out=${fifoOut}`];\n  // Whatever the client said starts the payload, run as it said: a runtime with a script of\n  // ours, or a program of the caller's own.  The gateway does not know which it is, and does\n  // not choose a runtime on the far end's behalf.\n  const workerProc = spawn(workerArgs[0]!, workerArgs.slice(1), {\n    stdio: [\"ignore\", \"pipe\", \"pipe\"],\n  });\n  child = workerProc;\n  forwardOutput(workerProc.stdout, wire, 1);\n  forwardOutput(workerProc.stderr, wire, 2);\n\n  const exited = new Promise<number>((settle) => {\n    // A payload killed by a signal (the client hung up, and we killed it) has no\n    // code — for us that is a clean end, not a failure.\n    workerProc.once(\"exit\", (code) => settle(code ?? 0));\n  });\n\n  try {\n    fifo = await Promise.race([\n      connection.transport,\n      exited.then((code) => {\n        throw new Error(`the payload exited with code ${code} before it opened its channel`);\n      }),\n    ]);\n  } catch (err) {\n    await fail(wire, errorText(err));\n    await teardown();\n    abandon();\n  }\n\n  // Relay: the protocol is the client's and the payload's business, not ours.\n  const relay = fifo;\n  relay.onMessage((line) => {\n    void wire.send(line).catch(() => {\n      /* client gone */\n    });\n  });\n  wire.onMessage((line) => {\n    void relay.send(line).catch(() => {\n      /* the payload is gone; its exit path cleans up */\n    });\n  });\n  wire.onClose(() => {\n    child?.kill();\n  });\n\n  const code = await exited;\n  await teardown();\n  await wire.close();\n  return code;\n}\n","// ── The gateway, as a program ──────────────────────────────────────────────\n//\n// A gateway is something a client runs: the first-stage command that makes a fifo\n// inside a foreign environment and relays frames between its own stdin/stdout and\n// the payload.  That is this file's whole job — it always serves, and it exits with\n// the code the run ended in.\n//\n// Serving lives in ./gateway.js and starts nothing by itself.  A file cannot decide\n// \"am I the program?\" from where it is: a consumer that bundles the node surface\n// into its own program carries this code along, and there the bundle *is* the\n// program — a payload would find a gateway booting on its wire.  So the decision is\n// in the layout instead: importing a module never starts anything, and running this\n// one always does.\n//\n// The client names it either way: `posipaki/remote/gateway-cli.js` is a published\n// specifier, so `import.meta.resolve` answers with the built file, and a consumer\n// with a program of its own stages that instead.  Nothing here works out its own\n// location — a path derived from `import.meta.url` is a guess about a layout the\n// bundler owns, and the guess is wrong the moment the module moves into a chunk.\n\nimport { GATEWAY_FAILED, runGateway } from \"./gateway.js\";\n\nvoid (async () => {\n  try {\n    process.exitCode = await runGateway();\n  } catch (err) {\n    process.stderr.write(`gateway: ${err instanceof Error ? err.message : String(err)}\\n`);\n    process.exitCode = GATEWAY_FAILED;\n  }\n})();\n"],"mappings":"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"}