@earendil-works/chord 1.5.0 → 1.5.1

package/dist/node/tui/sandbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox.js","sourceRoot":"","sources":["../../../src/node/tui/sandbox.ts"],"names":[],"mappings":"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","sourcesContent":["// The terminal's sandbox (slice 11 §4, decision \"Slice 11, P8\"; fix round 2: a child process, as the owner decided\n// after the worker thread was escaped through its shared realm): a Node child process of the launcher's binary.\n// - The operating system's side: its stdin, stdout and stderr are pipes to the launcher (never the terminal: no\n//   descriptor of the child is a TTY), its environment empty, its directory a private one holding only the bootstrap;\n//   Node's permission model with nothing allowed but reading the bootstrap (no other file read, no write, no network,\n//   no child processes, no workers, no addons, no inspector, no WASI) and `node:sqlite` removed\n//   (`--no-experimental-sqlite`: SQLite opens files past the permission model). An escape from the JavaScript layer\n//   reaches no terminal, no file, no socket, no launcher memory or token.\n// - The JavaScript side, a second layer: downloaded code (the base bundle, a CommonJS script; the plugins' registered\n//   scripts) is only evaluated by the bootstrap (`vm.Script` with no dynamic import callback, so `import()` throws),\n//   with a `require` answering the allowed builtins only (`SANDBOX_BUILTINS`); `process` is a substitute with\n//   `SANDBOX_PROCESS` only. The bootstrap keeps its own references to what it uses before any downloaded code runs.\n// Messages go both ways as length-prefixed binary frames (`pipe.ts`). Known gaps, each needing the JavaScript layer\n// broken first unless noted: the child may signal processes of the same user (Node has no permission for signals; the\n// launcher ignores SIGUSR1, which would open its inspector), read machine details (`os`), learn whether any path exists\n// (`require.resolve` fails one way for a file that exists, another for one that does not: Opus E13), and allocate\n// memory outside its heap (no limit without a shell's `ulimit`; only the child dies). Needs Node 26.5.1 or later.\n\nimport { type ChildProcessWithoutNullStreams, spawn } from \"node:child_process\";\nimport { mkdtemp, realpath, rm, writeFile } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport type { BridgeStart, LauncherMessage, SandboxMessage } from \"../../tui/bridge.ts\";\nimport { FrameReader, launcherFrame, MAX_PIPE_FRAME, startFrame } from \"./pipe.ts\";\n\n/** The largest base bundle a sandbox runs: 8 MiB. */\nexport const MAX_BUNDLE = 8 * 1024 * 1024;\n\n/**\n * The builtins code in the sandbox may `require`, each computation in memory without I/O, descriptors or machine\n * details: bytes and text (`buffer`, `string_decoder`, `punycode`, `querystring`), events and streams in memory\n * (`events`, `stream` and its submodules), formatting and type checks (`util`, `util/types`), URL and path strings\n * (`url`, `path`), timers, assertions, hashing and randomness (`crypto`: no keys from files, no network) and compression\n * in memory (`zlib`). Not `fs`, `tty`, `net`, `dgram`, `dns`, `http`, `https`, `http2`, `tls`, `child_process`,\n * `cluster`, `worker_threads`, `sqlite`, `inspector`, `vm`, `v8`, `os`, `module`, `process`, `perf_hooks`, `wasi`,\n * `repl`, `readline`, `trace_events` or anything else.\n */\nexport const SANDBOX_BUILTINS: readonly string[] = [\n\t\"assert\",\n\t\"assert/strict\",\n\t\"buffer\",\n\t\"crypto\",\n\t\"events\",\n\t\"path\",\n\t\"path/posix\",\n\t\"path/win32\",\n\t\"punycode\",\n\t\"querystring\",\n\t\"stream\",\n\t\"stream/consumers\",\n\t\"stream/promises\",\n\t\"stream/web\",\n\t\"string_decoder\",\n\t\"timers\",\n\t\"timers/promises\",\n\t\"url\",\n\t\"util\",\n\t\"util/types\",\n\t\"zlib\",\n];\n\n/**\n * The sandbox's `process`: a frozen plain object in place of Node's (no event emitter, so no prototype shared with\n * Node's internals leads back to the real one). Its properties, each harmless: which Node it is (`arch`, `platform`,\n * `version`, `versions`, `release`), time (`nextTick`, `hrtime`, `uptime`), ending the sandbox (`exit`), the permission\n * checks (`permission`), the allowed builtins (`getBuiltinModule`), fixed values (`env` empty, `argv`, `argv0`,\n * `execArgv`, `execPath`, `title`, `cwd` `/`), `stdout` (to the terminal through the bridge) and `stderr` (dropped),\n * and listener calls that keep nothing (`on`, `once`, `off`, `addListener`, `removeListener`, `removeAllListeners`,\n * `emit`, `emitWarning`, `listenerCount`, `listeners`). Not `binding`, `_linkedBinding`, `dlopen`, `_rawDebug`, `kill`,\n * `execve`, `chdir`, `abort`, `reallyExit`, `stdin`, `openStdin`, `report`, `pid`, `ppid`, `config`, the user and group\n * calls, `loadEnvFile`, `moduleLoadList`, resource and handle listings or any other.\n */\nexport const SANDBOX_PROCESS: readonly string[] = [\n\t\"addListener\",\n\t\"arch\",\n\t\"argv\",\n\t\"argv0\",\n\t\"cwd\",\n\t\"emit\",\n\t\"emitWarning\",\n\t\"env\",\n\t\"execArgv\",\n\t\"execPath\",\n\t\"exit\",\n\t\"getBuiltinModule\",\n\t\"hrtime\",\n\t\"listenerCount\",\n\t\"listeners\",\n\t\"nextTick\",\n\t\"off\",\n\t\"on\",\n\t\"once\",\n\t\"permission\",\n\t\"platform\",\n\t\"release\",\n\t\"removeAllListeners\",\n\t\"removeListener\",\n\t\"stderr\",\n\t\"stdout\",\n\t\"title\",\n\t\"uptime\",\n\t\"version\",\n\t\"versions\",\n];\n\n/**\n * The child's Node flags for its script `script`: the permission model allowing only reading that file, no SQLite, a\n * 96 MiB heap. Exported for the tests of the operating system's layer alone.\n */\nexport function sandboxFlags(script: string): string[] {\n\treturn [\"--permission\", `--allow-fs-read=${script}`, \"--no-experimental-sqlite\", \"--max-old-space-size=96\", script];\n}\n\n/** The bootstrap's file in the sandbox's directory: a script, not `-e`, which puts every builtin on `globalThis`. */\nexport const BOOTSTRAP_FILE = \"bootstrap.cjs\";\n\n/** The most bytes waiting for the sandbox to read them before it counts as stuck: 64 MiB. */\nconst MAX_UNREAD = 64 * 1024 * 1024;\n\n/** Throws unless this Node is 26.5.1 or later, the Node the sandbox's permissions were checked on. */\nexport function requireSandboxNode(version: string = process.versions.node): void {\n\tconst [major = 0, minor = 0, patch = 0] = version.split(\".\").map(Number);\n\tif (major > 26 || (major === 26 && (minor > 5 || (minor === 5 && patch >= 1)))) return;\n\tthrow new Error(`the terminal client needs Node 26.5.1 or later for its sandbox (this is Node ${version})`);\n}\n\n/**\n * The child's environment: empty, but for `LD_LIBRARY_PATH` when the launcher has one: the launcher needed it to run\n * this same binary (a Node built against libraries outside the system's paths), and the server cannot influence it.\n */\nexport function sandboxEnvironment(): Record<string, string> {\n\tconst libraries = process.env.LD_LIBRARY_PATH;\n\treturn libraries === undefined ? {} : { LD_LIBRARY_PATH: libraries };\n}\n\n/** A running sandbox: messages both ways, and its end. */\nexport class Sandbox {\n\treadonly #child: ChildProcessWithoutNullStreams;\n\treadonly #directory: string;\n\treadonly #onMessage: (message: SandboxMessage) => void;\n\treadonly #onEnd: (reason: string) => void;\n\treadonly #reader = new FrameReader();\n\treadonly #exited: Promise<void>;\n\t#ended = false;\n\t/** Whether the child has sent anything: its bootstrap was read, so the file goes. */\n\t#running = false;\n\n\t/**\n\t * Starts a sandbox running the base bundle `source` (a CommonJS script) with `start` on its bridge; `onMessage` gets\n\t * what it sends, `onEnd` its end (an exit, a crash, its memory limit, a malformed frame), once.\n\t */\n\tstatic async start(\n\t\tsource: string,\n\t\tstart: BridgeStart,\n\t\tonMessage: (message: SandboxMessage) => void,\n\t\tonEnd: (reason: string) => void,\n\t): Promise<Sandbox> {\n\t\trequireSandboxNode();\n\t\tif (Buffer.byteLength(source) > MAX_BUNDLE) throw new Error(\"terminal: the base bundle exceeds 8 MiB\");\n\t\t// Node resolves its entry before reading it; a symlinked ancestor would need a broader file grant.\n\t\tconst directory = await realpath(await mkdtemp(join(tmpdir(), \"chord-tui-\")));\n\t\tawait writeFile(join(directory, BOOTSTRAP_FILE), BOOTSTRAP);\n\t\tconst sandbox = new Sandbox(directory, onMessage, onEnd);\n\t\tsandbox.#write(startFrame(start, source));\n\t\treturn sandbox;\n\t}\n\n\tprivate constructor(\n\t\tdirectory: string,\n\t\tonMessage: (message: SandboxMessage) => void,\n\t\tonEnd: (reason: string) => void,\n\t) {\n\t\tthis.#directory = directory;\n\t\tthis.#onMessage = onMessage;\n\t\tthis.#onEnd = onEnd;\n\t\tthis.#child = spawn(process.execPath, sandboxFlags(join(directory, BOOTSTRAP_FILE)), {\n\t\t\tstdio: [\"pipe\", \"pipe\", \"pipe\"],\n\t\t\tenv: sandboxEnvironment(),\n\t\t\tcwd: directory,\n\t\t\twindowsHide: true,\n\t\t});\n\t\tthis.#exited = new Promise((resolve) => this.#child.once(\"close\", () => resolve()));\n\t\tthis.#child.stdout.on(\"data\", (chunk: Buffer) => this.#read(chunk));\n\t\t// Dropped: the sandbox writes only through the bridge, and the terminal is the launcher's.\n\t\tthis.#child.stderr.resume();\n\t\t// A write after the child ended fails here; its end is reported by `close`.\n\t\tthis.#child.stdin.on(\"error\", () => {});\n\t\tthis.#child.on(\"error\", (error) => this.#end(`the terminal client failed: ${error.message}`));\n\t\tthis.#child.on(\"close\", () => {\n\t\t\tthis.#end(\"the terminal client exited\");\n\t\t\tvoid rm(this.#directory, { recursive: true, force: true });\n\t\t});\n\t}\n\n\t/** Sends `message` to the sandbox; a sandbox not reading what it was sent is ended. */\n\tpost(message: LauncherMessage): void {\n\t\tif (!this.#ended) this.#write(launcherFrame(message));\n\t}\n\n\t/** Ends the sandbox and waits for its exit. */\n\tasync terminate(): Promise<void> {\n\t\tthis.#ended = true;\n\t\tthis.#child.kill(\"SIGKILL\");\n\t\tawait this.#exited;\n\t}\n\n\t#write(frame: Buffer): void {\n\t\tif (this.#child.stdin.writableLength + frame.length > MAX_UNREAD + MAX_PIPE_FRAME) {\n\t\t\tthis.#fail(\"the terminal client stopped reading\");\n\t\t\treturn;\n\t\t}\n\t\tthis.#child.stdin.write(frame);\n\t}\n\n\t/** The sandbox's output: its messages, each passed on; a malformed one ends the sandbox. */\n\t#read(chunk: Buffer): void {\n\t\tif (this.#ended) return;\n\t\tif (!this.#running) {\n\t\t\tthis.#running = true;\n\t\t\t// Read once at the start; a launcher killed later leaves at most an empty directory.\n\t\t\tvoid rm(join(this.#directory, BOOTSTRAP_FILE), { force: true });\n\t\t}\n\t\tlet messages: SandboxMessage[];\n\t\ttry {\n\t\t\tmessages = this.#reader.push(chunk);\n\t\t} catch (error) {\n\t\t\tthis.#fail((error as Error).message);\n\t\t\treturn;\n\t\t}\n\t\tfor (const message of messages) if (!this.#ended) this.#onMessage(message);\n\t}\n\n\t#fail(reason: string): void {\n\t\tthis.#child.kill(\"SIGKILL\");\n\t\tthis.#end(reason);\n\t}\n\n\t#end(reason: string): void {\n\t\tif (this.#ended) return;\n\t\tthis.#ended = true;\n\t\tthis.#onEnd(reason);\n\t}\n}\n\n/**\n * The trusted bootstrap (strict CommonJS, the child's main script). Before any downloaded code runs it keeps its own\n * references to what it uses (so code that changes shared prototypes later cannot steer it), closes the file system's\n * functions, shadows the real `process`'s listener calls, puts the substitute `process` in place, removes the module\n * globals and leaves the bridge on `globalThis`; then it waits for the launcher's start frame and evaluates the base\n * bundle through its own `require`. Frames as in `pipe.ts`.\n */\nconst BOOTSTRAP = `\"use strict\";\nconst real = process;\nconst getBuiltin = real.getBuiltinModule;\nconst apply = Reflect.apply;\nconst uncurry = Function.prototype.call.bind(Function.prototype.bind, Function.prototype.call);\nconst parse = JSON.parse;\nconst stringify = JSON.stringify;\nconst freeze = Object.freeze;\nconst define = Object.defineProperty;\nconst BufferFrom = Buffer.from;\nconst BufferAlloc = Buffer.allocUnsafe;\nconst BufferConcat = Buffer.concat;\nconst readUInt32BE = uncurry(Buffer.prototype.readUInt32BE);\nconst writeUInt32BE = uncurry(Buffer.prototype.writeUInt32BE);\nconst bufferText = uncurry(Buffer.prototype.toString);\nconst subarray = uncurry(Buffer.prototype.subarray);\nconst copyBytes = uncurry(Buffer.prototype.copy);\nconst isUint8Array = (value) => value instanceof Uint8Array;\nconst builtin0 = (id) => apply(getBuiltin, real, [id]);\nconst Script = builtin0(\"node:vm\").Script;\nconst runInThisContext = uncurry(Script.prototype.runInThisContext);\nconst nextTick = real.nextTick;\nconst hrtime = real.hrtime;\nconst hrtimeBigint = real.hrtime.bigint;\nconst uptime = real.uptime;\nconst exit = real.exit;\nconst input = real.stdin;\nconst output = real.stdout;\nconst writeOutput = uncurry(output.write);\nconst onInput = uncurry(input.on);\nconst MAX_FRAME = ${MAX_PIPE_FRAME};\nconst deny = () => {\n\tthrow new Error(\"unavailable in the terminal's sandbox\");\n};\n\n// The file system's functions closed: the permission model guards paths, not the pipes' descriptors.\nfor (const facade of [builtin0(\"node:fs\"), builtin0(\"node:fs/promises\")]) {\n\tfor (const name of Object.keys(facade)) {\n\t\tif (typeof facade[name] === \"function\") define(facade, name, { value: deny, writable: false, configurable: false, enumerable: true });\n\t}\n}\nconst v8 = builtin0(\"node:v8\");\nfor (const name of [\"writeHeapSnapshot\", \"getHeapSnapshot\", \"queryObjects\", \"setFlagsFromString\", \"takeCoverage\", \"startCpuProfile\", \"startHeapProfile\"]) {\n\tif (typeof v8[name] === \"function\") v8[name] = deny;\n}\nbuiltin0(\"node:module\").syncBuiltinESMExports();\n// Node emits on its own process (warnings among them): its listener calls are its own properties, not the shared\n// prototype's, which downloaded code may change.\nconst emitter = builtin0(\"node:events\").EventEmitter.prototype;\nfor (const name of Object.getOwnPropertyNames(emitter)) {\n\tif (name !== \"constructor\" && typeof emitter[name] === \"function\") define(real, name, { value: emitter[name], writable: false, configurable: false });\n}\n// Node reads properties its process does not have (noDeprecation, throwDeprecation, traceDeprecation,\n// traceProcessWarnings, channel, connected, …): such a read goes up the prototype chain, where a getter would get the\n// real process as its this (Opus E7: Buffer(1) warns, and the warning reads process.noDeprecation). Every prototype of\n// the chain, Object.prototype included, takes no new property and keeps its own ones, so no getter and no other\n// prototype gets in. Not frozen: Node assigns over prototype fields (\\`this._events ??= {}\\`).\nfor (let prototype = Object.getPrototypeOf(real); prototype !== null; prototype = Object.getPrototypeOf(prototype)) {\n\tfor (const key of Reflect.ownKeys(prototype)) define(prototype, key, { configurable: false });\n\tObject.preventExtensions(prototype);\n}\n\n// The allowed builtins, by name with or without \"node:\"; looked up in an object of no prototype.\nconst allowed = Object.create(null);\nfor (const name of ${JSON.stringify(SANDBOX_BUILTINS)}) allowed[name] = true;\nconst builtin = (id) => {\n\tif (typeof id !== \"string\") throw new Error(\"unavailable in the terminal's sandbox\");\n\tconst name = id.length > 5 && id[0] === \"n\" && id[1] === \"o\" && id[2] === \"d\" && id[3] === \"e\" && id[4] === \":\" ? id.slice(5) : id;\n\tif (typeof name !== \"string\" || allowed[name] !== true) throw new Error(id + \": unavailable in the terminal's sandbox\");\n\treturn builtin0(\"node:\" + name);\n};\n\n// Frames out: the message's header as JSON, its write text or socket bytes as the body.\nconst send = (message) => {\n\tconst kind = message.kind;\n\tlet header;\n\tlet body;\n\tif (kind === \"write\") {\n\t\tconst data = String(message.data);\n\t\t// Refused before it is copied: a huge string costs no buffer of its size.\n\t\tif (data.length > MAX_FRAME) throw new RangeError(\"the terminal's bridge takes frames of at most 17 MiB\");\n\t\theader = { kind };\n\t\tbody = BufferFrom(data);\n\t} else if (kind === \"socket_send\") {\n\t\tif (!isUint8Array(message.bytes)) throw new TypeError(\"socket_send: bytes expected\");\n\t\theader = { kind, socket: message.socket };\n\t\tbody = message.bytes;\n\t} else {\n\t\theader = message;\n\t}\n\tconst json = BufferFrom(stringify(header));\n\tconst length = 4 + json.length + (body === undefined ? 0 : body.length);\n\tif (length > MAX_FRAME) throw new RangeError(\"the terminal's bridge takes frames of at most 17 MiB\");\n\tconst prefix = BufferAlloc(8);\n\twriteUInt32BE(prefix, length, 0);\n\twriteUInt32BE(prefix, json.length, 4);\n\twriteOutput(output, BufferConcat(body === undefined ? [prefix, json] : [prefix, json, body]));\n};\n\n// The substitute process.\nconst stdout = freeze({ isTTY: false, write: (data) => (send({ kind: \"write\", data: String(data) }), true) });\nconst listening = (name) => [name, function () { return fake; }];\nconst fake = freeze({\n\tarch: real.arch,\n\tplatform: real.platform,\n\tversion: real.version,\n\tversions: freeze({ ...real.versions }),\n\trelease: freeze({ ...real.release }),\n\tnextTick: (...args) => apply(nextTick, real, args),\n\thrtime: Object.assign((...args) => apply(hrtime, real, args), { bigint: () => apply(hrtimeBigint, real, []) }),\n\tuptime: () => apply(uptime, real, []),\n\texit: (code) => apply(exit, real, [code]),\n\tpermission: real.permission,\n\tenv: freeze({}),\n\targv: freeze([\"node\"]),\n\targv0: \"node\",\n\texecArgv: freeze([]),\n\texecPath: \"node\",\n\ttitle: \"node\",\n\tcwd: () => \"/\",\n\tgetBuiltinModule: builtin,\n\tstdout,\n\tstderr: freeze({ isTTY: false, write: () => true }),\n\t...Object.fromEntries([\"on\", \"once\", \"off\", \"addListener\", \"removeListener\", \"removeAllListeners\"].map(listening)),\n\temit: () => false,\n\temitWarning: () => {},\n\tlistenerCount: () => 0,\n\tlisteners: () => [],\n});\ndefine(globalThis, \"process\", { value: fake, writable: false, configurable: false, enumerable: false });\nfor (const name of [\"BroadcastChannel\", \"localStorage\", \"sessionStorage\"]) delete globalThis[name];\n\n// Downloaded code runs only through here, with options of no prototype (nothing read from Object.prototype).\nconst evaluate = (text, filename) => {\n\tconst options = Object.create(null);\n\toptions.filename = String(filename);\n\treturn runInThisContext(new Script(String(text), options));\n};\n\n// Frames in: the first is the start (the bridge's start and the base bundle), the rest the launcher's messages.\nlet listener;\nlet started = false;\n// Unread bytes: one buffer, grown by doubling, each byte copied in once.\nlet pending = BufferAlloc(64 * 1024);\nlet start = 0;\nlet end = 0;\nconst received = (payload) => {\n\tconst headerLength = readUInt32BE(payload, 0);\n\tconst header = parse(bufferText(payload, \"utf8\", 4, 4 + headerLength));\n\tconst body = subarray(payload, 4 + headerLength);\n\tif (!started) {\n\t\tstarted = true;\n\t\trun(header.start, bufferText(body, \"utf8\"));\n\t\treturn;\n\t}\n\tif (header.kind === \"input\") header.data = bufferText(body, \"utf8\");\n\telse if (header.kind === \"socket_message\" || header.kind === \"attached\") header.bytes = new Uint8Array(body);\n\tif (listener !== undefined) listener(header);\n};\nonInput(input, \"data\", (chunk) => {\n\tif (end + chunk.length > pending.length) {\n\t\tconst unread = end - start;\n\t\tconst target = unread + chunk.length <= pending.length ? pending : BufferAlloc(Math.max(unread + chunk.length, pending.length * 2));\n\t\tcopyBytes(pending, target, 0, start, end);\n\t\tpending = target;\n\t\tstart = 0;\n\t\tend = unread;\n\t}\n\tcopyBytes(chunk, pending, end);\n\tend += chunk.length;\n\twhile (end - start >= 4) {\n\t\tconst length = readUInt32BE(pending, start);\n\t\tif (length > MAX_FRAME) apply(exit, real, [70]);\n\t\tif (end - start < 4 + length) break;\n\t\t// A copy: the buffer is reused, and what the frame carries is kept by the sandbox.\n\t\tconst payload = BufferAlloc(length);\n\t\tcopyBytes(pending, payload, 0, start + 4, start + 4 + length);\n\t\tstart += 4 + length;\n\t\treceived(payload);\n\t}\n\tif (start === end) start = end = 0;\n});\nonInput(input, \"end\", () => apply(exit, real, [0]));\nconst run = (start, source) => {\n\tglobalThis.chordBridge = freeze({\n\t\tstart: freeze(start),\n\t\tsend,\n\t\tonMessage: (next) => {\n\t\t\tlistener = next;\n\t\t},\n\t\tevaluate,\n\t});\n\ttry {\n\t\tconst base = { exports: {} };\n\t\tevaluate(\"(function (require, module, exports) {\" + source + \"\\\\n})\", \"chord-base.js\")(builtin, base, base.exports);\n\t} catch (error) {\n\t\tsend({ kind: \"failed\", message: String(error && error.message) });\n\t}\n};\n`;\n"]}

