@code-yeongyu/senpi-codemode 2026.10.10 → 2026.10.11

package/src/kernels/js/process-memory-host.ts

@@ -0,0 +1,83 @@
+import type { KernelMemoryThresholds } from "../../bridge/memory-protocol.ts";
+import { restartNotice } from "../shared/kernel-death.ts";
+import { KernelMemoryPolicy } from "../shared/kernel-memory.ts";
+import type { ResultMessage } from "./kernel-contract.ts";
+
+export interface JavaScriptProcessMemoryReading {
+	readonly liveBytes: number;
+	readonly measure: "footprint";
+}
+
+export type JavaScriptProcessFootprintReader = (pid: number) => { readonly bytes: number } | undefined;
+
+// Host-side memory for a process-mode js kernel: the in-heap worker reading cannot cross a process
+// boundary, so the host reads the child's footprint (the py/rb/jl pattern) and the shared policy
+// applies the notice and the ceiling. A crashed child re-announces itself through the restart notice
+// on the next result, mirroring ReplaceableKernel's restarted tag.
+export class JavaScriptProcessMemoryHost {
+	readonly #policy: KernelMemoryPolicy;
+	readonly #readFootprint: JavaScriptProcessFootprintReader | undefined;
+	#lastLiveBytes: number | undefined;
+	#restarted: string | null = null;
+
+	constructor(thresholds: KernelMemoryThresholds, readFootprint?: JavaScriptProcessFootprintReader) {
+		this.#readFootprint = readFootprint;
+		this.#policy = new KernelMemoryPolicy("js", thresholds, { collects: readFootprint === undefined });
+	}
+
+	get thresholds(): KernelMemoryThresholds {
+		return this.#policy.thresholds;
+	}
+
+	lastLiveBytes(pid: () => number | undefined): number | undefined {
+		const reading = this.#read(pid);
+		if (reading !== undefined) this.#lastLiveBytes = reading.liveBytes;
+		return this.#lastLiveBytes;
+	}
+
+	query(pid: () => number | undefined): JavaScriptProcessMemoryReading | undefined {
+		const reading = this.#read(pid);
+		if (reading !== undefined) this.#lastLiveBytes = reading.liveBytes;
+		return reading;
+	}
+
+	settled(message: ResultMessage, pid: () => number | undefined): ResultMessage {
+		const reading = this.#read(pid);
+		if (reading !== undefined) this.#lastLiveBytes = reading.liveBytes;
+		let result: ResultMessage = message;
+		if (reading !== undefined) {
+			const report = { liveBytes: reading.liveBytes, measure: "footprint" as const };
+			result = { ...result, memory: this.#policy.annotate(report) };
+		}
+		if (this.#restarted !== null) {
+			const notice = this.#restarted;
+			this.#restarted = null;
+			result = { ...result, notice, kernelState: "restarted" };
+		}
+		return result;
+	}
+
+	claimRecycle(idle: boolean): boolean {
+		if (!idle || !this.#policy.recyclePending) return false;
+		this.#policy.recycleStarted();
+		return true;
+	}
+
+	markRestarted(error: Error): void {
+		this.#restarted = restartNotice("js", error.message);
+	}
+
+	workerLost(): void {
+		this.#policy.kernelRetired();
+		this.#lastLiveBytes = undefined;
+	}
+
+	#read(pid: () => number | undefined): JavaScriptProcessMemoryReading | undefined {
+		if (this.#readFootprint === undefined) return undefined;
+		const current = pid();
+		if (current === undefined) return undefined;
+		const footprint = this.#readFootprint(current);
+		if (footprint === undefined) return undefined;
+		return { liveBytes: Math.round(footprint.bytes), measure: "footprint" };
+	}
+}

package/src/kernels/js/process-tree-host.ts

@@ -1,4 +1,5 @@
 import { execFile } from "node:child_process";
+import { killWindowsTree, listWindowsRows } from "./windows-tree-kill-host.ts";
 
 // Host-side twin of worker-runtime's `process-tree.js`. The worker file must stay plain
 // JavaScript (a Node worker thread spawned from a `.js` entry has no TypeScript loader), and
@@ -100,7 +101,7 @@ function sleep(ms: number): Promise<void> {
 /**
  * Retire whole process trees: snapshot the descendants first (a parent that dies before the
  * snapshot would reparent them to init), SIGTERM everything, wait `graceMs` for the pids to
- * disappear, then SIGKILL whatever is left. On Windows `taskkill /T /F` does the walk and the kill.
+ * disappear, then SIGKILL whatever is left. On Windows the checked tree is killed by pid (`windows-tree-kill.js`).
  */
 export async function terminateProcessTrees(
 	roots: readonly number[],
@@ -109,7 +110,8 @@ export async function terminateProcessTrees(
 	const liveRoots = roots.filter(isProcessAlive);
 	if (liveRoots.length === 0) return;
 	if (process.platform === "win32") {
-		for (const pid of liveRoots) await taskkillTree(pid);
+		const listing = listWindowsRows();
+		for (const pid of liveRoots) await killWindowsTree(pid, listing);
 		return;
 	}
 	const table = await readProcessTable();
@@ -150,9 +152,3 @@ async function withoutZombies(pids: number[]): Promise<number[]> {
 	}
 	return pids.filter((pid) => !zombies.has(pid));
 }
-
-function taskkillTree(pid: number): Promise<void> {
-	return new Promise((resolve) => {
-		execFile("taskkill", ["/T", "/F", "/PID", String(pid)], { windowsHide: true }, () => resolve());
-	});
-}

package/src/kernels/js/process-tree.d.ts

@@ -22,3 +22,14 @@ export function collectDescendants(table: ProcessTable, roots: readonly number[]
 export function ownedRoots(table: ProcessTable, parentPid: number, roots: readonly number[]): number[];
 
 export function terminateProcessTrees(roots: readonly number[], options: TerminateProcessTreesOptions): Promise<void>;
+export interface CellProcessGroup {
+	readonly pgid: number;
+	readonly leaderExited: boolean;
+}
+export interface TerminateProcessGroupsOptions {
+	readonly graceMs: number;
+}
+export function terminateProcessGroups(
+	groups: readonly CellProcessGroup[],
+	options: TerminateProcessGroupsOptions,
+): Promise<void>;

package/src/kernels/js/process-tree.js

@@ -1,4 +1,5 @@
 import { execFile } from "node:child_process";
+import { killWindowsTree, listWindowsRows } from "./windows-tree-kill.js";
 
 // Plain JS (with process-tree.d.ts) because the worker runtime imports it and
 // worker files cannot import TypeScript; the host imports the same module so a
@@ -6,6 +7,8 @@ import { execFile } from "node:child_process";
 
 const PS_MAX_BUFFER = 16 * 1024 * 1024;
 const EXIT_POLL_MS = 25;
+// A hung `ps` must not hold a cell's retirement; empty output then means nothing is signalled.
+const PS_LOOKUP_TIMEOUT_MS = 2_000;
 const ZOMBIE_CHECK_INTERVAL_MS = 250;
 
 export function isProcessAlive(pid) {
@@ -30,7 +33,7 @@ export function signalProcess(pid, signal) {
 
 /**
  * Parent-to-children map of every process visible to `ps`. Windows has no
- * `ps`; callers there kill through `taskkill /T`, which walks the tree itself.
+ * `ps`; callers there kill the checked tree from `windows-tree-kill.js`.
  */
 export async function readProcessTable() {
 	if (process.platform === "win32") return new Map();
@@ -78,13 +81,14 @@ function sleep(ms) {
  * Retire whole process trees: snapshot the descendants first (a parent that
  * dies before the snapshot would reparent them to init), SIGTERM everything,
  * wait `graceMs` for `settled` (or for the pids to disappear), then SIGKILL
- * whatever is left. On Windows `taskkill /T /F` does the walk and the kill.
+ * whatever is left. On Windows the checked tree is killed by pid (`windows-tree-kill.js`).
  */
 export async function terminateProcessTrees(roots, options) {
 	const liveRoots = roots.filter(isProcessAlive);
 	if (liveRoots.length === 0) return;
 	if (process.platform === "win32") {
-		for (const pid of liveRoots) await taskkillTree(pid);
+		const listing = listWindowsRows();
+		for (const pid of liveRoots) await killWindowsTree(pid, listing);
 		return;
 	}
 	const table = await readProcessTable();
@@ -98,6 +102,52 @@ export async function terminateProcessTrees(roots, options) {
 	await waitForExit(survivors, options.killWaitMs ?? options.graceMs, options.settled);
 }
 
+/**
+ * Retire whole process groups the worker created (POSIX): SIGTERM each group that still has members, wait `graceMs`,
+ * then SIGKILL what is left. A group whose leader already exited is skipped while a live process holds the leader's
+ * pid, since that pid was reused. The agent's own group is never signalled.
+ */
+export async function terminateProcessGroups(groups, options) {
+	if (process.platform === "win32") return;
+	const ours = (group) => groupHasMembers(group.pgid) && !(group.leaderExited && isProcessAlive(group.pgid));
+	const candidates = groups.filter((group) => Number.isInteger(group.pgid) && group.pgid > 1 && ours(group));
+	if (candidates.length === 0) return;
+	// Without the agent's own group there is no way to rule it out, so nothing is signalled.
+	const ownGroup = await processGroupOf(process.pid);
+	if (ownGroup === undefined) return;
+	const live = candidates.filter((group) => group.pgid !== ownGroup && ours(group));
+	for (const group of live) signalGroup(group.pgid, "SIGTERM");
+	const deadline = Date.now() + options.graceMs;
+	let remaining = live;
+	while (remaining.length > 0 && Date.now() < deadline) {
+		await sleep(EXIT_POLL_MS);
+		remaining = remaining.filter(ours);
+	}
+	for (const group of remaining) signalGroup(group.pgid, "SIGKILL");
+}
+
+function groupHasMembers(pgid) {
+	try {
+		process.kill(-pgid, 0);
+		return true;
+	} catch (error) {
+		return isRecord(error) && error.code === "EPERM";
+	}
+}
+
+function signalGroup(pgid, signal) {
+	try {
+		process.kill(-pgid, signal);
+	} catch {
+		// The group emptied between the check and the signal.
+	}
+}
+
+async function processGroupOf(pid) {
+	const text = (await ps(["-o", "pgid=", "-p", String(pid)], { timeout: PS_LOOKUP_TIMEOUT_MS })).trim();
+	return /^\d+$/u.test(text) ? Number(text) : undefined;
+}
+
 // `kill(pid, 0)` still succeeds for a zombie, and a child whose owning worker is
 // blocked or gone is never reaped, so liveness also consults `ps` state.
 async function waitForExit(pids, graceMs, settled) {
@@ -132,19 +182,14 @@ async function withoutZombies(pids) {
 }
 
 // `ps -p` exits non-zero when any listed pid is gone but still prints the rest.
-function ps(args) {
+function ps(args, options = {}) {
 	return new Promise((resolve) => {
-		execFile("ps", args, { maxBuffer: PS_MAX_BUFFER, windowsHide: true }, (_error, output) =>
+		execFile("ps", args, { maxBuffer: PS_MAX_BUFFER, windowsHide: true, ...options }, (_error, output) =>
 			resolve(typeof output === "string" ? output : String(output ?? "")),
 		);
 	});
 }
 
-function taskkillTree(pid) {
-	return new Promise((resolve) => {
-		execFile("taskkill", ["/T", "/F", "/PID", String(pid)], { windowsHide: true }, () => resolve());
-	});
-}
 
 function isRecord(value) {
 	return typeof value === "object" && value !== null;

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;