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

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-require.d.ts

@@ -0,0 +1,19 @@
+export interface CellRequireContext {
+	readonly cwdUrl: string;
+	readonly packageRootUrl?: string | null;
+}
+
+export interface CellResolve {
+	(specifier: string, options?: { readonly paths?: readonly string[] }): string;
+	paths(specifier: string): string[] | null;
+}
+
+export interface CellRequire {
+	(specifier: string): unknown;
+	readonly resolve: CellResolve;
+	readonly cache: Record<string, unknown>;
+}
+
+export function createCellRequire(context: () => CellRequireContext): CellRequire;
+
+export { createRequire } from "node:module";

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

@@ -0,0 +1,52 @@
+import { createRequire, isBuiltin } from "node:module";
+
+// `require` in a cell resolves the way `import` does there: builtins natively, relative paths from the cell's
+// directory, bare packages from the session's project first and then its managed package environment
+// (%bun add / %npm add). It uses the runtime's own CommonJS loader, so JSON files and the `require` export conditions
+// behave as in Node. Like Node's own `require`, it carries `resolve`, `resolve.paths` and `cache`.
+export function createCellRequire(context) {
+	const requirers = () => {
+		const { cwdUrl, packageRootUrl } = context();
+		const fromCwd = createRequire(new URL("package.json", cwdUrl));
+		const fromPackages = packageRootUrl ? createRequire(new URL("package.json", packageRootUrl)) : undefined;
+		return { fromCwd, fromPackages };
+	};
+	const isPathLike = (name) => name.startsWith(".") || name.startsWith("/") || /^[A-Za-z]:[\\/]/.test(name);
+	// The one lookup both the call and `resolve` use, so they can never pick different copies of a package. Builtins
+	// (`fs`, `node:fs`, Bun's `bun:sqlite`) and paths resolve natively; a bare name the project does not have falls
+	// back to the managed environment, and a miss there reports the project's own not-found error.
+	const resolve = function resolve(specifier, options) {
+		const name = String(specifier);
+		const { fromCwd, fromPackages } = requirers();
+		if (isBuiltin(name) || isPathLike(name) || fromPackages === undefined || options?.paths !== undefined) {
+			return fromCwd.resolve(name, options);
+		}
+		try {
+			return fromCwd.resolve(name, options);
+		} catch (error) {
+			if (error?.code !== "MODULE_NOT_FOUND") throw error;
+			try {
+				return fromPackages.resolve(name, options);
+			} catch (fallback) {
+				throw fallback?.code === "MODULE_NOT_FOUND" ? error : fallback;
+			}
+		}
+	};
+	resolve.paths = (specifier) => {
+		const name = String(specifier);
+		const { fromCwd, fromPackages } = requirers();
+		const own = fromCwd.resolve.paths(name);
+		if (own === null || fromPackages === undefined || isPathLike(name)) return own;
+		return [...new Set([...own, ...(fromPackages.resolve.paths(name) ?? [])])];
+	};
+	// The call loads exactly what `resolve` names: a builtin id or an absolute file, through the runtime's loader.
+	const require = function require(specifier) {
+		return requirers().fromCwd(resolve(specifier));
+	};
+	require.resolve = resolve;
+	// One CommonJS cache per runtime: the cell's view is the loader's own, so deleting an entry forces a reload.
+	Object.defineProperty(require, "cache", { enumerable: true, get: () => createRequire(import.meta.url).cache });
+	return require;
+}
+
+export { createRequire };

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

@@ -1,4 +1,6 @@
 // allow: SIZE_OK — private runtime state and installed globals must stay in one worker module.
+import { pathToFileURL } from "node:url";
+import { createCellRequire, createRequire } from "./worker-require.js";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
 import { inspect } from "node:util";