package/dist/node/workers/base.d.ts

@@ -0,0 +1,30 @@
+import { type BaseInputs } from "../plugins/base-inputs.ts";
+/** A worker kind's bundled base: the file workers are forked from, and the files it was built from. */
+export interface WorkerBase {
+    /** The files esbuild read for it with their bytes' hashes: the app's base code, a file differing outdates it. */
+    readonly inputs: BaseInputs;
+    /**
+     * The entry module's path, its chunks beside it: written at the first call, and again when a temporary-file cleaner
+     * removed one of them (into a new temporary directory, or its named one).
+     */
+    file(): string;
+    /** Removes the bundle's directory, when `file()` wrote it. */
+    remove(): void;
+}
+/**
+ * Bundles `entry` for workers forked with `execArgv` (its `--conditions` resolve imports as the child's Node would),
+ * in memory; its files are written at the handle's first `file()`, into `dir` (a private directory the handle owns:
+ * emptied first, removed by `remove`) or, without one, a new temporary directory. Rejects with esbuild's failure.
+ */
+export declare function buildWorkerBase(entry: string, execArgv: readonly string[], dir?: string): Promise<WorkerBase>;
+/**
+ * The files of the static import graph of Node code started from `entry` with `conditions`, with their bytes' hashes: a
+ * best-effort scan (esbuild bundles it only to record what it reads; nothing is written or run). It sees the literal
+ * imports of the graph, including lazy literal `import()`s Node may never run (conservative: such a file's edit asks
+ * for a restart); a computed `import(x)` and modules a loader provides are not seen, and an import that does not
+ * resolve (an inactive optional import of a missing file or package, a loader's scheme) is left out. It resolves as
+ * Node does: the conditions, `main`, no `tsconfig.json` `paths`; installed packages are left out (never compared).
+ * Rejects with esbuild's failure for anything else (a file it cannot parse).
+ */
+export declare function nodeBaseInputs(entry: string, conditions: readonly string[]): Promise<BaseInputs>;
+//# sourceMappingURL=base.d.ts.map

