@code-yeongyu/senpi-codemode 2026.7.25-2

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

@@ -0,0 +1,296 @@
+import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import { createInlineWorker, type WorkerLike } from "./inline-worker.ts";
+import {
+	assertJavaScriptKernelOpen,
+	type JavaScriptKernelMode,
+	type JavaScriptRunInput,
+	type LifecycleState,
+	type ResultMessage,
+	type ToolCallMessage,
+} from "./kernel-contract.ts";
+import { type JavaScriptKernelOptions, LocalModuleLoader, localBridgeConnection } from "./local-module-loader.ts";
+import { JavaScriptRunQueue, type PendingJavaScriptRun, stoppedResult } from "./run-queue.ts";
+import { bridgeError, spawnNodeWorker, WorkerStartupCancelledError, waitForReady } from "./worker-host.ts";
+
+export { JavaScriptKernelClosedError, type JavaScriptKernelMode, type JavaScriptRunInput } from "./kernel-contract.ts";
+export type { JavaScriptKernelOptions } from "./local-module-loader.ts";
+
+export class JavaScriptKernel {
+	readonly #options: JavaScriptKernelOptions;
+	readonly #moduleLoader: LocalModuleLoader;
+	#worker: WorkerLike | null = null;
+	#mode: JavaScriptKernelMode = "worker";
+	#lifecycle: LifecycleState = "open";
+	#ready: Promise<void> | null = null;
+	#startupAbort: AbortController | null = null;
+	#generation = 0;
+	#activation: Promise<void> | null = null;
+	#recovery: Promise<void> | null = null;
+	#closePromise: Promise<void> | null = null;
+	readonly #runs = new JavaScriptRunQueue();
+	#timeout: NodeJS.Timeout | null = null;
+	#toolWaiters: Array<(message: ToolCallMessage) => void> = [];
+	#pendingToolCalls: ToolCallMessage[] = [];
+
+	constructor(options: JavaScriptKernelOptions) {
+		this.#options = options;
+		this.#moduleLoader = new LocalModuleLoader(options);
+	}
+
+	get mode(): JavaScriptKernelMode {
+		return this.#mode;
+	}
+
+	async run(input: JavaScriptRunInput): Promise<ResultMessage> {
+		assertJavaScriptKernelOpen(this.#lifecycle, "run");
+		const promise = this.#runs.enqueue(input);
+		this.#activate();
+		return await promise;
+	}
+
+	async interrupt(reason = "interrupted"): Promise<void> {
+		assertJavaScriptKernelOpen(this.#lifecycle, "interrupt");
+		const active = this.#runs.active;
+		const target = this.#runs.takeInterruptTarget();
+		if (!target) return;
+		if (target === active) this.#clearTimeout();
+		this.#runs.settle(target, stoppedResult(target.input.cellId, `JS cell interrupted: ${reason}`));
+		await this.#restartAfterStop();
+	}
+
+	async reset(): Promise<void> {
+		assertJavaScriptKernelOpen(this.#lifecycle, "reset");
+		await this.#terminate();
+		assertJavaScriptKernelOpen(this.#lifecycle, "reset");
+		await this.#ensureReady();
+		this.#startNext();
+	}
+
+	deliverToolReply(message: Extract<HostToKernelMessage, { type: "tool-reply" }>): void {
+		if (this.#lifecycle === "open") this.#worker?.postMessage(message);
+	}
+
+	async nextToolCall(): Promise<ToolCallMessage> {
+		const pending = this.#pendingToolCalls.shift();
+		if (pending) return pending;
+		return await new Promise((resolve) => this.#toolWaiters.push(resolve));
+	}
+
+	async close(): Promise<void> {
+		if (this.#closePromise) return await this.#closePromise;
+		this.#worker?.postMessage({ type: "close" });
+		this.#lifecycle = "closing";
+		this.#runs.settleAll("JS kernel closed");
+		const recovery = this.#recovery;
+		const closePromise = (async () => {
+			if (recovery) await recovery;
+			await this.#terminate();
+		})().finally(() => {
+			this.#lifecycle = "closed";
+		});
+		this.#closePromise = closePromise;
+		return await closePromise;
+	}
+
+	#activate(): void {
+		if (this.#activation || this.#lifecycle !== "open" || this.#runs.active || !this.#runs.hasWaiting) return;
+		const activation = this.#activateWhenReady();
+		this.#activation = activation;
+		void activation.then(() => {
+			if (this.#activation === activation) this.#activation = null;
+			if (this.#lifecycle === "open" && !this.#runs.active && this.#runs.hasWaiting) this.#activate();
+		});
+	}
+
+	async #activateWhenReady(): Promise<void> {
+		try {
+			await this.#ensureReady();
+			if (this.#lifecycle === "open") this.#startNext();
+		} catch (error) {
+			if (error instanceof WorkerStartupCancelledError) return;
+			this.#runs.rejectWaiting(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+
+	async #ensureReady(): Promise<void> {
+		assertJavaScriptKernelOpen(this.#lifecycle, "run");
+		if (!this.#ready) {
+			const generation = ++this.#generation;
+			const controller = new AbortController();
+			this.#startupAbort = controller;
+			const ready = this.#startWorker(generation, controller.signal);
+			this.#ready = ready;
+			void ready.then(
+				() => {
+					if (this.#ready === ready) this.#startupAbort = null;
+				},
+				() => {
+					if (this.#ready === ready) {
+						this.#ready = null;
+						this.#startupAbort = null;
+					}
+				},
+			);
+		}
+		return await this.#ready;
+	}
+
+	async #startWorker(generation: number, signal: AbortSignal): Promise<void> {
+		let worker = this.#spawnWorker();
+		this.#publishWorker(worker, generation);
+		try {
+			await this.#initializeWorker(worker, signal);
+			return;
+		} catch (error) {
+			if (!this.#isCurrent(worker, generation) || error instanceof WorkerStartupCancelledError) {
+				await worker.terminate();
+				throw new WorkerStartupCancelledError();
+			}
+			if (worker.mode === "inline") throw error;
+			this.#worker = null;
+			await worker.terminate();
+		}
+		if (this.#lifecycle !== "open" || generation !== this.#generation) throw new WorkerStartupCancelledError();
+		worker = createInlineWorker(this.#options.cwd, this.#options.parallelPoolWidth);
+		this.#publishWorker(worker, generation);
+		await this.#initializeWorker(worker, signal);
+	}
+
+	#spawnWorker(): WorkerLike {
+		try {
+			const url = this.#options.workerEntryUrl ?? new URL("./worker-entry.js", import.meta.url);
+			return spawnNodeWorker(url, this.#options.cwd, this.#options.parallelPoolWidth);
+		} catch (error) {
+			if (!(error instanceof Error)) throw error;
+			return createInlineWorker(this.#options.cwd, this.#options.parallelPoolWidth);
+		}
+	}
+
+	#publishWorker(worker: WorkerLike, generation: number): void {
+		if (this.#lifecycle !== "open" || generation !== this.#generation) throw new WorkerStartupCancelledError();
+		this.#worker = worker;
+		this.#mode = worker.mode;
+		worker.onMessage((message) => {
+			if (this.#isCurrent(worker, generation)) this.#handleMessage(message);
+		});
+		worker.onError((error) => {
+			if (this.#isCurrent(worker, generation)) this.#handleCrash(error);
+		});
+	}
+
+	async #initializeWorker(worker: WorkerLike, signal: AbortSignal): Promise<void> {
+		const ready = waitForReady(worker, signal);
+		worker.postMessage({
+			type: "init",
+			sessionId: this.#options.sessionId,
+			connection: localBridgeConnection(this.#options),
+		});
+		await ready;
+	}
+
+	#isCurrent(worker: WorkerLike, generation: number): boolean {
+		return this.#lifecycle === "open" && this.#worker === worker && this.#generation === generation;
+	}
+
+	#startNext(): void {
+		if (this.#lifecycle !== "open" || this.#runs.active || !this.#worker) return;
+		const next = this.#runs.startNext(performance.now());
+		if (!next) return;
+		if (next.input.timeoutMs) {
+			this.#timeout = setTimeout(() => void this.#timeoutActive(next), next.input.timeoutMs);
+		}
+		this.#worker.postMessage({
+			type: "run",
+			cellId: next.input.cellId,
+			code: this.#moduleLoader.prepareCell(next.input.code),
+			timeoutMs: next.input.timeoutMs,
+		});
+	}
+
+	async #timeoutActive(run: PendingJavaScriptRun): Promise<void> {
+		if (!this.#runs.releaseActive(run)) return;
+		const durationMs = run.input.timeoutMs ?? 0;
+		this.#runs.settle(run, {
+			type: "result",
+			cellId: run.input.cellId,
+			ok: false,
+			error: { message: `JS cell timed out after ${durationMs}ms` },
+			durationMs,
+		});
+		await this.#restartAfterStop();
+	}
+
+	async #restartAfterStop(): Promise<void> {
+		if (this.#recovery) return await this.#recovery;
+		const recovery = this.#performRestartAfterStop();
+		this.#recovery = recovery;
+		try {
+			await recovery;
+		} finally {
+			if (this.#recovery === recovery) this.#recovery = null;
+		}
+	}
+
+	async #performRestartAfterStop(): Promise<void> {
+		try {
+			await this.#terminate();
+			if (this.#lifecycle !== "open") return;
+			await this.#ensureReady();
+			if (this.#lifecycle === "open") this.#startNext();
+		} catch (error) {
+			if (error instanceof WorkerStartupCancelledError) return;
+			this.#runs.rejectWaiting(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+
+	#handleMessage(message: KernelToHostMessage): void {
+		this.#options.onMessage?.(message);
+		this.#runs.active?.input.onMessage?.(message);
+		if (message.type === "tool-call") {
+			const waiter = this.#toolWaiters.shift();
+			if (waiter) waiter(message);
+			else this.#pendingToolCalls.push(message);
+			return;
+		}
+		if (message.type !== "result") return;
+		const active = this.#runs.active;
+		if (!active || active.input.cellId !== message.cellId) return;
+		this.#clearTimeout();
+		this.#runs.releaseActive(active);
+		this.#runs.settle(active, message);
+		this.#startNext();
+	}
+
+	#handleCrash(error: Error): void {
+		const active = this.#runs.active;
+		if (!active && this.#startupAbort) return;
+		this.#clearTimeout();
+		if (active) {
+			this.#runs.releaseActive(active);
+			this.#runs.settle(active, {
+				type: "result",
+				cellId: active.input.cellId,
+				ok: false,
+				error: bridgeError(error),
+				durationMs: this.#runs.durationMs(active, performance.now()),
+			});
+		}
+		void this.#restartAfterStop();
+	}
+
+	#clearTimeout(): void {
+		if (this.#timeout) clearTimeout(this.#timeout);
+		this.#timeout = null;
+	}
+
+	async #terminate(): Promise<void> {
+		this.#clearTimeout();
+		this.#generation += 1;
+		this.#startupAbort?.abort();
+		this.#startupAbort = null;
+		this.#ready = null;
+		const worker = this.#worker;
+		this.#worker = null;
+		if (worker) await worker.terminate();
+	}
+}

package/src/kernels/js/inline-worker-entry.js

@@ -0,0 +1,23 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { createWorkerCore } from "./worker-core.js";
+
+if (!parentPort) throw new Error("JS kernel inline fallback worker missing parentPort");
+
+const transport = {
+	send(message) {
+		parentPort.postMessage(message);
+	},
+	onMessage(handler) {
+		parentPort.on("message", handler);
+		return () => parentPort.off("message", handler);
+	},
+	close() {
+		parentPort.close();
+		setTimeout(() => process.exit(0), 0);
+	},
+};
+
+createWorkerCore(transport, {
+	cwd: workerData.cwd,
+	parallelPoolWidth: workerData.parallelPoolWidth,
+});

package/src/kernels/js/inline-worker.ts

@@ -0,0 +1,15 @@
+import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { JavaScriptKernelMode } from "./kernel-contract.ts";
+import { spawnNodeWorker } from "./worker-host.ts";
+
+export interface WorkerLike {
+	readonly mode: JavaScriptKernelMode;
+	postMessage(message: HostToKernelMessage): void;
+	onMessage(handler: (message: KernelToHostMessage) => void): () => void;
+	onError(handler: (error: Error) => void): () => void;
+	terminate(): Promise<void>;
+}
+
+export function createInlineWorker(cwd: string, parallelPoolWidth: number): WorkerLike {
+	return spawnNodeWorker(new URL("./inline-worker-entry.js", import.meta.url), cwd, parallelPoolWidth, "inline");
+}

package/src/kernels/js/kernel-contract.ts

@@ -0,0 +1,38 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+
+export type ResultMessage = Extract<KernelToHostMessage, { type: "result" }>;
+export type ToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;
+
+export type JavaScriptKernelMode = "worker" | "inline";
+
+export interface JavaScriptKernelOptions {
+	readonly sessionId: string;
+	readonly cwd: string;
+	readonly parallelPoolWidth: number;
+	readonly onMessage?: (message: KernelToHostMessage) => void;
+	readonly workerEntryUrl?: URL;
+}
+
+export interface JavaScriptRunInput {
+	readonly cellId: string;
+	readonly code: string;
+	readonly timeoutMs?: number;
+	readonly onMessage?: (message: KernelToHostMessage) => void;
+}
+
+export type KernelOperation = "run" | "reset" | "interrupt";
+export type LifecycleState = "open" | "closing" | "closed";
+
+export class JavaScriptKernelClosedError extends Error {
+	readonly name = "JavaScriptKernelClosedError";
+	readonly operation: KernelOperation;
+
+	constructor(operation: KernelOperation) {
+		super(`Cannot ${operation}: JavaScript kernel is closed`);
+		this.operation = operation;
+	}
+}
+
+export function assertJavaScriptKernelOpen(lifecycle: LifecycleState, operation: KernelOperation): void {
+	if (lifecycle !== "open") throw new JavaScriptKernelClosedError(operation);
+}

package/src/kernels/js/local-module-loader.ts

@@ -0,0 +1,108 @@
+import { join, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import type { BridgeConnectionConfig } from "../../bridge/protocol.ts";
+import {
+	RESERVED_AGENT_TOOL,
+	RESERVED_OUTPUT_TOOL,
+	TIMEOUT_PAUSE_OP,
+	TIMEOUT_RESUME_OP,
+} from "../../bridge/reserved.ts";
+import type { JavaScriptKernelOptions as BaseJavaScriptKernelOptions } from "./kernel-contract.ts";
+import { rewriteImports } from "./rewrite-imports.ts";
+
+const PREPARED_CELL_PREFIX = "/*senpi:prepared-cell*/";
+
+export interface LocalModuleLoaderOptions {
+	readonly cwd: string;
+	readonly localRoots?: Readonly<Record<string, string>>;
+	readonly artifactsDir?: string;
+}
+
+export type JavaScriptKernelOptions = BaseJavaScriptKernelOptions & LocalModuleLoaderOptions;
+
+export function localBridgeConnection(options: LocalModuleLoaderOptions): BridgeConnectionConfig {
+	return {
+		port: 1,
+		token: "local",
+		...(options.localRoots ? { localRoots: { ...options.localRoots } } : {}),
+		...(options.artifactsDir ? { artifactsDir: options.artifactsDir } : {}),
+	};
+}
+
+type RuntimeModuleContext = {
+	readonly cwdUrl: string;
+	readonly localRootUrls: Readonly<Record<string, string>>;
+	readonly reservedAgentTool: string;
+	readonly reservedOutputTool: string;
+	readonly timeoutPauseOp: string;
+	readonly timeoutResumeOp: string;
+};
+
+function directoryUrl(directory: string): string {
+	return pathToFileURL(`${resolve(directory)}${sep}`).href;
+}
+
+function runtimeContext(options: LocalModuleLoaderOptions): RuntimeModuleContext {
+	const roots: Record<string, string> = {};
+	for (const [scheme, root] of Object.entries(options.localRoots ?? {})) {
+		roots[scheme.toLowerCase()] = directoryUrl(root);
+	}
+	if (options.artifactsDir && roots.local === undefined) {
+		roots.local = directoryUrl(join(options.artifactsDir, "local"));
+	}
+	return {
+		cwdUrl: directoryUrl(options.cwd),
+		localRootUrls: roots,
+		reservedAgentTool: RESERVED_AGENT_TOOL,
+		reservedOutputTool: RESERVED_OUTPUT_TOOL,
+		timeoutPauseOp: TIMEOUT_PAUSE_OP,
+		timeoutResumeOp: TIMEOUT_RESUME_OP,
+	};
+}
+
+function loaderPrelude(context: RuntimeModuleContext): string {
+	const serialized = JSON.stringify(context);
+	return [
+		`globalThis.__senpi_module_context__ = ${serialized};`,
+		"globalThis.__senpi_reserved_agent_tool__ = globalThis.__senpi_module_context__.reservedAgentTool;",
+		"globalThis.__senpi_reserved_output_tool__ = globalThis.__senpi_module_context__.reservedOutputTool;",
+		"globalThis.__senpi_timeout_pause_op__ = globalThis.__senpi_module_context__.timeoutPauseOp;",
+		"globalThis.__senpi_timeout_resume_op__ = globalThis.__senpi_module_context__.timeoutResumeOp;",
+		"globalThis.__senpi_import__ = async (source, options) => {",
+		"  const context = globalThis.__senpi_module_context__;",
+		"  const specifier = String(source);",
+		"  const match = /^([a-z][a-z0-9+.-]*):\\/\\/(.*)$/i.exec(specifier);",
+		"  let target = specifier;",
+		"  if (match) {",
+		"    const scheme = match[1].toLowerCase();",
+		"    const root = context.localRootUrls[scheme];",
+		"    if (!root) throw new Error('Unsupported module protocol: ' + specifier);",
+		"    let relative;",
+		"    try { relative = decodeURIComponent(match[2].replaceAll('\\\\', '/')); }",
+		"    catch { throw new Error('Invalid module URL encoding: ' + specifier); }",
+		"    if (relative.startsWith('/') || relative.split('/').includes('..')) {",
+		"      throw new Error('Module path escapes ' + scheme + ':// root: ' + specifier);",
+		"    }",
+		"    target = new URL(relative, root).href;",
+		"  } else if (specifier.startsWith('./') || specifier.startsWith('../') || specifier === '.' || specifier === '..') {",
+		"    target = new URL(specifier, context.cwdUrl).href;",
+		"  } else if (specifier.startsWith('/') || /^[A-Za-z]:[\\\\/]/.test(specifier)) {",
+		"    const urlModule = await import('node:url');",
+		"    target = urlModule.pathToFileURL(specifier).href;",
+		"  }",
+		"  return options === undefined ? import(target) : import(target, options);",
+		"};",
+	].join("\n");
+}
+
+export class LocalModuleLoader {
+	readonly #prelude: string;
+
+	constructor(options: LocalModuleLoaderOptions) {
+		this.#prelude = loaderPrelude(runtimeContext(options));
+	}
+
+	prepareCell(code: string): string {
+		return `${PREPARED_CELL_PREFIX}${JSON.stringify({ prelude: this.#prelude, code: rewriteImports(code) })}`;
+	}
+}

package/src/kernels/js/prelude.ts

@@ -0,0 +1,15 @@
+export const JAVASCRIPT_KERNEL_PRELUDE = [
+	"print(...values): write stdout text.",
+	"display(value): emit JSON, image, or markdown display output.",
+	"log(message): emit a progress log line.",
+	"phase(title): emit a progress phase.",
+	"env(key?, value?): read, set, or list environment values.",
+	"read(path, options?): read UTF-8 text; plain paths use cwd and local:// uses the session local root.",
+	"write(path, content): write UTF-8 or binary data and return the resolved path.",
+	"tool.<name>(args): request a host tool call through the bridge.",
+	"completion(prompt, options?): request a host completion bridge call.",
+	"output(...ids, options?): retrieve task output through the reserved output bridge.",
+	"agent(prompt, options?): delegate work through the reserved agent bridge.",
+	"parallel(thunks): run async thunks through the configured bounded pool; preserves order and rethrows the lowest-index error after all settle.",
+	"pipeline(items, ...stages): map items through staged async transforms with a barrier between stages.",
+].join("\n");

package/src/kernels/js/rewrite-imports.ts

@@ -0,0 +1,164 @@
+import { parse } from "@babel/parser";
+import type { ImportDeclaration } from "@babel/types";
+
+const DYNAMIC_IMPORT_CALLEE =
+	'(typeof __senpi_import__ === "function" ? __senpi_import__ : (specifier, options) => import(specifier, options))';
+
+type AstNode = {
+	readonly type: string;
+	readonly start: number;
+	readonly end: number;
+	readonly value: Readonly<Record<string, unknown>>;
+};
+
+type TextEdit = {
+	readonly start: number;
+	readonly end: number;
+	readonly text: string;
+};
+
+class UnexpectedImportSpecifierError extends Error {
+	readonly name = "UnexpectedImportSpecifierError";
+}
+
+function assertNever(_value: never): never {
+	throw new UnexpectedImportSpecifierError("Unsupported import specifier");
+}
+
+function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function nodeFrom(value: unknown): AstNode | undefined {
+	if (!isRecord(value)) return undefined;
+	const type = value.type;
+	const start = value.start;
+	const end = value.end;
+	if (typeof type !== "string" || typeof start !== "number" || typeof end !== "number") return undefined;
+	return { type, start, end, value };
+}
+
+function parseProgram(code: string): ReturnType<typeof parse> | undefined {
+	try {
+		return parse(code, {
+			sourceType: "module",
+			allowAwaitOutsideFunction: true,
+			allowReturnOutsideFunction: true,
+			allowImportExportEverywhere: true,
+			allowNewTargetOutsideFunction: true,
+			allowSuperOutsideMethod: true,
+			allowUndeclaredExports: true,
+			errorRecovery: true,
+			plugins: ["typescript", "importAttributes"],
+		});
+	} catch (error) {
+		if (error instanceof SyntaxError) return undefined;
+		throw error;
+	}
+}
+
+function walkNodes(root: unknown, visit: (node: AstNode) => void): void {
+	const stack: unknown[] = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (Array.isArray(current)) {
+			for (let index = current.length - 1; index >= 0; index -= 1) stack.push(current[index]);
+			continue;
+		}
+		if (!isRecord(current)) continue;
+		const node = nodeFrom(current);
+		if (node) visit(node);
+		for (const [key, value] of Object.entries(current)) {
+			if (key === "loc" || key === "extra" || key === "range" || key.endsWith("Comments")) continue;
+			if (value !== null && typeof value === "object") stack.push(value);
+		}
+	}
+}
+
+function importOptions(node: ImportDeclaration): string | undefined {
+	if (!node.attributes || node.attributes.length === 0) return undefined;
+	const pairs = node.attributes.map((attribute) => {
+		const key = attribute.key.type === "Identifier" ? attribute.key.name : JSON.stringify(attribute.key.value);
+		return `${key}: ${JSON.stringify(attribute.value.value)}`;
+	});
+	return `{ with: { ${pairs.join(", ")} } }`;
+}
+
+function importCall(source: string, options: string | undefined): string {
+	const sourceLiteral = JSON.stringify(source);
+	return options ? `__senpi_import__(${sourceLiteral}, ${options})` : `__senpi_import__(${sourceLiteral})`;
+}
+
+function rewriteImportDeclaration(node: ImportDeclaration): string {
+	const call = importCall(node.source.value, importOptions(node));
+	let defaultName: string | undefined;
+	let namespaceName: string | undefined;
+	const namedBindings: Array<readonly [imported: string, local: string]> = [];
+
+	for (const specifier of node.specifiers) {
+		switch (specifier.type) {
+			case "ImportDefaultSpecifier":
+				defaultName = specifier.local.name;
+				break;
+			case "ImportNamespaceSpecifier":
+				namespaceName = specifier.local.name;
+				break;
+			case "ImportSpecifier": {
+				const imported =
+					specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+				namedBindings.push([imported, specifier.local.name]);
+				break;
+			}
+			default:
+				assertNever(specifier);
+		}
+	}
+
+	if (namedBindings.length > 0) {
+		const named = namedBindings
+			.map(([imported, local]) => (imported === local ? imported : `${imported}: ${local}`))
+			.join(", ");
+		const bindings = defaultName ? `default: ${defaultName}, ${named}` : named;
+		return `const { ${bindings} } = await ${call};`;
+	}
+	if (namespaceName && defaultName) {
+		return `const ${namespaceName} = await ${call}; const ${defaultName} = ${namespaceName}.default;`;
+	}
+	if (namespaceName) return `const ${namespaceName} = await ${call};`;
+	if (defaultName) return `const ${defaultName} = (await ${call}).default;`;
+	return `await ${call};`;
+}
+
+function dynamicImportEdit(node: AstNode): TextEdit | undefined {
+	if (node.type !== "CallExpression") return undefined;
+	const callee = nodeFrom(node.value.callee);
+	if (callee?.type !== "Import") return undefined;
+	return { start: callee.start, end: callee.end, text: DYNAMIC_IMPORT_CALLEE };
+}
+
+function applyEdits(code: string, edits: readonly TextEdit[]): string {
+	if (edits.length === 0) return code;
+	const descending = edits.toSorted((left, right) => right.start - left.start);
+	let output = code;
+	for (const edit of descending) {
+		output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+	}
+	return output;
+}
+
+export function rewriteImports(code: string): string {
+	if (!code.includes("import")) return code;
+	const ast = parseProgram(code);
+	if (!ast) return code;
+	const edits: TextEdit[] = [];
+
+	for (const node of ast.program.body) {
+		if (node.type !== "ImportDeclaration" || typeof node.start !== "number" || typeof node.end !== "number") continue;
+		edits.push({ start: node.start, end: node.end, text: rewriteImportDeclaration(node) });
+	}
+	walkNodes(ast.program, (node) => {
+		const edit = dynamicImportEdit(node);
+		if (edit) edits.push(edit);
+	});
+	return applyEdits(code, edits);
+}