@oh-my-pi/pi-coding-agent 14.8.1 → 14.9.1

package/src/debug/raw-sse.ts

@@ -0,0 +1,213 @@
+import { sanitizeText } from "@oh-my-pi/pi-natives";
+import { type Component, matchesKey, padding, replaceTabs, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+import { theme } from "../modes/theme/theme";
+import { copyToClipboard } from "../utils/clipboard";
+import { formatRawSseIsoTime, type RawSseDebugBuffer, rawSseRecordLines } from "./raw-sse-buffer";
+
+const MIN_VIEWER_WIDTH = 20;
+const VIEWER_FRAME_LINES = 5;
+
+function sanitizeFrameLine(line: string, width: number): string {
+	return truncateToWidth(replaceTabs(sanitizeText(line)), width);
+}
+
+export interface RawSseViewerOptions {
+	buffer: RawSseDebugBuffer;
+	terminalRows: number;
+	onExit: () => void;
+	onStatus?: (message: string) => void;
+	onUpdate?: () => void;
+}
+
+export class RawSseViewerComponent implements Component {
+	readonly #buffer: RawSseDebugBuffer;
+	readonly #terminalRows: number;
+	readonly #onExit: () => void;
+	readonly #onStatus?: (message: string) => void;
+	readonly #onUpdate?: () => void;
+	readonly #unsubscribe: () => void;
+	#scrollOffset = 0;
+	#followTail = true;
+	#lastRenderWidth = MIN_VIEWER_WIDTH;
+	#statusMessage: string | undefined;
+
+	constructor(options: RawSseViewerOptions) {
+		this.#buffer = options.buffer;
+		this.#terminalRows = options.terminalRows;
+		this.#onExit = options.onExit;
+		this.#onStatus = options.onStatus;
+		this.#onUpdate = options.onUpdate;
+		this.#unsubscribe = this.#buffer.subscribe(() => {
+			this.#followIfNeeded();
+			this.#onUpdate?.();
+		});
+	}
+
+	handleInput(keyData: string): void {
+		if (matchesKey(keyData, "escape") || matchesKey(keyData, "esc")) {
+			this.#unsubscribe();
+			this.#onExit();
+			return;
+		}
+
+		if (matchesKey(keyData, "ctrl+c")) {
+			this.#copyAll();
+			return;
+		}
+
+		if (matchesKey(keyData, "up")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.max(0, this.#scrollOffset - 1);
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "down")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.min(this.#maxScrollOffset(), this.#scrollOffset + 1);
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "pageUp")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.max(0, this.#scrollOffset - this.#bodyHeight());
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "pageDown")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.min(this.#maxScrollOffset(), this.#scrollOffset + this.#bodyHeight());
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "end")) {
+			this.#followTail = true;
+			this.#scrollToTail();
+			this.#onUpdate?.();
+		}
+	}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		this.#lastRenderWidth = Math.max(MIN_VIEWER_WIDTH, width);
+		this.#followIfNeeded();
+
+		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
+		const bodyHeight = this.#bodyHeight();
+		const rawLines = this.#renderRawLines(innerWidth);
+		const body = rawLines.slice(this.#scrollOffset, this.#scrollOffset + bodyHeight);
+		while (body.length < bodyHeight) body.push("");
+
+		return [
+			this.#frameTop(innerWidth),
+			this.#frameLine(this.#summaryText(), innerWidth),
+			this.#frameSeparator(innerWidth),
+			...body.map(line => this.#frameLine(line, innerWidth)),
+			this.#frameLine(this.#statusText(), innerWidth),
+			this.#frameBottom(innerWidth),
+		];
+	}
+
+	#renderRawLines(innerWidth: number): string[] {
+		const snapshot = this.#buffer.snapshot();
+		if (snapshot.records.length === 0) {
+			return [
+				theme.fg("muted", "No raw SSE frames captured yet."),
+				theme.fg("muted", "HTTP SSE providers populate this view while a model response is streaming."),
+			];
+		}
+
+		const lines: string[] = [];
+		if (snapshot.droppedRecords > 0) {
+			lines.push(
+				theme.fg(
+					"warning",
+					`: omp-debug-dropped records=${snapshot.droppedRecords} chars=${snapshot.droppedChars}`,
+				),
+			);
+			lines.push("");
+		}
+		for (const record of snapshot.records) {
+			for (const line of rawSseRecordLines(record)) {
+				lines.push(sanitizeFrameLine(line, innerWidth));
+			}
+			if (record.kind === "event" && record.truncated) {
+				lines.push(theme.fg("warning", `: omp-debug-event-truncated originalChars=${record.originalChars}`));
+			}
+			lines.push("");
+		}
+		return lines;
+	}
+
+	#summaryText(): string {
+		const snapshot = this.#buffer.snapshot();
+		const last = snapshot.lastUpdatedAt ? ` last=${formatRawSseIsoTime(snapshot.lastUpdatedAt)}` : "";
+		const follow = this.#followTail ? "follow:on" : "follow:off";
+		return ` # raw SSE | events=${snapshot.totalEvents} records=${snapshot.records.length}${last} | ${follow} | Esc back Ctrl+C copy End follow`;
+	}
+
+	#statusText(): string {
+		return this.#statusMessage ?? " Up/Down scroll  PgUp/PgDn page";
+	}
+
+	#bodyHeight(): number {
+		return Math.max(3, this.#terminalRows - VIEWER_FRAME_LINES);
+	}
+
+	#followIfNeeded(): void {
+		if (this.#followTail) this.#scrollToTail();
+	}
+
+	#scrollToTail(): void {
+		this.#scrollOffset = this.#maxScrollOffset();
+	}
+
+	#maxScrollOffset(): number {
+		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
+		return Math.max(0, this.#renderRawLines(innerWidth).length - this.#bodyHeight());
+	}
+
+	#copyAll(): void {
+		const payload = this.#buffer.toRawText();
+		if (payload.trim().length === 0) {
+			const message = "No raw SSE frames to copy";
+			this.#statusMessage = message;
+			this.#onStatus?.(message);
+			this.#onUpdate?.();
+			return;
+		}
+
+		try {
+			copyToClipboard(payload);
+			const message = "Copied raw SSE stream";
+			this.#statusMessage = message;
+			this.#onStatus?.(message);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.#statusMessage = `Copy failed: ${message}`;
+		}
+		this.#onUpdate?.();
+	}
+
+	#frameTop(innerWidth: number): string {
+		return `${theme.boxSharp.topLeft}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.topRight}`;
+	}
+
+	#frameSeparator(innerWidth: number): string {
+		return `${theme.boxSharp.teeRight}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.teeLeft}`;
+	}
+
+	#frameBottom(innerWidth: number): string {
+		return `${theme.boxSharp.bottomLeft}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.bottomRight}`;
+	}
+
+	#frameLine(content: string, innerWidth: number): string {
+		const truncated = truncateToWidth(content, innerWidth);
+		const remaining = Math.max(0, innerWidth - visibleWidth(truncated));
+		return `${theme.boxSharp.vertical}${truncated}${padding(remaining)}${theme.boxSharp.vertical}`;
+	}
+}

