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

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,10 +1,13 @@
 // 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";
 import { encodeDisplayImage, resolveDisplayOps } from "./display-image.js";
-import { terminateProcessTrees } from "./process-tree.js";
+import { terminateProcessGroups, terminateProcessTrees } from "./process-tree.js";
 import { awaitMaybePromise, indirectEval, wrapUserCode } from "./worker-indirect-eval.js";
+import { INJECTED_GROUP } from "./worker-cwd.js";
 import { installShellCapture } from "./worker-shell-capture.js";
 import { bindKernelBun } from "./worker-webview.js";
 import { createWorkpool } from "./workpool.js";
@@ -31,6 +34,10 @@ export class JsWorkerRuntime {
 	#hooks = null;
 	#pendingDisplays = [];
 	#children = new Set();
+	// Groups the worker created for cell children (senpi#2995). A group outlives its leader, so a grandchild re-parented
+	// to init is still found through it at retirement (senpi#3020).
+	#ownedGroups = new Map();
+	#childrenStopping;
 	#shellWaits = new Set();
 	#onChildEvent;
 	#onShellWaitChange;
@@ -47,6 +54,7 @@ export class JsWorkerRuntime {
 			generation: options.kernelGeneration ?? 1,
 			hostToolNames: options.hostToolNames ?? [],
 			foreignLanguageNames: options.foreignLanguageNames ?? [],
+			disabled: options.kernelToolsDisabled === true,
 		});
 		this.#installGlobals();
 	}
@@ -73,32 +81,48 @@ export class JsWorkerRuntime {
 				if (typeof prepared.sourceFile === "string") sourceName = prepared.sourceFile;
 			}
 			if (prelude) indirectEval(prelude, PRELUDE_SOURCE_URL);
-			const value = await awaitMaybePromise(indirectEval(bindKernelBun(wrapUserCode(cellCode)), sourceName));
+			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) {
 		if (child === null || typeof child !== "object" || typeof child.kill !== "function") return;
 		// `detached: true` is the cell saying it wants the process to outlive it.
-		if (isPlainObject(spawnOptions) && spawnOptions.detached === true) return;
+		const groupInjected = (globalThis[INJECTED_GROUP] ?? 0) > 0;
+		if (isPlainObject(spawnOptions) && spawnOptions.detached === true && !groupInjected) return;
 		this.#children.add(child);
 		const pid = Number.isInteger(child.pid) && child.pid > 0 ? child.pid : null;
+		// Bun.spawn children get their group from worker-cwd.js without the injection marker, so every tracked child is
+		// recorded; a child that is not a group leader names no group, and signalling it later finds nothing.
+		const ownGroupLeader = !(isPlainObject(spawnOptions) && spawnOptions.detached === false);
+		if (pid !== null && process.platform !== "win32" && ownGroupLeader) this.#ownedGroups.set(pid, child);
 		// The host keeps its own copy of live pids: if this worker is terminated
 		// while blocked, only the host can still retire them.
 		if (pid !== null) this.#onChildEvent?.({ pid, state: "spawned" });
@@ -112,10 +136,20 @@ export class JsWorkerRuntime {
 	#terminateChildren() {
 		const children = [...this.#children].filter(child => child.exitCode === null && child.signalCode === null);
 		this.#children.clear();
-		if (children.length === 0) return undefined;
+		// A leader that already exited leaves its group id reserved only while the group has members; if that pid now
+		// names a live process, it was reused by someone else and the group is not ours to signal (senpi#3020 review).
+		const groups = [...this.#ownedGroups].map(([pgid, child]) => ({
+			pgid,
+			leaderExited: child.exitCode !== null || child.signalCode !== null,
+		}));
+		this.#ownedGroups.clear();
+		if (children.length === 0 && groups.length === 0) return undefined;
 		const roots = children.map(child => child.pid).filter(pid => Number.isInteger(pid) && pid > 0);
 		const settled = Promise.allSettled(children.map(child => (child.exited instanceof Promise ? child.exited : Promise.resolve())));
-		return terminateProcessTrees(roots, { graceMs: CHILD_TERMINATION_GRACE_MS, settled });
+		return Promise.all([
+			roots.length > 0 ? terminateProcessTrees(roots, { graceMs: CHILD_TERMINATION_GRACE_MS, settled }) : undefined,
+			terminateProcessGroups(groups, { graceMs: CHILD_TERMINATION_GRACE_MS }),
+		]);
 	}
 
 	async #drainPendingDisplays() {
@@ -147,6 +181,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),
@@ -154,6 +199,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;
@@ -422,6 +469,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,6 @@
+import { assertCellLive } from "./cell-run-context.js";
+import { groupSignalNotice, noticeChildProcessGroupSignals, shellCommandText, signalsProcessGroup } from "./group-signal-notice.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
@@ -26,7 +29,9 @@ export function installShellCapture(options) {
 	bun.$ = capturedShell(originalShell, options);
 	bun.spawn = capturedSpawn(originalSpawn, options, pinEnv);
 	if (originalSpawnSync !== null) bun.spawnSync = capturedSpawnSync(originalSpawnSync, pinEnv);
+	const restoreChildProcessNotice = noticeChildProcessGroupSignals(options.emitText, options.isActive);
 	return () => {
+		restoreChildProcessNotice();
 		bun.$ = originalShell;
 		bun.spawn = originalSpawn;
 		if (originalSpawnSync !== null) bun.spawnSync = originalSpawnSync;
@@ -39,7 +44,9 @@ function isBunRuntime(bun) {
 
 function capturedShell(originalShell, options) {
 	const shell = (strings, ...expressions) => {
+		assertCellLive();
 		if (!options.isActive()) return originalShell(strings, ...expressions);
+		if (signalsProcessGroup(shellCommandText(strings, expressions))) options.emitText("stderr", groupSignalNotice("Bun.$"));
 		const promise = originalShell(isolateStdin(strings), ...expressions);
 		return captureShellPromise(promise, options);
 	};
@@ -132,6 +139,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 +156,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

@@ -19,6 +19,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 +35,12 @@ export class WorkerSlot {
 		return this.#mode;
 	}
 
+	get processPid(): number | undefined {
+		const worker = this.#worker;
+		if (worker?.mode === "process") return worker.pid;
+		return this.#lastProcessPid;
+	}
+
 	get present(): boolean {
 		return this.#worker !== null;
 	}
@@ -105,6 +112,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.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/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;
 }