posipaki 0.33.1 → 0.35.0

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/{gateway-BGdUHktZ.js → gateway-Cj3HSrl3.js}

@@ -1,12 +1,9 @@
-import { t as LIB_VERSION } from "./version-W7guWJeR.js";
 import { c as isProto, i as json1Channel, t as VERSION } from "./json1-DS3xxg13.js";
 import { mkdtemp, open, rm } from "node:fs/promises";
 import * as readline from "node:readline";
 import { execFile, spawn } from "node:child_process";
-import { createHash } from "node:crypto";
 import { tmpdir } from "node:os";
-import { dirname, extname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { basename, join } from "node:path";
 import { createReadStream, createWriteStream } from "node:fs";
 import { promisify } from "node:util";
 //#region src/remote/transports/fifo.ts
@@ -375,228 +372,37 @@ async function serverChannel(streams) {
 	return channel;
 }
 //#endregion
-//#region src/remote/kit.ts
-/** Runtimes a kit is happy to be run with, best first.  A caller may override. */
-const DEFAULT_RUNTIMES = [
-	"node",
-	"nodejs",
-	"bun"
-];
-/** Layout of a staged kit — the contract's own version, recorded in `version.json`. */
-const KIT_LAYOUT = 1;
-/** Where kits live on a host, relative to `$HOME`, unless the caller says otherwise. */
-const DEFAULT_KIT_PARENT = "bin/posipaki";
-/** Hex sha256 of some content. */
-function sha256Hex(content) {
-	return createHash("sha256").update(content).digest("hex");
-}
-/** The directory name a kit with these contents, this owner and this posipaki gets. */
-function kitName(app, manifestHash) {
-	return `${app.name}-${app.version}-posipaki-${LIB_VERSION}-${manifestHash.slice(0, 8)}`;
-}
-/**
-* One line naming a staged artifact: what it is, which posipaki it speaks, which
-* kit layout it was built for.  A client that staged it can judge compatibility
-* from this alone — nothing else is claimed.
-*/
-function versionLine(app, role, proto) {
-	return `${app.name}-${role} ${app.version} posipaki ${LIB_VERSION} proto ${proto} layout 1`;
-}
-/** Wrap base64 at a comfortable width; `base64 -d` ignores the newlines. */
-function wrapped(base64, width = 76) {
-	const lines = [];
-	for (let at = 0; at < base64.length; at += width) lines.push(base64.slice(at, at + width));
-	return lines.join("\n");
-}
-/**
-* Describe a kit around its files.  The manifest hash covers the files only, so
-* `version.json` — which records that hash — can be one of them without chasing
-* its own tail.
-*/
-function makeKit(files, options) {
-	const raw = files.map((file) => ({
-		name: file.name,
-		bytes: Buffer.byteLength(file.content),
-		sha256: sha256Hex(file.content),
-		base64: Buffer.from(file.content).toString("base64")
-	}));
-	const manifestHash = sha256Hex(raw.map((f) => `${f.name} ${f.sha256} ${f.bytes}`).join("\n"));
-	const kit = {
-		name: kitName(options.app, manifestHash),
-		manifestHash,
-		files: raw,
-		runtimes: [...options.runtimes ?? DEFAULT_RUNTIMES],
-		parent: options.parent ?? "bin/posipaki",
-		app: options.app
-	};
-	const version = Buffer.from(`${JSON.stringify(kitVersion(kit), null, 2)}\n`);
-	return {
-		...kit,
-		files: [...kit.files, {
-			name: "version.json",
-			bytes: version.byteLength,
-			sha256: sha256Hex(version),
-			base64: version.toString("base64")
-		}]
-	};
-}
-/** What `version.json` says: identity, versions, and the exact content hashes. */
-function kitVersion(kit) {
-	return {
-		kit: kit.name,
-		app: kit.app,
-		posipaki: LIB_VERSION,
-		layout: 1,
-		manifestHash: kit.manifestHash,
-		files: kit.files.map((file) => ({
-			name: file.name,
-			sha256: file.sha256,
-			bytes: file.bytes
-		}))
-	};
-}
-/** The `[ -f … ] && [ "$(wc -c < …)" -eq … ]` test for one file. */
-function presentTest(file) {
-	return `[ -f "$kit_dir/${file.name}" ] && [ "$(wc -c < "$kit_dir/${file.name}")" -eq ${file.bytes} ]`;
-}
-/** One file: write it to a temp name, then move it into place. */
-function writeFile(file) {
-	return [
-		`  base64 -d > "$tmp" <<'KIT_FILE'`,
-		wrapped(file.base64),
-		"KIT_FILE",
-		`  mv "$tmp" "$kit_dir/${file.name}" || { echo "error cannot install ${file.name}"; exit 73; }`
-	].join("\n");
-}
-/**
-* The bootstrap, as one POSIX sh script.
-*
-* Staging is the whole job.  The script always arrives on stdin, never in argv,
-* and that is also why it cannot carry the wire: the caller runs the payload on a
-* second channel into the same environment once this one has reported.
-*/
-function bootstrapScript(kit) {
-	const checks = kit.files.map(presentTest).join(" && \\\n  ");
-	return `${[
-		"# ── kit bootstrap ─────────────────────────────────────────────────────────",
-		"# probe, stage what is missing, report every step as one machine-readable line.",
-		"set -u",
-		"",
-		"if [ -z \"${HOME:-}\" ]; then echo \"error HOME is not set\"; exit 74; fi",
-		`kit_dir="$HOME/${kit.parent}/${kit.name}"`,
-		"",
-		"runtime=\"\"",
-		`for candidate in ${kit.runtimes.join(" ")}; do`,
-		"  if command -v \"$candidate\" >/dev/null 2>&1; then runtime=\"$(command -v \"$candidate\")\"; break; fi",
-		"done",
-		`if [ -z "$runtime" ]; then echo "error no runtime among: ${kit.runtimes.join(" ")}"; exit 75; fi`,
-		"if ! command -v base64 >/dev/null 2>&1; then echo \"error base64 is missing\"; exit 76; fi",
-		"",
-		`if ${checks}; then`,
-		"  echo \"present\"",
-		"else",
-		`  mkdir -p "$kit_dir" || { echo "error cannot create $kit_dir"; exit 73; }`,
-		"  tmp=\"$kit_dir/.staging.$$\"",
-		...kit.files.map(writeFile),
-		"  echo \"staged\"",
-		"fi",
-		"echo \"kit $kit_dir\"",
-		"echo \"runtime $runtime\""
-	].join("\n")}\n`;
-}
-/** Read the script's report back.  Missing or unknown lines are an error. */
-function parseBootstrapReport(stdout) {
-	let kitDir = "";
-	let runtime = "";
-	let staged = null;
-	for (const raw of stdout.split("\n")) {
-		const line = raw.trim();
-		if (line === "") continue;
-		if (line.startsWith("error ")) return {
-			kind: "error",
-			reason: line.slice(6)
-		};
-		if (line === "staged") {
-			staged = true;
-			continue;
-		}
-		if (line === "present") {
-			staged = false;
-			continue;
-		}
-		if (line.startsWith("kit ")) {
-			kitDir = line.slice(4);
-			continue;
-		}
-		if (line.startsWith("runtime ")) {
-			runtime = line.slice(8);
-			continue;
-		}
-	}
-	if (kitDir === "" || runtime === "" || staged === null) {
-		const seen = stdout.trim();
-		return {
-			kind: "error",
-			reason: seen === "" ? "no report at all" : `incomplete report: ${seen}`
-		};
-	}
-	return {
-		kind: "ready",
-		kitDir,
-		runtime,
-		staged
-	};
-}
-//#endregion
 //#region src/remote/gateway.ts
 const run = promisify(execFile);
 /** Exit code for "this environment could not be set up". */
 const GATEWAY_FAILED = 1;
-/**
-* Absolute path to the gateway's entry point — the file a client runs as a
-* program.  It is this module's sibling, under whatever name this module has:
-* `gateway-cli.ts` from source, `gateway-cli.js` in a build.
-*/
-const GATEWAY_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), `gateway-cli${extname(fileURLToPath(import.meta.url)) || ".js"}`);
 function errorText(err) {
 	return err instanceof Error ? err.message : String(err);
 }