package/src/edit/index.ts

@@ -1,6 +1,14 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt } from "@oh-my-pi/pi-utils";
 import type { Static } from "@sinclair/typebox";
+import {
+	executeHashlineSingle,
+	HashlineMismatchError,
+	type HashlineParams,
+	hashlineEditParamsSchema,
+} from "../hashline";
+import hashlineGrammarTemplate from "../hashline/grammar.lark" with { type: "text" };
+import { resolveHashlineGrammarPlaceholders } from "../hashline/hash";
 import {
 	createLspWritethrough,
 	type FileDiagnosticsResult,
@@ -16,16 +24,8 @@ import type { ToolSession } from "../tools";
 import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
-import { resolveHashlineGrammarPlaceholders } from "./line-hash";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
-import {
-	executeHashlineSingle,
-	HashlineMismatchError,
-	type HashlineParams,
-	hashlineEditParamsSchema,
-} from "./modes/hashline";
-import hashlineGrammarTemplate from "./modes/hashline.lark" with { type: "text" };
 import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
 import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
@@ -34,13 +34,12 @@ export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/ed
 export * from "./apply-patch";
 export * from "./diff";
 export * from "./file-read-cache";
-export * from "./line-hash";
 
 // Resolve the `$HFMT$` and `$HSEP$` placeholders in the hashline Lark grammar.
 const hashlineGrammar = resolveHashlineGrammarPlaceholders(hashlineGrammarTemplate);
 
+export * from "../hashline";
 export * from "./modes/apply-patch";
-export * from "./modes/hashline";
 export * from "./modes/patch";
 export * from "./modes/replace";
 export * from "./normalize";

package/src/edit/streaming.ts

@@ -12,17 +12,18 @@
  * The shared renderer / `ToolExecutionComponent` consult the strategy via
  * the injected `editMode` rather than probing argument shape.
  */
-import type { Theme } from "../modes/theme/theme";
-import { type EditMode, resolveEditMode } from "../utils/edit-mode";
-import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
-import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
+
 import {
 	computeHashlineDiff,
 	computeHashlineSectionDiff,
 	containsRecognizableHashlineOperations,
 	type HashlineInputSection,
 	splitHashlineInputs,
-} from "./modes/hashline";
+} from "../hashline";
+import type { Theme } from "../modes/theme/theme";
+import { type EditMode, resolveEditMode } from "../utils/edit-mode";
+import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
+import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
 import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
 import type { ReplaceEditEntry } from "./modes/replace";
 

