@oh-my-pi/pi-coding-agent 15.3.2 → 15.4.1

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

@@ -0,0 +1,265 @@
+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;
+}
+
+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>();
+
+	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 entry = await this.#ensureLocalModule(resolved);
+			return { mode: "local", value: entry.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;
+	}
+
+	async #buildLocalModule(modulePath: string): Promise<LocalModuleEntry> {
+		const rawSource = fs.readFileSync(modulePath, "utf8");
+		const stripped = stripTypeScriptSyntax(rawSource);
+		const moduleDir = path.dirname(modulePath);
+		const localDeps = new Set<string>();
+		for (const specifier of 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.#resolveLinkedModule(modulePath, String(specifier));
+			},
+		});
+		const entry: LocalModuleEntry = { version, identifier, module };
+		this.#moduleEntries.set(modulePath, entry);
+		try {
+			await module.link(async specifier => await this.#resolveLinkedModule(modulePath, specifier));
+			await module.evaluate();
+			return entry;
+		} catch (error) {
+			this.#moduleEntries.delete(modulePath);
+			throw error;
+		}
+	}
+
+	async #resolveLinkedModule(referrerPath: string, specifier: string): Promise<vm.Module> {
+		const baseDir = path.dirname(referrerPath);
+		const resolved = resolveImportSpecifier(baseDir, specifier);
+		if (isLocalPathSpecifier(specifier) && isManagedLocalModulePath(resolved)) {
+			return (await this.#ensureLocalModule(resolved)).module;
+		}
+		return await this.#ensureExternalModule(normalizeImportTarget(resolved));
+	}
+
+	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 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.txt

@@ -51,6 +51,10 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 		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),
 	};
 
 	globalThis.console = consoleBridge;

package/src/eval/js/shared/rewrite-imports.ts

@@ -57,6 +57,10 @@ type BabelExpressionStatement = {
 };
 
 type BabelProgramNode = BabelImportDeclaration | BabelLexicalDecl | BabelExpressionStatement | { type: string };
+type BabelModuleSourceDeclaration = {
+	type: "ImportDeclaration" | "ExportNamedDeclaration" | "ExportAllDeclaration";
+	source?: { value: string; start: number; end: number } | null;
+};
 
 type BabelNode = { type: string; start: number; end: number; [key: string]: unknown };
 
@@ -189,6 +193,84 @@ export function rewriteImports(code: string): string {
 	}
 	return result;
 }
+export function collectModuleSourceSpecifiers(code: string): string[] {
+	const ast = parseProgram(code);
+	if (!ast) return [];
+	const sources: string[] = [];
+	for (const node of ast.program.body) {
+		if (
+			(node.type === "ImportDeclaration" ||
+				node.type === "ExportNamedDeclaration" ||
+				node.type === "ExportAllDeclaration") &&
+			typeof (node as BabelModuleSourceDeclaration).source?.value === "string"
+		) {
+			sources.push((node as BabelModuleSourceDeclaration).source!.value);
+		}
+	}
+	return sources;
+}
+
+export function rewriteModuleSourceSpecifiers(code: string, replacer: (source: string) => string): string {
+	const ast = parseProgram(code);
+	if (!ast) return code;
+
+	type Edit = { start: number; end: number; text: string };
+	const edits: Edit[] = [];
+
+	for (const node of ast.program.body) {
+		if (
+			node.type !== "ImportDeclaration" &&
+			node.type !== "ExportNamedDeclaration" &&
+			node.type !== "ExportAllDeclaration"
+		) {
+			continue;
+		}
+		const source = (node as BabelModuleSourceDeclaration).source;
+		if (!source || typeof source.value !== "string") continue;
+		const next = replacer(source.value);
+		if (next === source.value) continue;
+		edits.push({ start: source.start, end: source.end, text: JSON.stringify(next) });
+	}
+
+	if (edits.length === 0) return code;
+	edits.sort((a, b) => b.start - a.start);
+	let result = code;
+	for (const edit of edits) {
+		result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+	}
+	return result;
+}
+
+export function rewriteDynamicImports(code: string, callee = "__omp_import__"): string {
+	if (!code.includes("import")) return code;
+	const ast = parseProgram(code);
+	if (!ast) return code;
+
+	type Edit = { start: number; end: number; text: string };
+	const edits: Edit[] = [];
+	walkNodes(ast, node => {
+		if (node.type !== "CallExpression") return;
+		const call = node as unknown as { callee?: { type?: string; start?: number; end?: number } };
+		const callCallee = call.callee;
+		if (
+			!callCallee ||
+			callCallee.type !== "Import" ||
+			typeof callCallee.start !== "number" ||
+			typeof callCallee.end !== "number"
+		) {
+			return;
+		}
+		edits.push({ start: callCallee.start, end: callCallee.end, text: callee });
+	});
+
+	if (edits.length === 0) return code;
+	edits.sort((a, b) => b.start - a.start);
+	let result = code;
+	for (const edit of edits) {
+		result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+	}
+	return result;
+}
 
 function collectBindingNames(pattern: unknown, names: string[]): void {
 	if (!pattern || typeof pattern !== "object") return;
@@ -390,6 +472,9 @@ function stripTypeScript(code: string): string {
 		return code;
 	}
 }
