@code-yeongyu/senpi-codemode 2026.10.9 → 2026.10.10-3

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-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/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

@@ -3,6 +3,7 @@ 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 { createWorkerMemory } from "./worker-memory.js";
 import { JsWorkerRuntime } from "./worker-runtime.js";
@@ -127,8 +128,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 +139,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();
 			}

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-package-resolve.js

@@ -0,0 +1,153 @@
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { isBuiltin } from "node:module";
+import { dirname, join, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// A cell's bare import runs `import()` from this worker's own module, so the runtime resolves it from Senpi's install
+// tree, not the session's project or its managed package revision. This resolver walks `node_modules` from each root
+// the cell names, in order, and resolves the package entry the way ESM does (the `exports` field with import
+// conditions), so ESM-only packages load and the first root that has the package wins.
+const RESOLVE_PACKAGE = Symbol.for("senpi.kernel.resolvePackage");
+const CONDITIONS = typeof globalThis.Bun === "object" ? ["bun", "node", "import", "default"] : ["node", "import", "default"];
+
+function isFile(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+
+function isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+function splitSpecifier(specifier) {
+	const parts = specifier.split("/");
+	const nameParts = specifier.startsWith("@") ? 2 : 1;
+	if (parts.length < nameParts || parts.slice(0, nameParts).some((part) => part === "" || part === "." || part === ".."))
+		return undefined;
+	const rest = parts.slice(nameParts).join("/");
+	return { name: parts.slice(0, nameParts).join("/"), subpath: rest === "" ? "." : `./${rest}` };
+}
+
+function conditionalTarget(target) {
+	if (typeof target === "string") return target;
+	if (Array.isArray(target)) {
+		for (const candidate of target) {
+			const resolved = conditionalTarget(candidate);
+			if (resolved !== undefined) return resolved;
+		}
+		return undefined;
+	}
+	if (target === null || typeof target !== "object") return undefined;
+	for (const [condition, value] of Object.entries(target)) {
+		if (condition !== "default" && !CONDITIONS.includes(condition)) continue;
+		const resolved = conditionalTarget(value);
+		if (resolved !== undefined) return resolved;
+	}
+	return undefined;
+}
+
+function exportsTarget(exportsField, subpath) {
+	const subpathKeyed =
+		exportsField !== null &&
+		typeof exportsField === "object" &&
+		!Array.isArray(exportsField) &&
+		Object.keys(exportsField).some((key) => key.startsWith("."));
+	if (!subpathKeyed) return subpath === "." ? conditionalTarget(exportsField) : undefined;
+	if (Object.hasOwn(exportsField, subpath)) return conditionalTarget(exportsField[subpath]);
+	let best;
+	for (const key of Object.keys(exportsField)) {
+		const star = key.indexOf("*");
+		if (star < 0 || key.includes("*", star + 1)) continue;
+		const prefix = key.slice(0, star);
+		const suffix = key.slice(star + 1);
+		if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix) || subpath.length < prefix.length + suffix.length)
+			continue;
+		if (best === undefined || prefix.length > best.prefix.length) {
+			best = { key, prefix, match: subpath.slice(prefix.length, subpath.length - suffix.length) };
+		}
+	}
+	if (best === undefined || hasInvalidSegment(best.match)) return undefined;
+	const target = conditionalTarget(exportsField[best.key]);
+	return target === undefined ? undefined : target.replaceAll("*", best.match);
+}
+
+// Node refuses a pattern match or target with "." / ".." / "node_modules" segments (ERR_INVALID_MODULE_SPECIFIER).
+function hasInvalidSegment(path) {
+	return path.split(/[\\/]/).some((segment) => segment === "." || segment === ".." || segment === "node_modules");
+}
+
+function legacyFile(path) {
+	for (const candidate of [path, `${path}.js`, `${path}.mjs`, `${path}.cjs`, join(path, "index.js")]) {
+		if (isFile(candidate)) return candidate;
+	}
+	return undefined;
+}
+
+function packageEntry(packageDir, subpath, specifier) {
+	let manifest;
+	try {
+		manifest = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8"));
+	} catch {
+		return legacyFile(join(packageDir, subpath === "." ? "index.js" : subpath));
+	}
+	if (manifest.exports !== undefined && manifest.exports !== null) {
+		const target = exportsTarget(manifest.exports, subpath);
+		if (typeof target !== "string" || !target.startsWith("./") || hasInvalidSegment(target.slice(2))) {
+			const error = new Error(`Package subpath '${subpath}' is not exported for import by '${specifier}'`);
+			error.code = "ERR_PACKAGE_PATH_NOT_EXPORTED";
+			throw error;
+		}
+		return join(packageDir, target);
+	}
+	if (subpath !== ".") return legacyFile(join(packageDir, subpath));
+	const moduleEntry = typeof globalThis.Bun === "object" && typeof manifest.module === "string" ? manifest.module : undefined;
+	const main = moduleEntry ?? (typeof manifest.main === "string" ? manifest.main : "index.js");
+	return legacyFile(join(packageDir, main));
+}
+
+function findPackageDir(name, rootUrl) {
+	let directory = fileURLToPath(rootUrl);
+	for (;;) {
+		const candidate = join(directory, "node_modules", name);
+		if (isDirectory(candidate)) return candidate;
+		const parent = dirname(directory);
+		if (parent === directory) return undefined;
+		directory = parent;
+	}
+}
+
+/**
+ * The file URL the bare `specifier` resolves to from the first of `rootUrls` whose `node_modules` chain has its
+ * package, or undefined when it names a builtin or no root has the package (the caller then imports it natively).
+ */
+export function resolvePackage(specifier, rootUrls) {
+	if (specifier.includes(":") || isBuiltin(specifier)) return undefined;
+	const parts = splitSpecifier(specifier);
+	if (parts === undefined) return undefined;
+	for (const rootUrl of rootUrls) {
+		if (typeof rootUrl !== "string") continue;
+		const packageDir = findPackageDir(parts.name, rootUrl);
+		if (packageDir === undefined) continue;
+		const entry = packageEntry(packageDir, parts.subpath, specifier);
+		if (entry === undefined) continue;
+		let real = entry;
+		try {
+			real = realpathSync(entry);
+		} catch {
+			// A missing target fails in the import itself, with the runtime's own error.
+		}
+		return pathToFileURL(real.endsWith(sep) ? real.slice(0, -1) : real).href;
+	}
+	return undefined;
+}
+
+export function installPackageResolver() {
+	globalThis[RESOLVE_PACKAGE] = resolvePackage;
+}

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