package/src/eval/js/context-manager.ts

@@ -5,6 +5,7 @@ import { pathToFileURL } from "node:url";
 import * as util from "node:util";
 import * as vm from "node:vm";
 
+import { parse as babelParse } from "@babel/parser";
 import * as Diff from "diff";
 import type { ToolSession } from "../../tools";
 import { ToolError } from "../../tools/tool-errors";
@@ -488,65 +489,108 @@ function buildRequire(cwd: string): NodeJS.Require {
 	return createRequire(pathToFileURL(path.join(cwd, "[eval]")).href);
 }
 
-// Static `import ... from "x"` is not valid inside vm.runInContext. Rewrite the common
-// forms to dynamic `await import(...)` so users can paste ESM-style imports verbatim.
-const STATIC_IMPORT_RE = /^[ \t]*import\b(?:[ \t]+([^'"\n]+?)[ \t]+from)?[ \t]*(['"])([^'"\n]+)\2[ \t]*;?[ \t]*$/gm;
-
-function splitTopLevel(clause: string): string[] {
-	const out: string[] = [];
-	let depth = 0;
-	let buf = "";
-	for (const ch of clause) {
-		if (ch === "{") depth++;
-		else if (ch === "}") depth--;
-		if (ch === "," && depth === 0) {
-			if (buf.trim()) out.push(buf.trim());
-			buf = "";
-		} else {
-			buf += ch;
-		}
-	}
-	if (buf.trim()) out.push(buf.trim());
-	return out;
+// Static `import ... from "x"` is not valid inside vm.runInContext (script-mode parsing).
+// Rewrite top-level static imports to dynamic `await import(...)` so users can paste ESM
+// source verbatim. We use a real parser instead of regex matching so imports embedded in
+// string literals, template literals, or comments — common in codemods — stay intact.
+
+type BabelImportDeclaration = {
+	type: "ImportDeclaration";
+	start: number;
+	end: number;
+	source: { value: string };
+	specifiers: ReadonlyArray<{
+		type: "ImportDefaultSpecifier" | "ImportNamespaceSpecifier" | "ImportSpecifier";
+		local: { name: string };
+		imported?: { type: "Identifier"; name: string } | { type: "StringLiteral"; value: string };
+	}>;
+	attributes?: ReadonlyArray<{
+		key: { type: "Identifier"; name: string } | { type: "StringLiteral"; value: string };
+		value: { value: string };
+	}>;
+};
+
+function buildDynamicImportCall(sourceLiteral: string, withClause: string | undefined): string {
+	return withClause ? `import(${sourceLiteral}, { with: ${withClause} })` : `import(${sourceLiteral})`;
 }
 
-function rewriteImportClause(clause: string, sourceLiteral: string): string {
+function buildWithClause(node: BabelImportDeclaration): string | undefined {
+	const attrs = node.attributes;
+	if (!attrs || attrs.length === 0) return undefined;
+	const pairs = attrs.map(attr => {
+		const key = attr.key.type === "Identifier" ? attr.key.name : JSON.stringify(attr.key.value);
+		return `${key}: ${JSON.stringify(attr.value.value)}`;
+	});
+	return `{ ${pairs.join(", ")} }`;
+}
+
+function rewriteImportNode(node: BabelImportDeclaration): string {
+	const sourceLiteral = JSON.stringify(node.source.value);
+	const withClause = buildWithClause(node);
+	const importCall = buildDynamicImportCall(sourceLiteral, withClause);
+
 	let defaultName: string | undefined;
 	let namespaceName: string | undefined;
-	let namedBlock: string | undefined;
-	for (const part of splitTopLevel(clause)) {
-		if (part.startsWith("{")) {
-			namedBlock = part;
-		} else if (part.startsWith("*")) {
-			const m = part.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)$/);
-			if (!m) return `await import(${sourceLiteral}); /* unrewritten import: ${clause} */`;
-			namespaceName = m[1];
-		} else if (/^[A-Za-z_$][\w$]*$/.test(part)) {
-			defaultName = part;
-		} else {
-			return `await import(${sourceLiteral}); /* unrewritten import: ${clause} */`;
+	const namedPairs: Array<[string, string]> = [];
+	for (const spec of node.specifiers) {
+		if (spec.type === "ImportDefaultSpecifier") {
+			defaultName = spec.local.name;
+		} else if (spec.type === "ImportNamespaceSpecifier") {
+			namespaceName = spec.local.name;
+		} else if (spec.type === "ImportSpecifier" && spec.imported) {
+			const imported = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+			namedPairs.push([imported, spec.local.name]);
 		}
 	}
-	if (namedBlock) {
-		const inner = namedBlock.slice(1, -1).trim();
-		const renamed = inner.replace(/([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)/g, "$1: $2");
-		const props = defaultName ? `default: ${defaultName}, ${renamed}` : renamed;
-		return `const { ${props} } = await import(${sourceLiteral});`;
+
+	if (namedPairs.length > 0) {
+		const inner = namedPairs.map(([imp, loc]) => (imp === loc ? imp : `${imp}: ${loc}`)).join(", ");
+		const props = defaultName ? `default: ${defaultName}, ${inner}` : inner;
+		return `const { ${props} } = await ${importCall};`;
 	}
 	if (namespaceName && defaultName) {
-		return `const ${namespaceName} = await import(${sourceLiteral}); const ${defaultName} = ${namespaceName}.default;`;
+		return `const ${namespaceName} = await ${importCall}; const ${defaultName} = ${namespaceName}.default;`;
 	}
-	if (namespaceName) return `const ${namespaceName} = await import(${sourceLiteral});`;
-	if (defaultName) return `const ${defaultName} = (await import(${sourceLiteral})).default;`;
-	return `await import(${sourceLiteral});`;
+	if (namespaceName) return `const ${namespaceName} = await ${importCall};`;
+	if (defaultName) return `const ${defaultName} = (await ${importCall}).default;`;
+	return `await ${importCall};`;
 }
 
 export function rewriteStaticImports(code: string): string {
-	return code.replace(STATIC_IMPORT_RE, (_match, clause: string | undefined, _quote, source: string) => {
-		const literal = JSON.stringify(source);
-		if (!clause) return `await import(${literal});`;
-		return rewriteImportClause(clause.trim(), literal);
-	});
+	if (!code.includes("import")) return code;
+
+	let ast: { program: { body: ReadonlyArray<{ type: string }> } };
+	try {
+		ast = babelParse(code, {
+			sourceType: "module",
+			allowAwaitOutsideFunction: true,
+			allowReturnOutsideFunction: true,
+			allowImportExportEverywhere: true,
+			allowNewTargetOutsideFunction: true,
+			allowSuperOutsideMethod: true,
+			allowUndeclaredExports: true,
+			errorRecovery: true,
+		}) as unknown as typeof ast;
+	} catch {
+		// Parser bailed entirely — let the VM surface the real syntax error.
+		return code;
+	}
+
+	// Only rewrite top-level imports. Anything nested deeper is invalid JS anyway and the
+	// VM will report it.
+	const imports: BabelImportDeclaration[] = [];
+	for (const node of ast.program.body) {
+		if (node.type === "ImportDeclaration") imports.push(node as unknown as BabelImportDeclaration);
+	}
+	if (imports.length === 0) return code;
+
+	// Splice from the back so earlier offsets stay valid.
+	imports.sort((a, b) => b.start - a.start);
+	let result = code;
+	for (const node of imports) {
+		result = result.slice(0, node.start) + rewriteImportNode(node) + result.slice(node.end);
+	}
+	return result;
 }
 
 function wrapCode(code: string): { source: string; asyncWrapped: boolean } {

package/src/extensibility/extensions/loader.ts

@@ -17,7 +17,7 @@ import type { ExecOptions } from "../../exec/exec";
 import { execCommand } from "../../exec/exec";
 import type { CustomMessage } from "../../session/messages";
 import { EventBus } from "../../utils/event-bus";
-import { installLegacyPiSpecifierShim } from "../plugins/legacy-pi-compat";
+import { installLegacyPiSpecifierShim, loadLegacyPiModule } from "../plugins/legacy-pi-compat";
 import { getAllPluginExtensionPaths } from "../plugins/loader";
 
 import { resolvePath } from "../utils";
@@ -36,6 +36,12 @@ import type {
 installLegacyPiSpecifierShim();
 
 type HandlerFn = (...args: unknown[]) => Promise<unknown>;
+type LoadedExtensionModule = ExtensionFactory | { default?: ExtensionFactory };
+
+function getExtensionFactory(module: LoadedExtensionModule): ExtensionFactory | null {
+	const candidate = typeof module === "function" ? module : module.default;
+	return typeof candidate === "function" ? candidate : null;
+}
 
 export class ExtensionRuntimeNotInitializedError extends Error {
 	constructor() {
@@ -272,8 +278,8 @@ async function loadExtension(
 ): Promise<{ extension: Extension | null; error: string | null }> {
 	const resolvedPath = resolvePath(extensionPath, cwd);
 	try {
-		const module = await import(`omp-legacy-pi-file:${resolvedPath}`);
-		const factory = (module.default ?? module) as ExtensionFactory;
+		const module = (await loadLegacyPiModule(resolvedPath)) as LoadedExtensionModule;
+		const factory = getExtensionFactory(module);
 
 		if (typeof factory !== "function") {
 			return {

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -1,4 +1,7 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
 import * as path from "node:path";
+import * as url from "node:url";
 
 const LEGACY_PI_PACKAGE_MAP = {
 	"@mariozechner/pi-agent-core": "@oh-my-pi/pi-agent-core",
@@ -54,6 +57,10 @@ function getResolvedSpecifier(specifier: string): string {
 	return resolved;
 }
 
+function toImportSpecifier(resolvedPath: string): string {
+	return url.pathToFileURL(resolvedPath).href;
+}
+
 function rewriteLegacyPiImports(source: string): string {
 	return source.replace(
 		LEGACY_PI_IMPORT_SPECIFIER_REGEX,
@@ -63,42 +70,118 @@ function rewriteLegacyPiImports(source: string): string {
 				return match;
 			}
 
-			return `${prefix}${getResolvedSpecifier(remappedSpecifier)}${suffix}`;
+			return `${prefix}${toImportSpecifier(getResolvedSpecifier(remappedSpecifier))}${suffix}`;
 		},
 	);
 }
 
-// Match `from "..."`, `from '...'`, `import("...")`, `import('...')` import specifiers.
+// Match static `from "..."` / `from '...'` import specifiers.
+const STATIC_IMPORT_SPECIFIER_REGEX = /(from\s+["'])([^"']+)(["'])/g;
+// Match static imports plus dynamic `import("...")` / `import('...')` specifiers.
 const ANY_IMPORT_SPECIFIER_REGEX = /((?:from\s+|import\s*\(\s*)["'])([^"']+)(["'])/g;
 
-/**
- * Resolves bare module specifiers in a legacy-namespaced extension source file
- * to absolute paths anchored at the extension's own directory. Without this,
- * imports inside files loaded via the `omp-legacy-pi-file:` namespace bypass
- * Node-style node_modules lookup, so an extension cannot use its own deps.
- * Relative paths and already-resolved absolute paths are left untouched.
- */
+/** Resolve bare imports against the extension directory before loading mirrored legacy Pi files. */
+function isUrlLikeSpecifier(specifier: string): boolean {
+	return /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(specifier);
+}
+
+function shouldPreserveImportSpecifier(specifier: string): boolean {
+	return specifier.startsWith(".") || path.isAbsolute(specifier) || isUrlLikeSpecifier(specifier);
+}
+
+function toRewrittenImportSpecifier(resolvedPath: string): string {
+	return isUrlLikeSpecifier(resolvedPath) ? resolvedPath : toImportSpecifier(resolvedPath);
+}
+
 function rewriteBareImportsForLegacyExtension(source: string, importerPath: string): string {
 	const importerDir = path.dirname(importerPath);
 	return source.replace(ANY_IMPORT_SPECIFIER_REGEX, (match, prefix: string, specifier: string, suffix: string) => {
 		// Skip relative, absolute, URL-style, and already-resolved Node specifiers.
-		if (
-			specifier.startsWith(".") ||
-			specifier.startsWith("/") ||
-			specifier.startsWith("node:") ||
-			specifier.includes("://")
-		) {
+		if (shouldPreserveImportSpecifier(specifier)) {
 			return match;
 		}
 		try {
 			const resolved = Bun.resolveSync(specifier, importerDir);
-			return `${prefix}${resolved}${suffix}`;
+			return `${prefix}${toRewrittenImportSpecifier(resolved)}${suffix}`;
 		} catch {
 			return match;
 		}
 	});
 }
 
+interface LegacyPiMirrorState {
+	root: string;
+	seen: Map<string, string>;
+}
+
+function getMirrorPath(sourcePath: string, state: LegacyPiMirrorState): string {
+	const extension = path.extname(sourcePath) || ".js";
+	const digest = Bun.hash(sourcePath).toString(36);
+	return path.join(state.root, `${digest}${extension}`);
+}
+
+async function rewriteRelativeImportsForLegacyExtension(
+	source: string,
+	importerPath: string,
+	state: LegacyPiMirrorState,
+): Promise<string> {
+	const replacements = new Map<string, string>();
+
+	for (const match of source.matchAll(STATIC_IMPORT_SPECIFIER_REGEX)) {
+		const specifier = match[2];
+		if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+			continue;
+		}
+
+		const resolved = Bun.resolveSync(specifier, path.dirname(importerPath));
+		const mirrored = await mirrorLegacyPiFile(resolved, state);
+		replacements.set(specifier, toImportSpecifier(mirrored));
+	}
+
+	if (replacements.size === 0) {
+		return source;
+	}
+
+	return source.replace(STATIC_IMPORT_SPECIFIER_REGEX, (match, prefix: string, specifier: string, suffix: string) => {
+		const replacement = replacements.get(specifier);
+		return replacement ? `${prefix}${replacement}${suffix}` : match;
+	});
+}
+
+async function rewriteLegacyPiImportsForRuntime(
+	source: string,
+	importerPath: string,
+	state: LegacyPiMirrorState,
+): Promise<string> {
+	const withRelativeResolved = await rewriteRelativeImportsForLegacyExtension(source, importerPath, state);
+	const withLegacyRemap = rewriteLegacyPiImports(withRelativeResolved);
+	return rewriteBareImportsForLegacyExtension(withLegacyRemap, importerPath);
+}
+
+async function mirrorLegacyPiFile(sourcePath: string, state: LegacyPiMirrorState): Promise<string> {
+	const resolvedPath = path.resolve(sourcePath);
+	const cached = state.seen.get(resolvedPath);
+	if (cached) {
+		return cached;
+	}
+
+	const mirrorPath = getMirrorPath(resolvedPath, state);
+	state.seen.set(resolvedPath, mirrorPath);
+
+	const raw = await Bun.file(resolvedPath).text();
+	const rewritten = await rewriteLegacyPiImportsForRuntime(raw, resolvedPath, state);
+	await Bun.write(mirrorPath, rewritten);
+	return mirrorPath;
+}
+
+export async function loadLegacyPiModule(resolvedPath: string): Promise<unknown> {
+	const root = path.join(os.tmpdir(), "omp-legacy-pi-file", Bun.hash(resolvedPath).toString(36));
+	await fs.rm(root, { recursive: true, force: true });
+	const state: LegacyPiMirrorState = { root, seen: new Map() };
+	const mirroredEntry = await mirrorLegacyPiFile(resolvedPath, state);
+	return import(`${toImportSpecifier(mirroredEntry)}?mtime=${Date.now()}`);
+}
+
 function getLoader(path: string): "js" | "jsx" | "ts" | "tsx" {
 	if (path.endsWith(".tsx")) {
 		return "tsx";
@@ -150,10 +233,6 @@ export function installLegacyPiSpecifierShim(): void {
 
 			build.onLoad({ filter: /\.[cm]?[jt]sx?$/, namespace: LEGACY_PI_FILE_NAMESPACE }, async args => {
 				const raw = await Bun.file(args.path).text();
-				// Bare specifiers (e.g. "lodash", "@scope/pkg/sub") imported from a legacy-namespaced
-				// extension file would otherwise bypass Node-style node_modules lookup because the
-				// importer lives in a custom namespace. Pre-resolve them to absolute paths so the
-				// extension's own node_modules are honored.
 				const withLegacyRemap = rewriteLegacyPiImports(raw);
 				const withBareResolved = rewriteBareImportsForLegacyExtension(withLegacyRemap, args.path);
 				return {