@wahack/pi-coding-agent 15.11.0

package/src/eval/js/shared/local-module-loader.ts

@@ -0,0 +1,342 @@
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import * as vm from "node:vm";
+import { collectModuleSourceSpecifiers, stripTypeScriptSyntax } from "./rewrite-imports";
+
+interface LocalModuleEntry {
+	version: number;
+	identifier: string;
+	module: vm.SourceTextModule;
+	/** Memoized link+evaluate of this module as a graph root; set lazily by `#loadLocalModule`. */
+	loaded?: Promise<void>;
+}
+
+export type LocalImportResolution = { mode: "local"; value: unknown } | { mode: "external"; target: string };
+
+const LOCAL_MODULE_EXTENSIONS = new Set([".js", ".jsx", ".mjs", ".ts", ".tsx", ".mts"]);
+
+export class LocalModuleLoader {
+	#context: vm.Context;
+	#sessionTag: string;
+	#moduleMtimes = new Map<string, number>();
+	#moduleDeps = new Map<string, Set<string>>();
+	#moduleParents = new Map<string, Set<string>>();
+	#moduleVersions = new Map<string, number>();
+	#moduleEntries = new Map<string, LocalModuleEntry>();
+	#moduleBuilds = new Map<string, Promise<LocalModuleEntry>>();
+	#externalModules = new Map<string, Promise<vm.Module>>();
+	#requireCache = new Map<string, NodeJS.Require>();
+	#modulePaths = new WeakMap<vm.Module, string>();
+
+	constructor(sessionId: string) {
+		this.#context = vm.createContext(globalThis);
+		this.#sessionTag = Bun.hash(sessionId).toString(16);
+	}
+
+	async resolveForRun(cwd: string, source: string): Promise<LocalImportResolution> {
+		this.#refreshTrackedLocalModules();
+		return await this.#resolveFromBase(cwd, source);
+	}
+
+	async resolveForModule(moduleUrl: string, source: string, cwd: string): Promise<LocalImportResolution> {
+		this.#refreshTrackedLocalModules();
+		const modulePath = this.filenameForUrl(moduleUrl);
+		const baseDir = modulePath ? path.dirname(modulePath) : cwd;
+		return await this.#resolveFromBase(baseDir, source);
+	}
+
+	requireForFile(moduleUrlOrPath: string | undefined, cwd: string): NodeJS.Require {
+		const basePath = this.filenameForUrl(moduleUrlOrPath) ?? path.join(cwd, "[eval]");
+		let cached = this.#requireCache.get(basePath);
+		if (!cached) {
+			cached = buildRequire(basePath);
+			this.#requireCache.set(basePath, cached);
+		}
+		return cached;
+	}
+
+	filenameForUrl(moduleUrlOrPath: string | undefined): string | null {
+		if (!moduleUrlOrPath) return null;
+		if (moduleUrlOrPath.startsWith("file://")) return fileURLToPath(moduleUrlOrPath);
+		return path.isAbsolute(moduleUrlOrPath) ? moduleUrlOrPath : null;
+	}
+
+	dirnameForUrl(moduleUrlOrPath: string | undefined, cwd: string): string {
+		const filename = this.filenameForUrl(moduleUrlOrPath);
+		return filename ? path.dirname(filename) : cwd;
+	}
+
+	async #resolveFromBase(baseDir: string, source: string): Promise<LocalImportResolution> {
+		const resolved = resolveImportSpecifier(baseDir, source);
+		if (isLocalPathSpecifier(source) && isManagedLocalModulePath(resolved)) {
+			const module = await this.#loadLocalModule(resolved);
+			return { mode: "local", value: module.namespace };
+		}
+		return { mode: "external", target: normalizeImportTarget(resolved) };
+	}
+
+	async #ensureLocalModule(modulePath: string): Promise<LocalModuleEntry> {
+		const existing = this.#moduleEntries.get(modulePath);
+		if (existing) return existing;
+		const building = this.#moduleBuilds.get(modulePath);
+		if (building) return await building;
+		const buildPromise = this.#buildLocalModule(modulePath).finally(() => {
+			if (this.#moduleBuilds.get(modulePath) === buildPromise) this.#moduleBuilds.delete(modulePath);
+		});
+		this.#moduleBuilds.set(modulePath, buildPromise);
+		return await buildPromise;
+	}
+
+	// Construct (parse + register) a local module WITHOUT linking or evaluating it.
+	// Linking and evaluation are driven once from the graph root in `#linkAndEvaluate`;
+	// doing them per-module inside the recursive linker re-enters Bun's node:vm linker
+	// mid-instantiation, which segfaults JSC (getImportedModule on a null record) whenever
+	// the local graph contains an import cycle.
+	async #buildLocalModule(modulePath: string): Promise<LocalModuleEntry> {
+		const rawSource = fs.readFileSync(modulePath, "utf8");
+		const stripped = stripTypeScriptSyntax(rawSource, {
+			force: isTypeScriptModulePath(modulePath),
+			loader: stripLoaderForPath(modulePath),
+		});
+		const moduleDir = path.dirname(modulePath);
+		const localDeps = new Set<string>();
+		for (const specifier of await collectModuleSourceSpecifiers(stripped)) {
+			const resolved = resolveImportSpecifier(moduleDir, specifier);
+			if (isLocalPathSpecifier(specifier) && isManagedLocalModulePath(resolved)) {
+				localDeps.add(resolved);
+			}
+		}
+		this.#setModuleDependencies(modulePath, localDeps);
+		this.#moduleMtimes.set(modulePath, fs.statSync(modulePath).mtimeMs);
+		const version = this.#moduleVersions.get(modulePath) ?? 1;
+		this.#moduleVersions.set(modulePath, version);
+		const fileUrl = pathToFileURL(modulePath).href;
+		const identifier = `${fileUrl}?omp-session=${this.#sessionTag}&v=${version}`;
+		const wrappedSource = buildModuleSource(stripped, modulePath);
+		const module = new vm.SourceTextModule(wrappedSource, {
+			context: this.#context,
+			identifier,
+			initializeImportMeta: meta => {
+				(meta as { url?: string; path?: string; dir?: string }).url = fileUrl;
+				(meta as { url?: string; path?: string; dir?: string }).path = modulePath;
+				(meta as { url?: string; path?: string; dir?: string }).dir = moduleDir;
+			},
+			importModuleDynamically: async specifier => {
+				return await this.#resolveDynamicImport(modulePath, String(specifier));
+			},
+		});
+		this.#modulePaths.set(module, modulePath);
+		const entry: LocalModuleEntry = { version, identifier, module };
+		this.#moduleEntries.set(modulePath, entry);
+		return entry;
+	}
+
+	// Construct (if needed) then link+evaluate a local module as a graph root, returning
+	// the evaluated module. Link and evaluate run exactly once over the whole reachable
+	// graph; the static linker only constructs dependencies, letting node:vm instantiate
+	// cyclic graphs in a single pass.
+	async #loadLocalModule(modulePath: string): Promise<vm.SourceTextModule> {
+		const entry = await this.#ensureLocalModule(modulePath);
+		entry.loaded ??= this.#linkAndEvaluate(entry, modulePath);
+		await entry.loaded;
+		return entry.module;
+	}
+
+	async #linkAndEvaluate(entry: LocalModuleEntry, modulePath: string): Promise<void> {
+		const { module } = entry;
+		try {
+			if (module.status === "unlinked") await module.link(this.#linkResolve);
+			if (module.status === "linked") await module.evaluate();
+		} catch (error) {
+			this.#invalidateFailedLoad(modulePath);
+			throw error;
+		}
+		if (module.status === "errored") {
+			this.#invalidateFailedLoad(modulePath);
+			throw module.error;
+		}
+	}
+
+	// Shared static-link resolver for `module.link()`. node:vm passes the referencing
+	// module and reuses this one resolver for the entire graph, so the referrer path is
+	// recovered from `#modulePaths`. Local dependencies are constructed but NOT linked or
+	// evaluated here (the root drives that); externals are loaded eagerly — they carry no
+	// imports and cannot participate in a cycle.
+	#linkResolve = async (specifier: string, referencingModule: vm.Module): Promise<vm.Module> => {
+		const referrerPath = this.#modulePaths.get(referencingModule);
+		if (referrerPath === undefined) {
+			throw new Error(`local module loader: unknown referrer while linking "${specifier}"`);
+		}
+		const resolved = resolveImportSpecifier(path.dirname(referrerPath), specifier);
+		if (isLocalPathSpecifier(specifier) && isManagedLocalModulePath(resolved)) {
+			return (await this.#ensureLocalModule(resolved)).module;
+		}
+		return await this.#ensureExternalModule(normalizeImportTarget(resolved));
+	};
+
+	// Resolver for runtime `import()` inside evaluated module code: the result must be a
+	// fully linked+evaluated module, so local targets are loaded as graph roots.
+	async #resolveDynamicImport(referrerPath: string, specifier: string): Promise<vm.Module> {
+		const resolved = resolveImportSpecifier(path.dirname(referrerPath), specifier);
+		if (isLocalPathSpecifier(specifier) && isManagedLocalModulePath(resolved)) {
+			return await this.#loadLocalModule(resolved);
+		}
+		return await this.#ensureExternalModule(normalizeImportTarget(resolved));
+	}
+
+	// A failed link/evaluate can leave a partial graph cached. Drop every reachable module
+	// that is not fully evaluated so the next attempt reconstructs it; fully evaluated
+	// modules keep valid namespaces and stay cached.
+	#invalidateFailedLoad(rootPath: string): void {
+		const stack = [rootPath];
+		const seen = new Set<string>();
+		while (stack.length > 0) {
+			const current = stack.pop();
+			if (current === undefined || seen.has(current)) continue;
+			seen.add(current);
+			const entry = this.#moduleEntries.get(current);
+			if (entry && entry.module.status === "evaluated") continue;
+			this.#moduleEntries.delete(current);
+			this.#moduleBuilds.delete(current);
+			const deps = this.#moduleDeps.get(current);
+			if (deps) for (const dep of deps) stack.push(dep);
+		}
+	}
+
+	async #ensureExternalModule(target: string): Promise<vm.Module> {
+		const existing = this.#externalModules.get(target);
+		if (existing) return await existing;
+		const loadPromise = (async () => {
+			const namespace = await import(target);
+			const exportNames = Object.keys(namespace);
+			const module = new vm.SyntheticModule(
+				exportNames,
+				function () {
+					for (const name of exportNames) {
+						this.setExport(name, namespace[name as keyof typeof namespace]);
+					}
+				},
+				{ context: this.#context, identifier: target },
+			);
+			await module.link(() => {
+				throw new Error("Synthetic external modules have no dependencies");
+			});
+			await module.evaluate();
+			return module;
+		})();
+		this.#externalModules.set(target, loadPromise);
+		try {
+			return await loadPromise;
+		} catch (error) {
+			if (this.#externalModules.get(target) === loadPromise) this.#externalModules.delete(target);
+			throw error;
+		}
+	}
+
+	#refreshTrackedLocalModules(): void {
+		const changed: string[] = [];
+		for (const [modulePath, previousMtime] of this.#moduleMtimes.entries()) {
+			let nextMtime: number | undefined;
+			try {
+				nextMtime = fs.statSync(modulePath).mtimeMs;
+			} catch {
+				nextMtime = undefined;
+			}
+			if (nextMtime === previousMtime) continue;
+			if (nextMtime === undefined) this.#moduleMtimes.delete(modulePath);
+			else this.#moduleMtimes.set(modulePath, nextMtime);
+			changed.push(modulePath);
+		}
+		for (const modulePath of changed) {
+			this.#invalidateModuleAndParents(modulePath, new Set());
+		}
+	}
+
+	#invalidateModuleAndParents(modulePath: string, seen: Set<string>): void {
+		if (seen.has(modulePath)) return;
+		seen.add(modulePath);
+		this.#moduleEntries.delete(modulePath);
+		this.#moduleBuilds.delete(modulePath);
+		this.#moduleVersions.set(modulePath, (this.#moduleVersions.get(modulePath) ?? 1) + 1);
+		const parents = [...(this.#moduleParents.get(modulePath) ?? [])];
+		for (const parent of parents) this.#invalidateModuleAndParents(parent, seen);
+	}
+
+	#setModuleDependencies(modulePath: string, deps: Set<string>): void {
+		const previousDeps = this.#moduleDeps.get(modulePath);
+		if (previousDeps) {
+			for (const dep of previousDeps) {
+				const parents = this.#moduleParents.get(dep);
+				if (!parents) continue;
+				parents.delete(modulePath);
+				if (parents.size === 0) this.#moduleParents.delete(dep);
+			}
+		}
+		this.#moduleDeps.set(modulePath, new Set(deps));
+		for (const dep of deps) {
+			const parents = this.#moduleParents.get(dep) ?? new Set<string>();
+			parents.add(modulePath);
+			this.#moduleParents.set(dep, parents);
+		}
+	}
+}
+
+function buildRequire(fromPath: string): NodeJS.Require {
+	const basePath = path.extname(fromPath) ? fromPath : path.join(fromPath, "[eval]");
+	return createRequire(pathToFileURL(basePath).href);
+}
+
+function buildModuleSource(source: string, modulePath: string): string {
+	const moduleDir = path.dirname(modulePath);
+	return [
+		`const require = globalThis.__omp_get_require__(${JSON.stringify(pathToFileURL(modulePath).href)});`,
+		`const __filename = ${JSON.stringify(modulePath)};`,
+		`const __dirname = ${JSON.stringify(moduleDir)};`,
+		source,
+	].join("\n");
+}
+
+function resolveImportSpecifier(cwd: string, source: string): string {
+	if (/^[a-z][a-z0-9+.-]*:/i.test(source)) return source;
+	try {
+		return Bun.resolveSync(source, cwd);
+	} catch {
+		return source;
+	}
+}
+
+function isLocalPathSpecifier(source: string): boolean {
+	return (
+		source.startsWith("./") ||
+		source.startsWith("../") ||
+		source === "." ||
+		source === ".." ||
+		source.startsWith("/") ||
+		source.startsWith("~/") ||
+		/^[a-zA-Z]:[\\/]/.test(source)
+	);
+}
+
+function isTypeScriptModulePath(modulePath: string): boolean {
+	const ext = path.extname(modulePath);
+	return ext === ".ts" || ext === ".tsx" || ext === ".mts";
+}
+
+function stripLoaderForPath(modulePath: string): "ts" | "tsx" {
+	return path.extname(modulePath) === ".tsx" ? "tsx" : "ts";
+}
+
+function isManagedLocalModulePath(target: string): boolean {
+	return (
+		path.isAbsolute(target) &&
+		LOCAL_MODULE_EXTENSIONS.has(path.extname(target)) &&
+		!target.includes(`${path.sep}node_modules${path.sep}`)
+	);
+}
+
+function normalizeImportTarget(target: string): string {
+	if (path.isAbsolute(target)) return pathToFileURL(target).href;
+	return target;
+}