package/dist/node/workers/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/node/workers/base.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,KAAK,UAAU,EAAiC,MAAM,2BAA2B,CAAC;AAG3F,uGAAuG;AACvG,MAAM,WAAW,UAAU;IAC1B,iHAAiH;IACjH,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B;;;OAGG;IACH,IAAI,IAAI,MAAM,CAAC;IACf,8DAA8D;IAC9D,MAAM,IAAI,IAAI,CAAC;CACf;AAaD;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA+CnH;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAkBtG"}

package/dist/node/workers/base.js

@@ -0,0 +1,255 @@
+// The worker base (decision "Workers start from the base code the server booted with"): a worker kind's entry and the
+// base code it imports, bundled once by esbuild when the workers component builds it (the kit: right after the server
+// listens), as the surfaces build their base bundles. Every worker of the kind is forked from this snapshot, so an edit
+// of the app's source while the server runs reaches workers only through a restart of the server. Packages installed under `node_modules` (native
+// addons, packages reading their own files) and Node builtins stay external: Node loads them at each fork from where
+// the build resolved them. Everything else, the app's files and workspace packages linked into `node_modules`, is
+// inlined. The bundle is split at each dynamic `import()` esbuild can follow: the entry module and the chunks it imports
+// statically load at each fork, a lazily imported module (pi-ai's provider APIs and the packages they import) only when
+// the worker imports it. Every file is an ES module with an inline source map, written at the first fork (`file()`;
+// a handle never forked writes nothing) into one private directory its handle owns and removes: a new temporary one, or
+// one the caller names (the kit's per kind in the data directory: the same path at every start, so Node's compile cache
+// knows the files). Every file the build read is recorded with its bytes' hash
+// (`BaseInputs`), as its one read hands them to esbuild.
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { isBuiltin } from "node:module";
+import { tmpdir } from "node:os";
+import { basename, dirname, extname, join, parse, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { build } from "esbuild";
+import { readRecorded, recordedSources } from "../plugins/base-inputs.js";
+import { conditionsOf } from "../surfaces/bundle.js";
+/**
+ * What `import.meta.url`, `.dirname` and `.filename` (and a CommonJS file's free `__dirname` and `__filename`) become: a
+ * module's own constants (`moduleLocations`).
+ */
+const MODULE_URL = "__chordModuleUrl";
+const MODULE_DIRNAME = "__chordModuleDirname";
+const MODULE_FILENAME = "__chordModuleFilename";
+/** The entry module's name in the bundle's directory (`worker.mjs`); chunks are named `<name>-<hash>.mjs`. */
+const ENTRY_NAME = "worker";
+/**
+ * Bundles `entry` for workers forked with `execArgv` (its `--conditions` resolve imports as the child's Node would),
+ * in memory; its files are written at the handle's first `file()`, into `dir` (a private directory the handle owns:
+ * emptied first, removed by `remove`) or, without one, a new temporary directory. Rejects with esbuild's failure.
+ */
+export async function buildWorkerBase(entry, execArgv, dir) {
+    // Built as if at the file system's root: the source map's paths relative to it, made absolute by `sourceRoot`.
+    const root = parse(resolve(entry)).root;
+    const inputs = new Map();
+    const result = await build({
+        entryPoints: [{ in: entry, out: ENTRY_NAME }],
+        // One flat directory: every chunk imports the others as `./<name>`, and the source maps' paths stay relative to
+        // the root.
+        outdir: root,
+        entryNames: "[name]",
+        chunkNames: "[name]-[hash]",
+        outExtension: { ".js": ".mjs" },
+        // A dynamic `import()` esbuild can follow becomes a chunk Node loads only when the worker imports it, with the
+        // packages it imports: inlined into one module, every lazily imported module would load and run at each fork.
+        splitting: true,
+        write: false,
+        bundle: true,
+        format: "esm",
+        platform: "node",
+        // Node's own resolution: the child's conditions, `main` only (no `module` condition or field).
+        conditions: conditionsOf(execArgv),
+        mainFields: ["main"],
+        // Every imported module runs, as Node runs it: `sideEffects: false` and pure annotations drop none (the entry's
+        // own package may say it, as Chord's does).
+        ignoreAnnotations: true,
+        // Function and class names as the source has them (`name` stays what unbundled code sees).
+        keepNames: true,
+        sourcemap: "inline",
+        sourcesContent: false,
+        sourceRoot: pathToFileURL(root).href,
+        // A CommonJS file of the base code requires through this (each chunk has its own); external packages by their
+        // absolute paths.
+        banner: {
+            js: 'import { createRequire as __chordCreateRequire } from "node:module"; const require = __chordCreateRequire(import.meta.url);',
+        },
+        define: {
+            "import.meta.url": MODULE_URL,
+            "import.meta.dirname": MODULE_DIRNAME,
+            "import.meta.filename": MODULE_FILENAME,
+            __dirname: MODULE_DIRNAME,
+            __filename: MODULE_FILENAME,
+        },
+        plugins: [installedPackages(), moduleLocations(inputs), recordedSources(inputs)],
+        logLevel: "silent",
+    });
+    const files = result.outputFiles.map((output) => ({ name: basename(output.path), contents: output.contents }));
+    return new BundleFiles(files, inputs, dir);
+}
+/**
+ * The files of the static import graph of Node code started from `entry` with `conditions`, with their bytes' hashes: a
+ * best-effort scan (esbuild bundles it only to record what it reads; nothing is written or run). It sees the literal
+ * imports of the graph, including lazy literal `import()`s Node may never run (conservative: such a file's edit asks
+ * for a restart); a computed `import(x)` and modules a loader provides are not seen, and an import that does not
+ * resolve (an inactive optional import of a missing file or package, a loader's scheme) is left out. It resolves as
+ * Node does: the conditions, `main`, no `tsconfig.json` `paths`; installed packages are left out (never compared).
+ * Rejects with esbuild's failure for anything else (a file it cannot parse).
+ */
+export async function nodeBaseInputs(entry, conditions) {
+    const inputs = new Map();
+    await build({
+        entryPoints: [entry],
+        write: false,
+        bundle: true,
+        format: "esm",
+        platform: "node",
+        conditions: [...conditions],
+        mainFields: ["main"],
+        // Node reads no tsconfig.json: its `paths` would resolve an import elsewhere than Node does.
+        tsconfigRaw: "{}",
+        // Every file the bundle reaches is read, as Node would load it; the output is dropped.
+        ignoreAnnotations: true,
+        plugins: [staticGraph(), recordedSources(inputs)],
+        logLevel: "silent",
+    });
+    return inputs;
+}
+/**
+ * The scan's resolution (`nodeBaseInputs`): an import resolving under a `node_modules` directory and one that does not
+ * resolve at all are left out (external); the rest resolves as esbuild does.
+ */
+function staticGraph() {
+    return {
+        name: "chord-node-base-static-graph",
+        setup(builder) {
+            builder.onResolve({ filter: /.*/ }, async (args) => {
+                if (args.pluginData === RESOLVING || args.kind === "entry-point" || isBuiltin(args.path))
+                    return undefined;
+                const resolved = await builder.resolve(args.path, {
+                    kind: args.kind,
+                    importer: args.importer,
+                    resolveDir: args.resolveDir,
+                    pluginData: RESOLVING,
+                });
+                const outside = resolved.errors.length > 0 || resolved.external || resolved.path.split(sep).includes("node_modules");
+                return outside ? { path: args.path, external: true } : resolved;
+            });
+        },
+    };
+}
+/** Marks the resolver's own call, so the plugin does not resolve it again. */
+const RESOLVING = Symbol("chord.worker-base.resolving");
+/**
+ * Keeps a package resolved under a `node_modules` directory external, by its absolute file (a URL for an `import`, a
+ * path for a `require`): the bundle lives elsewhere, so a bare specifier would not resolve from it. A workspace
+ * package resolves to its real path outside `node_modules` and is inlined. A specifier that does not resolve is left to
+ * esbuild (an error, or a warning for a `require` in a `try`).
+ */
+function installedPackages() {
+    return {
+        name: "chord-worker-installed-packages",
+        setup(builder) {
+            builder.onResolve({ filter: /^[^./]/ }, async (args) => {
+                if (args.pluginData === RESOLVING || isBuiltin(args.path))
+                    return undefined;
+                const resolved = await builder.resolve(args.path, {
+                    kind: args.kind,
+                    importer: args.importer,
+                    resolveDir: args.resolveDir,
+                    pluginData: RESOLVING,
+                });
+                if (resolved.errors.length > 0)
+                    return undefined;
+                if (!resolved.path.split(sep).includes("node_modules"))
+                    return resolved;
+                const path = args.kind.startsWith("require") ? resolved.path : pathToFileURL(resolved.path).href;
+                return { path, external: true };
+            });
+        },
+    };
+}
+/** Whether a source names its own location. */
+const LOCATIONS = /import\.meta|__dirname|__filename/;
+/** The loaders of the source files `moduleLocations` reads: every extension its filter matches. */
+const LOADERS = {
+    ".js": "js",
+    ".mjs": "js",
+    ".cjs": "js",
+    ".jsx": "jsx",
+    ".ts": "ts",
+    ".mts": "ts",
+    ".cts": "ts",
+    ".tsx": "tsx",
+};
+/**
+ * Keeps `import.meta.url`, `.dirname` and `.filename`, `__dirname` and `__filename` naming each module's source file, not
+ * the bundle (base code finds files beside it this way: p2's plugins directory): a module using them gets its own
+ * constants, which `define` puts in their place. Declared on its first line, so the source map's lines stay. It reads
+ * (and records in `inputs`) every source file of its extensions, which it hands to esbuild changed or as read.
+ */
+function moduleLocations(inputs) {
+    return {
+        name: "chord-worker-module-locations",
+        setup(builder) {
+            builder.onLoad({ filter: /\.(?:[cm]?[jt]s|[jt]sx)$/ }, async (args) => {
+                if (args.namespace !== "file")
+                    return undefined;
+                const bytes = await readRecorded(args.path, inputs);
+                // The filter matched one of `LOADERS`' extensions.
+                const loader = LOADERS[extname(args.path)];
+                const source = bytes.toString("utf8");
+                if (!LOCATIONS.test(source))
+                    return { contents: bytes, loader };
+                const constants = [
+                    [MODULE_URL, pathToFileURL(args.path).href],
+                    [MODULE_DIRNAME, dirname(args.path)],
+                    [MODULE_FILENAME, args.path],
+                ].map(([name, value]) => `${name} = ${JSON.stringify(value)}`);
+                return { contents: `var ${constants.join(", ")};${source}`, loader };
+            });
+        },
+    };
+}
+/**
+ * The bundle as files: written at the first `file()` (a named directory is shared with later starts: a handle whose
+ * owner closed before forking must never touch it) into its named directory (emptied first: the files of an earlier
+ * build go) or a new private temporary one, again when one of them is gone; the directory removed with the handle.
+ */
+class BundleFiles {
+    inputs;
+    #files;
+    #named;
+    /** Where the files were written; `undefined` before the first `file()` and after `remove`. */
+    #dir;
+    constructor(files, inputs, named) {
+        this.#files = files;
+        this.inputs = inputs;
+        this.#named = named;
+    }
+    file() {
+        // A long-running server's temporary directory may be cleaned (systemd-tmpfiles, macOS), a chunk no worker
+        // imported for a while first: a fork needs all of them. A temporary directory is a new one, never the old name:
+        // another user may have made that one since (a named directory is the app's own, private).
+        const dir = this.#dir;
+        if (dir !== undefined && this.#files.every((file) => existsSync(join(dir, file.name)))) {
+            return join(dir, `${ENTRY_NAME}.mjs`);
+        }
+        this.remove();
+        return join(this.#write(), `${ENTRY_NAME}.mjs`);
+    }
+    remove() {
+        if (this.#dir !== undefined)
+            rmSync(this.#dir, { recursive: true, force: true });
+        this.#dir = undefined;
+    }
+    /** Writes the bundle's files into its private directory (mode 0700, each file 0600); the directory. */
+    #write() {
+        let dir = this.#named;
+        if (dir === undefined)
+            dir = mkdtempSync(join(tmpdir(), "chord-worker-"));
+        else {
+            rmSync(dir, { recursive: true, force: true });
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        }
+        for (const file of this.#files)
+            writeFileSync(join(dir, file.name), file.contents, { mode: 0o600 });
+        this.#dir = dir;
+        return dir;
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/node/workers/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../src/node/workers/base.ts"],"names":[],"mappings":"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","sourcesContent":["// The worker base (decision \"Workers start from the base code the server booted with\"): a worker kind's entry and the\n// base code it imports, bundled once by esbuild when the workers component builds it (the kit: right after the server\n// listens), as the surfaces build their base bundles. Every worker of the kind is forked from this snapshot, so an edit\n// of the app's source while the server runs reaches workers only through a restart of the server. Packages installed under `node_modules` (native\n// addons, packages reading their own files) and Node builtins stay external: Node loads them at each fork from where\n// the build resolved them. Everything else, the app's files and workspace packages linked into `node_modules`, is\n// inlined. The bundle is split at each dynamic `import()` esbuild can follow: the entry module and the chunks it imports\n// statically load at each fork, a lazily imported module (pi-ai's provider APIs and the packages they import) only when\n// the worker imports it. Every file is an ES module with an inline source map, written at the first fork (`file()`;\n// a handle never forked writes nothing) into one private directory its handle owns and removes: a new temporary one, or\n// one the caller names (the kit's per kind in the data directory: the same path at every start, so Node's compile cache\n// knows the files). Every file the build read is recorded with its bytes' hash\n// (`BaseInputs`), as its one read hands them to esbuild.\n\nimport { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from \"node:fs\";\nimport { isBuiltin } from \"node:module\";\nimport { tmpdir } from \"node:os\";\nimport { basename, dirname, extname, join, parse, resolve, sep } from \"node:path\";\nimport { pathToFileURL } from \"node:url\";\nimport { build, type Loader, type Plugin } from \"esbuild\";\nimport { type BaseInputs, readRecorded, recordedSources } from \"../plugins/base-inputs.ts\";\nimport { conditionsOf } from \"../surfaces/bundle.ts\";\n\n/** A worker kind's bundled base: the file workers are forked from, and the files it was built from. */\nexport interface WorkerBase {\n\t/** The files esbuild read for it with their bytes' hashes: the app's base code, a file differing outdates it. */\n\treadonly inputs: BaseInputs;\n\t/**\n\t * The entry module's path, its chunks beside it: written at the first call, and again when a temporary-file cleaner\n\t * removed one of them (into a new temporary directory, or its named one).\n\t */\n\tfile(): string;\n\t/** Removes the bundle's directory, when `file()` wrote it. */\n\tremove(): void;\n}\n\n/**\n * What `import.meta.url`, `.dirname` and `.filename` (and a CommonJS file's free `__dirname` and `__filename`) become: a\n * module's own constants (`moduleLocations`).\n */\nconst MODULE_URL = \"__chordModuleUrl\";\nconst MODULE_DIRNAME = \"__chordModuleDirname\";\nconst MODULE_FILENAME = \"__chordModuleFilename\";\n\n/** The entry module's name in the bundle's directory (`worker.mjs`); chunks are named `<name>-<hash>.mjs`. */\nconst ENTRY_NAME = \"worker\";\n\n/**\n * Bundles `entry` for workers forked with `execArgv` (its `--conditions` resolve imports as the child's Node would),\n * in memory; its files are written at the handle's first `file()`, into `dir` (a private directory the handle owns:\n * emptied first, removed by `remove`) or, without one, a new temporary directory. Rejects with esbuild's failure.\n */\nexport async function buildWorkerBase(entry: string, execArgv: readonly string[], dir?: string): Promise<WorkerBase> {\n\t// Built as if at the file system's root: the source map's paths relative to it, made absolute by `sourceRoot`.\n\tconst root = parse(resolve(entry)).root;\n\tconst inputs = new Map<string, string>();\n\tconst result = await build({\n\t\tentryPoints: [{ in: entry, out: ENTRY_NAME }],\n\t\t// One flat directory: every chunk imports the others as `./<name>`, and the source maps' paths stay relative to\n\t\t// the root.\n\t\toutdir: root,\n\t\tentryNames: \"[name]\",\n\t\tchunkNames: \"[name]-[hash]\",\n\t\toutExtension: { \".js\": \".mjs\" },\n\t\t// A dynamic `import()` esbuild can follow becomes a chunk Node loads only when the worker imports it, with the\n\t\t// packages it imports: inlined into one module, every lazily imported module would load and run at each fork.\n\t\tsplitting: true,\n\t\twrite: false,\n\t\tbundle: true,\n\t\tformat: \"esm\",\n\t\tplatform: \"node\",\n\t\t// Node's own resolution: the child's conditions, `main` only (no `module` condition or field).\n\t\tconditions: conditionsOf(execArgv),\n\t\tmainFields: [\"main\"],\n\t\t// Every imported module runs, as Node runs it: `sideEffects: false` and pure annotations drop none (the entry's\n\t\t// own package may say it, as Chord's does).\n\t\tignoreAnnotations: true,\n\t\t// Function and class names as the source has them (`name` stays what unbundled code sees).\n\t\tkeepNames: true,\n\t\tsourcemap: \"inline\",\n\t\tsourcesContent: false,\n\t\tsourceRoot: pathToFileURL(root).href,\n\t\t// A CommonJS file of the base code requires through this (each chunk has its own); external packages by their\n\t\t// absolute paths.\n\t\tbanner: {\n\t\t\tjs: 'import { createRequire as __chordCreateRequire } from \"node:module\"; const require = __chordCreateRequire(import.meta.url);',\n\t\t},\n\t\tdefine: {\n\t\t\t\"import.meta.url\": MODULE_URL,\n\t\t\t\"import.meta.dirname\": MODULE_DIRNAME,\n\t\t\t\"import.meta.filename\": MODULE_FILENAME,\n\t\t\t__dirname: MODULE_DIRNAME,\n\t\t\t__filename: MODULE_FILENAME,\n\t\t},\n\t\tplugins: [installedPackages(), moduleLocations(inputs), recordedSources(inputs)],\n\t\tlogLevel: \"silent\",\n\t});\n\tconst files = result.outputFiles.map((output) => ({ name: basename(output.path), contents: output.contents }));\n\treturn new BundleFiles(files, inputs, dir);\n}\n\n/**\n * The files of the static import graph of Node code started from `entry` with `conditions`, with their bytes' hashes: a\n * best-effort scan (esbuild bundles it only to record what it reads; nothing is written or run). It sees the literal\n * imports of the graph, including lazy literal `import()`s Node may never run (conservative: such a file's edit asks\n * for a restart); a computed `import(x)` and modules a loader provides are not seen, and an import that does not\n * resolve (an inactive optional import of a missing file or package, a loader's scheme) is left out. It resolves as\n * Node does: the conditions, `main`, no `tsconfig.json` `paths`; installed packages are left out (never compared).\n * Rejects with esbuild's failure for anything else (a file it cannot parse).\n */\nexport async function nodeBaseInputs(entry: string, conditions: readonly string[]): Promise<BaseInputs> {\n\tconst inputs = new Map<string, string>();\n\tawait build({\n\t\tentryPoints: [entry],\n\t\twrite: false,\n\t\tbundle: true,\n\t\tformat: \"esm\",\n\t\tplatform: \"node\",\n\t\tconditions: [...conditions],\n\t\tmainFields: [\"main\"],\n\t\t// Node reads no tsconfig.json: its `paths` would resolve an import elsewhere than Node does.\n\t\ttsconfigRaw: \"{}\",\n\t\t// Every file the bundle reaches is read, as Node would load it; the output is dropped.\n\t\tignoreAnnotations: true,\n\t\tplugins: [staticGraph(), recordedSources(inputs)],\n\t\tlogLevel: \"silent\",\n\t});\n\treturn inputs;\n}\n\n/**\n * The scan's resolution (`nodeBaseInputs`): an import resolving under a `node_modules` directory and one that does not\n * resolve at all are left out (external); the rest resolves as esbuild does.\n */\nfunction staticGraph(): Plugin {\n\treturn {\n\t\tname: \"chord-node-base-static-graph\",\n\t\tsetup(builder) {\n\t\t\tbuilder.onResolve({ filter: /.*/ }, async (args) => {\n\t\t\t\tif (args.pluginData === RESOLVING || args.kind === \"entry-point\" || isBuiltin(args.path)) return undefined;\n\t\t\t\tconst resolved = await builder.resolve(args.path, {\n\t\t\t\t\tkind: args.kind,\n\t\t\t\t\timporter: args.importer,\n\t\t\t\t\tresolveDir: args.resolveDir,\n\t\t\t\t\tpluginData: RESOLVING,\n\t\t\t\t});\n\t\t\t\tconst outside =\n\t\t\t\t\tresolved.errors.length > 0 || resolved.external || resolved.path.split(sep).includes(\"node_modules\");\n\t\t\t\treturn outside ? { path: args.path, external: true } : resolved;\n\t\t\t});\n\t\t},\n\t};\n}\n\n/** Marks the resolver's own call, so the plugin does not resolve it again. */\nconst RESOLVING = Symbol(\"chord.worker-base.resolving\");\n\n/**\n * Keeps a package resolved under a `node_modules` directory external, by its absolute file (a URL for an `import`, a\n * path for a `require`): the bundle lives elsewhere, so a bare specifier would not resolve from it. A workspace\n * package resolves to its real path outside `node_modules` and is inlined. A specifier that does not resolve is left to\n * esbuild (an error, or a warning for a `require` in a `try`).\n */\nfunction installedPackages(): Plugin {\n\treturn {\n\t\tname: \"chord-worker-installed-packages\",\n\t\tsetup(builder) {\n\t\t\tbuilder.onResolve({ filter: /^[^./]/ }, async (args) => {\n\t\t\t\tif (args.pluginData === RESOLVING || isBuiltin(args.path)) return undefined;\n\t\t\t\tconst resolved = await builder.resolve(args.path, {\n\t\t\t\t\tkind: args.kind,\n\t\t\t\t\timporter: args.importer,\n\t\t\t\t\tresolveDir: args.resolveDir,\n\t\t\t\t\tpluginData: RESOLVING,\n\t\t\t\t});\n\t\t\t\tif (resolved.errors.length > 0) return undefined;\n\t\t\t\tif (!resolved.path.split(sep).includes(\"node_modules\")) return resolved;\n\t\t\t\tconst path = args.kind.startsWith(\"require\") ? resolved.path : pathToFileURL(resolved.path).href;\n\t\t\t\treturn { path, external: true };\n\t\t\t});\n\t\t},\n\t};\n}\n\n/** Whether a source names its own location. */\nconst LOCATIONS = /import\\.meta|__dirname|__filename/;\n\n/** The loaders of the source files `moduleLocations` reads: every extension its filter matches. */\nconst LOADERS: Readonly<Record<string, Loader>> = {\n\t\".js\": \"js\",\n\t\".mjs\": \"js\",\n\t\".cjs\": \"js\",\n\t\".jsx\": \"jsx\",\n\t\".ts\": \"ts\",\n\t\".mts\": \"ts\",\n\t\".cts\": \"ts\",\n\t\".tsx\": \"tsx\",\n};\n\n/**\n * Keeps `import.meta.url`, `.dirname` and `.filename`, `__dirname` and `__filename` naming each module's source file, not\n * the bundle (base code finds files beside it this way: p2's plugins directory): a module using them gets its own\n * constants, which `define` puts in their place. Declared on its first line, so the source map's lines stay. It reads\n * (and records in `inputs`) every source file of its extensions, which it hands to esbuild changed or as read.\n */\nfunction moduleLocations(inputs: Map<string, string>): Plugin {\n\treturn {\n\t\tname: \"chord-worker-module-locations\",\n\t\tsetup(builder) {\n\t\t\tbuilder.onLoad({ filter: /\\.(?:[cm]?[jt]s|[jt]sx)$/ }, async (args) => {\n\t\t\t\tif (args.namespace !== \"file\") return undefined;\n\t\t\t\tconst bytes = await readRecorded(args.path, inputs);\n\t\t\t\t// The filter matched one of `LOADERS`' extensions.\n\t\t\t\tconst loader = LOADERS[extname(args.path)]!;\n\t\t\t\tconst source = bytes.toString(\"utf8\");\n\t\t\t\tif (!LOCATIONS.test(source)) return { contents: bytes, loader };\n\t\t\t\tconst constants = [\n\t\t\t\t\t[MODULE_URL, pathToFileURL(args.path).href],\n\t\t\t\t\t[MODULE_DIRNAME, dirname(args.path)],\n\t\t\t\t\t[MODULE_FILENAME, args.path],\n\t\t\t\t].map(([name, value]) => `${name} = ${JSON.stringify(value)}`);\n\t\t\t\treturn { contents: `var ${constants.join(\", \")};${source}`, loader };\n\t\t\t});\n\t\t},\n\t};\n}\n\n/** One output file of the bundle: its name in the bundle's directory and its contents. */\ninterface BundleFile {\n\treadonly name: string;\n\treadonly contents: Uint8Array;\n}\n\n/**\n * The bundle as files: written at the first `file()` (a named directory is shared with later starts: a handle whose\n * owner closed before forking must never touch it) into its named directory (emptied first: the files of an earlier\n * build go) or a new private temporary one, again when one of them is gone; the directory removed with the handle.\n */\nclass BundleFiles implements WorkerBase {\n\treadonly inputs: BaseInputs;\n\treadonly #files: readonly BundleFile[];\n\treadonly #named: string | undefined;\n\t/** Where the files were written; `undefined` before the first `file()` and after `remove`. */\n\t#dir: string | undefined;\n\n\tconstructor(files: readonly BundleFile[], inputs: BaseInputs, named: string | undefined) {\n\t\tthis.#files = files;\n\t\tthis.inputs = inputs;\n\t\tthis.#named = named;\n\t}\n\n\tfile(): string {\n\t\t// A long-running server's temporary directory may be cleaned (systemd-tmpfiles, macOS), a chunk no worker\n\t\t// imported for a while first: a fork needs all of them. A temporary directory is a new one, never the old name:\n\t\t// another user may have made that one since (a named directory is the app's own, private).\n\t\tconst dir = this.#dir;\n\t\tif (dir !== undefined && this.#files.every((file) => existsSync(join(dir, file.name)))) {\n\t\t\treturn join(dir, `${ENTRY_NAME}.mjs`);\n\t\t}\n\t\tthis.remove();\n\t\treturn join(this.#write(), `${ENTRY_NAME}.mjs`);\n\t}\n\n\tremove(): void {\n\t\tif (this.#dir !== undefined) rmSync(this.#dir, { recursive: true, force: true });\n\t\tthis.#dir = undefined;\n\t}\n\n\t/** Writes the bundle's files into its private directory (mode 0700, each file 0600); the directory. */\n\t#write(): string {\n\t\tlet dir = this.#named;\n\t\tif (dir === undefined) dir = mkdtempSync(join(tmpdir(), \"chord-worker-\"));\n\t\telse {\n\t\t\trmSync(dir, { recursive: true, force: true });\n\t\t\tmkdirSync(dir, { recursive: true, mode: 0o700 });\n\t\t}\n\t\tfor (const file of this.#files) writeFileSync(join(dir, file.name), file.contents, { mode: 0o600 });\n\t\tthis.#dir = dir;\n\t\treturn dir;\n\t}\n}\n"]}

package/dist/node/workers/child.d.ts

@@ -0,0 +1,4 @@
+export type { CrossedError } from "./control.ts";
+export { type ProcessLock, processLock } from "./lock.ts";
+export { type WorkerMainOptions, type WorkerPlugins, type WorkerResult, type WorkerStart, workerMain, } from "./main.ts";
+//# sourceMappingURL=child.d.ts.map

package/dist/node/workers/child.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child.d.ts","sourceRoot":"","sources":["../../../src/node/workers/child.ts"],"names":[],"mappings":"AAIA,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,KAAK,WAAW,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC1D,OAAO,EACN,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,UAAU,GACV,MAAM,WAAW,CAAC"}

package/dist/node/workers/child.js

@@ -0,0 +1,6 @@
+// The worker process's side of the workers component (`@earendil-works/chord/workers/child`): `workerMain` and
+// `processLock` without the server's side, whose worker base bundles with esbuild. A worker entry imports this, so a
+// forked worker never loads esbuild.
+export { processLock } from "./lock.js";
+export { workerMain, } from "./main.js";
+//# sourceMappingURL=child.js.map

package/dist/node/workers/child.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"child.js","sourceRoot":"","sources":["../../../src/node/workers/child.ts"],"names":[],"mappings":"AAAA,+GAA+G;AAC/G,qHAAqH;AACrH,qCAAqC;AAGrC,OAAO,EAAoB,WAAW,EAAE,MAAM,WAAW,CAAC;AAC1D,OAAO,EAKN,UAAU,GACV,MAAM,WAAW,CAAC","sourcesContent":["// The worker process's side of the workers component (`@earendil-works/chord/workers/child`): `workerMain` and\n// `processLock` without the server's side, whose worker base bundles with esbuild. A worker entry imports this, so a\n// forked worker never loads esbuild.\n\nexport type { CrossedError } from \"./control.ts\";\nexport { type ProcessLock, processLock } from \"./lock.ts\";\nexport {\n\ttype WorkerMainOptions,\n\ttype WorkerPlugins,\n\ttype WorkerResult,\n\ttype WorkerStart,\n\tworkerMain,\n} from \"./main.ts\";\n"]}

package/dist/node/workers/control.d.ts

@@ -0,0 +1,83 @@
+import type { Address } from "../../contracts/index.ts";
+import { type FailureCause } from "../../data/index.ts";
+import type { ReloadReport } from "../../host/index.ts";
+import type { JsonValue } from "../../json.ts";
+import type { PluginScript } from "../plugins/runtime.ts";
+/** An error as it crosses: its message, and a ChordError's code and reason. */
+export type CrossedError = {
+    readonly message: string;
+    readonly code?: string;
+    readonly reason?: string;
+};
+/** A reload report as it crosses: its errors crossed. */
+export type CrossedReport = {
+    readonly plugins: ReloadReport["plugins"];
+    readonly failed: readonly {
+        readonly plugin: string;
+        readonly error: CrossedError;
+    }[];
+    readonly objects: readonly {
+        readonly object: string;
+        readonly kind: string;
+        readonly cause?: CrossedCause;
+    }[];
+};
+/** A failure cause as it crosses. */
+type CrossedCause = {
+    readonly kind: FailureCause["kind"];
+    readonly error: CrossedError;
+};
+/** What the server sends a worker. */
+export type ToWorker = {
+    readonly kind: "start";
+    readonly address: Address;
+    readonly start: JsonValue;
+    readonly scripts: readonly PluginScript[];
+    readonly lock: string;
+} | {
+    readonly kind: "shutdown";
+} | {
+    readonly kind: "reload";
+    readonly scripts: readonly PluginScript[];
+};
+/** What a worker sends the server. */
+export type FromWorker = {
+    readonly kind: "started";
+} | {
+    readonly kind: "ready";
+    readonly idle: boolean;
+    readonly report: CrossedReport;
+} | {
+    readonly kind: "idle";
+    readonly idle: boolean;
+} | {
+    readonly kind: "fatal";
+    readonly error: CrossedError;
+} | {
+    readonly kind: "reloaded";
+    readonly report: CrossedReport;
+} | {
+    readonly kind: "reloaded";
+    readonly error: CrossedError;
+};
+/** `message` in its envelope, as it goes over the IPC channel. */
+export declare function envelope(message: ToWorker | FromWorker): {
+    readonly [ENVELOPE]: ToWorker | FromWorker;
+};
+/** The envelope's key: a control message is `{ "chord.workers": message }`. */
+declare const ENVELOPE = "chord.workers";
+/**
+ * The control message in an IPC message, or `undefined` for anything else (a link frame, the app's own). A trust
+ * boundary in name only: both ends are the app's processes, so only the envelope is checked.
+ */
+export declare function controlOf<M extends ToWorker | FromWorker>(message: unknown): M | undefined;
+/** `error` as it crosses. */
+export declare function crossed(error: unknown): CrossedError;
+/** A crossed error as an error again: a ChordError when its code is one, an `Error` otherwise. */
+export declare function uncrossed(error: CrossedError): Error;
+/** `report` as it crosses. */
+export declare function crossedReport(report: ReloadReport): CrossedReport;
+/** A crossed report as a report again. */
+export declare function uncrossedReport(report: CrossedReport): ReloadReport;
+export {};
+//# sourceMappingURL=control.d.ts.map

package/dist/node/workers/control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../../src/node/workers/control.ts"],"names":[],"mappings":"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"}

package/dist/node/workers/control.js

@@ -0,0 +1,77 @@
+// The control channel between the server and a worker (slice 10 §3): JSON messages beside the link's `Uint8Array`
+// frames on one IPC channel (the IPC link skips them), and errors as they cross it (`{ message, code?, reason? }`,
+// never a stack or a cause).
+import { ChordError, isChordError } from "../../data/index.js";
+import { chordErrorFromJson } from "../../data/internal.js";
+/** `message` in its envelope, as it goes over the IPC channel. */
+export function envelope(message) {
+    return { [ENVELOPE]: message };
+}
+/** The envelope's key: a control message is `{ "chord.workers": message }`. */
+const ENVELOPE = "chord.workers";
+/**
+ * The control message in an IPC message, or `undefined` for anything else (a link frame, the app's own). A trust
+ * boundary in name only: both ends are the app's processes, so only the envelope is checked.
+ */
+export function controlOf(message) {
+    if (typeof message !== "object" || message === null || !(ENVELOPE in message))
+        return undefined;
+    // Sent by the other end of this channel through `envelope`.
+    return message[ENVELOPE];
+}
+/** `error` as it crosses. */
+export function crossed(error) {
+    if (isChordError(error)) {
+        return {
+            message: error.message,
+            code: error.code,
+            ...(error.reason === undefined ? {} : { reason: error.reason }),
+        };
+    }
+    return { message: error instanceof Error ? error.message : String(error) };
+}
+/** A crossed error as an error again: a ChordError when its code is one, an `Error` otherwise. */
+export function uncrossed(error) {
+    if (error.code === undefined)
+        return new Error(error.message);
+    try {
+        return chordErrorFromJson({
+            code: error.code,
+            message: error.message,
+            ...(error.reason === undefined ? {} : { reason: error.reason }),
+        });
+    }
+    catch {
+        return new Error(error.message);
+    }
+}
+/** `report` as it crosses. */
+export function crossedReport(report) {
+    return {
+        plugins: report.plugins,
+        failed: report.failed.map(({ plugin, error }) => ({ plugin, error: crossed(error) })),
+        objects: report.objects.map((each) => each.kind === "parked"
+            ? {
+                object: each.object,
+                kind: each.kind,
+                cause: { kind: each.cause.kind, error: crossed(each.cause.error) },
+            }
+            : each),
+    };
+}
+/** A crossed report as a report again. */
+export function uncrossedReport(report) {
+    return {
+        plugins: report.plugins,
+        failed: report.failed.map(({ plugin, error }) => ({ plugin, error: uncrossed(error) })),
+        objects: report.objects.map(({ object, kind, cause }) => {
+            if (cause === undefined)
+                return { object, kind: kind };
+            const error = uncrossed(cause.error);
+            // A parked object's cause is a ChordError on the worker; one that crossed without a code is wrapped as one.
+            const chord = isChordError(error) ? error : new ChordError({ code: "unavailable", message: error.message });
+            return { object, kind: "parked", cause: { kind: cause.kind, error: chord } };
+        }),
+    };
+}
+//# sourceMappingURL=control.js.map

package/dist/node/workers/control.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.js","sourceRoot":"","sources":["../../../src/node/workers/control.ts"],"names":[],"mappings":"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","sourcesContent":["// The control channel between the server and a worker (slice 10 §3): JSON messages beside the link's `Uint8Array`\n// frames on one IPC channel (the IPC link skips them), and errors as they cross it (`{ message, code?, reason? }`,\n// never a stack or a cause).\n\nimport type { Address } from \"../../contracts/index.ts\";\nimport { ChordError, type FailureCause, isChordError } from \"../../data/index.ts\";\nimport { chordErrorFromJson } from \"../../data/internal.ts\";\nimport type { ReloadReport } from \"../../host/index.ts\";\nimport type { JsonValue } from \"../../json.ts\";\nimport type { PluginScript } from \"../plugins/runtime.ts\";\n\n/** An error as it crosses: its message, and a ChordError's code and reason. */\nexport type CrossedError = { readonly message: string; readonly code?: string; readonly reason?: string };\n\n/** A reload report as it crosses: its errors crossed. */\nexport type CrossedReport = {\n\treadonly plugins: ReloadReport[\"plugins\"];\n\treadonly failed: readonly { readonly plugin: string; readonly error: CrossedError }[];\n\treadonly objects: readonly { readonly object: string; readonly kind: string; readonly cause?: CrossedCause }[];\n};\n\n/** A failure cause as it crosses. */\ntype CrossedCause = { readonly kind: FailureCause[\"kind\"]; readonly error: CrossedError };\n\n/** What the server sends a worker. */\nexport type ToWorker =\n\t| {\n\t\t\treadonly kind: \"start\";\n\t\t\treadonly address: Address;\n\t\t\treadonly start: JsonValue;\n\t\t\treadonly scripts: readonly PluginScript[];\n\t\t\treadonly lock: string;\n\t  }\n\t| { readonly kind: \"shutdown\" }\n\t| { readonly kind: \"reload\"; readonly scripts: readonly PluginScript[] };\n\n/** What a worker sends the server. */\nexport type FromWorker =\n\t| { readonly kind: \"started\" }\n\t| { readonly kind: \"ready\"; readonly idle: boolean; readonly report: CrossedReport }\n\t| { readonly kind: \"idle\"; readonly idle: boolean }\n\t| { readonly kind: \"fatal\"; readonly error: CrossedError }\n\t| { readonly kind: \"reloaded\"; readonly report: CrossedReport }\n\t| { readonly kind: \"reloaded\"; readonly error: CrossedError };\n\n/** `message` in its envelope, as it goes over the IPC channel. */\nexport function envelope(message: ToWorker | FromWorker): { readonly [ENVELOPE]: ToWorker | FromWorker } {\n\treturn { [ENVELOPE]: message };\n}\n\n/** The envelope's key: a control message is `{ \"chord.workers\": message }`. */\nconst ENVELOPE = \"chord.workers\";\n\n/**\n * The control message in an IPC message, or `undefined` for anything else (a link frame, the app's own). A trust\n * boundary in name only: both ends are the app's processes, so only the envelope is checked.\n */\nexport function controlOf<M extends ToWorker | FromWorker>(message: unknown): M | undefined {\n\tif (typeof message !== \"object\" || message === null || !(ENVELOPE in message)) return undefined;\n\t// Sent by the other end of this channel through `envelope`.\n\treturn (message as { readonly [ENVELOPE]: M })[ENVELOPE];\n}\n\n/** `error` as it crosses. */\nexport function crossed(error: unknown): CrossedError {\n\tif (isChordError(error)) {\n\t\treturn {\n\t\t\tmessage: error.message,\n\t\t\tcode: error.code,\n\t\t\t...(error.reason === undefined ? {} : { reason: error.reason }),\n\t\t};\n\t}\n\treturn { message: error instanceof Error ? error.message : String(error) };\n}\n\n/** A crossed error as an error again: a ChordError when its code is one, an `Error` otherwise. */\nexport function uncrossed(error: CrossedError): Error {\n\tif (error.code === undefined) return new Error(error.message);\n\ttry {\n\t\treturn chordErrorFromJson({\n\t\t\tcode: error.code,\n\t\t\tmessage: error.message,\n\t\t\t...(error.reason === undefined ? {} : { reason: error.reason }),\n\t\t});\n\t} catch {\n\t\treturn new Error(error.message);\n\t}\n}\n\n/** `report` as it crosses. */\nexport function crossedReport(report: ReloadReport): CrossedReport {\n\treturn {\n\t\tplugins: report.plugins,\n\t\tfailed: report.failed.map(({ plugin, error }) => ({ plugin, error: crossed(error) })),\n\t\tobjects: report.objects.map((each) =>\n\t\t\teach.kind === \"parked\"\n\t\t\t\t? {\n\t\t\t\t\t\tobject: each.object,\n\t\t\t\t\t\tkind: each.kind,\n\t\t\t\t\t\tcause: { kind: each.cause.kind, error: crossed(each.cause.error) },\n\t\t\t\t\t}\n\t\t\t\t: each,\n\t\t),\n\t};\n}\n\n/** A crossed report as a report again. */\nexport function uncrossedReport(report: CrossedReport): ReloadReport {\n\treturn {\n\t\tplugins: report.plugins,\n\t\tfailed: report.failed.map(({ plugin, error }) => ({ plugin, error: uncrossed(error) })),\n\t\tobjects: report.objects.map(({ object, kind, cause }) => {\n\t\t\tif (cause === undefined)\n\t\t\t\treturn { object, kind: kind as Exclude<ReloadReport[\"objects\"][number][\"kind\"], \"parked\"> };\n\t\t\tconst error = uncrossed(cause.error);\n\t\t\t// A parked object's cause is a ChordError on the worker; one that crossed without a code is wrapped as one.\n\t\t\tconst chord = isChordError(error) ? error : new ChordError({ code: \"unavailable\", message: error.message });\n\t\t\treturn { object, kind: \"parked\", cause: { kind: cause.kind, error: chord } as FailureCause };\n\t\t}),\n\t};\n}\n"]}

package/dist/node/workers/index.d.ts

@@ -0,0 +1,4 @@
+export { nodeBaseInputs } from "./base.ts";
+export * from "./child.ts";
+export { createWorkers, type WorkerState, type Workers, type WorkersBuilt, type WorkersError, type WorkersOptions, } from "./workers.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/node/workers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/node/workers/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,OAAO,EACN,aAAa,EACb,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,cAAc,GACnB,MAAM,cAAc,CAAC"}