-function flagValue(argv, name) {
-	const prefix = `--${name}=`;
-	return argv.find((a) => a.startsWith(prefix))?.slice(prefix.length);
-}
-/** A `--flag=<positive integer>` argument, or undefined. */
-function positiveInt(value) {
-	const n = Number(value);
-	return value !== void 0 && Number.isFinite(n) && n >= 1 ? Math.floor(n) : void 0;
+/**
+* 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 argv that boots this gateway — built by the client, read by
 * {@link gatewayBoot}, so the two halves cannot drift apart.
+*
+* The payload comes first and its arguments after it, so a positional argument of the
+* payload's own can never be mistaken for the payload.
 */
 function gatewayArgs(boot) {
-	return [
-		`--worker=${boot.worker}`,
-		`--env=${boot.env}`,
-		`--app-name=${boot.app.name}`,
-		`--app-version=${boot.app.version}`,
-		...boot.poolSize === void 0 ? [] : [`--pool-size=${boot.poolSize}`]
-	];
+	return [boot.worker, ...boot.passthrough];
 }
 /** The boot a gateway was started with, or the reason it cannot start. */
 function gatewayBoot(argv) {
-	const worker = flagValue(argv, "worker");
-	if (!worker) throw new Error("no --worker=<script>: the gateway needs a payload to relay to");
-	const name = flagValue(argv, "app-name");
-	const version = flagValue(argv, "app-version");
-	if (!name || !version) throw new Error("no --app-name=<name> and --app-version=<version>: the gateway names its artifact");
+	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 {
-		app: {
-			name,
-			version
-		},
-		env: flagValue(argv, "env") ?? "unnamed",
-		poolSize: positiveInt(flagValue(argv, "pool-size")),
+		passthrough,
 		worker
 	};
 }
@@ -627,16 +433,7 @@ function forwardOutput(stream, wire, fd) {
 * Serve one environment over stdin/stdout.  Returns the exit code; the caller
 * turns it into `process.exitCode`.
 */
-async function runGateway(argv = process.argv) {
-	if (argv.includes("--version")) {
-		const name = flagValue(argv, "app-name") ?? "posipaki";
-		const version = flagValue(argv, "app-version") ?? "-";
-		process.stdout.write(`${versionLine({
-			name,
-			version
-		}, "gateway", VERSION)}\n`);
-		return 0;
-	}
+async function runGateway(argv = process.argv.slice(2)) {
 	const wire = new LineTransport({
 		read: process.stdin,
 		write: process.stdout
@@ -648,8 +445,8 @@ async function runGateway(argv = process.argv) {
 		await fail(wire, errorText(err));
 		abandon();
 	}
-	const { env, poolSize, worker } = booted;
-	const dir = await mkdtemp(join(tmpdir(), `posipaki-${env.replace(/\//g, "-")}-`));
+	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;
@@ -695,12 +492,11 @@ async function runGateway(argv = process.argv) {
 	const connection = FifoUtf8NlineTransport.beginConnect(fifoIn, fifoOut);
 	const workerArgs = [
 		worker,
-		`--env=${env}`,
-		...poolSize === void 0 ? [] : [`--pool-size=${poolSize}`],
+		...passthrough,
 		`--fifo-in=${fifoIn}`,
 		`--fifo-out=${fifoOut}`
 	];
-	const workerProc = spawn(process.execPath, workerArgs, { stdio: [
+	const workerProc = spawn(workerArgs[0], workerArgs.slice(1), { stdio: [
 		"ignore",
 		"pipe",
 		"pipe"
@@ -736,6 +532,6 @@ async function runGateway(argv = process.argv) {
 	return code;
 }
 //#endregion
-export { fdStreams as C, stderrSink as D, serverChannel as E, FifoUtf8NlineTransport as O, errorReason as S, parseOutputFrame as T, LineTransport as _, runGateway as a, clientChannel as b, KIT_LAYOUT as c, kitVersion as d, makeKit as f, HANDSHAKE_TIMEOUT_MS as g, versionLine as h, gatewayBoot as i, bootstrapScript as l, sha256Hex as m, GATEWAY_SCRIPT as n, DEFAULT_KIT_PARENT as o, parseBootstrapReport as p, gatewayArgs as r, DEFAULT_RUNTIMES as s, GATEWAY_FAILED as t, kitName as u, OutputFilter as v, outputFrame as w, errorFrame as x, StdioWireError as y };
+export { FifoUtf8NlineTransport as _, HANDSHAKE_TIMEOUT_MS as a, StdioWireError as c, errorReason as d, fdStreams as f, stderrSink as g, serverChannel as h, runGateway as i, clientChannel as l, parseOutputFrame as m, gatewayArgs as n, LineTransport as o, outputFrame as p, gatewayBoot as r, OutputFilter as s, GATEWAY_FAILED as t, errorFrame as u };
 
-//# sourceMappingURL=gateway-BGdUHktZ.js.map
+//# sourceMappingURL=gateway-Cj3HSrl3.js.map

package/dist/gateway-Cj3HSrl3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-Cj3HSrl3.js","names":["errorText","Lines"],"sources":["../src/remote/transports/fifo.ts","../src/remote/stdio.ts","../src/remote/gateway.ts"],"sourcesContent":["// ── 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","// ── 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","// ── 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"],"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.33.0";
+declare const LIB_VERSION = "0.35.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

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

package/dist/remote/gateway-cli.js

@@ -1,4 +1,4 @@
-import { a as runGateway } from "../gateway-BGdUHktZ.js";
+import { i as runGateway } from "../gateway-Cj3HSrl3.js";
 //#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\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":";;CAgBM,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":[],"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"}

package/dist/remote/index.d.ts

@@ -1,6 +1,6 @@
 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";
-import { a as isMsg, i as isInit, n as StringTransport, o as isProto, r as isExit, s as isState, t as Channel } from "../channel-HCjngMq_.js";
+import { l as ActorDefinition, v as ReflectionOptions } from "../hooks-CfQ8EhKW.js";
+import { a as isExit, c as isProto, i as StringTransport, l as isState, n as remoteClient, o as isInit, r as Channel, s as isMsg, t as ClientSpawner } from "../client-DHI-6XPF.js";
 //#region src/remote/server.d.ts
 type Spawner = () => Promise<Channel>;
 declare function makeSender(fromName: string, parentName: string | null, parentId: symbol | null): {
@@ -9,10 +9,6 @@ declare function makeSender(fromName: string, parentName: string | null, parentI
 };
 declare function serveRemoteActor<Args, State, InMsg extends Message, OutMsg extends Message, R extends ReflectionOptions>(actor: ActorDefinition<Args, State, InMsg, OutMsg, R>, spawner: Spawner): Promise<void>;
 //#endregion
-//#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
 //#region src/remote/protocols/json1.d.ts
 declare const VERSION = "json.v1";
 declare function encode(frame: Record<string, unknown>): string;

package/dist/remote/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/remote/server.ts","../../src/remote/client.ts","../../src/remote/protocols/json1.ts","../../src/remote/transports/websocket.ts","../../src/remote/transports/worker.ts","../../src/remote/spawners/ws-client.ts","../../src/remote/spawners/ws-server.ts","../../src/remote/spawners/worker-client.ts","../../src/remote/spawners/worker-self.ts"],"mappings":";;;;KAWY,gBAAgB,QAAQ;iBAEpB,WACd,kBACA,2BACA;EACG;EAAkB;;iBAOD,iBACpB,MACA,OACA,cAAc,SACd,eAAe,SACf,UAAU,mBACV,OAAO,gBAAgB,MAAM,OAAO,OAAO,QAAQ,IAAI,SAAS,UAAU;;;KCfhE,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;;;cCpBlC;iBAEG,OAAO,OAAO;iBAId,OAAO,cAAc;iBAIrB,aAAa,WAAW,kBAAkB;;;;;;;;UCJzC;EACf,KAAK;EACL,MAAM,eAAe;WACZ;EACT,aAAa;IAAS;;EACtB;;;cAIW;cAEA,8BAA8B;UACjC;UACA;UACA;UACA;EAER,YAAY,IAAI;MAWZ;EAIJ,UAAU,UAAU;EAQpB,mBAAmB;EAMnB,QAAQ;MAIJ;EAIE,KAAK,gBAAgB;EAMrB,SAAS;;;;;cC/DJ;;;;;;UAOI;EACf,YAAY;EACZ,aAAa;IAAS;;EACtB,YAAY;EACZ;;cAGW,2BAA2B;UAC9B;UACA;UACA;UACA;EAER,YAAY,QAAQ;MAgBhB;EAIJ,UAAU,UAAU,OAAO;EAQ3B,mBAAmB,OAAO;EAM1B,QAAQ;MAIJ;EAIE,KAAK,OAAO,0BAA0B;EAKtC,SAAS;;;;KClEL,qBAAqB;WACtB;EACT,KAAK;EACL,MAAM,eAAe;EACrB;EACA,WAAW;EACX,aAAa;IAAS;;EACtB;;iBAac,gBAAgB,gBAC9B,gBAAgB,MAAM,kBACtB,gBAAe,gBACd,cAAc;;;iBCzBD,gBAAgB,IAAI,gBAAgB;;;;;;;UAcnC;EACf,KAAK;EACL,MAAM,eAAe;WACZ;EACT;;;;;;;;;;;;;;;;;;;;;iBAsBc,mBAAmB,IAAI,yBAAyB;;;KCxCpD,kBAAkB,gBAAgB;iBAI9B,oBAAoB,gBAClC,gBAAgB,MAAM,kBACtB,aAAY,aACX,cAAc;;;iBCRD,kBAAkB,YAAW,aAAmD"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/remote/server.ts","../../src/remote/protocols/json1.ts","../../src/remote/transports/websocket.ts","../../src/remote/transports/worker.ts","../../src/remote/spawners/ws-client.ts","../../src/remote/spawners/ws-server.ts","../../src/remote/spawners/worker-client.ts","../../src/remote/spawners/worker-self.ts"],"mappings":";;;;KAWY,gBAAgB,QAAQ;iBAEpB,WACd,kBACA,2BACA;EACG;EAAkB;;iBAOD,iBACpB,MACA,OACA,cAAc,SACd,eAAe,SACf,UAAU,mBACV,OAAO,gBAAgB,MAAM,OAAO,OAAO,QAAQ,IAAI,SAAS,UAAU;;;cCtB/D;iBAEG,OAAO,OAAO;iBAId,OAAO,cAAc;iBAIrB,aAAa,WAAW,kBAAkB;;;;;;;;UCJzC;EACf,KAAK;EACL,MAAM,eAAe;WACZ;EACT,aAAa;IAAS;;EACtB;;;cAIW;cAEA,8BAA8B;UACjC;UACA;UACA;UACA;EAER,YAAY,IAAI;MAWZ;EAIJ,UAAU,UAAU;EAQpB,mBAAmB;EAMnB,QAAQ;MAIJ;EAIE,KAAK,gBAAgB;EAMrB,SAAS;;;;;cC/DJ;;;;;;UAOI;EACf,YAAY;EACZ,aAAa;IAAS;;EACtB,YAAY;EACZ;;cAGW,2BAA2B;UAC9B;UACA;UACA;UACA;EAER,YAAY,QAAQ;MAgBhB;EAIJ,UAAU,UAAU,OAAO;EAQ3B,mBAAmB,OAAO;EAM1B,QAAQ;MAIJ;EAIE,KAAK,OAAO,0BAA0B;EAKtC,SAAS;;;;KClEL,qBAAqB;WACtB;EACT,KAAK;EACL,MAAM,eAAe;EACrB;EACA,WAAW;EACX,aAAa;IAAS;;EACtB;;iBAac,gBAAgB,gBAC9B,gBAAgB,MAAM,kBACtB,gBAAe,gBACd,cAAc;;;iBCzBD,gBAAgB,IAAI,gBAAgB;;;;;;;UAcnC;EACf,KAAK;EACL,MAAM,eAAe;WACZ;EACT;;;;;;;;;;;;;;;;;;;;;iBAsBc,mBAAmB,IAAI,yBAAyB;;;KCxCpD,kBAAkB,gBAAgB;iBAI9B,oBAAoB,gBAClC,gBAAgB,MAAM,kBACtB,aAAY,aACX,cAAc;;;iBCRD,kBAAkB,YAAW,aAAmD"}