@prometheus-ai/agent 0.5.0

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

@@ -0,0 +1,237 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import * as Diff from "diff";
+import { ToolError } from "../../../tools/tool-errors";
+import type { JsStatusEvent } from "./types";
+
+export interface HelperOptions {
+	path?: string;
+	hidden?: boolean;
+	maxDepth?: number;
+	limit?: number;
+	offset?: number;
+	reverse?: boolean;
+	unique?: boolean;
+	count?: boolean;
+}
+
+/**
+ * Inputs the helper factory needs from its host runtime. `cwd` is a getter so the runtime
+ * can update it between cells (e.g. when the agent's session cwd changes) without
+ * recreating helpers.
+ */
+export interface HelperContext {
+	cwd(): string;
+	env: Map<string, string>;
+	emitStatus(event: JsStatusEvent): void;
+}
+
+/**
+ * The set of functions exposed to user code via `globalThis.__prometheus_helpers__`. The JS
+ * prelude reads from this bag and attaches short aliases (`read`, `write`, `tree`, ...)
+ * onto the global scope.
+ */
+export interface HelperBundle {
+	read(rawPath: string, options?: HelperOptions): Promise<string>;
+	writeFile(rawPath: string, data: unknown): Promise<string>;
+	append(rawPath: string, content: string): Promise<string>;
+	sortText(text: string, options?: HelperOptions): string;
+	uniqText(text: string, options?: HelperOptions): string | Array<[number, string]>;
+	counter(items: string | string[], options?: HelperOptions): Array<[number, string]>;
+	diff(rawA: string, rawB: string): Promise<string>;
+	tree(searchPath?: string, options?: HelperOptions): Promise<string>;
+	env(key?: string, value?: string): string | Record<string, string> | undefined;
+}
+
+const utf8Encoder = new TextEncoder();
+
+export function createHelpers(ctx: HelperContext): HelperBundle {
+	return {
+		read: async (rawPath, options = {}) => {
+			const { filePath, file, size } = await resolveRegularFile(ctx, rawPath);
+			let text = await file.text();
+			const offset = typeof options.offset === "number" ? options.offset : 1;
+			const limit = typeof options.limit === "number" ? options.limit : undefined;
+			if (offset > 1 || limit !== undefined) {
+				const lines = text.split(/\r?\n/);
+				const start = Math.max(0, offset - 1);
+				const end = limit !== undefined ? start + limit : lines.length;
+				text = lines.slice(start, end).join("\n");
+			}
+			ctx.emitStatus({ op: "read", path: filePath, bytes: size, chars: text.length });
+			return text;
+		},
+		writeFile: async (rawPath, data) => {
+			if (!isWriteData(data)) {
+				throw new ToolError("write() expects string, Blob, ArrayBuffer, or TypedArray data");
+			}
+			const filePath = resolvePath(ctx, rawPath);
+			if (typeof data === "string" || data instanceof Blob || data instanceof ArrayBuffer) {
+				await Bun.write(filePath, data);
+			} else {
+				await Bun.write(filePath, new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+			}
+			ctx.emitStatus({ op: "write", path: filePath, bytes: getDataSize(data) });
+			return filePath;
+		},
+		append: async (rawPath, content) => {
+			const target = resolvePath(ctx, rawPath);
+			await Bun.write(
+				target,
+				`${await Bun.file(target)
+					.text()
+					.catch(() => "")}${content}`,
+			);
+			ctx.emitStatus({
+				op: "append",
+				path: target,
+				chars: content.length,
+				bytes: utf8Encoder.encode(content).byteLength,
+			});
+			return target;
+		},
+		sortText: (text, options = {}) => {
+			const lines = String(text).split(/\r?\n/);
+			const deduped = options.unique ? Array.from(new Set(lines)) : lines;
+			const sorted = deduped.sort((a, b) => a.localeCompare(b));
+			if (options.reverse) sorted.reverse();
+			const result = sorted.join("\n");
+			ctx.emitStatus({
+				op: "sort",
+				lines: sorted.length,
+				reverse: options.reverse === true,
+				unique: options.unique === true,
+			});
+			return result;
+		},
+		uniqText: (text, options = {}) => {
+			const lines = String(text)
+				.split(/\r?\n/)
+				.filter(line => line.length > 0);
+			const groups: Array<[number, string]> = [];
+			for (const line of lines) {
+				const last = groups.at(-1);
+				if (last && last[1] === line) {
+					last[0] += 1;
+					continue;
+				}
+				groups.push([1, line]);
+			}
+			ctx.emitStatus({ op: "uniq", groups: groups.length, count_mode: options.count === true });
+			if (options.count) return groups;
+			return groups.map(([, line]) => line).join("\n");
+		},
+		counter: (items, options = {}) => {
+			const values = Array.isArray(items) ? items : String(items).split(/\r?\n/).filter(Boolean);
+			const counts = new Map<string, number>();
+			for (const item of values) counts.set(item, (counts.get(item) ?? 0) + 1);
+			const entries = Array.from(counts.entries())
+				.map(([item, count]) => [count, item] as [number, string])
+				.sort((a, b) => (options.reverse === false ? a[0] - b[0] : b[0] - a[0]) || a[1].localeCompare(b[1]));
+			const limited = entries.slice(0, options.limit ?? entries.length);
+			ctx.emitStatus({ op: "counter", unique: counts.size, total: values.length, top: limited.slice(0, 10) });
+			return limited;
+		},
+		diff: async (rawA, rawB) => {
+			const fileA = resolvePath(ctx, rawA);
+			const fileB = resolvePath(ctx, rawB);
+			const [a, b] = await Promise.all([Bun.file(fileA).text(), Bun.file(fileB).text()]);
+			const result = Diff.createTwoFilesPatch(fileA, fileB, a, b, "", "", { context: 3 });
+			ctx.emitStatus({
+				op: "diff",
+				file_a: fileA,
+				file_b: fileB,
+				identical: a === b,
+				preview: result.slice(0, 500),
+			});
+			return result;
+		},
+		tree: async (searchPath = ".", options = {}) => {
+			const root = resolvePath(ctx, searchPath);
+			const maxDepth = options.maxDepth ?? 3;
+			const showHidden = options.hidden ?? false;
+			const lines: string[] = [`${root}/`];
+			let entryCount = 0;
+			const walk = async (dir: string, prefix: string, depth: number): Promise<void> => {
+				if (depth > maxDepth) return;
+				const entries = (await fs.promises.readdir(dir, { withFileTypes: true }))
+					.filter(entry => showHidden || !entry.name.startsWith("."))
+					.sort((a, b) => a.name.localeCompare(b.name));
+				for (let index = 0; index < entries.length; index++) {
+					const entry = entries[index];
+					const isLast = index === entries.length - 1;
+					const connector = isLast ? "└── " : "├── ";
+					const suffix = entry.isDirectory() ? "/" : "";
+					lines.push(`${prefix}${connector}${entry.name}${suffix}`);
+					entryCount += 1;
+					if (entry.isDirectory()) {
+						await walk(path.join(dir, entry.name), `${prefix}${isLast ? "    " : "│   "}`, depth + 1);
+					}
+				}
+			};
+			await walk(root, "", 1);
+			const result = lines.join("\n");
+			ctx.emitStatus({ op: "tree", path: root, entries: entryCount, preview: result.slice(0, 1000) });
+			return result;
+		},
+		env: (key, value) => {
+			if (!key) {
+				const merged = Object.fromEntries(Object.entries(getMergedEnv(ctx)).sort(([a], [b]) => a.localeCompare(b)));
+				ctx.emitStatus({ op: "env", count: Object.keys(merged).length, keys: Object.keys(merged).slice(0, 20) });
+				return merged;
+			}
+			if (value !== undefined) {
+				ctx.env.set(key, value);
+				ctx.emitStatus({ op: "env", key, value, action: "set" });
+				return value;
+			}
+			const result = ctx.env.get(key) ?? Bun.env[key];
+			ctx.emitStatus({ op: "env", key, value: result, action: "get" });
+			return result;
+		},
+	};
+}
+
+function getMergedEnv(ctx: HelperContext): Record<string, string> {
+	const merged: Record<string, string> = {};
+	for (const [key, value] of Object.entries(Bun.env)) {
+		if (typeof value === "string") merged[key] = value;
+	}
+	for (const [key, value] of ctx.env) merged[key] = value;
+	return merged;
+}
+
+function resolvePath(ctx: HelperContext, value: string): string {
+	if (path.isAbsolute(value)) return path.normalize(value);
+	return path.resolve(ctx.cwd(), value);
+}
+
+async function resolveRegularFile(
+	ctx: HelperContext,
+	rawPath: string,
+): Promise<{ filePath: string; file: Bun.BunFile; size: number }> {
+	if (/^[a-z][a-z0-9+.-]*:\/\//i.test(rawPath)) {
+		throw new ToolError(`Protocol paths are not supported by read(): ${rawPath}`);
+	}
+	const filePath = resolvePath(ctx, rawPath);
+	const file = Bun.file(filePath);
+	const stat = await file.stat();
+	if (stat.isDirectory()) {
+		throw new ToolError(`Directory paths are not supported by read(): ${filePath}`);
+	}
+	return { filePath, file, size: stat.size };
+}
+
+function getDataSize(data: string | Blob | ArrayBuffer | ArrayBufferView): number {
+	if (typeof data === "string") return utf8Encoder.encode(data).byteLength;
+	if (data instanceof Blob) return data.size;
+	if (data instanceof ArrayBuffer) return data.byteLength;
+	return data.byteLength;
+}
+
+function isWriteData(value: unknown): value is string | Blob | ArrayBuffer | ArrayBufferView {
+	return (
+		typeof value === "string" || value instanceof Blob || value instanceof ArrayBuffer || ArrayBuffer.isView(value)
+	);
+}

package/src/eval/js/shared/indirect-eval.ts

@@ -0,0 +1,30 @@
+/**
+ * Indirect eval — runs in the host's global scope, isolating bindings declared with
+ * `const`/`let` from this module's closure. Used by both the JS eval worker and the
+ * browser tab worker to execute user-supplied source without `node:vm`.
+ *
+ * Why not vm.runInContext: Bun crashes the parent process with SIGTRAP when
+ * `Worker.terminate()` fires while a worker is mid-`vm.runInContext` synchronous loop.
+ * Indirect eval does not trip that bug.
+ *
+ * The optional `filename` is appended as a `//# sourceURL=...` pragma so V8 attributes
+ * stack frames to the user cell instead of `<anonymous>`.
+ */
+export function indirectEval(source: string, filename?: string): unknown {
+	const withPragma = filename ? `${source}\n//# sourceURL=${filename}` : source;
+	// Read `eval` via a property access so the call site is *indirect* (global scope),
+	// not direct (this module's lexical scope). The cast erases the DOM lib return type.
+	// We deliberately avoid `node:vm` because Bun crashes the parent with SIGTRAP when
+	// Worker.terminate() fires mid-`vm.runInContext` synchronous loop — indirect eval is
+	// the executor for user code in the worker.
+	// biome-ignore lint/security/noGlobalEval: see comment above — this is the executor.
+	const geval = globalThis.eval as (src: string) => unknown;
+	return geval(withPragma);
+}
+
+export async function awaitMaybePromise<T>(value: T | Promise<T>): Promise<T> {
+	if (!value || typeof value !== "object" || typeof (value as { then?: unknown }).then !== "function") {
+		return value;
+	}
+	return await (value as Promise<T>);
+}

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 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}?prometheus-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.__prometheus_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;