pi-ptc-subagents 0.1.2 → 0.1.3

package/dist/worker.js

@@ -1,759 +1,4 @@
-import { a as describeValue, c as workerProtocolSpec } from "./protocol-DUnAP1Ro.js";
-import { stripTypeScriptTypes } from "node:module";
-import { parentPort, workerData } from "node:worker_threads";
-import { inspect } from "node:util";
-//#region src/runtime/worker-main.ts
-/**
-* Worker-side PTC runtime: installs one surface, runs one program, routes `tools.*`
-* calls back to the host.
-*
-* State machine (ADR-0017 §5):
-*
-*   CREATED ── function entry ──────────────────────────► BOOTING
-*      │                                                   │
-*      │                                          control port installed
-*      │                                                   │
-*      │                                           ┌───────┴───────┐
-*      │                                           │               │
-*      │                                           ▼               ▼
-*      │   (host sends init)                  READY ◄─── ready sent
-*      │       │                                 │
-*      │       ▼                                 │ init
-*      │   RUNNING                               │
-*      │       │                                 │
-*      │   (program completes / throws / cancel) │
-*      │       │                                 │
-*      │       ▼                                 │
-*      │   reset() + ready sent ───────────────► READY
-*      │
-*      └── (host closes control port) ─► worker terminates, no further transitions
-*
-* A later `connect` re-enters `READY` from wherever the worker is: a handover, not a wait — which is
-* how a worker the host abandoned is picked up by the next run (see the connect handler, ADR-0017
-* §10(h)).
-*
-* The `ready` frame has two meanings under ADR-0017 §5:
-*   - cold start: "booted, send init".
-*   - warm reuse: "cleared per-run state, ready for next init".
-*
-* Run identity: every accepted `init` starts a new run and claims the worker for it
-* (a run ordinal, captured by that run). A run only owns the worker until the next
-* `init` supersedes it — so the reset that ends a run must prove it still owns the
-* worker before it clears anything (see `reset`).
-*
-* Frame ownership: a run's outbound frames (`log`, `narration`, `phase`, `call`, `result`,
-* `error`) are posted through the control port that run captured when its `init` arrived —
-* never through "whichever port the worker is connected to now". Warm reuse replaces the
-* connection while a superseded run may still be unwinding, so routing is what keeps one run's
-* terminal frame from settling the next one (see `post` and `startRun`).
-*
-* The worker is loaded by file URL (`dist/worker.js`, see `worker-entry.ts`); V8's
-* code cache and Node's module cache survive across warm-reuse spawns. The
-* SELF-CONTAINMENT RULE that previously gated this module — `Function.prototype.toString()`
-* of `workerMain` into a `data:` URL — is retired.
-*/
-function workerMain(deps) {
-	const hostFrame = deps.protocol.hostFrame;
-	const workerFrame = deps.protocol.workerFrame;
-	const logLevel = deps.protocol.logLevel;
-	const errorKind = deps.protocol.errorKind;
-	/** Wrapper name used to compile a program body (`return …` is legal inside it). */
-	const programName = "__ptcProgram";
-	/** Active lifecycle state — see the doc comment at the top of the module. */
-	let state = "CREATED";
-	/**
-	* Run ordinal: incremented once per accepted `init` frame, never decremented. The value
-	* a run was born with is its identity for life — `reset()` checks it against this
-	* counter before touching anything.
-	*/
-	let runGeneration = 0;
-	let control;
-	let cancelled;
-	let nextCallId = 1;
-	/** Call frames posted and not yet answered; capped by `maxPendingCalls` (ADR-0004). */
-	let inFlightCalls = 0;
-	let maxPendingCalls = Number.POSITIVE_INFINITY;
-	const admissionWaiters = [];
-	const pending = /* @__PURE__ */ new Map();
-	/**
-	* Snapshot of `globalThis` taken once, at boot (end of `installWarningCapture`), i.e. the
-	* "warm baseline" a reset restores to.
-	*
-	* What it covers: `globalThis`'s own enumerable string keys — the way a PTC program normally
-	* touches the realm. A `globalThis.x = 1` left by run N is deleted before run N+1 starts, and any
-	* `console` / `tools` / `log` / `phase` / `parallel` / `pipeline` installed by run N is put back
-	* to its boot value for run N+1 to replace with its own install.
-	*
-	* What it does **not** cover — a superseded run's leftovers that survive into the next one, so
-	* "warm reuse is hermetic" would be the wrong reading of this snapshot:
-	*   - a property added to `globalThis` that is non-enumerable or symbol-keyed (`Object.keys` is
-	*     what both the snapshot and the restore walk, so such a property is neither deleted nor put
-	*     back);
-	*   - anything reachable through another object: `Array.prototype.x = 1`, a mutated built-in, the
-	*     module-level state of a module the program imported (Node caches modules per worker, and a
-	*     program can `import()` one);
-	*   - `process` state the program wrote — `process.title`, `process.exitCode`, listeners it added;
-	*   - timers it started, which keep firing (see `startRun`).
-	*
-	* Those are known, accepted limits of warm reuse rather than oversights of this snapshot.
-	*
-	* The *boot* snapshot is the only clean starting point there is: a later `connect` must not
-	* take a new one, or whatever the run it superseded left behind would be part of the baseline
-	* and would be restored into every run after it.
-	*/
-	let warmBaseline;
-	const globals = () => globalThis;
-	class ToolCallError extends Error {
-		toolName;
-		constructor(toolName, message) {
-			super(message);
-			this.name = "ToolCallError";
-			this.toolName = toolName;
-		}
-	}
-	const messageOf = (error) => error instanceof Error ? error.message : String(error);
-	/**
-	* Trim a stack down to what a reader can act on.
-	*
-	* Capped at a small depth so the model-facing stack stays inside the output budget.
-	* Now that the worker is loaded by file URL, no `data:text/javascript,…` frames
-	* appear at all — the rule kept the previous bootstrap's encoded payload from
-	* filling the stack.
-	*/
-	const stackOf = (error) => {
-		if (!(error instanceof Error) || typeof error.stack !== "string") return void 0;
-		const lines = error.stack.split("\n");
-		const kept = [lines[0] ?? ""];
-		for (const line of lines.slice(1)) {
-			kept.push(line);
-			if (kept.length >= 6) break;
-		}
-		return kept.join("\n");
-	};
-	/**
-	* Post a frame through `port` — the control port the caller's run belongs to — defaulting to
-	* the port the worker is currently connected to.
-	*
-	* Invariant (ADR-0017 §10(b)): *a run's outbound frames travel only through the port that run
-	* captured at `init` time*. Warm reuse installs a new port while a superseded run may still be
-	* unwinding, and that run's terminal `result` must not land on the *next* run's port — the host
-	* reads any `result` there as "the current run settled" (`handleFrame` → `finish()`), which
-	* would end a run whose program never finished. The port of a run the host has abandoned has
-	* been closed on the host's side, so its late frames fail to send and are dropped here; that is
-	* the right outcome for a frame nobody owns any more.
-	*
-	* Only realm-level frames — the `connect` handshake's `ready`, warning `log`s, which belong to
-	* the worker rather than to a program — use the default.
-	*/
-	const post = (frame, port = control) => {
-		if (!port) return false;
-		try {
-			port.postMessage(frame);
-			return true;
-		} catch {
-			return false;
-		}
-	};
-	const postLog = (level, text, port) => {
-		post({
-			kind: workerFrame.log,
-			level,
-			text
-		}, port);
-	};
-	const postError = (kind, message, stack, port) => {
-		post(stack === void 0 ? {
-			kind: workerFrame.error,
-			error: {
-				kind,
-				message
-			}
-		} : {
-			kind: workerFrame.error,
-			error: {
-				kind,
-				message,
-				stack
-			}
-		}, port);
-	};
-	const abortError = (reason) => {
-		const error = /* @__PURE__ */ new Error(reason === "timeout" ? "PTC run timed out" : "PTC run was cancelled");
-		error.name = "AbortError";
-		return error;
-	};
-	const closedError = () => {
-		const error = /* @__PURE__ */ new Error("the PTC control channel closed before the call completed");
-		error.name = "AbortError";
-		return error;
-	};
-	/**
-	* Admission control for host binding calls.
-	*
-	* "Maximum simultaneous host binding calls" is the worker's invariant to keep: a call
-	* frame is only posted once fewer than `maxPendingCalls` are outstanding, so a wide
-	* `Promise.all` / `parallel()` burst queues here rather than arriving at the host in one
-	* tick. The host still counts arrivals as a backstop, but it must never see this budget
-	* exceeded by a well-behaved program.
-	*
-	* Waiting for a slot is cancel-aware: `cancel` and a closed control port reject waiters
-	* immediately, so an oversized burst unwinds at once instead of waiting out the grace
-	* window before the host terminates the worker.
-	*/
-	const acquireCallSlot = async () => {
-		if (inFlightCalls < maxPendingCalls) {
-			inFlightCalls += 1;
-			return;
-		}
-		await new Promise((resolve, reject) => {
-			admissionWaiters.push({
-				resolve,
-				reject
-			});
-		});
-	};
-	const releaseCallSlot = () => {
-		const next = admissionWaiters.shift();
-		if (next) {
-			next.resolve();
-			return;
-		}
-		inFlightCalls -= 1;
-	};
-	const rejectAdmissionWaiters = (error) => {
-		while (admissionWaiters.length > 0) {
-			const waiter = admissionWaiters.shift();
-			if (waiter) waiter.reject(error);
-		}
-	};
-	/** Settle every outstanding call and every admission wait, so nothing can hang. */
-	const flushPendingCalls = (error) => {
-		rejectAdmissionWaiters(error);
-		for (const [callId, entry] of pending) {
-			pending.delete(callId);
-			entry.reject(error);
-		}
-	};
-	/**
-	* F3 — reinstall the frozen per-run environment carried in `workerData`.
-	*
-	* The spawn already passes the same snapshot as the worker's `env` option; rebuilding
-	* `process.env` from `workerData` here is what makes the snapshot the authority: the
-	* program's environment is the frozen record, never whatever `process.env` happened
-	* to hold when a binding call crossed the wire.
-	*/
-	const installFrozenEnv = () => {
-		const data = deps.workerData;
-		if (typeof data !== "object" || data === null) return;
-		const snapshot = data.env;
-		if (typeof snapshot !== "object" || snapshot === null || Array.isArray(snapshot)) return;
-		const env = snapshot;
-		for (const key of Object.keys(process.env)) if (!(key in env)) delete process.env[key];
-		for (const key of Object.keys(env)) {
-			const value = env[key];
-			if (typeof value === "string") process.env[key] = value;
-		}
-	};
-	/**
-	* Lossless-JSON materialization of the program's return value (R1 §3 `invalid-output`).
-	*
-	* Plain JSON only: class instances, `Date`/`Map`/`Set`, functions, symbols, bigints,
-	* non-finite numbers and cycles are rejected with a path-qualified reason instead of
-	* being silently lossy through the transport. `undefined` follows `JSON.stringify`:
-	* object properties are dropped, array slots become `null`.
-	*/
-	const toJsonValue = (value) => {
-		const seen = /* @__PURE__ */ new Set();
-		const walk = (candidate, path) => {
-			if (candidate === null) return {
-				ok: true,
-				value: null
-			};
-			if (typeof candidate === "string" || typeof candidate === "boolean") return {
-				ok: true,
-				value: candidate
-			};
-			if (typeof candidate === "undefined") return {
-				ok: true,
-				value: void 0
-			};
-			if (typeof candidate === "number") {
-				if (!Number.isFinite(candidate)) return {
-					ok: false,
-					reason: `${path} is ${String(candidate)}, which is not representable as JSON`
-				};
-				return {
-					ok: true,
-					value: candidate
-				};
-			}
-			if (typeof candidate !== "object") return {
-				ok: false,
-				reason: `${path} is ${describeValue(candidate)}; results must be lossless JSON`
-			};
-			if (Array.isArray(candidate)) {
-				if (seen.has(candidate)) return {
-					ok: false,
-					reason: `${path} is a circular reference`
-				};
-				seen.add(candidate);
-				const items = [];
-				for (let index = 0; index < candidate.length; index += 1) {
-					const item = walk(candidate[index], `${path}[${index}]`);
-					if (!item.ok) return item;
-					items.push(item.value === void 0 ? null : item.value);
-				}
-				seen.delete(candidate);
-				return {
-					ok: true,
-					value: items
-				};
-			}
-			const prototype = Object.getPrototypeOf(candidate);
-			if (prototype !== Object.prototype && prototype !== null) {
-				const ctor = candidate.constructor;
-				return {
-					ok: false,
-					reason: `${path} is a ${ctor && typeof ctor.name === "string" && ctor.name.length > 0 ? ctor.name : "an object"}; results must be plain JSON objects`
-				};
-			}
-			if (seen.has(candidate)) return {
-				ok: false,
-				reason: `${path} is a circular reference`
-			};
-			seen.add(candidate);
-			const entries = {};
-			for (const key of Object.keys(candidate)) {
-				const item = walk(candidate[key], `${path}.${key}`);
-				if (!item.ok) return item;
-				if (item.value !== void 0) entries[key] = item.value;
-			}
-			seen.delete(candidate);
-			return {
-				ok: true,
-				value: entries
-			};
-		};
-		return walk(value, "result");
-	};
-	const formatArgs = (args) => args.map((arg) => typeof arg === "string" ? arg : deps.inspect(arg, {
-		depth: 4,
-		breakLength: Infinity,
-		colors: false
-	})).join(" ");
-	/**
-	* Capture `console` instead of letting worker stdio reach the host terminal.
-	*
-	* Only the printing methods exist on this surface; everything routes to `log` frames
-	* so the model (not the terminal) sees the program's output. Log frames belong to the run
-	* whose console this is, hence the captured `port`.
-	*/
-	const installConsole = (port) => {
-		const write = (level) => {
-			return (...args) => {
-				postLog(level, formatArgs(args), port);
-			};
-		};
-		globals().console = {
-			log: write(logLevel.log),
-			info: write(logLevel.info),
-			warn: write(logLevel.warn),
-			error: write(logLevel.error),
-			debug: write(logLevel.debug)
-		};
-	};
-	/**
-	* Route `process.emitWarning` output through `log` frames.
-	*
-	* Node's default warning printer writes to stderr, which is piped to the host terminal.
-	* `ExperimentalWarning`s are dropped rather than forwarded: the PTC runtime itself uses
-	* experimental Node APIs (type stripping, for one) and those warnings are about the
-	* harness, not about the program — forwarding them would put Node-internals noise into
-	* every run's logs.
-	*/
-	const installWarningCapture = () => {
-		if (typeof process.removeAllListeners !== "function" || typeof process.on !== "function") return;
-		process.removeAllListeners("warning");
-		process.on("warning", (warning) => {
-			const record = typeof warning === "object" && warning !== null ? warning : void 0;
-			const name = record && typeof record.name === "string" ? record.name : "Warning";
-			if (name === "ExperimentalWarning") return;
-			const detail = record && typeof record.message === "string" ? record.message : String(warning);
-			postLog(logLevel.warn, `${name}: ${detail}`);
-		});
-	};
-	/**
-	* Compile a program body into a callable.
-	*
-	* The body is wrapped in an async function so `return` and `await` work at the top
-	* level, then run through `stripTypeScriptTypes` so the same body may carry type
-	* annotations (DSH's "type annotations are advisory, the code runs type-stripped").
-	* JavaScript the TypeScript parser rejects falls back to the unstripped source; a
-	* genuine syntax error then surfaces from the `Function` constructor instead.
-	*/
-	const compileProgram = (code) => {
-		const wrapped = `async function ${programName}() {\n${code}\n}`;
-		let source = wrapped;
-		try {
-			source = deps.stripTypes(wrapped, { mode: "strip" });
-		} catch {
-			source = wrapped;
-		}
-		return new Function(`${source}\nreturn ${programName}();`);
-	};
-	const runProgram = async (code, generation, port) => {
-		try {
-			let program;
-			try {
-				program = compileProgram(code);
-			} catch (error) {
-				postError(errorKind.exception, `program failed to compile: ${messageOf(error)}`, stackOf(error), port);
-				return;
-			}
-			try {
-				const value = await program();
-				const normalized = toJsonValue(value);
-				if (!normalized.ok) {
-					postError(errorKind.invalidOutput, normalized.reason, void 0, port);
-					return;
-				}
-				post(normalized.value === void 0 ? { kind: workerFrame.result } : {
-					kind: workerFrame.result,
-					value: normalized.value
-				}, port);
-			} catch (error) {
-				postError(cancelled ?? errorKind.exception, messageOf(error), stackOf(error), port);
-			}
-		} finally {
-			await reset(generation, port);
-		}
-	};
-	/**
-	* `tools.<name>(args)` — acquire an admission slot, post a call frame, and await the
-	* matching `call-result`.
-	*
-	* The slot is released on every exit path (settled, admission refused by `post`, cancel),
-	* which is what keeps a burst draining instead of deadlocking. Call frames carry the
-	* binding's own run port: a superseded run's late call is dropped at its closed port instead
-	* of arriving at the host as a call for a run it never made.
-	*/
-	const makeBinding = (name, port) => {
-		return async (args) => {
-			if (cancelled) throw abortError(cancelled);
-			await acquireCallSlot();
-			try {
-				if (cancelled) throw abortError(cancelled);
-				const callId = nextCallId;
-				nextCallId += 1;
-				const promise = new Promise((resolve, reject) => {
-					pending.set(callId, {
-						resolve,
-						reject
-					});
-				});
-				if (!post({
-					kind: workerFrame.call,
-					callId,
-					tool: name,
-					args
-				}, port)) {
-					pending.delete(callId);
-					throw new ToolCallError(name, `${name}() could not be called: the arguments are not transferable or the run has ended`);
-				}
-				return await promise;
-			} finally {
-				releaseCallSlot();
-			}
-		};
-	};
-	const settleCall = (frame) => {
-		const callId = frame.callId;
-		if (typeof callId !== "number") return;
-		const entry = pending.get(callId);
-		if (!entry) return;
-		pending.delete(callId);
-		if (frame.ok === true) {
-			entry.resolve(frame.value);
-			return;
-		}
-		entry.reject(new ToolCallError(typeof frame.tool === "string" ? frame.tool : "unknown", typeof frame.message === "string" ? frame.message : "binding call failed"));
-	};
-	const cancelPending = (reason) => {
-		cancelled = reason;
-		flushPendingCalls(abortError(reason));
-	};
-	/**
-	* Confirm a cancel that has nothing to flush, and forget it.
-	*
-	* A cancel can arrive while the worker is idle — booting, or freshly reset and waiting for the
-	* next `init`. There is no program to interrupt and no pending call to reject, so the honest
-	* answer is to report the cancel: the host asked to stop, and it should settle now rather than
-	* wait out its grace window for a run that will never start (and the `init` it might send next
-	* would clear the verdict and run the program anyway).
-	*/
-	const reportIdleCancel = (reason, port) => {
-		cancelled = void 0;
-		const error = abortError(reason);
-		postError(reason, error.message, void 0, port);
-	};
-	const assertItemCount = (helper, count, maxItemsPerCall) => {
-		if (count > maxItemsPerCall) throw new RangeError(`${helper}() received ${count} items, exceeding maxItemsPerCall (${maxItemsPerCall})`);
-	};
-	const installWorkflowHelpers = (args, maxItemsPerCall, port) => {
-		const target = globals();
-		target.args = args === void 0 ? null : args;
-		target.log = (message) => {
-			if (typeof message !== "string") throw new TypeError(`log(message) expects a string, received ${describeValue(message)}`);
-			post({
-				kind: workerFrame.narration,
-				message
-			}, port);
-		};
-		target.phase = (title) => {
-			if (typeof title !== "string") throw new TypeError(`phase(title) expects a string, received ${describeValue(title)}`);
-			post({
-				kind: workerFrame.phase,
-				title
-			}, port);
-		};
-		target.parallel = async (thunks) => {
-			if (!Array.isArray(thunks)) throw new TypeError(`parallel(thunks) expects an array of functions, received ${describeValue(thunks)}`);
-			assertItemCount("parallel", thunks.length, maxItemsPerCall);
-			for (let index = 0; index < thunks.length; index += 1) if (typeof thunks[index] !== "function") throw new TypeError(`parallel(thunks) expects functions; item ${index} is ${describeValue(thunks[index])}`);
-			return await Promise.all(thunks.map(async (thunk) => {
-				try {
-					return await thunk();
-				} catch {
-					return null;
-				}
-			}));
-		};
-		target.pipeline = async (items, ...stages) => {
-			if (!Array.isArray(items)) throw new TypeError(`pipeline(items, ...stages) expects an array of items, received ${describeValue(items)}`);
-			assertItemCount("pipeline", items.length, maxItemsPerCall);
-			if (stages.length === 0) throw new TypeError("pipeline(items, ...stages) requires at least one stage function");
-			for (let index = 0; index < stages.length; index += 1) if (typeof stages[index] !== "function") throw new TypeError(`pipeline(items, ...stages) expects stage functions; stage ${index} is ${describeValue(stages[index])}`);
-			const stageFunctions = stages;
-			return await Promise.all(items.map(async (item, index) => {
-				try {
-					let current = item;
-					for (const stage of stageFunctions) current = await stage(current, item, index);
-					return current;
-				} catch {
-					return null;
-				}
-			}));
-		};
-	};
-	/**
-	* Restore `globalThis` to the warm baseline taken at the end of the worker's
-	* boot-time setup (`installWarningCapture`).
-	*
-	* This is stronger than deleting the known `RUN_GLOBAL_KEYS`: it also wipes any
-	* stray property the previous run's program left behind (`globalThis.x = 1` and
-	* similar). Without it, warm reuse would leak state from one run to the next.
-	* Enumerating own *enumerable string* keys is also its limit — see `warmBaseline`
-	* for the leftovers that walk past it.
-	*
-	* Properties in the baseline are restored even if the program overwrote them —
-	* that is what keeps `console` honest for the next run, since the program's
-	* console override does not survive the reset.
-	*/
-	const restoreWarmBaseline = () => {
-		if (!warmBaseline) return;
-		const target = globals();
-		for (const key of Object.keys(target)) if (!warmBaseline.has(key)) delete target[key];
-		for (const [key, value] of warmBaseline) {
-			const descriptor = Object.getOwnPropertyDescriptor(target, key);
-			if (descriptor !== void 0 && descriptor.writable === false) continue;
-			try {
-				target[key] = value;
-			} catch {}
-		}
-	};
-	/**
-	* RUNNING → READY: clear the per-run state this worker owns so it is safe to accept
-	* another `init` frame on warm reuse (ADR-0017 §5).
-	*
-	* Order matters: flush first so no settled call leaks into the next run, then
-	* restore the warm baseline (the program may have left values behind that would
-	* shadow the next install), then rehydrate the frozen env so the next run starts
-	* from the same `process.env` snapshot the host captured. State transitions to
-	* `READY` last — only when the worker is actually eligible for the next `init`.
-	*
-	* What it clears is exactly: the outstanding calls and admission waiters, the run
-	* bookkeeping (`inFlightCalls`, `cancelled`, `nextCallId`, `pending`), `globalThis`'s own
-	* enumerable keys (via the warm baseline — see `warmBaseline` for what that misses) and
-	* `process.env`. It does **not** stop timers the program left running; nothing can, see
-	* `startRun`. And when the run that produced this reset was superseded, none of it happens at
-	* all: the clearing then falls to the *next* run's `startRun` (see the invariant below).
-	*
-	* Invariant — a reset is scoped to the run that produced it: `generation` is the run
-	* ordinal the finishing run was born with. If the worker has since been handed to a
-	* newer run (`generation !== runGeneration`), this reset is a no-op: it must not clear
-	* the newer run's calls, globals or bookkeeping, and it must not post `ready` (the
-	* host reads `ready` as "the current run settled, send the next init" — posting a
-	* stranger's `ready` is what makes a program execute twice). Ownership is captured at
-	* `init` time rather than read from the shared `state`, because `state` belongs to
-	* whoever owns the worker now. `port` is the run's own control port for the same reason:
-	* a `ready` that survives the ownership check still has no business on another run's port.
-	*/
-	const reset = async (generation, port) => {
-		if (state !== "RUNNING" || generation !== runGeneration) return;
-		flushPendingCalls(closedError());
-		inFlightCalls = 0;
-		cancelled = void 0;
-		nextCallId = 1;
-		pending.clear();
-		restoreWarmBaseline();
-		installFrozenEnv();
-		state = "READY";
-		post({ kind: workerFrame.ready }, port);
-	};
-	/**
-	* Claim the worker for one run and install that run's surface.
-	*
-	* `port` is the channel the run's `init` arrived on; it *is* the run's control port for life.
-	* Every frame the run produces afterwards — `log`, `narration`, `phase`, `call`, `result`,
-	* `error`, its closing `ready` — is posted through it, even if the worker has since been handed
-	* to another run (see `post`).
-	*
-	* The run starts from a clean realm. That cannot be left to the previous run's `reset()`: a run
-	* the host abandoned is superseded, and its reset is a generation-guarded no-op — so its strays on
-	* `globalThis` (`tools`, the workflow helpers, whatever its program assigned) and its bookkeeping
-	* would otherwise live on into this run and break the isolation warm reuse promises (ADR-0017
-	* §10(d) — and note §5 is explicit that the reset handshake is *not* where isolation comes
-	* from). Clearing here is unconditional: one run starting is the end of everything the previous
-	* round was doing, whatever the previous round did or did not do.
-	*
-	* "Clean" is what `restoreWarmBaseline` can restore — `globalThis`'s own enumerable keys, then the
-	* frozen env and this run's fresh installs — plus this worker's run bookkeeping. It is honestly
-	* not every trace a program can leave: a timer it started keeps firing, a prototype it patched
-	* stays patched, and `process` state it wrote stays written (see `warmBaseline` for the list).
-	* Timers are the leftover this function used to claim to clear, and the claim was false: Node
-	* offers no way to enumerate a worker's pending timers — inside a worker thread
-	* `process._getActiveHandles()` returns `[]` and `process.getActiveResourcesInfo()` reports names
-	* (`"Timeout"`), not handles (both checked on Node 24.21.0). A leftover interval is therefore a
-	* known, accepted limitation of warm reuse, not something this function clears.
-	*/
-	const startRun = (frame, generation, port) => {
-		restoreWarmBaseline();
-		cancelled = void 0;
-		inFlightCalls = 0;
-		pending.clear();
-		installFrozenEnv();
-		installConsole(port);
-		maxPendingCalls = typeof frame.maxPendingCalls === "number" && Number.isFinite(frame.maxPendingCalls) && frame.maxPendingCalls > 0 ? frame.maxPendingCalls : Number.POSITIVE_INFINITY;
-		const tools = {};
-		const bindingNames = Array.isArray(frame.bindings) ? frame.bindings.filter((name) => typeof name === "string") : [];
-		for (const name of bindingNames) tools[name] = makeBinding(name, port);
-		const available = bindingNames.join(", ") || "(none)";
-		const candidates = Array.isArray(frame.bindingCandidates) ? frame.bindingCandidates : [];
-		for (const name of candidates) {
-			if (typeof name !== "string" || tools[name]) continue;
-			tools[name] = async () => {
-				throw new ToolCallError(name, `no binding named "${name}" in this run; available bindings: ${available}`);
-			};
-		}
-		globals().tools = tools;
-		if (frame.surface === "workflow") {
-			const maxItemsPerCall = typeof frame.maxItemsPerCall === "number" ? frame.maxItemsPerCall : 0;
-			installWorkflowHelpers(frame.args, maxItemsPerCall, port);
-		}
-		runProgram(typeof frame.code === "string" ? frame.code : "", generation, port);
-	};
-	/**
-	* Handle one host frame, tagging it with the port it arrived on: that port *is* the run's
-	* control port if the frame is an `init` (see `startRun`), so the run's frames stay on the
-	* channel its own host is listening to.
-	*/
-	const handleHostFrame = (raw, port) => {
-		if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return;
-		const frame = raw;
-		if (frame.kind === hostFrame.init) {
-			if (state !== "READY") return;
-			runGeneration += 1;
-			const generation = runGeneration;
-			state = "RUNNING";
-			startRun(frame, generation, port);
-			return;
-		}
-		if (frame.kind === hostFrame.callResult) {
-			settleCall(frame);
-			return;
-		}
-		if (frame.kind === hostFrame.cancel) {
-			const reason = frame.reason === "timeout" ? "timeout" : "abort";
-			if (state === "READY") {
-				reportIdleCancel(reason, port);
-				return;
-			}
-			cancelPending(reason);
-		}
-	};
-	state = "BOOTING";
-	deps.parentPort.on("message", (value) => {
-		if (typeof value !== "object" || value === null) return;
-		const frame = value;
-		if (frame.kind !== hostFrame.connect) return;
-		const port = frame.port;
-		if (typeof port !== "object" || port === null || typeof port.on !== "function") return;
-		const connected = port;
-		control = connected;
-		connected.on("message", (raw) => {
-			handleHostFrame(raw, connected);
-		});
-		connected.on("close", () => {
-			if (control === connected) flushPendingCalls(closedError());
-		});
-		installWarningCapture();
-		const isFirstBoot = warmBaseline === void 0;
-		if (isFirstBoot) warmBaseline = new Map(Object.entries(globals()));
-		state = "READY";
-		if (cancelled !== void 0) {
-			if (isFirstBoot) {
-				reportIdleCancel(cancelled, connected);
-				return;
-			}
-			cancelled = void 0;
-		}
-		post({ kind: workerFrame.ready }, connected);
-	});
-}
-//#endregion
-//#region src/runtime/worker-entry.ts
-/**
-* Worker entry — loaded by file URL (ADR-0017 §7).
-*
-* The previous bootstrap composed a `data:text/javascript,…` URL from
-* `Function.prototype.toString()` of `workerMain`, which kept the package as a
-* single self-contained file but paid a fresh V8 spin-up + module-graph parse
-* for every worker spawn (no code-cache reuse). After the rolldown dual-entry
-* build emits `dist/worker.js` as a sibling of `dist/index.js`, this file is
-* the target the host loads; V8 and Node's module cache survive across
-* warm-reuse spawns.
-*
-* The protocol tables travel as static imports in both bundles (host imports
-* from `dist/index.js`, worker imports from `dist/worker.js`) — both files
-* bundle `./protocol.ts`, so each side constructs `workerProtocolSpec()`
-* independently and the wire strings stay aligned. This removes the build-time
-* protocol literal the data: URL used to carry.
-*
-* `workerData` is the spawn-time payload `{ env }` — the frozen per-run env
-* snapshot (F3, ADR-0005) — and nothing else. Run identity is *not* spawn-time:
-* a warm worker outlives the run that spawned it, so the host sends each run's
-* `runId` in its own `init` frame instead. `workerMain` reads neither (see its
-* `WorkerMainDeps.workerData` note); `runId` is host-side bookkeeping for
-* attributing frames to a run.
-*/
-workerMain({
-	parentPort,
-	workerData,
-	inspect,
-	stripTypes: stripTypeScriptTypes,
-	protocol: workerProtocolSpec()
-});
-//#endregion
-export {};
-
+import{a as e,c as t}from"./protocol-CfOgxz3u.js";import{stripTypeScriptTypes as n}from"node:module";import{parentPort as r,workerData as i}from"node:worker_threads";import{inspect as a}from"node:util";function o(t){let n=t.protocol.hostFrame,r=t.protocol.workerFrame,i=t.protocol.logLevel,a=t.protocol.errorKind,o=`__ptcProgram`,s=`CREATED`,c=0,l,u,d=1,f=0,p=1/0,m=[],h=/* @__PURE__ */ new Map,g,_=()=>globalThis;class v extends Error{toolName;constructor(e,t){super(t),this.name=`ToolCallError`,this.toolName=e}}let y=e=>e instanceof Error?e.message:String(e),b=e=>{if(!(e instanceof Error)||typeof e.stack!=`string`)return;let t=e.stack.split(`
+`),n=[t[0]??``];for(let e of t.slice(1))if(n.push(e),n.length>=6)break;return n.join(`
+`)},x=(e,t=l)=>{if(!t)return!1;try{return t.postMessage(e),!0}catch{return!1}},S=(e,t,n)=>{x({kind:r.log,level:e,text:t},n)},C=(e,t,n,i)=>{x(n===void 0?{kind:r.error,error:{kind:e,message:t}}:{kind:r.error,error:{kind:e,message:t,stack:n}},i)},w=e=>{let t=/* @__PURE__ */ Error(e===`timeout`?`PTC run timed out`:`PTC run was cancelled`);return t.name=`AbortError`,t},T=()=>{let e=/* @__PURE__ */ Error(`the PTC control channel closed before the call completed`);return e.name=`AbortError`,e},E=async()=>{if(f<p){f+=1;return}await new Promise((e,t)=>{m.push({resolve:e,reject:t})})},D=()=>{let e=m.shift();if(e){e.resolve();return}--f},O=e=>{for(;m.length>0;){let t=m.shift();t&&t.reject(e)}},k=e=>{O(e);for(let[t,n]of h)h.delete(t),n.reject(e)},A=()=>{let e=t.workerData;if(typeof e!=`object`||!e)return;let n=e.env;if(typeof n!=`object`||!n||Array.isArray(n))return;let r=n;for(let e of Object.keys(process.env))e in r||delete process.env[e];for(let e of Object.keys(r)){let t=r[e];typeof t==`string`&&(process.env[e]=t)}},j=t=>{let n=/* @__PURE__ */ new Set,r=(t,i)=>{if(t===null)return{ok:!0,value:null};if(typeof t==`string`||typeof t==`boolean`)return{ok:!0,value:t};if(t===void 0)return{ok:!0,value:void 0};if(typeof t==`number`)return Number.isFinite(t)?{ok:!0,value:t}:{ok:!1,reason:`${i} is ${String(t)}, which is not representable as JSON`};if(typeof t!=`object`)return{ok:!1,reason:`${i} is ${e(t)}; results must be lossless JSON`};if(Array.isArray(t)){if(n.has(t))return{ok:!1,reason:`${i} is a circular reference`};n.add(t);let e=[];for(let n=0;n<t.length;n+=1){let a=r(t[n],`${i}[${n}]`);if(!a.ok)return a;e.push(a.value===void 0?null:a.value)}return n.delete(t),{ok:!0,value:e}}let a=Object.getPrototypeOf(t);if(a!==Object.prototype&&a!==null){let e=t.constructor;return{ok:!1,reason:`${i} is a ${e&&typeof e.name==`string`&&e.name.length>0?e.name:`an object`}; results must be plain JSON objects`}}if(n.has(t))return{ok:!1,reason:`${i} is a circular reference`};n.add(t);let o={};for(let e of Object.keys(t)){let n=r(t[e],`${i}.${e}`);if(!n.ok)return n;n.value!==void 0&&(o[e]=n.value)}return n.delete(t),{ok:!0,value:o}};return r(t,`result`)},M=e=>e.map(e=>typeof e==`string`?e:t.inspect(e,{depth:4,breakLength:1/0,colors:!1})).join(` `),N=e=>{let t=t=>(...n)=>{S(t,M(n),e)};_().console={log:t(i.log),info:t(i.info),warn:t(i.warn),error:t(i.error),debug:t(i.debug)}},P=()=>{typeof process.removeAllListeners==`function`&&typeof process.on==`function`&&(process.removeAllListeners(`warning`),process.on(`warning`,e=>{let t=typeof e==`object`&&e?e:void 0,n=t&&typeof t.name==`string`?t.name:`Warning`;if(n===`ExperimentalWarning`)return;let r=t&&typeof t.message==`string`?t.message:String(e);S(i.warn,`${n}: ${r}`)}))},F=e=>{let n=`async function ${o}() {\n${e}\n}`,r=n;try{r=t.stripTypes(n,{mode:`strip`})}catch{r=n}return Function(`${r}\nreturn ${o}();`)},I=async(e,t,n)=>{try{let t;try{t=F(e)}catch(e){C(a.exception,`program failed to compile: ${y(e)}`,b(e),n);return}try{let e=await t(),i=j(e);if(!i.ok){C(a.invalidOutput,i.reason,void 0,n);return}x(i.value===void 0?{kind:r.result}:{kind:r.result,value:i.value},n)}catch(e){C(u??a.exception,y(e),b(e),n)}}finally{await W(t,n)}},L=(e,t)=>async n=>{if(u)throw w(u);await E();try{if(u)throw w(u);let i=d;d+=1;let a=new Promise((e,t)=>{h.set(i,{resolve:e,reject:t})});if(!x({kind:r.call,callId:i,tool:e,args:n},t))throw h.delete(i),new v(e,`${e}() could not be called: the arguments are not transferable or the run has ended`);return await a}finally{D()}},R=e=>{let t=e.callId;if(typeof t!=`number`)return;let n=h.get(t);if(n){if(h.delete(t),e.ok===!0){n.resolve(e.value);return}n.reject(new v(typeof e.tool==`string`?e.tool:`unknown`,typeof e.message==`string`?e.message:`binding call failed`))}},z=e=>{u=e,k(w(e))},B=(e,t)=>{u=void 0;let n=w(e);C(e,n.message,void 0,t)},V=(e,t,n)=>{if(t>n)throw RangeError(`${e}() received ${t} items, exceeding maxItemsPerCall (${n})`)},H=(t,n,i)=>{let a=_();a.args=t===void 0?null:t,a.log=t=>{if(typeof t!=`string`)throw TypeError(`log(message) expects a string, received ${e(t)}`);x({kind:r.narration,message:t},i)},a.phase=t=>{if(typeof t!=`string`)throw TypeError(`phase(title) expects a string, received ${e(t)}`);x({kind:r.phase,title:t},i)},a.parallel=async t=>{if(!Array.isArray(t))throw TypeError(`parallel(thunks) expects an array of functions, received ${e(t)}`);V(`parallel`,t.length,n);for(let n=0;n<t.length;n+=1)if(typeof t[n]!=`function`)throw TypeError(`parallel(thunks) expects functions; item ${n} is ${e(t[n])}`);return await Promise.all(t.map(async e=>{try{return await e()}catch{return null}}))},a.pipeline=async(t,...r)=>{if(!Array.isArray(t))throw TypeError(`pipeline(items, ...stages) expects an array of items, received ${e(t)}`);if(V(`pipeline`,t.length,n),r.length===0)throw TypeError(`pipeline(items, ...stages) requires at least one stage function`);for(let t=0;t<r.length;t+=1)if(typeof r[t]!=`function`)throw TypeError(`pipeline(items, ...stages) expects stage functions; stage ${t} is ${e(r[t])}`);let i=r;return await Promise.all(t.map(async(e,t)=>{try{let n=e;for(let r of i)n=await r(n,e,t);return n}catch{return null}}))}},U=()=>{if(!g)return;let e=_();for(let t of Object.keys(e))g.has(t)||delete e[t];for(let[t,n]of g){let r=Object.getOwnPropertyDescriptor(e,t);if(r===void 0||r.writable!==!1)try{e[t]=n}catch{}}},W=async(e,t)=>{s===`RUNNING`&&e===c&&(k(T()),f=0,u=void 0,d=1,h.clear(),U(),A(),s=`READY`,x({kind:r.ready},t))},G=(e,t,n)=>{U(),u=void 0,f=0,h.clear(),A(),N(n),p=typeof e.maxPendingCalls==`number`&&Number.isFinite(e.maxPendingCalls)&&e.maxPendingCalls>0?e.maxPendingCalls:1/0;let r={},i=Array.isArray(e.bindings)?e.bindings.filter(e=>typeof e==`string`):[];for(let e of i)r[e]=L(e,n);let a=i.join(`, `)||`(none)`,o=Array.isArray(e.bindingCandidates)?e.bindingCandidates:[];for(let e of o)typeof e!=`string`||r[e]||(r[e]=async()=>{throw new v(e,`no binding named "${e}" in this run; available bindings: ${a}`)});if(_().tools=r,e.surface===`workflow`){let t=typeof e.maxItemsPerCall==`number`?e.maxItemsPerCall:0;H(e.args,t,n)}I(typeof e.code==`string`?e.code:``,t,n)},K=(e,t)=>{if(typeof e!=`object`||!e||Array.isArray(e))return;let r=e;if(r.kind===n.init){if(s!==`READY`)return;c+=1;let e=c;s=`RUNNING`,G(r,e,t);return}if(r.kind===n.callResult){R(r);return}if(r.kind===n.cancel){let e=r.reason===`timeout`?`timeout`:`abort`;if(s===`READY`){B(e,t);return}z(e)}};s=`BOOTING`,t.parentPort.on(`message`,e=>{if(typeof e!=`object`||!e)return;let t=e;if(t.kind!==n.connect)return;let i=t.port;if(typeof i!=`object`||!i||typeof i.on!=`function`)return;let a=i;l=a,a.on(`message`,e=>{K(e,a)}),a.on(`close`,()=>{l===a&&k(T())}),P();let o=g===void 0;if(o&&(g=new Map(Object.entries(_()))),s=`READY`,u!==void 0){if(o){B(u,a);return}u=void 0}x({kind:r.ready},a)})}o({parentPort:r,workerData:i,inspect:a,stripTypes:n,protocol:t()});export{};
 //# sourceMappingURL=worker.js.map