package/src/eval/js/shared/prelude.ts

@@ -0,0 +1,2 @@
+import javascriptPrelude from "./prelude.txt" with { type: "text" };
+export const JAVASCRIPT_PRELUDE_SOURCE = javascriptPrelude;

package/src/eval/js/shared/prelude.txt

@@ -0,0 +1,246 @@
+if (!globalThis.__omp_js_prelude_loaded__) {
+	globalThis.__omp_js_prelude_loaded__ = true;
+
+	const isPlainObject = value => value !== null && typeof value === "object" && !Array.isArray(value);
+	const optionsArg = (name, value, rest, example) => {
+		if (rest.length > 0) {
+			throw new TypeError(
+				`${name}() takes options as a single trailing object literal, not positional arguments (got ${rest.length + 1} extra args). Pass them as ${name}(..., ${example}).`,
+			);
+		}
+		if (value === undefined || value === null) return {};
+		if (!isPlainObject(value)) {
+			const kind = Array.isArray(value) ? "an array" : typeof value;
+			throw new TypeError(
+				`${name}() options must be a trailing object literal like ${example}, not ${kind}. JS helpers never take positional options.`,
+			);
+		}
+		return value;
+	};
+	const callHelper = (name, ...args) => globalThis.__omp_helpers__[name](...args);
+
+	const read = (path, opts, ...rest) => callHelper("read", path, optionsArg("read", opts, rest, "{ offset, limit }"));
+	const write = async (path, data) => callHelper("writeFile", path, data);
+	const append = (path, content) => callHelper("append", path, content);
+	const sort = (text, opts, ...rest) => callHelper("sortText", text, optionsArg("sort", opts, rest, "{ reverse, unique }"));
+	const uniq = (text, opts, ...rest) => callHelper("uniqText", text, optionsArg("uniq", opts, rest, "{ count }"));
+	const counter = (items, opts, ...rest) =>
+		callHelper("counter", items, optionsArg("counter", opts, rest, "{ limit, reverse }"));
+	const diff = (a, b) => callHelper("diff", a, b);
+	const tree = (path = ".", opts, ...rest) => callHelper("tree", path, optionsArg("tree", opts, rest, "{ maxDepth, showHidden }"));
+	const env = (key, value) => callHelper("env", key, value);
+
+	const tool = new Proxy(
+		{},
+		{
+			get(_target, prop) {
+				if (typeof prop !== "string") return undefined;
+				return async args => globalThis.__omp_call_tool__(prop, args ?? {});
+			},
+		},
+	);
+
+	const output = async (...args) => {
+		let opts = {};
+		let ids = args;
+		if (args.length > 0) {
+			const last = args.at(-1);
+			if (last && typeof last === "object" && !Array.isArray(last)) {
+				opts = last;
+				ids = args.slice(0, -1);
+			}
+		}
+		const reads = ids.map(id => tool.read({ path: `agent://${id}`, ...opts }));
+		const values = await Promise.all(reads);
+		return values.length === 1 ? values[0] : values;
+	};
+
+	const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+
+	const completion = async (prompt, opts, ...rest) => {
+		const o = optionsArg("completion", opts, rest, "{ model, system, schema }");
+		const res = await globalThis.__omp_call_tool__("__completion__", { prompt, ...o });
+		const text = res && typeof res === "object" ? res.text : res;
+		return hasOwn(o, "schema") ? JSON.parse(text) : text;
+	};
+
+	const agent = async (prompt, opts, ...rest) => {
+		const o = optionsArg("agent", opts, rest, "{ agentType, model, label, schema }");
+		const res = await globalThis.__omp_call_tool__("__agent__", { prompt, ...o });
+		const text = res && typeof res === "object" ? res.text : res;
+		return hasOwn(o, "schema") ? JSON.parse(text) : text;
+	};
+
+	// Pool ceiling mirrors the task tool's `task.maxConcurrency` setting so an
+	// eval fan-out runs as wide as a `task` batch would. 0 (and any non-finite
+	// reply) means unbounded — run every item at once.
+	const __concurrencyLimit = async () => {
+		try {
+			const r = await globalThis.__omp_call_tool__("__concurrency__", {});
+			const n = Math.trunc(Number(r && typeof r === "object" ? r.limit : r));
+			return Number.isFinite(n) && n > 0 ? n : 0;
+		} catch {
+			return 0;
+		}
+	};
+
+	const __pool = async (items, fn) => {
+		const list = Array.from(items ?? []);
+		if (list.length === 0) return [];
+		const limit = await __concurrencyLimit();
+		const concurrency = limit > 0 ? Math.min(limit, list.length) : list.length;
+		const results = new Array(list.length);
+		// Barrier semantics (mirrors the Python _pool_map): every item settles
+		// before we return or throw, then the lowest-index error propagates.
+		// Early-rejecting would orphan in-flight thunks (e.g. live agent()
+		// subagents) whose worker-side promises would never be observed.
+		const errors = new Map();
+		let next = 0;
+		const worker = async () => {
+			while (true) {
+				const index = next++;
+				if (index >= list.length) return;
+				try {
+					results[index] = await fn(list[index], index);
+				} catch (error) {
+					errors.set(index, error);
+				}
+			}
+		};
+		await Promise.all(Array.from({ length: concurrency }, () => worker()));
+		if (errors.size > 0) throw errors.get(Math.min(...errors.keys()));
+		return results;
+	};
+
+	const parallel = async thunks =>
+		__pool(thunks, (thunk, index) => {
+			if (typeof thunk !== "function") throw new TypeError("parallel() expects an iterable of functions");
+			return thunk(index);
+		});
+
+	const pipeline = async (items, ...stages) => {
+		let current = Array.from(items ?? []);
+		for (const stage of stages) {
+			if (typeof stage !== "function") throw new TypeError("pipeline() stages must be functions");
+			current = await __pool(current, stage);
+		}
+		return current;
+	};
+
+	const log = message => globalThis.__omp_emit_status__("log", { message: String(message) });
+
+	const phase = title => {
+		globalThis.__omp_phase__ = String(title);
+		globalThis.__omp_emit_status__("phase", { title: String(title) });
+	};
+
+	const __budgetSnap = async () => {
+		const r = await globalThis.__omp_call_tool__("__budget__", {});
+		return r && typeof r === "object" ? r : {};
+	};
+
+	const budget = {
+		total: async () => {
+			const s = await __budgetSnap();
+			return s.total ?? null;
+		},
+		spent: async () => Number((await __budgetSnap()).spent ?? 0),
+		remaining: async () => {
+			const s = await __budgetSnap();
+			return s.total == null ? Infinity : Math.max(0, Number(s.total) - Number(s.spent ?? 0));
+		},
+		hard: async () => Boolean((await __budgetSnap()).hard),
+	};
+
+	const display = value => {
+		globalThis.__omp_display__(value);
+	};
+
+	const formatArgs = args => args.map(arg => (typeof arg === "string" ? arg : arg));
+
+	const consoleTimers = new Map();
+	const consoleCounts = new Map();
+	const consoleBridge = {
+		log: (...args) => globalThis.__omp_log__("log", ...formatArgs(args)),
+		info: (...args) => globalThis.__omp_log__("info", ...formatArgs(args)),
+		warn: (...args) => globalThis.__omp_log__("warn", ...formatArgs(args)),
+		error: (...args) => globalThis.__omp_log__("error", ...formatArgs(args)),
+		debug: (...args) => globalThis.__omp_log__("debug", ...formatArgs(args)),
+		table: (data, columns) =>
+			columns === undefined
+				? globalThis.__omp_table__(data)
+				: globalThis.__omp_table__(data, columns),
+		dir: (value, _options) => globalThis.__omp_log__("log", value),
+		dirxml: (...args) => globalThis.__omp_log__("log", ...formatArgs(args)),
+		trace: (...args) => {
+			const stack = (new Error().stack ?? "").split("\n").slice(2).join("\n");
+			globalThis.__omp_log__("log", args.length > 0 ? `Trace: ${formatArgs(args).join(" ")}` : "Trace", `\n${stack}`);
+		},
+		assert: (condition, ...args) => {
+			if (condition) return;
+			if (args.length > 0) globalThis.__omp_log__("error", "Assertion failed:", ...formatArgs(args));
+			else globalThis.__omp_log__("error", "Assertion failed");
+		},
+		group: (...args) => {
+			if (args.length > 0) globalThis.__omp_log__("log", ...formatArgs(args));
+		},
+		groupCollapsed: (...args) => {
+			if (args.length > 0) globalThis.__omp_log__("log", ...formatArgs(args));
+		},
+		groupEnd: () => {},
+		time: label => {
+			consoleTimers.set(String(label ?? "default"), Date.now());
+		},
+		timeLog: (label, ...args) => {
+			const key = String(label ?? "default");
+			const start = consoleTimers.get(key);
+			if (start === undefined) {
+				globalThis.__omp_log__("warn", `Timer '${key}' does not exist`);
+				return;
+			}
+			globalThis.__omp_log__("log", `${key}: ${Date.now() - start}ms`, ...formatArgs(args));
+		},
+		timeEnd: label => {
+			const key = String(label ?? "default");
+			const start = consoleTimers.get(key);
+			if (start === undefined) {
+				globalThis.__omp_log__("warn", `Timer '${key}' does not exist`);
+				return;
+			}
+			consoleTimers.delete(key);
+			globalThis.__omp_log__("log", `${key}: ${Date.now() - start}ms`);
+		},
+		count: label => {
+			const key = String(label ?? "default");
+			const next = (consoleCounts.get(key) ?? 0) + 1;
+			consoleCounts.set(key, next);
+			globalThis.__omp_log__("log", `${key}: ${next}`);
+		},
+		countReset: label => {
+			consoleCounts.delete(String(label ?? "default"));
+		},
+	};
+
+	globalThis.console = consoleBridge;
+	globalThis.print = consoleBridge.log;
+	globalThis.display = display;
+	globalThis.tool = tool;
+	globalThis.completion = completion;
+	globalThis.output = output;
+	globalThis.agent = agent;
+	globalThis.parallel = parallel;
+	globalThis.pipeline = pipeline;
+	globalThis.log = log;
+	globalThis.phase = phase;
+	globalThis.budget = budget;
+	globalThis.__pool = __pool;
+	globalThis.read = read;
+	globalThis.write = write;
+	globalThis.append = append;
+	globalThis.sort = sort;
+	globalThis.uniq = uniq;
+	globalThis.counter = counter;
+	globalThis.diff = diff;
+	globalThis.tree = tree;
+	globalThis.env = env;
+}