uigraph 1.0.0 → 1.0.2

package/dist/execute-BoTKl80U.mjs

@@ -1,1715 +0,0 @@
-import { D as combineUsage, M as formatSize, R as writeOutputFile, a as CODEMODE_DOCS_PATH, d as parseCodemodeSource, f as renderToolSample, l as getCodemodeCallableTools, o as CODEMODE_STORE_ENTRY_TYPE, p as toCodemodeIdentifier, r as createToolSearchDocument, t as Bm25Ranker, u as toCodemodeDeclaration } from "./tool-DHDYqsyG.mjs";
-import { C as getQuickJSWasmPath, g as getCodemodeWorkerSpecifier } from "./config-D8DMGzIq.mjs";
-import { createRequire } from "node:module";
-import { readFile } from "node:fs/promises";
-import { Worker } from "node:worker_threads";
-//#region node_modules/.pnpm/@earendil-works+pi-codemode@1.2.0/node_modules/@earendil-works/pi-codemode/dist/runtime/protocol.js
-function isWorkerToHostMessage(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const type = value.type;
-	return type === "call" || type === "output" || type === "done" || type === "crash" || type === "started" || type === "idle";
-}
-//#endregion
-//#region node_modules/.pnpm/@earendil-works+pi-codemode@1.2.0/node_modules/@earendil-works/pi-codemode/dist/runtime/execution.js
-/**
-* Host side of an execution, shared by every place a VM can run.
-*
-* The host owns everything the script must not influence: the tool table, call records, output,
-* the deadline, the caller's abort signal, and the decoding of what the VM reports. The VM itself
-* runs somewhere a {@link VmLauncher} decides: a worker thread (`CodemodeSandbox`), the calling
-* thread (`InlineCodemodeSandbox`), or another isolate reached over RPC (`RemoteCodemodeSandbox`).
-* The two sides only exchange the messages in `protocol.ts`, so the launchers differ in transport
-* and termination, not in behavior.
-*
-* Lifecycle of one execution:
-* 1. The constructor arms the deadline and abort listener, then asks the launcher for a channel.
-* 2. Messages from the VM arrive through {@link VmEvents.message}; tool calls run here and their
-*    results go back through {@link VmChannel.post}. Replies produced before the launcher has
-*    returned its channel are queued and flushed when it arrives.
-* 3. The first terminal event wins: `done`, `crash`, a launcher failure, the deadline, or an abort.
-*    `finish()` aborts pending tool calls, stops the channel, and resolves the result once the
-*    channel reports it stopped. Later events are ignored.
-*
-* The launcher, not this class, is responsible for actually stopping a running VM: a worker is
-* terminated, an in-thread VM is interrupted and disposed, and a remote VM is told to stop at its
-* next exchange.
-*/
-const DEFAULT_TIMEOUT_MS = 3e5;
-const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-const RESERVED_GLOBALS = /* @__PURE__ */ new Set([
-	"tools",
-	"ALL_TOOLS",
-	"console",
-	"text",
-	"image",
-	"exit",
-	"globalThis",
-	"store",
-	"load"
-]);
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function serializeStore(store) {
-	const serialized = {};
-	for (const [key, value] of Object.entries(store ?? {})) {
-		const json = JSON.stringify(value);
-		if (json !== void 0) serialized[key] = json;
-	}
-	return serialized;
-}
-/**
-* The prelude that serializes values for the host runs in the same VM as the script, so a script
-* that patches built-ins (for example `Array.prototype.toJSON`) can make it send malformed data.
-* Payloads that do not decode throw this error, and the execution fails as a sandbox error.
-*/
-var BridgeError = class extends Error {};
-function parseBridgeJson(json, what) {
-	try {
-		return JSON.parse(json);
-	} catch {
-		throw new BridgeError(`${what} is not valid JSON`);
-	}
-}
-function parseStoreWrites(json) {
-	const entries = parseBridgeJson(json, "store writes");
-	if (!Array.isArray(entries)) throw new BridgeError("store writes are not an array");
-	const writes = {
-		set: {},
-		delete: []
-	};
-	for (const entry of entries) {
-		if (!Array.isArray(entry) || typeof entry[0] !== "string" || (entry.length === 2 ? typeof entry[1] !== "string" : entry.length !== 1)) throw new BridgeError("store writes contain a malformed entry");
-		const [key, value] = entry;
-		if (value === void 0) writes.delete.push(key);
-		else writes.set[key] = parseBridgeJson(value, `store value for ${JSON.stringify(key)}`);
-	}
-	return writes;
-}
-function parseScriptError(json) {
-	const parsed = parseBridgeJson(json, "script error");
-	if (typeof parsed !== "object" || parsed === null) throw new BridgeError("script error is not an object");
-	const { name, message, stack } = parsed;
-	if (typeof message !== "string" || name !== void 0 && typeof name !== "string" || stack !== void 0 && typeof stack !== "string") throw new BridgeError("script error is malformed");
-	return {
-		kind: "script",
-		name,
-		message,
-		stack
-	};
-}
-/** Checks global names: identifiers or `namespace.member`, not shadowing a built-in global or each other. */
-function checkGlobals(globals) {
-	const names = /* @__PURE__ */ new Set();
-	const namespaces = /* @__PURE__ */ new Set();
-	for (const global of globals) {
-		const parts = global.name.split(".");
-		if (parts.length > 2 || !parts.every((part) => IDENTIFIER.test(part)) || RESERVED_GLOBALS.has(parts[0])) throw new Error(`Invalid global name "${global.name}"`);
-		if (names.has(global.name)) throw new Error(`Global "${global.name}" is already registered`);
-		if (parts.length === 2) namespaces.add(parts[0]);
-		names.add(global.name);
-	}
-	for (const name of namespaces) if (names.has(name)) throw new Error(`Global "${name}" conflicts with the namespace "${name}"`);
-}
-/** One script run in its own VM. */
-var Execution = class {
-	promise;
-	resolveResult;
-	channel;
-	/** Replies produced before the launcher returned the channel. */
-	unsent = [];
-	executors;
-	control;
-	/** Result numbers `deliver()` used. */
-	delivered = /* @__PURE__ */ new Set();
-	signal;
-	timer;
-	output = [];
-	calls = [];
-	pending = /* @__PURE__ */ new Map();
-	/** Whether the execution has its outcome. */
-	finished = false;
-	constructor(options) {
-		this.promise = new Promise((resolve) => {
-			this.resolveResult = resolve;
-		});
-		this.executors = options.executors;
-		this.control = options.control;
-		this.signal = options.signal;
-		if (Number.isFinite(options.timeoutMs)) this.timer = setTimeout(() => {
-			this.finish({
-				kind: "timeout",
-				message: `Execution timed out after ${options.timeoutMs} ms`
-			});
-		}, options.timeoutMs);
-		if (options.signal) {
-			if (options.signal.aborted) this.onAbort();
-			else options.signal.addEventListener("abort", this.onAbort, { once: true });
-		}
-		if (this.finished) return;
-		const data = {
-			code: options.code,
-			tools: options.tools.map((tool) => ({
-				name: tool.name,
-				jsName: tool.jsName ?? toCodemodeIdentifier(tool.name),
-				description: tool.description ?? ""
-			})),
-			globals: options.globals.map((global) => ({
-				name: global.name,
-				spread: global.spread === true
-			})),
-			memoryLimitBytes: options.memoryLimitBytes,
-			store: options.store,
-			...options.deterministic ? { deterministic: options.deterministic } : {}
-		};
-		const events = {
-			message: (message) => this.receive(message),
-			failure: (error) => this.finish(error)
-		};
-		new Promise((resolve) => resolve(options.launch(data, events))).then((channel) => {
-			if (this.finished) {
-				channel.stop().catch(() => void 0);
-				return;
-			}
-			this.channel = channel;
-			for (const message of this.unsent.splice(0)) channel.post(message);
-		}, (error) => {
-			this.finish({
-				kind: "sandbox",
-				message: errorMessage(error)
-			});
-		});
-	}
-	/** `CodemodeRun.deliver()`. */
-	deliver(seq, now, id, outcome) {
-		if (this.finished) return;
-		if (!Number.isFinite(now)) throw new Error(`The clock value of result ${seq} is not a finite number`);
-		if (!Number.isInteger(seq) || seq < 1 || this.delivered.has(seq)) throw new Error(`Result number ${seq} is not a positive integer used once`);
-		const pending = this.pending.get(id);
-		if (pending === void 0) throw new Error(`Call ${id} is not waiting for a result`);
-		if (!outcome.ok && outcome.properties !== void 0) {
-			const { properties } = outcome;
-			if (typeof properties !== "object" || properties === null || Array.isArray(properties)) throw new Error(`The properties of result ${seq} are not an object`);
-		}
-		const payload = outcome.ok ? outcome.value === void 0 ? void 0 : JSON.stringify(outcome.value) : outcome.message;
-		const properties = !outcome.ok && outcome.properties !== void 0 ? JSON.stringify(outcome.properties) : void 0;
-		this.delivered.add(seq);
-		this.pending.delete(id);
-		if (pending.record) {
-			pending.record.status = outcome.ok ? "ok" : "error";
-			pending.record.durationMs = performance.now() - pending.startedAt;
-		}
-		this.post({
-			type: "result",
-			id,
-			ok: outcome.ok,
-			payload,
-			seq,
-			now,
-			...properties === void 0 ? {} : { properties }
-		});
-	}
-	abort(message) {
-		this.finish({
-			kind: "aborted",
-			message
-		});
-		return this.promise;
-	}
-	onAbort = () => {
-		const reason = this.signal?.reason;
-		this.finish({
-			kind: "aborted",
-			message: reason instanceof Error ? reason.message : "Execution aborted"
-		});
-	};
-	post(message) {
-		if (this.channel) this.channel.post(message);
-		else this.unsent.push(message);
-	}
-	/** An exception here would escape into the launcher's transport and leave the execution unsettled. */
-	receive(message) {
-		try {
-			this.handleMessage(message);
-		} catch (error) {
-			this.finish({
-				kind: "sandbox",
-				message: error instanceof BridgeError ? `Sandbox bridge broken: ${error.message}. The script may have modified built-ins such as a prototype's toJSON.` : `Sandbox host failed: ${errorMessage(error)}`
-			});
-		}
-	}
-	handleMessage(message) {
-		if (this.finished) return;
-		if (!isWorkerToHostMessage(message)) throw new BridgeError("unknown message from the worker");
-		switch (message.type) {
-			case "output":
-				this.output.push(message.item);
-				break;
-			case "call":
-				if (this.pending.has(message.id)) throw new BridgeError(`duplicate call id ${message.id}`);
-				if (this.control) this.forwardCall(message, this.control);
-				else this.handleCall(message);
-				break;
-			case "started":
-				this.control?.onStarted?.(message.fingerprint);
-				break;
-			case "idle":
-				this.control?.onIdle?.(message.seq, message.issued);
-				break;
-			case "done":
-				this.handleDone(message);
-				break;
-			case "crash": this.finish({
-				kind: "sandbox",
-				message: message.message
-			});
-		}
-	}
-	handleDone(message) {
-		if (!message.ok) {
-			this.finish(parseScriptError(message.error), void 0, void 0, message.during);
-			return;
-		}
-		const value = message.value === void 0 ? void 0 : parseBridgeJson(message.value, "return value");
-		this.finish(void 0, value, parseStoreWrites(message.writes), message.during);
-	}
-	/** A host-controlled run: record the call and hand it to the caller, which answers with `deliver()`. */
-	forwardCall(message, control) {
-		const { id, name, target } = message;
-		const args = message.args === void 0 ? void 0 : parseBridgeJson(message.args, "call arguments");
-		const record = target === "tool" ? {
-			name,
-			status: "cancelled",
-			durationMs: 0
-		} : void 0;
-		if (record) this.calls.push(record);
-		this.pending.set(id, {
-			record,
-			startedAt: performance.now(),
-			controller: new AbortController()
-		});
-		control.onCall({
-			id,
-			target,
-			name,
-			args
-		});
-	}
-	async handleCall(message) {
-		const { id, name } = message;
-		const isTool = message.target === "tool";
-		const record = isTool ? {
-			name,
-			status: "cancelled",
-			durationMs: 0
-		} : void 0;
-		if (record) this.calls.push(record);
-		const pending = {
-			record,
-			startedAt: performance.now(),
-			controller: new AbortController()
-		};
-		this.pending.set(id, pending);
-		let status;
-		let reply;
-		try {
-			const tool = (isTool ? this.executors.tools : this.executors.globals).get(name);
-			if (!tool) throw new Error(`Unknown ${isTool ? "tool" : "global"} "${name}"`);
-			const args = message.args === void 0 ? void 0 : JSON.parse(message.args);
-			const value = await tool.execute(args, { signal: pending.controller.signal });
-			reply = {
-				type: "result",
-				id,
-				ok: true,
-				payload: value === void 0 ? void 0 : JSON.stringify(value)
-			};
-			status = "ok";
-		} catch (error) {
-			reply = {
-				type: "result",
-				id,
-				ok: false,
-				payload: errorMessage(error)
-			};
-			status = "error";
-		}
-		if (!this.pending.delete(id)) return;
-		if (record) {
-			record.status = status;
-			record.durationMs = performance.now() - pending.startedAt;
-		}
-		this.post(reply);
-	}
-	finish(error, value, writes, during) {
-		if (this.finished) return;
-		this.finished = true;
-		clearTimeout(this.timer);
-		this.signal?.removeEventListener("abort", this.onAbort);
-		const now = performance.now();
-		for (const pending of this.pending.values()) {
-			if (pending.record) pending.record.durationMs = now - pending.startedAt;
-			pending.controller.abort();
-		}
-		this.pending.clear();
-		this.unsent = [];
-		const ended = during === void 0 ? {} : { during: {
-			seq: during.seq,
-			issued: during.issued
-		} };
-		const result = error ? {
-			ok: false,
-			error,
-			output: this.output,
-			calls: this.calls,
-			...ended
-		} : {
-			ok: true,
-			value,
-			output: this.output,
-			calls: this.calls,
-			storeWrites: writes ?? {
-				set: {},
-				delete: []
-			},
-			...ended
-		};
-		if (!this.channel) {
-			this.resolveResult(result);
-			return;
-		}
-		this.channel.stop().catch(() => void 0).then(() => this.resolveResult(result));
-	}
-};
-/**
-* Tool table, defaults, and in-flight executions; the behavior every sandbox shares. Subclasses
-* only choose where the VM runs by passing a {@link VmLauncher}.
-*
-* The script sees `tools.<name>(args)` for every registered tool, `ALL_TOOLS`, the output helpers
-* `text`, `image`, `exit`, and `console.*`, `store`/`load`, and the configured globals; nothing
-* else (no timers, `fetch`, `process`, `require`, modules). Each `execute()` gets its own VM; the
-* sandbox only holds the tool table and defaults. `close()` aborts in-flight executions.
-*/
-var CodemodeSandboxBase = class {
-	toolsByName = /* @__PURE__ */ new Map();
-	globalsByName = /* @__PURE__ */ new Map();
-	timeoutMs;
-	memoryLimitBytes;
-	launch;
-	running = /* @__PURE__ */ new Set();
-	closed = false;
-	constructor(options, launch) {
-		this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-		this.memoryLimitBytes = options.memoryLimitBytes;
-		this.launch = launch;
-		for (const tool of options.tools ?? []) this.registerTool(tool);
-		checkGlobals(options.globals ?? []);
-		for (const global of options.globals ?? []) this.globalsByName.set(global.name, global);
-	}
-	/** Throws if a tool with the same name is already registered. */
-	registerTool(tool) {
-		if (this.toolsByName.has(tool.name)) throw new Error(`Tool "${tool.name}" is already registered`);
-		this.toolsByName.set(tool.name, tool);
-	}
-	unregisterTool(name) {
-		return this.toolsByName.delete(name);
-	}
-	get tools() {
-		return [...this.toolsByName.values()];
-	}
-	get globals() {
-		return [...this.globalsByName.values()];
-	}
-	/**
-	* `code` is an async function body: `return` and top-level `await` work.
-	* Never rejects for script failures; those come back as `{ ok: false }`.
-	* The script can use `store(key, value)` and `load(key)` on `options.store`.
-	*/
-	execute(code, options = {}) {
-		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Sandbox is closed"));
-		const tools = new Map(this.toolsByName);
-		const execution = new Execution({
-			code,
-			tools: [...tools.values()],
-			globals: [...this.globalsByName.values()],
-			executors: {
-				tools,
-				globals: this.globalsByName
-			},
-			timeoutMs: options.timeoutMs ?? this.timeoutMs,
-			signal: options.signal,
-			memoryLimitBytes: this.memoryLimitBytes,
-			store: serializeStore(options.store),
-			launch: this.launch
-		});
-		this.running.add(execution);
-		return execution.promise.finally(() => this.running.delete(execution));
-	}
-	/**
-	* Run `code` deterministically, with the caller answering its calls: the same script, start time, seed, tools,
-	* globals, and store, answered with the same results in the same `seq` order, makes the same calls with the same
-	* arguments and produces the same output, on any VM with the same fingerprint. A host can therefore replay it
-	* after a restart. The VM runs in UTC, its clock reads `startedAt` and then the `now` of the result being
-	* processed, its randomness comes from `seed`, and `WeakRef` and `FinalizationRegistry` do not exist.
-	*
-	* The sandbox's own tools and globals are not used: the run declares its own, and every call goes to
-	* `options.onCall`. Never rejects for script failures; abort through `options.signal` to end the run with an
-	* error the script cannot catch.
-	*/
-	start(code, options) {
-		if (this.closed) throw new Error("Sandbox is closed");
-		if (!Number.isFinite(options.startedAt) || options.startedAt < 0) throw new Error("startedAt must be a non-negative number of milliseconds since the epoch");
-		if (!Number.isInteger(options.seed) || options.seed < 0 || options.seed > 4294967295) throw new Error("seed must be a 32-bit unsigned integer");
-		const tools = options.tools ?? [];
-		if (new Set(tools.map((tool) => tool.name)).size !== tools.length) throw new Error("Tool names must be unique");
-		const scriptNames = tools.map((tool) => tool.jsName ?? toCodemodeIdentifier(tool.name));
-		if (new Set(scriptNames).size !== tools.length) throw new Error("Tool script names must be unique");
-		const globals = options.globals ?? [];
-		checkGlobals(globals);
-		const execution = new Execution({
-			code,
-			tools,
-			globals,
-			executors: {
-				tools: /* @__PURE__ */ new Map(),
-				globals: /* @__PURE__ */ new Map()
-			},
-			timeoutMs: options.timeoutMs ?? Number.POSITIVE_INFINITY,
-			signal: options.signal,
-			memoryLimitBytes: this.memoryLimitBytes,
-			store: serializeStore(options.store),
-			deterministic: {
-				startedAt: options.startedAt,
-				seed: options.seed
-			},
-			control: {
-				onStarted: options.onStarted,
-				onCall: options.onCall,
-				onIdle: options.onIdle
-			},
-			launch: this.launch
-		});
-		this.running.add(execution);
-		return {
-			result: execution.promise.finally(() => this.running.delete(execution)),
-			deliver: (seq, now, id, outcome) => execution.deliver(seq, now, id, outcome),
-			get finished() {
-				return execution.finished;
-			}
-		};
-	}
-	/** Aborts in-flight executions (they resolve with `kind: "aborted"`) and rejects new ones. */
-	async close() {
-		this.closed = true;
-		await Promise.all([...this.running].map((execution) => execution.abort("Sandbox closed")));
-	}
-};
-//#endregion
-//#region node_modules/.pnpm/@earendil-works+pi-codemode@1.2.0/node_modules/@earendil-works/pi-codemode/dist/wasm.js
-const modules = /* @__PURE__ */ new Map();
-/**
-* Read and compile the QuickJS wasm once per path. `path` defaults to the file in the installed
-* `quickjs-wasi` package; pass it when that file lives elsewhere, for example embedded in a Bun
-* compiled executable. A failed load is retried on the next call.
-*/
-function loadQuickJSWasm(path) {
-	const resolved = path ?? createRequire(import.meta.url).resolve("quickjs-wasi/quickjs.wasm");
-	let module = modules.get(resolved);
-	if (!module) {
-		const { WebAssembly } = globalThis;
-		module = readFile(resolved).then((bytes) => WebAssembly.compile(bytes)).catch((error) => {
-			modules.delete(resolved);
-			throw error;
-		});
-		modules.set(resolved, module);
-	}
-	return module;
-}
-//#endregion
-//#region node_modules/.pnpm/@earendil-works+pi-codemode@1.2.0/node_modules/@earendil-works/pi-codemode/dist/runtime/host.js
-function defaultWorkerUrl() {
-	return new URL(import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js", import.meta.url);
-}
-/**
-* Each execution gets its own worker thread and QuickJS VM. A fresh worker per run keeps
-* termination simple: a runaway script, including one that only spins the microtask queue, is
-* killed with `terminate()` and cannot poison a later run. Before terminating, the host sets a
-* shared interrupt flag that the VM polls, because Bun's `terminate()` cannot stop a thread that
-* is spinning in wasm.
-*/
-function workerLauncher(wasm, workerUrl) {
-	return async (data, events) => {
-		let module;
-		try {
-			module = await (wasm ?? loadQuickJSWasm());
-		} catch (error) {
-			throw new Error(`Failed to load QuickJS: ${errorMessage(error)}`);
-		}
-		const interrupt = new SharedArrayBuffer(4);
-		const workerData = {
-			...data,
-			wasm: module,
-			interrupt
-		};
-		let worker;
-		try {
-			worker = new Worker(workerUrl, { workerData });
-		} catch (error) {
-			throw new Error(`Failed to start worker: ${errorMessage(error)}`);
-		}
-		worker.on("message", (message) => {
-			if (typeof message === "object" && message !== null && ("watch:import" in message || "watch:require" in message)) return;
-			events.message(message);
-		});
-		worker.on("error", (error) => {
-			events.failure({
-				kind: "sandbox",
-				name: error instanceof Error ? error.name : void 0,
-				message: errorMessage(error)
-			});
-		});
-		worker.on("exit", (code) => {
-			events.failure({
-				kind: "sandbox",
-				message: `Worker exited with code ${code} before the script settled`
-			});
-		});
-		return {
-			post: (message) => worker.postMessage(message),
-			stop: async () => {
-				Atomics.store(new Int32Array(interrupt), 0, 1);
-				await worker.terminate().catch(() => void 0);
-			}
-		};
-	};
-}
-/**
-* Runs JavaScript in a QuickJS VM (a separate wasm instance) inside a worker thread. The worker
-* keeps script execution off the host thread: QuickJS runs synchronously, so a spinning script on
-* the host thread would block its event loop. Requires `node:worker_threads` (Node or Bun); see
-* `InlineCodemodeSandbox` and `RemoteCodemodeSandbox` in `@earendil-works/pi-codemode/portable`
-* for other runtimes.
-*/
-var CodemodeSandbox = class extends CodemodeSandboxBase {
-	constructor(options = {}) {
-		super(options, workerLauncher(options.wasm, options.workerUrl ?? defaultWorkerUrl()));
-	}
-};
-new TextDecoder();
-(function(SuppressedError) {
-	return function(env) {
-		function fail(e) {
-			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-			env.hasError = true;
-		}
-		var r, s = 0;
-		function next() {
-			while (r = env.stack.pop()) try {
-				if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-				if (r.dispose) {
-					var result = r.dispose.call(r.value);
-					if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
-						fail(e);
-						return next();
-					});
-				} else s |= 1;
-			} catch (e) {
-				fail(e);
-			}
-			if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-			if (env.hasError) throw env.error;
-		}
-		return next();
-	};
-})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
-	var e = new Error(message);
-	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-new TextDecoder();
-new TextEncoder();
-//#endregion
-//#region node_modules/.pnpm/@earendil-works+pi-codemode@1.2.0/node_modules/@earendil-works/pi-codemode/dist/runtime/prelude-source.js
-/**
-* JavaScript evaluated inside the QuickJS VM before the script runs.
-*
-* The VM is its own wasm instance, so nothing here guards a realm boundary.
-* The prelude keeps the host bridge in a closure so the script cannot call it
-* directly, and builds `tools`, `ALL_TOOLS`, the output helpers (`text`, `image`,
-* `exit`, `console`), and globals on top of it. Tool arguments and results cross
-* as JSON strings and are parsed on this side.
-*
-* Output helpers: `text(value)` appends a text item (non-strings are
-* JSON-stringified), `image(urlOrItem)` appends an image from a base64 `data:` URL, an
-* `{ image_url }` object, or an image block `{ type: "image", data, mimeType }`, and `exit()` ends the script
-* successfully. `console.*` appends text items marked as console output.
-*
-* `store(key, value)` and `load(key)` are synchronous: they work on a snapshot of
-* JSON text passed in as `storeJson`, and the keys the script wrote are reported
-* with a successful "done".
-*
-* Evaluates to a function `(bridge, toolsJson, globalsJson, storeJson) => { settle, run, stalled }`.
-* `settle(id, ok, payload, propertiesJson)` settles call `id`; a rejection's `Error` gets the own properties of the
-* `propertiesJson` object, except `name`, `message`, and `stack`.
-* `toolsJson` lists `{ name, jsName, description }`: `tools[jsName]` and `tools[name]` call the
-* tool, and `ALL_TOOLS` lists `{ name: jsName, description }`.
-* `stalled()` reports a script that has not finished while no host call is pending: with no timers
-* or I/O in the VM, nothing can ever resume it.
-* `globalsJson` lists `{ name, spread }`; `a.b` names are grouped into a frozen `a` object.
-* `bridge(kind, a, b, c)` with kind "call" or "global" (id, name, argsJson),
-* "output" ("text" or "console", text) or ("image", data, mimeType), or "done" (ok, valueJsonOrErrorJson, writesJson).
-*
-* Before anything else the prelude freezes the built-ins and makes the built-in globals read-only.
-* The prelude shares them with the script, so a script that patched one (for example
-* `Array.prototype.toJSON`) could otherwise corrupt what the prelude reports to the host.
-*/
-const MAX_STORE_VALUE_CHARS = 262144;
-const MAX_STORE_TOTAL_CHARS = 1048576;
-/**
-* Output one script may produce with `text()`, `image()`, and `console.*`: characters of text and
-* base64 image data, and items. The host keeps all output until the script ends, so without a
-* limit a script that prints in a loop grows the host's memory until it crashes. The item limit
-* covers loops that print empty strings.
-*/
-const MAX_OUTPUT_CHARS = 16777216;
-const MAX_OUTPUT_ITEMS = 1e5;
-const IMAGE_HELPER_EXPECTS = "image expects a non-empty image URL string, an object with image_url, or an image block { type: \"image\", data, mimeType }";
-const PRELUDE_SOURCE = `(function (bridge, toolsJson, globalsJson, storeJson) {
-	"use strict";
-
-	// Freeze every object reachable from the built-in globals, plus the intrinsics that are only
-	// reachable from instances (iterator and generator prototypes, %TypedArray%).
-	//
-	// Freezing alone breaks ordinary code through the "override mistake": a data property that is
-	// read-only on a prototype cannot be assigned on an instance either, so
-	// this.name = "MyError" in an Error subclass would throw. Commonly overridden properties
-	// become accessors whose setter defines an own property on the instance instead.
-	(function lockdown() {
-		const OVERRIDABLE = new Set(["constructor", "name", "message", "toString", "toLocaleString", "valueOf", "toJSON"]);
-		const seen = new Set([globalThis]);
-		const queue = [];
-		const add = (value) => {
-			if ((typeof value === "object" && value !== null) || typeof value === "function") {
-				if (!seen.has(value)) {
-					seen.add(value);
-					queue.push(value);
-				}
-			}
-		};
-
-		// Accessors from an object literal have no own prototype object, unlike function expressions,
-		// whose prototype.constructor would be converted again without end.
-		function allowOverride(object, key, value, enumerable) {
-			const { get, set } = Object.getOwnPropertyDescriptor(
-				{
-					get accessor() {
-						return value;
-					},
-					set accessor(next) {
-						if (this === object) {
-							throw new TypeError("Cannot assign to read only property '" + String(key) + "' of a built-in");
-						}
-						if ((typeof this !== "object" || this === null) && typeof this !== "function") return;
-						Object.defineProperty(this, key, { value: next, writable: true, enumerable: true, configurable: true });
-					},
-				},
-				"accessor",
-			);
-			Object.defineProperty(object, key, { get, set, enumerable, configurable: false });
-			add(get);
-			add(set);
-		}
-
-		for (const key of Reflect.ownKeys(globalThis)) {
-			const descriptor = Object.getOwnPropertyDescriptor(globalThis, key);
-			add(descriptor.value);
-			add(descriptor.get);
-			add(descriptor.set);
-			if ("value" in descriptor && descriptor.configurable) {
-				Object.defineProperty(globalThis, key, { writable: false, configurable: false });
-			}
-		}
-		add(Object.getPrototypeOf(function* () {}));
-		add(Object.getPrototypeOf(async function () {}));
-		add(Object.getPrototypeOf(async function* () {}));
-		add(Object.getPrototypeOf(Int8Array));
-		add(Object.getPrototypeOf([][Symbol.iterator]()));
-		add(Object.getPrototypeOf(new Map()[Symbol.iterator]()));
-		add(Object.getPrototypeOf(new Set()[Symbol.iterator]()));
-		add(Object.getPrototypeOf(""[Symbol.iterator]()));
-		add(Object.getPrototypeOf(/a/[Symbol.matchAll]("")));
-		if (typeof Iterator === "function") {
-			if (typeof Iterator.prototype.map === "function") add(Object.getPrototypeOf([].values().map((x) => x)));
-			if (typeof Iterator.from === "function") add(Object.getPrototypeOf(Iterator.from({ next() {} })));
-		}
-
-		while (queue.length > 0) {
-			const object = queue.pop();
-			add(Object.getPrototypeOf(object));
-			const descriptors = Object.getOwnPropertyDescriptors(object);
-			for (const key of Reflect.ownKeys(descriptors)) {
-				const descriptor = descriptors[key];
-				if ("value" in descriptor) {
-					add(descriptor.value);
-					if (
-						descriptor.writable &&
-						descriptor.configurable &&
-						(object === Object.prototype || OVERRIDABLE.has(key))
-					) {
-						allowOverride(object, key, descriptor.value, descriptor.enumerable);
-					}
-				} else {
-					add(descriptor.get);
-					add(descriptor.set);
-				}
-			}
-			Object.freeze(object);
-		}
-	})();
-	const stringify = JSON.stringify;
-	const parse = JSON.parse;
-	const promiseThen = Promise.prototype.then;
-	const ErrorCtor = Error;
-	const TypeErrorCtor = TypeError;
-	const RangeErrorCtor = RangeError;
-	const pending = new Map();
-	let nextId = 1;
-	let finished = false;
-	// Thrown by exit() to unwind the script after it already reported success.
-	const EXIT = Object.freeze({});
-
-	function done(ok, payload, writes) {
-		if (finished) return;
-		finished = true;
-		bridge("done", ok, payload, writes);
-	}
-
-	function serialize(value) {
-		return value === undefined ? undefined : stringify(value);
-	}
-
-	// QuickJS stacks list frames only. Prefix "Name: message" like V8 so the
-	// text reads the same as a Node error, and drop this prelude's frames.
-	function errorText(error) {
-		const head = error.message ? error.name + ": " + error.message : String(error.name);
-		const frames =
-			typeof error.stack === "string"
-				? error.stack.split("\\n").filter((line) => line.trim() && !line.includes("codemode-prelude.js"))
-				: [];
-		return [head, ...frames].join("\\n");
-	}
-
-	function format(value) {
-		if (typeof value === "string") return value;
-		if (value instanceof ErrorCtor) return errorText(value);
-		try {
-			const json = stringify(value);
-			return json === undefined ? String(value) : json;
-		} catch {
-			return String(value);
-		}
-	}
-
-	// The host requires string fields. A script can set an error's name or message to anything, so
-	// they are coerced, and a value whose coercion throws gets a placeholder.
-	function describeError(error) {
-		try {
-			if (error instanceof ErrorCtor) {
-				return stringify({ name: String(error.name), message: String(error.message), stack: errorText(error) });
-			}
-			return stringify({ message: String(format(error)) });
-		} catch {
-			return stringify({ message: "The script threw a value that cannot be described" });
-		}
-	}
-
-	function caller(kind, name, spread) {
-		return (...args) =>
-			new Promise((resolve, reject) => {
-				let json;
-				try {
-					json = serialize(spread ? args : args[0]);
-				} catch (error) {
-					reject(error);
-					return;
-				}
-				const id = nextId++;
-				pending.set(id, { resolve, reject });
-				bridge(kind, id, name, json);
-			});
-	}
-
-	const tools = Object.create(null);
-	const allTools = [];
-	for (const { name, jsName, description } of parse(toolsJson)) {
-		const fn = caller("call", name);
-		// The first tool wins when two names normalize to the same identifier.
-		if (!(jsName in tools)) {
-			tools[jsName] = fn;
-			allTools.push(Object.freeze({ name: jsName, description }));
-		}
-		if (!(name in tools)) tools[name] = fn;
-	}
-	Object.freeze(tools);
-	Object.freeze(allTools);
-
-	// Reading a member that does not exist throws an error that names the close matches, instead of
-	// a later "not a function". \`in\` checks still work.
-	const comparable = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
-	function guard(target, label, names, hint) {
-		return new Proxy(target, {
-			get(object, property, receiver) {
-				if (typeof property !== "string" || property in object || property in Object.prototype || property === "then" || property === "toJSON") {
-					return Reflect.get(object, property, receiver);
-				}
-				const wanted = comparable(property);
-				const exact = names.filter((name) => comparable(name) === wanted);
-				const close = exact.length > 0 ? exact : names.filter((name) => wanted && (comparable(name).includes(wanted) || wanted.includes(comparable(name))));
-				let message = label + "." + property + " does not exist.";
-				if (close.length > 0) message += " Did you mean " + close.slice(0, 5).map((name) => label + "." + name).join(", ") + "?";
-				else if (names.length <= 20) message += " Available: " + names.join(", ") + ".";
-				if (hint) message += " " + hint;
-				message += ' Check for a member with "' + property + '" in ' + label + ".";
-				throw new TypeErrorCtor(message);
-			},
-		});
-	}
-	const toolsProxy = guard(
-		tools,
-		"tools",
-		allTools.map((tool) => tool.name),
-		"ALL_TOOLS lists every tool; searchTools(query) finds tools by topic.",
-	);
-
-	const namespaces = new Map();
-	for (const { name, spread } of parse(globalsJson)) {
-		const fn = caller("global", name, spread);
-		const dot = name.indexOf(".");
-		if (dot === -1) {
-			Object.defineProperty(globalThis, name, { value: fn, enumerable: true });
-			continue;
-		}
-		const namespace = name.slice(0, dot);
-		if (!namespaces.has(namespace)) namespaces.set(namespace, Object.create(null));
-		namespaces.get(namespace)[name.slice(dot + 1)] = fn;
-	}
-	for (const [namespace, members] of namespaces) {
-		Object.freeze(members);
-		const value = guard(members, namespace, Object.keys(members));
-		Object.defineProperty(globalThis, namespace, { value, enumerable: true });
-	}
-
-	// key -> JSON text. Sizes count key and JSON characters.
-	const stored = new Map(Object.entries(parse(storeJson)));
-	const writes = new Map();
-	let storedChars = 0;
-	for (const [key, json] of stored) storedChars += key.length + json.length;
-
-	const STORE_HINT =
-		"store() is for small state such as IDs or summaries. Show images with image(), keep large data in variables, or write it to a file with a tool.";
-
-	function checkKey(name, key) {
-		if (typeof key !== "string") throw new TypeError(name + "() key must be a string");
-	}
-
-	function store(key, value) {
-		checkKey("store", key);
-		const previous = stored.has(key) ? key.length + stored.get(key).length : 0;
-		if (value === undefined) {
-			stored.delete(key);
-			storedChars -= previous;
-			writes.set(key, undefined);
-			return;
-		}
-		let json;
-		try {
-			json = stringify(value);
-		} catch (error) {
-			throw new TypeError("store(" + stringify(key) + ") value is not JSON-serializable: " + format(error));
-		}
-		if (json === undefined) {
-			throw new TypeError("store(" + stringify(key) + ") value is not JSON-serializable");
-		}
-		if (json.length > ${MAX_STORE_VALUE_CHARS}) {
-			throw new RangeError(
-				"store(" + stringify(key) + ") value has " + json.length + " characters of JSON, more than the limit of ${MAX_STORE_VALUE_CHARS}. " +
-					STORE_HINT,
-			);
-		}
-		const next = storedChars - previous + key.length + json.length;
-		if (next > ${MAX_STORE_TOTAL_CHARS}) {
-			throw new RangeError(
-				"store is full: stored values would exceed ${MAX_STORE_TOTAL_CHARS} characters of JSON. Delete keys with store(key, undefined). " +
-					STORE_HINT,
-			);
-		}
-		stored.set(key, json);
-		storedChars = next;
-		writes.set(key, json);
-	}
-
-	function load(key) {
-		checkKey("load", key);
-		const json = stored.get(key);
-		return json === undefined ? undefined : parse(json);
-	}
-
-	function serializeWrites() {
-		const entries = [];
-		for (const [key, json] of writes) entries.push(json === undefined ? [key] : [key, json]);
-		return stringify(entries);
-	}
-
-	Object.defineProperty(globalThis, "store", { value: store, enumerable: true });
-	Object.defineProperty(globalThis, "load", { value: load, enumerable: true });
-
-	let outputChars = 0;
-	let outputItems = 0;
-
-	// Past the output limits the script fails: done() reports the error, so catching it does not
-	// resume output, and the host ends the script.
-	function output(kind, data, mimeType) {
-		if (finished) return;
-		outputChars += data.length;
-		outputItems++;
-		if (outputChars > ${MAX_OUTPUT_CHARS} || outputItems > ${MAX_OUTPUT_ITEMS}) {
-			const error = new RangeErrorCtor(
-				"script output exceeded the limit of ${MAX_OUTPUT_CHARS} characters or ${MAX_OUTPUT_ITEMS} text(), image(), and console calls. " +
-					"Print a summary instead, or write large data to a file with a tool.",
-			);
-			done(false, describeError(error));
-			throw error;
-		}
-		bridge("output", kind, data, mimeType);
-	}
-
-	// Primitives become their string form, everything else JSON.
-	function outputText(value) {
-		if (value === undefined || value === null || typeof value !== "object" && typeof value !== "function") {
-			return String(value);
-		}
-		const json = stringify(value);
-		return json === undefined ? String(value) : json;
-	}
-
-	function text(value) {
-		let rendered;
-		try {
-			rendered = outputText(value);
-		} catch (error) {
-			throw new TypeErrorCtor(error instanceof ErrorCtor ? error.message : String(error));
-		}
-		output("text", rendered);
-	}
-
-	function imageUrl(value) {
-		if (typeof value === "string") return value;
-		if (typeof value !== "object" || value === null || Array.isArray(value)) {
-			throw new TypeErrorCtor(${JSON.stringify(IMAGE_HELPER_EXPECTS)});
-		}
-		if (value.image_url !== undefined) {
-			if (typeof value.image_url !== "string") throw new TypeErrorCtor(${JSON.stringify(IMAGE_HELPER_EXPECTS)});
-			return value.image_url;
-		}
-		if (typeof value.type !== "string") throw new TypeErrorCtor(${JSON.stringify(IMAGE_HELPER_EXPECTS)});
-		if (value.type !== "image") {
-			throw new TypeErrorCtor('image only accepts image blocks, got "' + value.type + '"');
-		}
-		if (typeof value.data !== "string" || value.data === "") throw new TypeErrorCtor("image expected image block data");
-		if (value.data.toLowerCase().startsWith("data:")) return value.data;
-		return "data:;base64," + value.data;
-	}
-
-	// Base64 of the signatures of the formats providers accept inline (PNG, JPEG except
-	// JPEG-LS, GIF, "RIFF....WEBP"). Signatures start at byte 0, so their encodings are prefixes.
-	const IMAGE_SIGNATURES = [
-		["image/png", /^iVBORw0KGg/],
-		["image/jpeg", /^[/]9j[/](?!9)/],
-		["image/gif", /^R0lGOD[dl]h/],
-		["image/webp", /^UklG.{8}RUJQ/],
-	];
-
-	function image(value) {
-		const url = imageUrl(value);
-		if (url === "") throw new TypeErrorCtor(${JSON.stringify(IMAGE_HELPER_EXPECTS)});
-		const colon = url.indexOf(":");
-		const scheme = colon === -1 ? "" : url.slice(0, colon).toLowerCase();
-		if (scheme === "http" || scheme === "https") {
-			throw new TypeErrorCtor("remote image URLs are not supported in tool outputs. Pass a base64 data URI instead");
-		}
-		const comma = url.indexOf(",");
-		const header = comma === -1 ? [] : url.slice(colon + 1, comma).split(";");
-		if (scheme !== "data" || comma === -1 || header.slice(1).every((part) => part.toLowerCase() !== "base64")) {
-			throw new TypeErrorCtor("invalid image output. Pass a base64 data URI instead");
-		}
-		// Providers reject the whole request on a bad image, and a persisted image block would be
-		// resent on every later turn. Line breaks from wrapped base64 are dropped. The declared type
-		// is ignored in favor of the detected one, as providers also reject mismatches.
-		const data = url.slice(comma + 1).replace(/\\s+/g, "");
-		if (data.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(data)) {
-			throw new TypeErrorCtor("invalid image output. The image data is not valid base64 (truncated or corrupted?)");
-		}
-		const head = data.slice(0, 16);
-		const signature = IMAGE_SIGNATURES.find(([, pattern]) => pattern.test(head));
-		if (!signature) {
-			throw new TypeErrorCtor("invalid image output. The image data is not a PNG, JPEG, GIF, or WebP image");
-		}
-		output("image", data, signature[0]);
-	}
-
-	function exit() {
-		let writesJson;
-		try {
-			writesJson = serializeWrites();
-		} catch (error) {
-			done(false, describeError(error));
-			throw EXIT;
-		}
-		done(true, undefined, writesJson);
-		throw EXIT;
-	}
-
-	const console = {};
-	for (const level of ["log", "info", "warn", "error", "debug"]) {
-		console[level] = (...args) => {
-			output("console", args.map(format).join(" "));
-		};
-	}
-	Object.freeze(console);
-
-	Object.defineProperty(globalThis, "tools", { value: toolsProxy, enumerable: true });
-	Object.defineProperty(globalThis, "ALL_TOOLS", { value: allTools, enumerable: true });
-	Object.defineProperty(globalThis, "console", { value: console, enumerable: true });
-	Object.defineProperty(globalThis, "text", { value: text, enumerable: true });
-	Object.defineProperty(globalThis, "image", { value: image, enumerable: true });
-	Object.defineProperty(globalThis, "exit", { value: exit, enumerable: true });
-
-	return {
-		settle(id, ok, payload, propertiesJson) {
-			const entry = pending.get(id);
-			if (!entry) return;
-			pending.delete(id);
-			if (!ok) {
-				const error = new ErrorCtor(payload);
-				if (propertiesJson !== undefined) {
-					const properties = parse(propertiesJson);
-					for (const key of Object.keys(properties)) {
-						if (key === "name" || key === "message" || key === "stack") continue;
-						Object.defineProperty(error, key, { value: properties[key], writable: true, enumerable: true, configurable: true });
-					}
-				}
-				entry.reject(error);
-				return;
-			}
-			let value;
-			try {
-				value = payload === undefined ? undefined : parse(payload);
-			} catch (error) {
-				entry.reject(error);
-				return;
-			}
-			entry.resolve(value);
-		},
-		run(fn) {
-			let promise;
-			try {
-				promise = fn(toolsProxy, console);
-			} catch (error) {
-				done(false, describeError(error));
-				return;
-			}
-			promiseThen.call(
-				promise,
-				(value) => {
-					let json;
-					try {
-						json = serialize(value);
-					} catch (error) {
-						done(false, describeError(error));
-						return;
-					}
-					done(true, json, serializeWrites());
-				},
-				(error) => {
-					done(false, describeError(error));
-				},
-			);
-		},
-		stalled() {
-			if (finished || pending.size > 0) return false;
-			done(
-				false,
-				stringify({
-					name: "Error",
-					message:
-						"The script is waiting on a promise that can never settle: no tool call is pending, and timers do not exist here.",
-				}),
-			);
-			return true;
-		},
-	};
-})`;
-//#endregion
-//#region node_modules/.pnpm/@earendil-works+pi-codemode@1.2.0/node_modules/@earendil-works/pi-codemode/dist/runtime/vm.js
-/** FNV-1a over UTF-16 code units, as 8 hex digits: identifies the prelude in the fingerprint. */
-function fnv1a(text) {
-	let hash = 2166136261;
-	for (let index = 0; index < text.length; index++) {
-		hash ^= text.charCodeAt(index);
-		hash = Math.imul(hash, 16777619);
-	}
-	return (hash >>> 0).toString(16).padStart(8, "0");
-}
-fnv1a(PRELUDE_SOURCE);
-//#endregion
-//#region node_modules/.pnpm/@earendil-works+pi-coding-agent@1.2.0_@aws-sdk+credential-provider-node@3.972.86_@model_cb83c1bd7a7ff5cede8c43e329c5cf76/node_modules/@earendil-works/pi-coding-agent/dist/extensions/codemode/execute.js
-/**
-* Runs one codemode script in the sandbox. Split from tool.ts and loaded through
-* execute.lazy.ts so the sandbox runtime only loads when a script runs.
-*/
-const ARGS_PREVIEW_CHARS = 200;
-const ERROR_PREVIEW_CHARS = 500;
-/** `models.classify()` and `models.generateImages()` calls one script may have in flight; `Promise.all` over many items queues the rest. */
-const MAX_CONCURRENT_MODEL_CALLS = 4;
-/**
-* Heap limit for the QuickJS VM. The worker shares pi's process, so without a limit a runaway
-* script can grow to wasm32's 4 GiB and take the session down. Overruns throw
-* `InternalError: out of memory` inside the script.
-*/
-const CODEMODE_MEMORY_LIMIT_BYTES = 268435456;
-const MODEL_TYPES = /* @__PURE__ */ new Set([
-	"chat",
-	"image",
-	"classifier"
-]);
-function truncateText(text, maxChars) {
-	return text.length > maxChars ? `${text.slice(0, maxChars - 3)}...` : text;
-}
-function previewArgs(args) {
-	if (args === void 0) return "";
-	try {
-		return truncateText(JSON.stringify(args) ?? "", ARGS_PREVIEW_CHARS);
-	} catch {
-		return "";
-	}
-}
-function textOf(result) {
-	return (result.content ?? []).filter((block) => block.type === "text").map((block) => block.text).join("\n");
-}
-function toModelType(value) {
-	if (typeof value === "string" && MODEL_TYPES.has(value)) return value;
-	throw new Error(`Unknown model type ${JSON.stringify(value)}. Use "chat", "image", or "classifier".`);
-}
-function toProvider(value) {
-	if (value === void 0 || value === null) return void 0;
-	if (typeof value !== "string") throw new Error("provider must be a string");
-	return value;
-}
-/** Catalog entry for scripts. `headers` is dropped because models.json headers can carry credentials. */
-function toModelInfo(model) {
-	const info = { ...model };
-	delete info.headers;
-	return info;
-}
-/** `an image`, `a classifier`. */
-function withArticle(word) {
-	return `${/^[aeiou]/.test(word) ? "an" : "a"} ${word}`;
-}
-/** A script value in an error message: `undefined`, `a string`, `an array`, or its keys (`{ prompt }`). */
-function describeValue(value) {
-	if (value === void 0 || value === null) return String(value);
-	if (Array.isArray(value)) return value.length === 0 ? "an empty array" : "an array";
-	if (typeof value === "object") {
-		const keys = Object.keys(value);
-		if (keys.length === 0) return "{}";
-		return `{ ${keys.slice(0, 6).join(", ")}${keys.length > 6 ? ", ..." : ""} }`;
-	}
-	return typeof value === "string" ? "a string" : `a ${typeof value}`;
-}
-const CLASSIFIER_CONTEXT_SHAPE = "{ state: { ... }, images?: [{ type: \"image\", data: <base64>, mimeType }], questions: { <id>: { type: \"choice\", instructions, criteria: { <label>: <meaning> } } | { type: \"score\", instructions, criteria: [<lowest level>, ..., <highest level>] } | { type: \"bool\", instructions, criteria: { true: <meaning>, false: <meaning> } } } }";
-/** Check a script's classifier context, so mistakes fail with the expected shape instead of a provider error. */
-function checkClassifierContext(context) {
-	const fail = (problem) => /* @__PURE__ */ new Error(`models.classify() ${problem}. Expected context: ${CLASSIFIER_CONTEXT_SHAPE}. See "Classify" in ${CODEMODE_DOCS_PATH}.`);
-	if (typeof context !== "object" || context === null || Array.isArray(context)) throw fail(`expects a context object as its second argument, got ${describeValue(context)}`);
-	const { state, images, questions } = context;
-	if (typeof state !== "object" || state === null || Array.isArray(state)) throw fail(`context.state must be an object, got ${describeValue(state)}`);
-	if (images !== void 0) {
-		if (!Array.isArray(images)) throw fail(`context.images must be an array, got ${describeValue(images)}`);
-		images.forEach((image, index) => {
-			if (image?.type !== "image" || typeof image.data !== "string" || typeof image.mimeType !== "string") throw fail(`context.images[${index}] must be an image block, got ${describeValue(image)}`);
-		});
-	}
-	if (typeof questions !== "object" || questions === null || Array.isArray(questions) || Object.keys(questions).length === 0) throw fail(`context.questions must map question IDs to questions, got ${describeValue(questions)}`);
-	const isStrings = (values) => values.length > 0 && values.every((value) => typeof value === "string");
-	for (const [id, question] of Object.entries(questions)) {
-		const at = `context.questions.${id}`;
-		if (typeof question !== "object" || question === null || Array.isArray(question)) throw fail(`${at} must be a question object, got ${describeValue(question)}`);
-		const { type, instructions, criteria } = question;
-		if (typeof instructions !== "string") throw fail(`${at}.instructions must be a string`);
-		if (type === "choice") {
-			if (typeof criteria !== "object" || criteria === null || Array.isArray(criteria) || !isStrings(Object.values(criteria))) throw fail(`${at} is a "choice" question, so criteria must map each label to its meaning`);
-		} else if (type === "score") {
-			if (!Array.isArray(criteria) || !isStrings(criteria)) throw fail(`${at} is a "score" question, so criteria must list the levels as strings, lowest first`);
-		} else if (type === "bool") {
-			const labels = criteria;
-			if (typeof labels?.true !== "string" || typeof labels.false !== "string") throw fail(`${at} is a "bool" question, so criteria must be { true: string, false: string }`);
-		} else throw fail(`${at}.type must be "choice", "score", or "bool", got ${JSON.stringify(type)}`);
-	}
-	return context;
-}
-/** Check a script's image context, so mistakes such as `{ prompt }` fail with the expected shape. */
-function checkImagesContext(context) {
-	const fail = (problem) => /* @__PURE__ */ new Error(`models.generateImages() ${problem}. Expected context: { input: [{ type: "text", text: <prompt> }, ...optional { type: "image", data: <base64>, mimeType } references] }. See "Generate images" in ${CODEMODE_DOCS_PATH}.`);
-	if (typeof context !== "object" || context === null || Array.isArray(context)) throw fail(`expects a context object as its second argument, got ${describeValue(context)}`);
-	const { input } = context;
-	if (!Array.isArray(input) || input.length === 0) throw fail(`context.input must be a non-empty array of blocks, got ${describeValue(input)}`);
-	input.forEach((block, index) => {
-		if (block?.type === "text" && typeof block.text === "string") return;
-		if (block?.type === "image" && typeof block.data === "string" && typeof block.mimeType === "string") return;
-		throw fail(`context.input[${index}] must be a text or image block, got ${describeValue(block)}`);
-	});
-	return context;
-}
-/** Runs at most `limit` calls at once, in call order. */
-function createLimiter(limit) {
-	let active = 0;
-	const waiting = [];
-	return async (run) => {
-		if (active >= limit) await new Promise((resolve) => waiting.push(resolve));
-		active++;
-		try {
-			return await run();
-		} finally {
-			active--;
-			waiting.shift()?.();
-		}
-	};
-}
-function isStoreEntryData(data) {
-	if (typeof data !== "object" || data === null) return false;
-	const { set, delete: deleted } = data;
-	return typeof set === "object" && set !== null && Array.isArray(deleted) && deleted.every((key) => typeof key === "string");
-}
-/** Values of `load()`: the `codemode-store` entries on the branch, applied from the root. */
-function readCodemodeStore(branch) {
-	const store = /* @__PURE__ */ new Map();
-	for (const entry of branch) {
-		if (entry.type !== "custom" || entry.customType !== "codemode-store" || !isStoreEntryData(entry.data)) continue;
-		for (const key of entry.data.delete) store.delete(key);
-		for (const [key, value] of Object.entries(entry.data.set)) store.set(key, value);
-	}
-	return Object.fromEntries(store);
-}
-/** Default token budget for script output. */
-const DEFAULT_MAX_OUTPUT_TOKENS = 1e4;
-/** Characters per token when estimating. */
-const CHARS_PER_TOKEN = 4;
-/** Like the script's `text()`: strings as is, other values as compact JSON. */
-function valueText(value) {
-	if (typeof value === "string") return value;
-	return JSON.stringify(value) ?? String(value);
-}
-/**
-* Lay out the script's output so the model can tell items apart: providers join adjacent text
-* blocks with a newline or with nothing. With more than one text item (`text()` or the returned
-* value), each starts with a `==> text N/M <==` line. `console.*` lines follow all other output in
-* one `<console_output>` block.
-*/
-function formatOutput(output) {
-	const total = output.filter((item) => item.type === "text" && !item.console).length;
-	const items = [];
-	const consoleLines = [];
-	let index = 0;
-	for (const item of output) if (item.type === "image") items.push(item);
-	else if (item.console) consoleLines.push(item.text);
-	else {
-		index++;
-		items.push({
-			type: "text",
-			text: total > 1 ? `==> text ${index}/${total} <==\n${item.text}` : item.text
-		});
-	}
-	if (consoleLines.length > 0) items.push({
-		type: "text",
-		text: `<console_output>\n${consoleLines.join("\n")}\n</console_output>`
-	});
-	return items;
-}
-/**
-* Join adjacent text items into one, each part starting on its own line. The separator check looks
-* at the last non-empty part, not the joined text: reading the end of a growing concatenation makes
-* V8 copy it on every item, which is quadratic (#10678).
-*/
-function joinAdjacentText(items) {
-	const joined = [];
-	let parts = [];
-	let lastPart = "";
-	const flush = () => {
-		if (parts.length > 0) joined.push({
-			type: "text",
-			text: parts.join("")
-		});
-		parts = [];
-		lastPart = "";
-	};
-	for (const item of items) {
-		if (item.type !== "text") {
-			flush();
-			joined.push(item);
-			continue;
-		}
-		if (lastPart !== "" && !lastPart.endsWith("\n")) {
-			parts.push("\n");
-			lastPart = "\n";
-		}
-		parts.push(item.text);
-		if (item.text !== "") lastPart = item.text;
-	}
-	flush();
-	return joined;
-}
-function formatCallSummary(calls) {
-	if (calls.length === 0) return "No tool calls were made.";
-	return `Tool calls made before the failure (they are not undone): ${calls.map((call) => `${call.name} (${call.status})`).join(", ")}`;
-}
-function formatError(result, calls) {
-	const { error } = result;
-	return `${error.kind === "script" ? error.stack ?? `${error.name ?? "Error"}: ${error.message}` : error.kind === "timeout" ? `Script timed out: ${error.message}` : error.kind === "aborted" ? `Script aborted: ${error.message}` : `Script sandbox failed: ${error.message}`}\n\n${formatCallSummary(calls)}`;
-}
-/** Write the full text output to a temp file, like bash does for truncated output. */
-async function spillOutput(text) {
-	try {
-		return { path: await writeOutputFile("pi-codemode", ".txt", text) };
-	} catch (error) {
-		return { error: error instanceof Error ? error.message : String(error) };
-	}
-}
-/** File extensions of the image types `image()` accepts. Must list every type the sandbox's `image()` detects. */
-const IMAGE_EXTENSIONS = {
-	"image/png": ".png",
-	"image/jpeg": ".jpg",
-	"image/gif": ".gif",
-	"image/webp": ".webp"
-};
-/**
-* Save each image to a temp file and put a text item with its path before it. The model sees the
-* image but has no other way to reach its bytes: scripts cannot write files, and `write` only takes
-* text. Images shown more than once are saved once.
-*/
-async function saveImages(items) {
-	const labels = /* @__PURE__ */ new Map();
-	const label = async ({ data, mimeType }) => {
-		const bytes = Buffer.from(data, "base64");
-		const kind = `${mimeType}, ${formatSize(bytes.length)}`;
-		const extension = IMAGE_EXTENSIONS[mimeType];
-		if (!extension) throw new Error(`No file extension for image type ${mimeType}`);
-		try {
-			return `[Image saved to ${await writeOutputFile("pi-codemode", extension, bytes)} (${kind})]`;
-		} catch (error) {
-			return `[Image (${kind}) could not be saved: ${error instanceof Error ? error.message : String(error)}]`;
-		}
-	};
-	return (await Promise.all(items.map(async (item) => {
-		if (item.type !== "image") return [item];
-		let pending = labels.get(item.data);
-		if (!pending) {
-			pending = label(item);
-			labels.set(item.data, pending);
-		}
-		return [{
-			type: "text",
-			text: await pending
-		}, item];
-	}))).flat();
-}
-/**
-* Apply the token budget: when the combined text exceeds it, the text items become one
-* item that keeps the start and end of the text, and images follow it. The full text is written to
-* a temp file.
-*/
-async function truncateOutput(items, maxTokens) {
-	const texts = items.filter((item) => item.type === "text").map((item) => item.text);
-	const combined = texts.join("\n");
-	const budget = maxTokens * CHARS_PER_TOKEN;
-	if (texts.length === 0 || combined.length <= budget) return { items };
-	const headChars = Math.floor(budget / 2);
-	const tailChars = budget - headChars;
-	const removed = combined.length - headChars - tailChars;
-	const head = combined.slice(0, headChars);
-	const tail = tailChars > 0 ? combined.slice(-tailChars) : "";
-	let text = `Warning: truncated output (original token count: ${Math.ceil(combined.length / CHARS_PER_TOKEN)})\nTotal output lines: ${combined.split("\n").length}\n\n${head}…${Math.ceil(removed / CHARS_PER_TOKEN)} tokens truncated…${tail}`;
-	const spilled = await spillOutput(combined);
-	text += "path" in spilled ? `\n\n[Full output: ${spilled.path} (read with offset/limit)]` : `\n\n[Could not save the full output: ${spilled.error}]`;
-	return {
-		items: [{
-			type: "text",
-			text
-		}, ...items.filter((item) => item.type === "image")],
-		..."path" in spilled ? { fullOutputPath: spilled.path } : {}
-	};
-}
-/**
-* The value a script receives for a nested call: a tool that declares
-* `outputSchema` resolves to its `structuredContent`, also for error results that carry one (such
-* as MCP results with `isError`); any other tool resolves to its text content. Other failures
-* reject with the tool's error text.
-*/
-function toScriptValue(tool, outcome) {
-	const { result } = outcome;
-	if (tool.outputSchema && result.structuredContent !== void 0) return result.structuredContent;
-	const text = textOf(result);
-	if (outcome.isError) throw new Error(text || `Tool "${tool.name}" failed`);
-	return text;
-}
-/**
-* Run one script. Without a session context (a plain Agent or a direct call) scripts cannot call
-* tools, `store()` starts empty, and writes are dropped.
-*/
-async function executeCodemode(toolCallId, input, signal, onUpdate, ctx, options = {}) {
-	const startedAt = performance.now();
-	const { code, options: sourceOptions } = parseCodemodeSource(input.code);
-	const calls = [];
-	let modelUsage;
-	let generatedImages = 0;
-	const addGeneratedImages = (count) => {
-		generatedImages += count;
-	};
-	const addModelUsage = (usage) => {
-		modelUsage = modelUsage ? combineUsage(modelUsage, usage) : usage;
-	};
-	const snapshot = () => ({ calls: calls.map((call) => ({ ...call })) });
-	const publish = () => onUpdate?.({
-		content: [],
-		details: snapshot()
-	});
-	publish();
-	const callable = ctx ? getCodemodeCallableTools(ctx.tools) : [];
-	const guidelines = options.getToolGuidelines?.();
-	const samples = new Map(callable.map((tool) => [tool.name, renderToolSample(toCodemodeDeclaration(tool, guidelines?.get(tool.name)))]));
-	const sandbox = new CodemodeSandbox({
-		tools: callable.map((tool) => ({
-			name: tool.name,
-			description: samples.get(tool.name),
-			execute: async (args, { signal: callSignal }) => {
-				const record = {
-					id: `${toolCallId}/?`,
-					name: tool.name,
-					args: previewArgs(args),
-					status: "running"
-				};
-				calls.push(record);
-				publish();
-				const callStartedAt = performance.now();
-				if (!ctx) throw new Error("Tool calls need a session");
-				const outcome = await ctx.executeTool(tool.name, args, { signal: callSignal });
-				record.id = outcome.toolCall.id;
-				record.durationMs = performance.now() - callStartedAt;
-				if (outcome.isError) {
-					record.status = callSignal.aborted ? "cancelled" : "error";
-					record.error = truncateText(textOf(outcome.result) || `Tool "${tool.name}" failed`, ERROR_PREVIEW_CHARS);
-				} else record.status = "ok";
-				publish();
-				return toScriptValue(tool, outcome);
-			}
-		})),
-		globals: [...createDiscoveryGlobals(callable, samples, options), ...options.models && ctx ? createModelGlobals(ctx.modelRegistry, toolCallId, calls, publish, addModelUsage, addGeneratedImages) : []],
-		timeoutMs: sourceOptions.timeoutMs ?? Number.POSITIVE_INFINITY,
-		memoryLimitBytes: CODEMODE_MEMORY_LIMIT_BYTES,
-		wasm: loadQuickJSWasm(getQuickJSWasmPath()),
-		workerUrl: getCodemodeWorkerSpecifier()
-	});
-	let result;
-	try {
-		const store = ctx ? readCodemodeStore(ctx.sessionManager.getBranch()) : {};
-		result = await sandbox.execute(code, {
-			signal,
-			store
-		});
-	} finally {
-		await sandbox.close();
-	}
-	for (const call of calls) if (call.status === "running") call.status = "cancelled";
-	const scriptOutput = [...result.output];
-	if (result.ok) {
-		const { set, delete: deleted } = result.storeWrites;
-		if (Object.keys(set).length > 0 || deleted.length > 0) options.appendEntry?.(CODEMODE_STORE_ENTRY_TYPE, {
-			set,
-			delete: deleted
-		});
-		if (result.value !== void 0) scriptOutput.push({
-			type: "text",
-			text: valueText(result.value)
-		});
-	}
-	const items = formatOutput(scriptOutput);
-	if (!result.ok) items.push({
-		type: "text",
-		text: `Script error:\n${formatError(result, calls)}`
-	});
-	if (generatedImages > 0 && !items.some((item) => item.type === "image")) items.push({
-		type: "text",
-		text: `Note: models.generateImages() returned ${generatedImages} image${generatedImages === 1 ? "" : "s"} that the script did not show. Show each image block of result.output with image(block).`
-	});
-	const truncated = await truncateOutput(joinAdjacentText(items), sourceOptions.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS);
-	const output = joinAdjacentText(await saveImages(truncated.items));
-	const wallTime = ((performance.now() - startedAt) / 1e3).toFixed(1);
-	const header = `${result.ok ? "Script completed" : "Script failed"}\nWall time ${wallTime} seconds\nOutput:\n`;
-	const details = snapshot();
-	if (truncated.fullOutputPath) details.fullOutputPath = truncated.fullOutputPath;
-	return {
-		content: [{
-			type: "text",
-			text: header
-		}, ...output],
-		details,
-		...modelUsage ? { usage: modelUsage } : {},
-		...result.ok ? {} : { isError: true }
-	};
-}
-/**
-* Whether `query` names the namespace: its name or one of its aliases, as written or as the same
-* script identifier (`dev-radius` and `dev_radius` are both `dev_radius`).
-*/
-function isNamespaceName(namespace, query) {
-	const queryId = toCodemodeIdentifier(query);
-	return [namespace.name, ...namespace.aliases ?? []].some((name) => name === query || toCodemodeIdentifier(name) === queryId);
-}
-/**
-* `searchTools()`, `describeTool()`, and `describeNamespace()`: ranked search and lookup over the
-* script's nested tools and their namespaces.
-*/
-function createDiscoveryGlobals(tools, samples, options) {
-	const ranker = new Bm25Ranker();
-	const entry = (name) => ({
-		name: toCodemodeIdentifier(name),
-		description: samples.get(name) ?? ""
-	});
-	return [
-		{
-			name: "searchTools",
-			spread: true,
-			execute: (args) => {
-				const [query, searchOptions] = args;
-				if (typeof query !== "string") throw new Error("searchTools() expects a query string");
-				const limit = searchOptions?.limit ?? 8;
-				if (typeof limit !== "number" || !Number.isInteger(limit) || limit <= 0) throw new Error("searchTools() limit must be a positive integer");
-				const namespace = searchOptions?.namespace;
-				if (namespace !== void 0 && namespace !== null && typeof namespace !== "string") throw new Error("searchTools() namespace must be a string");
-				const documents = tools.flatMap((tool) => {
-					const toolNamespace = options.getToolNamespace?.(tool.name);
-					if (namespace && (!toolNamespace || !isNamespaceName(toolNamespace, namespace))) return [];
-					return [createToolSearchDocument(tool, toolNamespace)];
-				});
-				return ranker.rank(query, documents, limit).map((match) => entry(match.name));
-			}
-		},
-		{
-			name: "describeTool",
-			spread: true,
-			execute: (args) => {
-				const [name] = args;
-				if (typeof name !== "string") throw new Error("describeTool() expects a tool name");
-				const tool = tools.find((candidate) => candidate.name === name || toCodemodeIdentifier(candidate.name) === name);
-				return tool ? samples.get(tool.name) : void 0;
-			}
-		},
-		{
-			name: "describeNamespace",
-			spread: true,
-			execute: (args) => {
-				const [name] = args;
-				if (typeof name !== "string") throw new Error("describeNamespace() expects a namespace name");
-				let namespace;
-				const names = [];
-				for (const tool of tools) {
-					const toolNamespace = options.getToolNamespace?.(tool.name);
-					if (!toolNamespace || !isNamespaceName(toolNamespace, name)) continue;
-					namespace ??= toolNamespace;
-					names.push(toCodemodeIdentifier(tool.name));
-				}
-				if (!namespace) return void 0;
-				return {
-					name: namespace.name,
-					...namespace.description ? { description: namespace.description } : {},
-					...namespace.instructions ? { instructions: namespace.instructions } : {},
-					tools: names
-				};
-			}
-		}
-	];
-}
-/**
-* `models.*` for scripts: the model registry methods documented in docs/codemode.md.
-* Classifier and image calls appear as nested call rows so the renderer shows them, and their usage
-* goes to `addUsage`. Rows show only the model, never prompts or image data.
-*/
-function createModelGlobals(models, toolCallId, calls, publish, addUsage, addGeneratedImages) {
-	const limit = createLimiter(MAX_CONCURRENT_MODEL_CALLS);
-	let callCount = 0;
-	/**
-	* Resolve the script's model by provider and id only, check the context, then run the call as a
-	* nested call row. A script-supplied baseUrl or headers must never receive the credentials.
-	*/
-	const runModelCall = async (name, type, [model, context], checkContext, run) => {
-		const listHint = `List the ${type} models you can use with models.getAvailableOfType("${type}").`;
-		const given = model;
-		if (typeof given?.provider !== "string" || typeof given.id !== "string") {
-			const undefinedHint = model === void 0 || model === null ? " models.getModelOfType() returns undefined for an unknown provider or id." : "";
-			throw new Error(`${name}() expects ${withArticle(type)} model as its first argument, got ${describeValue(model)}.${undefinedHint} ${listHint}`);
-		}
-		const provider = given.provider;
-		const id = given.id;
-		const ref = `${provider}/${id}`;
-		const resolved = models.getModelOfType(type, provider, id);
-		if (!resolved) {
-			const actualType = [...MODEL_TYPES].find((other) => other !== type && models.getModelOfType(other, provider, id) !== void 0);
-			throw new Error(actualType ? `"${ref}" is ${withArticle(actualType)} model, not ${withArticle(type)} model. ${listHint}` : `Unknown ${type} model "${ref}". ${listHint}`);
-		}
-		const checked = checkContext(context);
-		const record = {
-			id: `${toolCallId}/${name}/${++callCount}`,
-			name,
-			args: `${resolved.provider}/${resolved.id}`,
-			status: "running"
-		};
-		calls.push(record);
-		publish();
-		const startedAt = performance.now();
-		const result = await limit(() => run(resolved, checked));
-		record.durationMs = performance.now() - startedAt;
-		record.status = result.stopReason === "stop" ? "ok" : result.stopReason === "aborted" ? "cancelled" : "error";
-		if (result.errorMessage) record.error = truncateText(result.errorMessage, ERROR_PREVIEW_CHARS);
-		if (result.usage) {
-			record.cost = result.usage.cost.total;
-			addUsage(result.usage);
-		}
-		publish();
-		return result;
-	};
-	return Object.entries({
-		"models.getModelsOfType": (args) => {
-			const [type, provider] = args;
-			return models.getModelsOfType(toModelType(type), toProvider(provider)).map(toModelInfo);
-		},
-		"models.getAvailableOfType": async (args, { signal }) => {
-			const [type, provider] = args;
-			return (await models.getAvailableOfType(toModelType(type), toProvider(provider), { signal })).map(toModelInfo);
-		},
-		"models.getModelOfType": (args) => {
-			const [type, provider, id] = args;
-			if (typeof provider !== "string" || typeof id !== "string") throw new Error(`models.getModelOfType(type, provider, id) expects three strings, got (${args.map(describeValue).join(", ")}). The provider and the id are separate arguments, for example models.getModelOfType("classifier", "typesafe", "jev-latest").`);
-			const model = models.getModelOfType(toModelType(type), provider, id);
-			return model === void 0 ? void 0 : toModelInfo(model);
-		},
-		"models.classify": (args, { signal }) => runModelCall("models.classify", "classifier", args, checkClassifierContext, (resolved, context) => models.classify(resolved, context, { signal })),
-		"models.generateImages": (args, { signal }) => runModelCall("models.generateImages", "image", args, checkImagesContext, async (resolved, context) => {
-			const result = await models.generateImages(resolved, context, { signal });
-			addGeneratedImages(result.output.filter((block) => block.type === "image").length);
-			return result;
-		})
-	}).map(([name, execute]) => ({
-		name,
-		spread: true,
-		execute
-	}));
-}
-//#endregion
-export { executeCodemode, readCodemodeStore };