@@ -31,6 +33,7 @@ export class JsWorkerRuntime {
 	#hooks = null;
 	#pendingDisplays = [];
 	#children = new Set();
+	#childrenStopping;
 	#shellWaits = new Set();
 	#onChildEvent;
 	#onShellWaitChange;
@@ -47,6 +50,7 @@ export class JsWorkerRuntime {
 			generation: options.kernelGeneration ?? 1,
 			hostToolNames: options.hostToolNames ?? [],
 			foreignLanguageNames: options.foreignLanguageNames ?? [],
+			disabled: options.kernelToolsDisabled === true,
 		});
 		this.#installGlobals();
 	}
@@ -65,30 +69,43 @@ export class JsWorkerRuntime {
 		try {
 			let prelude = "";
 			let cellCode = code;
+			let sourceName = cellId;
 			if (code.startsWith(PREPARED_CELL_PREFIX)) {
 				const prepared = JSON.parse(code.slice(PREPARED_CELL_PREFIX.length));
 				if (!isPlainObject(prepared) || typeof prepared.prelude !== "string" || typeof prepared.code !== "string") throw new Error("Invalid prepared JavaScript cell payload");
 				({ prelude, code: cellCode } = prepared);
+				if (typeof prepared.sourceFile === "string") sourceName = prepared.sourceFile;
 			}
 			if (prelude) indirectEval(prelude, PRELUDE_SOURCE_URL);
-			const value = await awaitMaybePromise(indirectEval(bindKernelBun(wrapUserCode(cellCode)), cellId));
+			const shadowed = [];
+			const source = bindKernelBun(wrapUserCode(cellCode, shadowed));
+			if (shadowed.length > 0) this.#emitText("stderr", shadowNote(shadowed));
+			const value = await awaitMaybePromise(indirectEval(source, sourceName));
 			await this.#drainPendingDisplays();
 			return value;
 		} finally {
-			this.#pendingDisplays = [];
-			// A child still running here has lost its only owner: the cell that
-			// spawned it is over, nothing will await it again, and it would be
-			// reparented to init. Retire it the way timeout and abort cleanup
-			// already do, unless the cell asked for a detached process.
-			await this.#terminateChildren();
-			this.#hooks = null;
+			// A released run finishing late must not clear the state of the cell running now.
+			if (this.#hooks === hooks) await this.release();
 		}
 	}
 
+	/** Ends the current run's ownership now: its displays, its hooks, and (unless detached) its child processes. */
+	async release() {
+		const hooks = this.#hooks;
+		this.#pendingDisplays = [];
+		// A child still running here has lost its only owner: the cell that
+		// spawned it is over, nothing will await it again, and it would be
+		// reparented to init. Retire it the way timeout and abort cleanup
+		// already do, unless the cell asked for a detached process.
+		await Promise.all([this.#childrenStopping, this.#terminateChildren()]);
+		this.#childrenStopping = undefined;
+		if (this.#hooks === hooks) this.#hooks = null;
+	}
+
 	interrupt() {
 		// The tree snapshot, SIGTERM, and SIGKILL escalation run on their own so
 		// the caller's interrupt latency stays that of the acknowledgement.
-		void this.#terminateChildren();
+		this.#childrenStopping = this.#terminateChildren();
 	}
 
 	#trackChild(child, spawnOptions) {
@@ -145,6 +162,17 @@ export class JsWorkerRuntime {
 			return isPlainObject(opts) && opts.handle === true ? handles.handle(value) : value;
 		};
 		globalThis.wait = async (list, options) => await handles.wait(list, options);
+		// The `%bun add` / `%npm add` installer as a call: same environment, receipt, cancellation and codes (senpi row 38).
+		globalThis.packages = Object.freeze({
+			install: async (manager, requirements, options = {}) => {
+				if (!isPlainObject(options)) throw new TypeError("packages.install(): options must be an object, e.g. { timeout: 120 }");
+				return await this.#callTool("__packages_install__", {
+					manager,
+					requirements,
+					...(options.timeout !== undefined ? { timeout: options.timeout } : {}),
+				});
+			},
+		});
 		globalThis.handle = value => handles.handle(value);
 		globalThis.tool = createToolNamespace(
 			(fn, metadata) => this.#tools.define(fn, metadata),
@@ -152,6 +180,8 @@ export class JsWorkerRuntime {
 			{ defined: () => this.#tools.defined(), undefine: (name) => this.#tools.undefine(name) },
 		);
 		globalThis.tools = globalThis.tool;
+		globalThis.require = createCellRequire(() => globalThis.__senpi_module_context__ ?? { cwdUrl: pathToFileURL(`${process.cwd()}/`).href });
+		globalThis.createRequire = createRequire;
 		const originalLog = console.log.bind(console);
 		const originalError = console.error.bind(console);
 		const originalStdoutWrite = process.stdout.write;
@@ -420,6 +450,12 @@ export class JsWorkerRuntime {
 	}
 }
 
+function shadowNote(names) {
+	const list = names.map((name) => `\`${name}\``).join(", ");
+	const restore = names.map((name) => `delete ${name}`).join("; ");
+	return `Note: ${list} ${names.length === 1 ? "shadows a kernel or platform global" : "shadow kernel or platform globals"} in your later cells; the kernel and imported libraries keep the original. \`${restore}\` restores ${names.length === 1 ? "it" : "them"}.\n`;
+}
+
 function isPlainObject(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }

package/src/kernels/js/worker-shadow-guard.js

@@ -12,10 +12,6 @@ function protectedGlobals() {
 	return protectedGlobalNames;
 }
 
-export function findShadowedGlobalName(bindings) {
-	const names = protectedGlobals();
-	for (const name of bindings) {
-		if (names.has(name)) return name;
-	}
-	return undefined;
+export function isKernelGlobal(name) {
+	return protectedGlobals().has(name);
 }

package/src/kernels/js/worker-shell-capture.js

@@ -1,3 +1,5 @@
+import { assertCellLive } from "./cell-run-context.js";
+
 const SHELL_CONFIG_METHODS = ["env", "cwd", "nothrow", "throws"];
 const SHELL_READ_METHODS = ["text", "json", "lines", "arrayBuffer", "bytes", "blob"];
 // `true | ( … )` hands every command in the template an empty pipe as stdin. The worker thread shares
@@ -39,6 +41,7 @@ function isBunRuntime(bun) {
 
 function capturedShell(originalShell, options) {
 	const shell = (strings, ...expressions) => {
+		assertCellLive();
 		if (!options.isActive()) return originalShell(strings, ...expressions);
 		const promise = originalShell(isolateStdin(strings), ...expressions);
 		return captureShellPromise(promise, options);
@@ -132,6 +135,7 @@ function outputText(value) {
 // without an explicit env must get the worker's view pinned too (measured on Bun 1.4.0).
 function capturedSpawnSync(originalSpawnSync, pinEnv) {
 	return (...args) => {
+		assertCellLive();
 		if (!pinEnv) return originalSpawnSync(...args);
 		const [first, second] = args;
 		if (Array.isArray(first)) {
@@ -148,6 +152,7 @@ function capturedSpawnSync(originalSpawnSync, pinEnv) {
 
 function capturedSpawn(originalSpawn, options, pinEnv) {
 	return (...args) => {
+		assertCellLive();
 		if (!options.isActive()) return originalSpawn(...args);
 		const [first, second] = args;
 		let child;

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) => {

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

@@ -2,8 +2,10 @@ import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import { createInlineWorker, type WorkerLike } from "./inline-worker.ts";
+import { retireWorker } from "./interrupt-bounds.ts";
 import { resolveKernelToolNameSource } from "./kernel-contract.ts";
 import { type JavaScriptKernelOptions, localBridgeConnection } from "./local-module-loader.ts";
+import { resolveJsProcessEntryUrl, spawnProcessWorker } from "./process-worker.ts";
 import { spawnNodeWorker, WorkerStartupCancelledError, waitForReady } from "./worker-host.ts";
 
 export interface JavaScriptWorkerEntryUrlOptions extends CodemodeRuntimeAssetEnvironment {
@@ -15,6 +17,21 @@ export function resolveJsWorkerEntryUrl(options: JavaScriptWorkerEntryUrlOptions
 	return pathToFileURL(requireCodemodeRuntimeAsset(localPath, join("kernels", "js", "worker-entry.js"), options));
 }
 
+/**
+ * How long a process-mode kernel child gets to report ready. A child that a starved host never schedules would
+ * otherwise hold every queued cell forever: no cell's own timeout is armed until the kernel is up.
+ */
+export const PROCESS_STARTUP_DEADLINE_MS = 30_000;
+
+export class ProcessKernelStartupTimeoutError extends Error {
+	constructor(deadlineMs: number) {
+		super(
+			`JavaScript kernel process did not become ready within ${deadlineMs / 1000}s; it was stopped, and the next cell starts a fresh one`,
+		);
+		this.name = "ProcessKernelStartupTimeoutError";
+	}
+}
+
 export interface WorkerStartupHooks {
 	readonly options: JavaScriptKernelOptions;
 	readonly kernelGeneration: number;
@@ -36,6 +53,13 @@ export async function startWorkerWithInlineFallback(hooks: WorkerStartupHooks, s
 			await worker.terminate();
 			throw new WorkerStartupCancelledError();
 		}
+		// Process mode never falls back: the user asked for isolation, so a failed start stays visible. The child that
+		// failed to start is stopped (bounded), so a stuck one is not left behind.
+		if (worker.mode === "process") {
+			hooks.retire(worker);
+			await retireWorker(worker);
+			throw error;
+		}
 		if (worker.mode === "inline") throw error;
 		hooks.retire(worker);
 		await worker.terminate();
@@ -47,6 +71,15 @@ export async function startWorkerWithInlineFallback(hooks: WorkerStartupHooks, s
 }
 
 function spawnWorker(options: JavaScriptKernelOptions): WorkerLike {
+	if (options.isolation === "process") {
+		const url = resolveJsProcessEntryUrl();
+		return spawnProcessWorker(url, {
+			cwd: options.cwd,
+			parallelPoolWidth: options.parallelPoolWidth,
+			...(options.processCommandPath === undefined ? {} : { searchPath: options.processCommandPath }),
+			...(options.processExecPath === undefined ? {} : { execPath: options.processExecPath }),
+		});
+	}
 	try {
 		const url = options.workerEntryUrl ?? resolveJsWorkerEntryUrl();
 		return spawnNodeWorker(url, options.cwd, options.parallelPoolWidth);
@@ -57,7 +90,10 @@ function spawnWorker(options: JavaScriptKernelOptions): WorkerLike {
 }
 
 async function initializeWorker(worker: WorkerLike, hooks: WorkerStartupHooks, signal: AbortSignal): Promise<void> {
-	const ready = waitForReady(worker, signal);
+	const ready =
+		worker.mode === "process"
+			? withStartupDeadline(waitForReady(worker, signal), hooks.options)
+			: waitForReady(worker, signal);
 	const options = hooks.options;
 	worker.postMessage({
 		type: "init",
@@ -68,6 +104,18 @@ async function initializeWorker(worker: WorkerLike, hooks: WorkerStartupHooks, s
 		foreignLanguageNames: resolveKernelToolNameSource(options.foreignLanguageNames),
 		...(options.sessionEnv === undefined ? {} : { sessionEnv: options.sessionEnv }),
 		...(options.memory === undefined ? {} : { memory: options.memory }),
+		...(options.kernelToolsEnabled === false ? { kernelToolsDisabled: true } : {}),
 	});
 	await ready;
 }
+
+function withStartupDeadline(ready: Promise<void>, options: JavaScriptKernelOptions): Promise<void> {
+	const deadlineMs = options.processStartupDeadlineMs ?? PROCESS_STARTUP_DEADLINE_MS;
+	let timer: NodeJS.Timeout | undefined;
+	const expired = new Promise<never>((_resolve, reject) => {
+		timer = setTimeout(() => reject(new ProcessKernelStartupTimeoutError(deadlineMs)), deadlineMs);
+	});
+	// When the deadline wins, the stopped child's readiness promise rejects later; that outcome is already reported.
+	ready.catch(() => {});
+	return Promise.race([ready, expired]).finally(() => clearTimeout(timer));
+}

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

@@ -1,3 +1,4 @@
+import { onCellRelease } from "./cell-run-context.js";
 import { DELIVER_EVENT, WebViewPortClient, webViewError } from "./worker-webview-client.js";
 
 // Bun constructs "chrome"-backend WebViews only on the process main thread, and this kernel runs in
@@ -5,6 +6,7 @@ import { DELIVER_EVENT, WebViewPortClient, webViewError } from "./worker-webview
 // `Bun` parameter bound to a stand-in whose `WebView` forwards Chrome-backed views to the
 // main-thread service over a private port; every other `Bun.*` member is the real one.
 const KERNEL_BUN = Symbol.for("senpi.kernel.bun");
+const KERNEL_PROCESS_MODE = Symbol.for("senpi.kernel.processMode");
 
 export function bindKernelBun(source) {
 	if (!globalThis[KERNEL_BUN]) return source;
@@ -17,6 +19,10 @@ export function installKernelWebView(requestPort) {
 	globalThis[KERNEL_BUN] = shadowBun(bun, createKernelWebView(bun.WebView, requestPort));
 }
 
+export function markKernelProcessMode() {
+	globalThis[KERNEL_PROCESS_MODE] = true;
+}
+
 function shadowBun(real, WebView) {
 	return new Proxy(
 		{},
@@ -35,7 +41,10 @@ function shadowBun(real, WebView) {
 }
 
 // The macOS default (WebKit) stays a native worker view: its host process serves any thread.
+// A process-mode kernel already runs its cells on the child's main thread, so the native
+// WebView constructs there directly and no MessagePort proxy is ever needed.
 function needsMainThread(options) {
+	if (globalThis[KERNEL_PROCESS_MODE]) return false;
 	const backend = options?.backend;
 	if (backend === undefined) return process.platform !== "darwin";
 	return backend === "chrome" || (typeof backend === "object" && backend !== null && backend.type === "chrome");
@@ -82,13 +91,16 @@ function createKernelWebView(NativeWebView, requestPort) {
 		#console;
 		#ready;
 		#closed = false;
+		#forgetRelease;
 		onNavigated = null;
 		onNavigationFailed = null;
 
 		constructor(options = {}) {
 			if (!needsMainThread(options)) {
 				const view = new NativeWebView(options);
-				natives.add(new WeakRef(view));
+				const ref = new WeakRef(view);
+				natives.add(ref);
+				onCellRelease(() => ref.deref()?.close());
 				return view;
 			}
 			super();
@@ -96,6 +108,7 @@ function createKernelWebView(NativeWebView, requestPort) {
 			this.#console = capture;
 			proxied.add(this);
 			live.add(this);
+			this.#forgetRelease = onCellRelease(() => this.close());
 			const viewId = this.#viewId;
 			this.#ready = connect().then(async client => {
 				client.register(viewId, this);
@@ -149,6 +162,7 @@ function createKernelWebView(NativeWebView, requestPort) {
 		close() {
 			if (this.#closed) return;
 			this.#closed = true;
+			this.#forgetRelease?.();
 			live.delete(this);
 			const viewId = this.#viewId;
 			this.#ready.then(

package/src/kernels/js/workpool.js

@@ -4,8 +4,11 @@ import { kernelToolError } from "./kernel-tools-errors.js";
 // Only host-tool sugar: no admission, worker, or queue state belongs to the kernel.
 export async function createWorkpool(callTool, agent, name, options = {}) {
 	if (inKernelToolInvoke()) throw kernelToolError("kernel_tool_recursion", "kernel tools may not invoke workpool()");
-	if (options === null || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some(key => key !== "mode")) {
-		throw new TypeError("workpool() options only accept mode");
+	if (options === null || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some(key => key !== "mode" && key !== "tools")) {
+		throw new TypeError("workpool() options only accept mode and tools");
+	}
+	if (options.tools !== undefined && (!Array.isArray(options.tools) || !options.tools.every(name => typeof name === "string"))) {
+		throw workpoolError("invalid_tools", `workpool() tools takes an array of tool names; got ${Array.isArray(options.tools) ? "an array with a non-string" : typeof options.tools}`);
 	}
 	const call = async args => {
 		try {

package/src/kernels/py/host-cell.ts

@@ -1,42 +1,19 @@
 import type { KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { HostCellExecutor } from "../../tool/types.ts";
-
-type HostCellOutcome = Awaited<ReturnType<HostCellExecutor>>;
-
+import { runHostCell as runSharedHostCell } from "../shared/host-cell.ts";
 import type { PendingRun, ResultMessage } from "./kernel-contract.ts";
-import { failedPythonResult } from "./transport.ts";
 
 export function runHostCell(
 	pending: PendingRun,
 	host: HostCellExecutor,
 	io: { readonly emit: (message: KernelToHostMessage) => void; readonly settle: (result: ResultMessage) => void },
 ): void {
-	const abort = new AbortController();
-	pending.hostAbort = abort;
-	const cellId = pending.input.cellId;
-	let finished = false;
-	// Output from an executor that was aborted, or after its outcome, belongs to no cell.
-	const emit = (message: KernelToHostMessage): void => {
-		if (!finished && !abort.signal.aborted) io.emit(message);
-	};
-	// Calling the executor inside a promise keeps a synchronous throw in this cell instead of failing the queue.
-	const done = new Promise<HostCellOutcome>((resolve) => resolve(host({ signal: abort.signal, emit }))).then(
-		(outcome): ResultMessage =>
-			outcome.ok
-				? {
-						type: "result",
-						cellId,
-						ok: true,
-						durationMs: 0,
-						...(outcome.valueRepr === undefined ? {} : { valueRepr: outcome.valueRepr }),
-					}
-				: { type: "result", cellId, ok: false, error: outcome.error, durationMs: 0 },
-		(error: unknown): ResultMessage =>
-			failedPythonResult(cellId, error instanceof Error ? error.message : String(error)),
-	);
-	pending.hostDone = done;
-	void done.then((result) => {
-		finished = true;
-		if (!abort.signal.aborted) io.settle(result);
+	const run = runSharedHostCell(pending.input.cellId, host, {
+		emit: io.emit,
+		settle: io.settle,
+		durationMs: () => 0,
+		settleAfterAbort: false,
 	});
+	pending.hostAbort = run.abort;
+	pending.hostDone = run.done;
 }

package/src/kernels/py/kernel.ts

@@ -5,6 +5,7 @@ import type {
 	KernelToolsInvokeOptions,
 	KernelToolsInvokeRequest,
 } from "../js/kernel-tools-types.ts";
+import { inputAtStart } from "../shared/cell-source-at-start.ts";
 import { describeExit } from "../shared/kernel-death.ts";
 import { KernelMemoryHost } from "../shared/kernel-memory-host.ts";
 import { KernelPreludeTracker } from "../shared/kernel-prelude-plan.ts";
@@ -243,10 +244,15 @@ export class PythonKernel {
 			});
 			return;
 		}
+		const input = inputAtStart(pending.input);
+		if ("refused" in input) {
+			this.#settleRun(pending, failedPythonResult(pending.input.cellId, input.refused));
+			return;
+		}
 		try {
 			this.#transport?.run({
-				...pending.input,
-				preludePlan: this.#preludes.plan(pending.input.kernelPreludes ?? []),
+				...input,
+				preludePlan: this.#preludes.plan(input.kernelPreludes ?? []),
 			});
 		} catch (error) {
 			const failure = error instanceof Error ? error : new Error(String(error));