@@ -47,6 +47,7 @@ export class JsWorkerRuntime {
 			generation: options.kernelGeneration ?? 1,
 			hostToolNames: options.hostToolNames ?? [],
 			foreignLanguageNames: options.foreignLanguageNames ?? [],
+			disabled: options.kernelToolsDisabled === true,
 		});
 		this.#installGlobals();
 	}

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

@@ -4,6 +4,7 @@ import type { WorkerLike } from "./inline-worker.ts";
 import { retireWorker, type WorkerRetirement } from "./interrupt-bounds.ts";
 import type { JavaScriptKernelMode } from "./kernel-contract.ts";
 import type { JavaScriptKernelOptions } from "./local-module-loader.ts";
+import type { JavaScriptProcessWorker } from "./process-worker.ts";
 import { KernelWebViewClients } from "./webview-host.ts";
 import { WorkerStartupCancelledError } from "./worker-host.ts";
 import { startWorkerWithInlineFallback } from "./worker-startup.ts";
@@ -19,6 +20,7 @@ export class WorkerSlot {
 	readonly #options: JavaScriptKernelOptions;
 	readonly #listeners: WorkerSlotListeners;
 	#worker: WorkerLike | null = null;
+	#lastProcessPid: number | undefined;
 	#webViews: KernelWebViewClients | null = null;
 	#mode: JavaScriptKernelMode = "worker";
 	#generation = 0;
@@ -34,6 +36,12 @@ export class WorkerSlot {
 		return this.#mode;
 	}
 
+	get processPid(): number | undefined {
+		const worker = this.#worker;
+		if (worker?.mode === "process") return (worker as JavaScriptProcessWorker).pid;
+		return this.#lastProcessPid;
+	}
+
 	get present(): boolean {
 		return this.#worker !== null;
 	}
@@ -105,6 +113,7 @@ export class WorkerSlot {
 	#publish(worker: WorkerLike, generation: number): void {
 		if (!this.#listeners.isOpen() || generation !== this.#generation) throw new WorkerStartupCancelledError();
 		this.#worker = worker;
+		if (worker.mode === "process") this.#lastProcessPid = (worker as JavaScriptProcessWorker).pid;
 		const webViews = new KernelWebViewClients((message, transfer) => worker.postMessage(message, transfer));
 		this.#webViews = webViews;
 		worker.onMessage((message) => {