+export function stripTypeScriptSyntax(code: string): string {
+	return stripTypeScript(code);
+}
 
 // Heuristic: any of the obvious TS-only tokens. Plain JS using `as` only inside strings
 // won't match because we require a leading word boundary plus a colon/keyword neighbor.

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

@@ -1,23 +1,23 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Console } from "node:console";
 import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
-import { pathToFileURL } from "node:url";
+import { Writable } from "node:stream";
 import * as util from "node:util";
 
 import { logger } from "@oh-my-pi/pi-utils";
 
-import { ToolError } from "../../../tools/tool-errors";
 import { createHelpers, type HelperBundle } from "./helpers";
 import { awaitMaybePromise, indirectEval } from "./indirect-eval";
+import { LocalModuleLoader } from "./local-module-loader";
 import { JAVASCRIPT_PRELUDE_SOURCE } from "./prelude";
 import { wrapCode } from "./rewrite-imports";
 import type { JsDisplayOutput, JsStatusEvent } from "./types";
 
 /**
- * Per-run callbacks. Returned by `getHooks()` on each helper/tool/display invocation so
- * the embedding worker can route emissions to the currently active run. Returning `null`
- * makes status/display/tool calls reject with an error — useful for guarding against
- * helpers being invoked outside a run window.
+ * Per-run callbacks. Runtime globals resolve these from AsyncLocalStorage so
+ * overlapping async cells can route output/tool calls back to their own run.
  */
 export interface RuntimeHooks {
 	onText(chunk: string): void;
@@ -25,11 +25,17 @@ export interface RuntimeHooks {
 	callTool(name: string, args: unknown): Promise<unknown>;
 }
 
+export interface RunContext {
+	runId: string;
+	hooks: RuntimeHooks;
+	cwd: string;
+	finalExpressionSet: boolean;
+	finalExpressionValue: unknown;
+}
+
 export interface RuntimeOptions {
 	initialCwd: string;
 	sessionId: string;
-	/** Resolve hooks for the run currently in flight, or `null` if nothing is active. */
-	getHooks(): RuntimeHooks | null;
 	/**
 	 * Extra globals installed alongside `__omp_helpers__` / prelude. Use for stable, lifetime-
 	 * of-the-worker bindings (e.g. browser's `page`, `browser`). Per-run scope should be set
@@ -118,19 +124,18 @@ export class JsRuntime {
 	#cwd: string;
 	readonly sessionId: string;
 	#env: Map<string, string>;
-	#getHooks: () => RuntimeHooks | null;
-	#finalExpressionSet = false;
-	#finalExpressionValue: unknown;
+	#als = new AsyncLocalStorage<RunContext>();
+	#moduleLoader: LocalModuleLoader;
 
 	constructor(opts: RuntimeOptions) {
 		this.#cwd = opts.initialCwd;
 		this.sessionId = opts.sessionId;
 		this.#env = new Map();
-		this.#getHooks = opts.getHooks;
+		this.#moduleLoader = new LocalModuleLoader(this.sessionId);
 		this.helpers = createHelpers({
-			cwd: () => this.#cwd,
+			cwd: () => this.#activeCwd(),
 			env: this.#env,
-			emitStatus: event => this.#getHooks()?.onDisplay({ type: "status", event }),
+			emitStatus: event => this.#activeHooks("emitStatus")?.onDisplay({ type: "status", event }),
 		});
 		this.#install(opts.extraGlobals);
 	}
@@ -154,29 +159,42 @@ export class JsRuntime {
 		Object.assign(globalThis, scope);
 	}
 
-	async run(code: string, filename?: string): Promise<unknown> {
-		this.#finalExpressionSet = false;
-		this.#finalExpressionValue = undefined;
-		const wrapped = wrapCode(code);
-		const value = indirectEval(wrapped.source, filename);
-		if (wrapped.finalExpressionReturned) {
-			const awaited = await awaitMaybePromise(value);
-			if (this.#finalExpressionSet) {
-				const finalValue = this.#finalExpressionValue;
-				this.#finalExpressionSet = false;
-				this.#finalExpressionValue = undefined;
-				const resolved = await awaitMaybePromise(finalValue);
-				return resolved;
+	async run(
+		code: string,
+		filename: string | undefined,
+		hooks: RuntimeHooks,
+		options: { runId?: string; cwd?: string } = {},
+	): Promise<unknown> {
+		const context: RunContext = {
+			runId: options.runId ?? crypto.randomUUID(),
+			hooks,
+			cwd: options.cwd ?? this.#cwd,
+			finalExpressionSet: false,
+			finalExpressionValue: undefined,
+		};
+		return await this.#als.run(context, async () => {
+			const wrapped = wrapCode(code);
+			const value = indirectEval(wrapped.source, filename);
+			if (wrapped.finalExpressionReturned) {
+				const awaited = await awaitMaybePromise(value);
+				if (context.finalExpressionSet) {
+					const finalValue = context.finalExpressionValue;
+					context.finalExpressionSet = false;
+					context.finalExpressionValue = undefined;
+					return await awaitMaybePromise(finalValue);
+				}
+				return awaited;
 			}
-			return awaited;
-		}
-		return await awaitMaybePromise(value);
+			return await awaitMaybePromise(value);
+		});
 	}
 
-	displayValue(value: unknown): void {
+	displayValue(value: unknown, hooks: RuntimeHooks | undefined = this.#als.getStore()?.hooks): void {
 		if (value === undefined) return;
-		const hooks = this.#getHooks();
-		if (!hooks) return;
+		if (!hooks) {
+			logger.warn("js runtime display called outside an active run");
+			return;
+		}
 		if (value && typeof value === "object") {
 			const record = value as Record<string, unknown>;
 			if (record.type === "image" && typeof record.mimeType === "string") {
@@ -207,45 +225,108 @@ export class JsRuntime {
 		hooks.onText(`${String(value)}\n`);
 	}
 
+	#activeCwd(): string {
+		return this.#als.getStore()?.cwd ?? this.#cwd;
+	}
+
+	#activeHooks(action: string): RuntimeHooks | undefined {
+		const hooks = this.#als.getStore()?.hooks;
+		if (!hooks) {
+			logger.warn("js runtime helper called outside an active run", { action });
+		}
+		return hooks;
+	}
+
+	#activeRequire(moduleUrlOrPath?: string): NodeJS.Require {
+		return this.#moduleLoader.requireForFile(moduleUrlOrPath, this.#activeCwd());
+	}
+
+	#moduleFilename(moduleUrlOrPath?: string): string {
+		return this.#moduleLoader.filenameForUrl(moduleUrlOrPath) ?? path.join(this.#activeCwd(), "[eval]");
+	}
+
+	#moduleDirname(moduleUrlOrPath?: string): string {
+		return this.#moduleLoader.dirnameForUrl(moduleUrlOrPath, this.#activeCwd());
+	}
+
+	#buildDynamicRequire(): NodeJS.Require {
+		const dynamicRequire = ((id: string) => this.#activeRequire()(id)) as NodeJS.Require;
+		const resolve = ((id: string, options?: { paths?: string[] }) =>
+			this.#activeRequire().resolve(id, options)) as NodeJS.Require["resolve"] & {
+			paths(request: string): string[] | null;
+		};
+		resolve.paths = request => this.#activeRequire().resolve.paths(request);
+		Object.defineProperties(dynamicRequire, {
+			resolve: { value: resolve, configurable: true },
+			cache: { get: () => this.#activeRequire().cache, configurable: true },
+			extensions: { get: () => this.#activeRequire().extensions, configurable: true },
+			main: { get: () => this.#activeRequire().main, configurable: true },
+		});
+		return dynamicRequire;
+	}
+
 	#install(extraGlobals: Record<string, unknown> | undefined): void {
 		const injected: Record<string, unknown> = {
 			__omp_session__: { cwd: this.#cwd, sessionId: this.sessionId },
 			__omp_helpers__: this.helpers,
 			__omp_call_tool__: async (name: string, args: unknown) => {
-				const hooks = this.#getHooks();
-				if (!hooks) throw new ToolError("Tool calls are only valid inside an active run");
+				const hooks = this.#activeHooks("tool");
+				if (!hooks) return undefined;
 				return await hooks.callTool(name, args);
 			},
 			__omp_import__: async (source: string, options?: ImportCallOptions) => {
-				const target = resolveImportSpecifier(this.#cwd, source);
-				// Always invalidate cached module records for user-owned source files so edits
-				// between cells are picked up. Bun ignores query-string busting on `file:` URLs
-				// but honors `delete require.cache[absPath]`; bare specifiers and URL schemes are
-				// left alone to keep package identity stable across cells.
-				if (isLocalPathSpecifier(source) && path.isAbsolute(target)) {
-					delete require.cache[target];
-				}
+				const resolved = await this.#moduleLoader.resolveForRun(this.#activeCwd(), source);
+				if (resolved.mode === "local") return resolved.value;
+				const target = resolved.target;
+				return options !== undefined ? await import(target, options) : await import(target);
+			},
+			__omp_import_from__: async (moduleUrl: string, source: string, options?: ImportCallOptions) => {
+				const resolved = await this.#moduleLoader.resolveForModule(moduleUrl, source, this.#activeCwd());
+				if (resolved.mode === "local") return resolved.value;
+				const target = resolved.target;
 				return options !== undefined ? await import(target, options) : await import(target);
 			},
+			__omp_get_require__: (moduleUrl?: string) => this.#activeRequire(moduleUrl),
+			__omp_get_filename__: (moduleUrl?: string) => this.#moduleFilename(moduleUrl),
+			__omp_get_dirname__: (moduleUrl?: string) => this.#moduleDirname(moduleUrl),
 			__omp_emit_status__: (op: string, data: Record<string, unknown> = {}) => {
 				const event: JsStatusEvent = { op, ...data };
-				this.#getHooks()?.onDisplay({ type: "status", event });
+				this.#activeHooks("emitStatus")?.onDisplay({ type: "status", event });
 			},
 			__omp_log__: (level: string, ...args: unknown[]) => {
 				const prefix = level === "error" ? "[error] " : level === "warn" ? "[warn] " : "";
 				const text = `${prefix}${formatConsoleArgs(args)}`;
-				this.#getHooks()?.onText(text.endsWith("\n") ? text : `${text}\n`);
+				this.#activeHooks("log")?.onText(text.endsWith("\n") ? text : `${text}\n`);
+			},
+			__omp_table__: (...args: unknown[]) => {
+				const hooks = this.#activeHooks("table");
+				if (!hooks) return;
+				let buffer = "";
+				const stream = new Writable({
+					write(chunk, _enc, cb) {
+						buffer += typeof chunk === "string" ? chunk : (chunk as Buffer).toString("utf8");
+						cb();
+					},
+				});
+				const tableConsole = new Console({ stdout: stream, colorMode: false });
+				(tableConsole.table as (...a: unknown[]) => void)(...args);
+				hooks.onText(buffer.endsWith("\n") ? buffer : `${buffer}\n`);
 			},
 			__omp_display__: (value: unknown) => this.displayValue(value),
 			__omp_set_final_expr__: (value: unknown) => {
-				this.#finalExpressionSet = true;
-				this.#finalExpressionValue = value;
+				const context = this.#als.getStore();
+				if (!context) {
+					logger.warn("js runtime final expression set outside an active run");
+					return;
+				}
+				context.finalExpressionSet = true;
+				context.finalExpressionValue = value;
 			},
 			webcrypto: crypto,
 			// `process` is intentionally not overridden — user code gets the host worker's real
 			// `process` object. Subsetting it caused segfaults in workers that share state with
 			// puppeteer/worker_threads internals.
-			require: buildRequire(this.#cwd),
+			require: this.#buildDynamicRequire(),
 			createRequire,
 			fs,
 		};
@@ -261,41 +342,3 @@ function formatConsoleArgs(args: unknown[]): string {
 		.map(arg => (typeof arg === "string" ? arg : util.inspect(arg, { depth: 6, colors: false, breakLength: 120 })))
 		.join(" ");
 }
-
-function buildRequire(cwd: string): NodeJS.Require {
-	return createRequire(pathToFileURL(path.join(cwd, "[eval]")).href);
-}
-
-/**
- * Resolve an import specifier emitted by `rewriteImports` against the active session
- * cwd. Relative paths (`./`, `../`, `/`) and bare specifiers (`pkg`, `@scope/pkg`) both go
- * through `Bun.resolveSync` rooted at the cwd so user-pasted ESM behaves as if it lived in
- * the project — not next to the worker module. URL-like specifiers (`file://`, `data:`,
- * `node:`, `http:`) are passed through unchanged.
- */
-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;
-	}
-}
-
-/**
- * Returns true when the original specifier is a relative or absolute filesystem path
- * (i.e. user-owned source the agent is iterating on). Bare specifiers and URL schemes
- * are excluded — `node:` built-ins cannot be reloaded, and busting bare packages would
- * defeat module identity for every cell while bringing no editing benefit.
- */
-function isLocalPathSpecifier(source: string): boolean {
-	return (
-		source.startsWith("./") ||
-		source.startsWith("../") ||
-		source === "." ||
-		source === ".." ||
-		source.startsWith("/") ||
-		source.startsWith("~/") ||
-		/^[a-zA-Z]:[\\/]/.test(source)
-	);
-}