@code-yeongyu/senpi-codemode 2026.10.8 → 2026.10.10-10

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

@@ -0,0 +1,298 @@
+import { execFileSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { accessSync, constants } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import { isKernelToHostMessage, parseBridgeJsonLine, validateBridgeMessage } from "../../bridge/protocol.ts";
+import type { EvalRuntimeInfo } from "../../tool/types.ts";
+import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
+import { type SubprocessLike, SubprocessProcess, spawnSubprocess } from "../shared/subprocess-process.ts";
+import type { WorkerLike } from "./inline-worker.ts";
+import { JavaScriptWorkerExitedError } from "./worker-host.ts";
+
+const PROCESS_CLOSE_GRACE_MS = 2_000;
+
+export interface JavaScriptProcessEntryUrlOptions extends CodemodeRuntimeAssetEnvironment {
+	readonly localPath?: string;
+}
+
+export function resolveJsProcessEntryUrl(options: JavaScriptProcessEntryUrlOptions = {}): URL {
+	const localPath = options.localPath ?? join(dirname(fileURLToPath(import.meta.url)), "process-entry.js");
+	return pathToFileURL(requireCodemodeRuntimeAsset(localPath, join("kernels", "js", "process-entry.js"), options));
+}
+
+export class JavaScriptProcessRuntimeUnavailableError extends Error {
+	readonly name = "JavaScriptProcessRuntimeUnavailableError";
+	readonly runtime: string;
+	readonly searchPath: string;
+
+	constructor(runtime: string, searchPath: string) {
+		super(
+			`JavaScript runtime is unavailable: no ${runtime} executable found on PATH${searchPath.length === 0 ? " (empty)" : ""}. Install bun or node, or use isolation.js: "worker".`,
+		);
+		this.runtime = runtime;
+		this.searchPath = searchPath;
+	}
+}
+
+export interface JavaScriptProcessWorkerOptions {
+	readonly cwd: string;
+	readonly parallelPoolWidth: number;
+	readonly searchPath?: string;
+	readonly execPath?: string;
+	readonly env?: NodeJS.ProcessEnv;
+	readonly spawn?: (
+		command: string,
+		args: readonly string[],
+		options: { cwd?: string; env?: NodeJS.ProcessEnv },
+	) => SubprocessLike;
+}
+
+export interface JavaScriptProcessWorker extends WorkerLike {
+	readonly pid?: number;
+}
+
+/**
+ * The runtime that runs the kernel child: the host's own runtime (bun when senpi runs on Bun, node otherwise), taken
+ * from the host's executable when that is the runtime itself, else found on PATH, the host's runtime first.
+ */
+export function resolveJavaScriptProcessCommand(
+	searchPath: string | undefined,
+	platform: NodeJS.Platform = process.platform,
+	hostRuntime: string = process.versions.bun === undefined ? "node" : "bun",
+	execPath: string = process.execPath,
+): string {
+	const candidates = hostRuntime === "bun" ? ["bun", "node"] : ["node", "bun"];
+	const extensions = platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+	if (runtimeNameOf(execPath) !== undefined && isExecutable(execPath)) return execPath;
+	const pathValue = searchPath ?? process.env.PATH ?? "";
+	if (pathValue.trim().length === 0) throw new JavaScriptProcessRuntimeUnavailableError(hostRuntime, "");
+	const directories = pathValue.split(platform === "win32" ? ";" : ":").filter((directory) => directory.length > 0);
+	for (const name of candidates) {
+		for (const directory of directories) {
+			for (const extension of extensions) {
+				const candidate = join(directory, `${name}${extension}`);
+				if (isExecutable(candidate)) return candidate;
+			}
+		}
+	}
+	throw new JavaScriptProcessRuntimeUnavailableError(hostRuntime, pathValue);
+}
+
+/**
+ * The badge identity of the child a process-mode kernel runs: the host's own identity when the child is the host's
+ * executable, else the resolved runtime with the version it reports. Undefined when no runtime resolves (the kernel
+ * then reports the capability gap on its first cell).
+ */
+export function processRuntimeInfo(searchPath: string | undefined): EvalRuntimeInfo | undefined {
+	let command: string;
+	try {
+		command = resolveJavaScriptProcessCommand(searchPath);
+	} catch (error) {
+		if (error instanceof JavaScriptProcessRuntimeUnavailableError) return undefined;
+		throw error;
+	}
+	const name = runtimeNameOf(command);
+	if (command === process.execPath || name === undefined) return undefined;
+	const version = execFileSync(command, ["--version"], { encoding: "utf8", timeout: 5_000 }).trim().replace(/^v/, "");
+	return { name, version, path: command, isolation: "process" };
+}
+
+/** "bun" or "node" from an executable path; undefined for anything else (a compiled senpi binary, for one). */
+export function runtimeNameOf(command: string): "bun" | "node" | undefined {
+	const name = basename(command).replace(/\.(exe|cmd|bat)$/i, "");
+	return name === "bun" || name === "node" ? name : undefined;
+}
+
+function isExecutable(path: string): boolean {
+	try {
+		accessSync(path, constants.X_OK);
+		return true;
+	} catch (error) {
+		if (
+			error instanceof Error &&
+			"code" in error &&
+			(error.code === "ENOENT" || error.code === "EACCES" || error.code === "ENOTDIR")
+		) {
+			return false;
+		}
+		throw error;
+	}
+}
+
+export function spawnProcessWorker(url: URL, options: JavaScriptProcessWorkerOptions): JavaScriptProcessWorker {
+	const command = resolveJavaScriptProcessCommand(options.searchPath, process.platform, undefined, options.execPath);
+	const isBun = runtimeNameOf(command) === "bun";
+	const args = isBun ? [fileURLToPath(url)] : ["--experimental-strip-types", fileURLToPath(url)];
+	const env: NodeJS.ProcessEnv = {
+		...process.env,
+		...options.env,
+		SENPI_CODEMODE_PROCESS_CWD: options.cwd,
+		SENPI_CODEMODE_PROCESS_POOL_WIDTH: String(options.parallelPoolWidth),
+	};
+	const child =
+		options.spawn === undefined
+			? spawnSubprocess(undefined, { command, args, cwd: options.cwd, env })
+			: options.spawn(command, args, { cwd: options.cwd, env });
+	const messageHandlers = new Set<(message: KernelToHostMessage) => void>();
+	const errorHandlers = new Set<(error: Error) => void>();
+	const frameToken = randomBytes(16).toString("hex");
+	const framePrefix = `${frameToken} `;
+	let crashCause: Error | undefined;
+	let stderrTail = "";
+	// A line that fails to parse may be the end of a frame a dying child was writing; it is reported only once the
+	// channel carries on, so the crash cause or the exit itself, not "invalid frame", settles the cell.
+	let pendingInvalidFrame: Error | undefined;
+	const reportPendingInvalidFrame = () => {
+		const error = pendingInvalidFrame;
+		pendingInvalidFrame = undefined;
+		if (error !== undefined) for (const handler of [...errorHandlers]) handler(error);
+	};
+	// Attached directly, not through SubprocessProcess, which stops reading stderr as soon as the exit is observed.
+	child.stderr.on("data", (chunk: string | Buffer) => {
+		stderrTail = `${stderrTail}${String(chunk)}`.slice(-STDERR_TAIL_CHARS);
+		const crash = crashCauseFrom(stderrTail, frameToken);
+		if (crash !== undefined) crashCause = crash;
+	});
+	const subprocess = new SubprocessProcess(child, {
+		onLine: (_process, line) => {
+			// Only a line carrying this process's token is a frame; any other line is output that
+			// reached the channel (a raw fd write, a child process) and is delivered as text.
+			if (!line.startsWith(framePrefix)) {
+				if (line.trim().length === 0) return;
+				reportPendingInvalidFrame();
+				for (const handler of [...messageHandlers]) handler({ type: "text", stream: "stdout", data: line });
+				return;
+			}
+			const parsed = decodeProcessFrame(line.slice(framePrefix.length), frameToken);
+			if (!parsed.ok) {
+				reportPendingInvalidFrame();
+				pendingInvalidFrame = new Error(
+					`JavaScript kernel process emitted an invalid frame: ${parsed.error.message}`,
+				);
+				return;
+			}
+			reportPendingInvalidFrame();
+			const message = parsed.message;
+			if (!isKernelToHostMessage(message)) return;
+			for (const handler of [...messageHandlers]) handler(message);
+		},
+		// Crash causes are read by the listener below, which stays attached until stderr ends.
+		onStderr: () => {},
+		onExit: (_process, code, signal) => {
+			pendingInvalidFrame = undefined;
+			// A dead child's last stderr bytes can still be in flight when its exit is observed: settle once stderr has
+			// ended (bounded), so the cause it reported is not replaced by the bare exit.
+			void stderrEnded(child.stderr, STDERR_DRAIN_GRACE_MS).then(() => {
+				// The child's own report of what killed it, as worker mode reports a thread's error; else the exit itself.
+				const error = crashCause ?? new JavaScriptWorkerExitedError(code ?? -1, signal);
+				for (const handler of [...errorHandlers]) handler(error);
+			});
+		},
+		onError: (_process, error) => {
+			for (const handler of [...errorHandlers]) handler(error);
+		},
+	});
+	// The token is the first line the entry reads, before any cell can run.
+	subprocess.send(`${frameToken}\n`);
+	return {
+		mode: "process",
+		get pid() {
+			return child.pid;
+		},
+		postMessage(message) {
+			subprocess.send(`${JSON.stringify(message)}\n`);
+		},
+		onMessage(handler) {
+			messageHandlers.add(handler);
+			return () => {
+				messageHandlers.delete(handler);
+			};
+		},
+		onError(handler) {
+			errorHandlers.add(handler);
+			return () => {
+				errorHandlers.delete(handler);
+			};
+		},
+		async terminate() {
+			const exited = await subprocess.shutdown(`${JSON.stringify({ type: "close" })}\n`);
+			if (!exited) await subprocess.terminate("SIGKILL", PROCESS_CLOSE_GRACE_MS);
+		},
+	};
+}
+
+const STDERR_TAIL_CHARS = 16 * 1024;
+const STDERR_DRAIN_GRACE_MS = 1_000;
+
+/** Resolves when the stream has ended or closed, or after the grace period, whichever comes first. */
+function stderrEnded(stream: NodeJS.ReadableStream, graceMs: number): Promise<void> {
+	if (("readableEnded" in stream && stream.readableEnded === true) || ("closed" in stream && stream.closed === true)) {
+		return Promise.resolve();
+	}
+	return new Promise((resolve) => {
+		const done = () => {
+			clearTimeout(timer);
+			stream.removeListener("end", done);
+			stream.removeListener("close", done);
+			resolve();
+		};
+		const timer = setTimeout(done, graceMs);
+		stream.once("end", done);
+		stream.once("close", done);
+	});
+}
+const BIGINT_MARKER = "\u0000senpi:bigint:";
+const UNDEFINED_MARKER = "\u0000senpi:undefined:";
+const BIGINT_DIGITS = /^-?\d+$/;
+
+/**
+ * A frame's `BigInt` and `undefined` values travel as markers (see process-entry.js `replacer`). They are revived
+ * before the frame is checked against the bridge schema: an optional field the child left `undefined` (a cell whose
+ * value is `undefined` has no `valueRepr`) arrives as a marker, and checked as-is it would fail the schema.
+ */
+function decodeProcessFrame(line: string, token: string): ReturnType<typeof validateBridgeMessage> {
+	const parsed = parseBridgeJsonLine(line);
+	if (!parsed.ok) return parsed;
+	const value = parsed.value;
+	if (typeof value === "object" && value !== null) reviveFrameValues(value, token);
+	return validateBridgeMessage(value);
+}
+
+/** The cause the child reported on stderr just before exiting (see process-entry.js `reportCrash`). */
+function crashCauseFrom(stderr: string, token: string): Error | undefined {
+	const prefix = `senpi-kernel-crash ${token} `;
+	const line = stderr.split("\n").find((candidate) => candidate.startsWith(prefix));
+	if (line === undefined) return undefined;
+	try {
+		const cause: unknown = JSON.parse(line.slice(prefix.length));
+		if (typeof cause !== "object" || cause === null || !("message" in cause) || typeof cause.message !== "string") {
+			return undefined;
+		}
+		const error = new Error(cause.message);
+		if ("name" in cause && typeof cause.name === "string") error.name = cause.name;
+		return error;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Turns the child's markers back, in place, into the values JSON cannot carry (a BigInt, an `undefined` property or
+ * element), so a frame matches what worker mode's structured clone delivers. A marker carries this child's frame
+ * token, so a cell's own data that merely looks like one is delivered as it is.
+ */
+function reviveFrameValues(container: object, token: string): void {
+	const bigintKey = `${BIGINT_MARKER}${token}`;
+	const undefinedKey = `${UNDEFINED_MARKER}${token}`;
+	for (const key of Object.keys(container)) {
+		const value: unknown = Reflect.get(container, key);
+		if (typeof value !== "object" || value === null) continue;
+		const keys = Object.keys(value);
+		const digits: unknown = keys.length === 1 && keys[0] === bigintKey ? Reflect.get(value, bigintKey) : undefined;
+		if (typeof digits === "string" && BIGINT_DIGITS.test(digits)) Reflect.set(container, key, BigInt(digits));
+		else if (keys.length === 1 && keys[0] === undefinedKey) Reflect.set(container, key, undefined);
+		else reviveFrameValues(value, token);
+	}
+}

package/src/kernels/js/rejection-reports.js

@@ -0,0 +1,61 @@
+import { cellOfRejection } from "./cell-run-context.js";
+
+const STACK_FRAMES = 3;
+
+// An unhandled rejection is reported, never fatal: the kernel keeps its variables (the Node REPL and Jupyter norm). The
+// report names the cell that started the work when it is known and lands on the cell running now, or on the next one.
+// A burst is folded into one report plus a count, so a stopped loop cannot flood a cell's output.
+export function createRejectionReports({ activeCell, emitText }) {
+	let waiting = null;
+	const shownInCell = new WeakMap();
+
+	function report(reason) {
+		const text = describe(reason, cellOfRejection(reason), activeCell());
+		const cell = activeCell();
+		if (cell === null || cell.released) {
+			if (waiting === null) waiting = { text, more: 0 };
+			else waiting.more++;
+			return;
+		}
+		const shown = shownInCell.get(cell) ?? 0;
+		shownInCell.set(cell, shown + 1);
+		if (shown === 0) emitText(text);
+	}
+
+	return {
+		report,
+		startCell(cell) {
+			if (waiting === null) return;
+			emitText(`${waiting.text}${moreLine(waiting.more)}`);
+			shownInCell.set(cell, 1);
+			waiting = null;
+		},
+		finishCell(cell) {
+			const shown = shownInCell.get(cell) ?? 0;
+			if (shown > 1) emitText(moreLine(shown - 1));
+		},
+	};
+}
+
+function moreLine(more) {
+	return more === 0 ? "" : `... and ${more} more unhandled promise ${more === 1 ? "rejection" : "rejections"}\n`;
+}
+
+function describe(reason, origin, running) {
+	const where =
+		origin === undefined
+			? "(the cell that started it is unknown)"
+			: origin === running && !origin.released
+				? "in this cell"
+				: `from cell ${origin.cellId}${origin.released ? ", after it was stopped" : ""}`;
+	return `Unhandled promise rejection ${where}: ${summary(reason)}\n`;
+}
+
+function summary(reason) {
+	if (!(reason instanceof Error)) return String(reason);
+	const frames = (reason.stack ?? "")
+		.split("\n")
+		.filter((line) => line.trim().startsWith("at "))
+		.slice(0, STACK_FRAMES);
+	return [`${reason.name}: ${reason.message}`, ...frames.map((line) => `    ${line.trim()}`)].join("\n");
+}

package/src/kernels/js/run-queue.ts

@@ -1,5 +1,6 @@
 import type { EvalStatusEvent, KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { JavaScriptRunInput } from "./kernel-contract.ts";
+import { crashedResult } from "./worker-host.ts";
 
 type ResultMessage = Extract<KernelToHostMessage, { type: "result" }>;
 
@@ -83,6 +84,12 @@ export class JavaScriptRunQueue {
 		return Math.max(0, Math.round(finishedAtMs - run.startedAtMs));
 	}
 
+	/** Settles `run` as crashed with `error`: the worker died under it. */
+	settleCrashed(run: PendingJavaScriptRun, error: Error): void {
+		this.releaseActive(run);
+		this.settle(run, crashedResult(run.input.cellId, error, this.durationMs(run, performance.now())));
+	}
+
 	releaseActive(run: PendingJavaScriptRun): boolean {
 		if (this.#active !== run) return false;
 		this.#active = null;

package/src/kernels/js/worker-core.js

@@ -1,9 +1,13 @@
+import { installCellOwnership } from "./cell-ownership.js";
+import { releaseCell, releasedCellError, runInCell } from "./cell-run-context.js";
 import { kernelToolCallContext } from "./kernel-tools-context.js";
 import { kernelToolError } from "./kernel-tools-errors.js";
 import { createKernelToolPump } from "./kernel-tools-pump.js";
 import { hostDeniedError, hostToolRefusal } from "./kernel-tools-scope.js";
 import { installSessionCwd } from "./worker-cwd.js";
+import { installPackageResolver } from "./worker-package-resolve.js";
 import { createHeapProbe } from "./worker-heap.js";
+import { createRejectionReports } from "./rejection-reports.js";
 import { createWorkerMemory } from "./worker-memory.js";
 import { JsWorkerRuntime } from "./worker-runtime.js";
 import { installKernelWebView } from "./worker-webview.js";
@@ -28,10 +32,17 @@ const SESSION_ENVIRONMENT_KEYS = [
 ];
 
 export function createWorkerCore(transport, options) {
+	const restoreOwnership = installCellOwnership();
 	let runtime = null;
 	let memory = null;
 	let heapProbe = null;
 	let activeCell = null;
+	const rejections = createRejectionReports({
+		activeCell: () => activeCell,
+		emitText: (data) => emit({ type: "text", stream: "stderr", data }),
+	});
+	const reportRejection = (reason) => rejections.report(reason);
+	process.on("unhandledRejection", reportRejection);
 	const pendingTools = new Map();
 	const pendingWebViewPorts = new Map();
 	const nestedInvokes = new Map();
@@ -45,23 +56,38 @@ export function createWorkerCore(transport, options) {
 		transport.send(message);
 	}
 
+	function stopProblem(cell, what, error) {
+		const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+		emit({ type: "text", stream: "stderr", data: `Stopping cell ${cell.cellId}: ${what}: ${detail}\n` });
+	}
+
 	async function runCell(message) {
 		if (!runtime) {
 			emit({ type: "result", cellId: message.cellId, ok: false, error: { message: "JS runtime not initialized" }, durationMs: 0 });
 			return;
 		}
 		const startedAtMs = performance.now();
-		activeCell = { cellId: message.cellId, interruption: null };
+		const release = Promise.withResolvers();
+		const cell = { cellId: message.cellId, interruption: null, released: false, release: release.reject };
+		activeCell = cell;
+		rejections.startCell(cell);
 		try {
-			const value = await runtime.run(message.code, message.cellId, {
-				emit,
-				callTool: async (toolName, args) => await callTool(toolName, args),
-			});
+			const run = runInCell(cell, () =>
+				runtime.run(message.code, message.cellId, {
+					emit: (event) => {
+						if (releasedCellError() === undefined) emit(event);
+					},
+					callTool: async (toolName, args) => await callTool(toolName, args),
+				}),
+			);
+			const value = await Promise.race([run, release.promise]);
+			rejections.finishCell(cell);
 			emit({ type: "result", cellId: message.cellId, ok: true, valueRepr: valueRepr(value), durationMs: durationMs(startedAtMs), ...memoryReport() });
 		} catch (error) {
+			rejections.finishCell(cell);
 			emit({ type: "result", cellId: message.cellId, ok: false, error: bridgeError(error), durationMs: durationMs(startedAtMs), ...memoryReport() });
 		} finally {
-			activeCell = null;
+			if (activeCell === cell) activeCell = null;
 		}
 	}
 
@@ -70,6 +96,8 @@ export function createWorkerCore(transport, options) {
 	}
 
 	async function callTool(toolName, args) {
+		const released = releasedCellError();
+		if (released !== undefined) throw released;
 		const nested = kernelToolCallContext.getStore();
 		if (!nested && activeCell?.interruption) throw activeCell.interruption;
 		if (nested?.signal.aborted) throw nested.signal.reason;
@@ -104,6 +132,17 @@ export function createWorkerCore(transport, options) {
 		}
 		kernelTools.abortAll(kernelToolError("kernel_tool_stale", interruption.message));
 		runtime.interrupt();
+		// A free event loop with no Bun.$ wait can let the cell go and keep the VM. A Bun.$ wait keeps the
+		// restart (#2453): the shell cannot be cancelled, so only retiring the worker ends it.
+		if (runtime.shellWaitActive) return;
+		const cell = activeCell;
+		for (const error of releaseCell(cell)) stopProblem(cell, "a resource it opened would not close", error);
+		// The result settles after the cell's children are gone, so the next cell never overlaps them. A failed release
+		// is reported as such, never left to surface as an unhandled rejection blamed on the stopped cell.
+		void runtime
+			.release()
+			.catch((error) => stopProblem(cell, "releasing its work failed", error))
+			.finally(() => cell.release(interruption));
 	}
 
 	function acknowledgeInterrupt() {
@@ -127,8 +166,9 @@ export function createWorkerCore(transport, options) {
 		}
 		if (message.type === "init") {
 			applySessionEnvironment(message.sessionEnv);
-			installSessionCwd(options.cwd);
+			installSessionCwd(options.cwd, options.cwdInstallOptions);
 			installKernelWebView(requestWebViewPort);
+			installPackageResolver();
 			runtime = new JsWorkerRuntime({
 				cwd: options.cwd,
 				parallelPoolWidth: options.parallelPoolWidth,
@@ -137,12 +177,15 @@ export function createWorkerCore(transport, options) {
 				kernelGeneration: message.kernelGeneration ?? 1,
 				hostToolNames: message.hostToolNames ?? [],
 				foreignLanguageNames: message.foreignLanguageNames ?? [],
+				kernelToolsDisabled: message.kernelToolsDisabled === true,
 				onChildEvent: (event) => emit({ type: "status", event: { op: CHILD_LIFECYCLE_OP, ...event } }),
 				onShellWaitChange: () => {
 					if (activeCell?.interruption) acknowledgeInterrupt();
 				},
 			});
-			if (message.memory) {
+			// A process-mode kernel measures its memory host-side as a footprint; the in-heap
+			// worker reading would contradict it, so the child keeps memory collection off.
+			if (message.memory && !options.processModeMemory) {
 				memory = createWorkerMemory(message.memory, (report) => emit({ type: "status", event: { op: MEMORY_COLLECTED_OP, ...report } }));
 				memory.captureBaseline();
 			}
@@ -181,6 +224,8 @@ export function createWorkerCore(transport, options) {
 	return {
 		dispose() {
 			unsubscribe();
+			restoreOwnership();
+			process.off("unhandledRejection", reportRejection);
 			globalThis.__senpi_restore_console__?.();
 		},
 	};

package/src/kernels/js/worker-cwd.js

@@ -52,8 +52,11 @@ const FS_PATH_ARGS = {
 const CHILD_PROCESS_FILE_ARGS = ["spawn", "spawnSync", "execFile", "execFileSync", "fork"];
 const CHILD_PROCESS_COMMAND_ARGS = ["exec", "execSync"];
 
-export function installSessionCwd(cwd) {
-	if (isMainThread) throw new Error("installSessionCwd must only run inside a kernel worker thread");
+export function installSessionCwd(cwd, options) {
+	// A process-mode kernel child IS the main thread; the worker guard relaxes only for that entry.
+	if (isMainThread && options?.allowMainThread !== true) {
+		throw new Error("installSessionCwd must only run inside a kernel worker thread");
+	}
 	const root = resolve(cwd);
 	const rootBytes = Buffer.from(root.endsWith(sep) ? root : `${root}${sep}`);
 	// fs also takes Buffer/Uint8Array paths; a relative one gets the session root prepended as bytes,

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

@@ -1,6 +1,7 @@
 import type { EventEmitter } from "node:events";
 import { Worker } from "node:worker_threads";
 import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import { describeExit } from "../shared/kernel-death.ts";
 import type { WorkerLike } from "./inline-worker.ts";
 import type { JavaScriptKernelMode } from "./kernel-contract.ts";
 
@@ -22,10 +23,16 @@ export class WorkerStartupCancelledError extends Error {
 export class JavaScriptWorkerExitedError extends Error {
 	readonly name = "JavaScriptWorkerExitedError";
 	readonly exitCode: number;
+	readonly exitSignal: string | null;
 
-	constructor(exitCode: number) {
-		super(`JavaScript worker exited with code ${exitCode}`);
+	constructor(exitCode: number, exitSignal: string | null = null) {
+		super(
+			exitSignal === null
+				? `JavaScript worker exited with code ${exitCode}`
+				: `JavaScript worker exited with ${describeExit(null, exitSignal)} (code ${exitCode})`,
+		);
 		this.exitCode = exitCode;
+		this.exitSignal = exitSignal;
 	}
 }
 

package/src/kernels/js/worker-indirect-eval.js

@@ -1,4 +1,13 @@
-import { findShadowedGlobalName } from "./worker-shadow-guard.js";
+import { isKernelGlobal } from "./worker-shadow-guard.js";
+
+// A cell may declare a name the kernel or the platform already defines (`const log = []`, `const fetch = ...`). The
+// binding lives in a per-kernel user scope that later cells read through `with`, so it persists for the user's cells
+// while the kernel, its prelude and imported libraries keep the original global. `delete <name>` in a cell restores it.
+const USER_SCOPE_KEY = Symbol.for("senpi.kernel.userScope");
+const USER_SCOPE = "__senpiUserScope";
+// The persistence rewrite itself writes through `globalThis`, so that one name cannot be shadowed.
+const UNSHADOWABLE = new Set(["globalThis"]);
+let shadowedNames = null;
 
 export function indirectEval(source, filename) {
 	const withPragma = filename ? `${source}\n//# sourceURL=${filename}` : source;
@@ -11,10 +20,31 @@ export async function awaitMaybePromise(value) {
 	return await value;
 }
 
-export function wrapUserCode(code) {
-	const persistentCode = persistTopLevelDeclarations(code);
-	if (scanTopLevelStatements(persistentCode).hasTopLevelReturn) return `(async () => {\n${persistentCode}\n})()`;
-	return `(async () => {\n${captureLastExpression(persistentCode)}\n})()`;
+/** Wraps a cell for persistent evaluation; `shadowed` receives the kernel-global names the cell declares. */
+export function wrapUserCode(code, shadowed = []) {
+	shadowedNames = shadowed;
+	let persistentCode;
+	try {
+		persistentCode = persistTopLevelDeclarations(code);
+	} finally {
+		shadowedNames = null;
+	}
+	const body = scanTopLevelStatements(persistentCode).hasTopLevelReturn ? persistentCode : captureLastExpression(persistentCode);
+	const scope = globalThis[USER_SCOPE_KEY];
+	if (shadowed.length === 0 && (scope === undefined || Object.keys(scope).length === 0)) return `(async () => {\n${body}\n})()`;
+	globalThis[USER_SCOPE_KEY] ??= Object.create(null);
+	return `(async (${USER_SCOPE}) => { with (${USER_SCOPE}) { return await (async () => {\n${body}\n})(); } })(globalThis[Symbol.for("senpi.kernel.userScope")])`;
+}
+
+function persistTarget(name) {
+	if (UNSHADOWABLE.has(name)) {
+		throw new Error(
+			`eval cell declares top-level \`${name}\`, which the JS kernel needs to keep cell variables between cells. Rename the binding (for example \`${name}Local\`).`,
+		);
+	}
+	if (!isKernelGlobal(name)) return `globalThis[${JSON.stringify(name)}]`;
+	if (shadowedNames !== null && !shadowedNames.includes(name)) shadowedNames.push(name);
+	return `${USER_SCOPE}[${JSON.stringify(name)}]`;
 }
 
 const IDENTIFIER_START_RE = /[$_\p{ID_Start}]/u;
@@ -267,14 +297,8 @@ function rewriteDeclaration(code, declarationStart, start, end, keyword) {
 		const bindings = [];
 		collectPatternNames(pattern, bindings);
 		if (bindings.length === 0) return undefined;
-		const shadowed = findShadowedGlobalName(bindings);
-		if (shadowed !== undefined) {
-			throw new Error(
-				`eval cell declares top-level \`${shadowed}\`, but a global with that name already exists in the JS kernel. Persisting it would replace that global for every later cell. Rename the binding (for example \`${shadowed}Local\`), or assign globalThis.${shadowed} explicitly if replacing it is truly intended.`,
-			);
-		}
 		if (preserveDeclaration) {
-			for (const name of bindings) assignments.push(`globalThis[${JSON.stringify(name)}] = ${name};`);
+			for (const name of bindings) assignments.push(`${persistTarget(name)} = ${name};`);
 			continue;
 		}
 		const target = rewriteBindingPattern(pattern);
@@ -296,7 +320,7 @@ function rewriteBindingPattern(source) {
 		const target = rewriteBindingPattern(pattern.slice(0, defaultStart));
 		return target === undefined ? undefined : `${target} = ${pattern.slice(defaultStart + 1).trim()}`;
 	}
-	if (IDENTIFIER_RE.test(pattern)) return `globalThis[${JSON.stringify(pattern)}]`;
+	if (IDENTIFIER_RE.test(pattern)) return persistTarget(pattern);
 	if (pattern.startsWith("{") && pattern.endsWith("}")) {
 		const properties = splitPatternElements(pattern.slice(1, -1)).map((property) => rewriteObjectBinding(property));
 		if (properties.some((property) => property === undefined)) return undefined;