@volter/browser-wali 0.1.166 → 0.1.168

package/dist/worker-program.js

@@ -1,4 +1,5 @@
 import { KernelProcessTable, kernelProcessOwner } from "@volter/browser-runtime/kernel-processes.js";
+import { waliJumpTransfer } from "./jumps.js";
 import { forkKernelProcessIdentity } from "./kernel-process-client.js";
 import { releaseWaliSharedBuffers } from "./shared-buffer-pool.js";
 import { createSharedFileLayer, lowerTreeOf, sharedFileLayerEntries, withoutHostTrees } from "./shared-file-layer.js";
@@ -10,7 +11,7 @@ import { SharedWaliStdinWriter } from "./stdin.js";
 import { findImportedMemory } from "./module-layout.js";
 import { createWaliSignalState, defaultStops, defaultTerminates, WaliSignals } from "./signals.js";
 import { waliSharedPipeDescribesFd } from "./shared-pipes.js";
-import { applyProcessFilesystemPatch, closeSharedPipe, createProcessFilesystemPatch, encodeProcessPatch, publishProcessCompletion, readSharedPipe, writeSharedPipe, } from "./process-bridge.js";
+import { applyProcessFilesystemPatch, closeSharedPipe, createProcessFilesystemPatch, encodeProcessPatch, waliExecCompletion, waliTerminalInput, publishProcessCompletion, readSharedPipe, writeSharedPipe, } from "./process-bridge.js";
 import { createBrowserFileLockChannel, sharedBrowserFileLockCoordinator, } from "@volter/browser-runtime/browser-file-locks.js";
 import { createBrowserFileCoherenceChannel, sharedBrowserFileCoherenceCoordinator, } from "@volter/browser-runtime/browser-file-coherence.js";
 import { currentEntry, patchWithContent, ProcessFilesystemBase } from "@volter/browser-runtime/browser-process-filesystem.js";
@@ -18,20 +19,43 @@ import { pageWorker } from "@volter/browser-runtime/page-workers.js";
 import { createWaliWaitAgent, startWaliWaitAgent, WaliWaitTable, waliWaitOwner } from "./wait-state.js";
 import { WaliForkPool } from "./fork-pool.js";
 import { WaliExecPool, createWaliProgramWorker } from "./exec-pool.js";
+import { WaliKernelNetwork } from "./kernel-network.js";
+import { WaliKernelFilesystem } from "./kernel-filesystem.js";
 const kernelProcesses = new WeakMap();
 const forkPools = new WeakMap();
 const execPools = new WeakMap();
+const kernelNetworks = new WeakMap();
+const kernelFilesystems = new WeakMap();
 // A pooled worker can have served a different program object. Old queued
 // replies must not match that object's first run after listeners change.
 let nextRunId = 1;
+/** Host commit failures are kernel diagnostics, never bytes written by a guest. */
+class WaliFilesystemCommitError extends Error {
+    code = "WALI_FILESYSTEM_COMMIT";
+    constructor(message, cause) { super(message, { cause }); }
+}
+function isFilesystemCommitError(error) {
+    const seen = new Set();
+    while (typeof error === "object" && error !== null && !seen.has(error)) {
+        seen.add(error);
+        if ("code" in error && error.code === "WALI_FILESYSTEM_COMMIT")
+            return true;
+        error = "cause" in error ? error.cause : undefined;
+    }
+    return false;
+}
 /** Runs one unchanged WALI executable off the UI thread while retaining its compiled module. */
 /**
  * Each program's module, compiled by the first worker that ran it, for every
  * worker after: a module is compiled once per page, not once per worker. Only
- * a pinned artifact is kept; a `blob:` module is a URL of its own each run.
+ * a pinned artifact is kept, including a local Blob admitted with its digest.
  */
 const compiledModules = new Map();
 const compiledKey = (url, integrity) => integrity ? `${url}\n${integrity}` : undefined;
+/** Artifact owner retirement, after its last active image has ended. */
+export function forgetWaliModule(url, integrity) {
+    compiledModules.delete(compiledKey(url, integrity));
+}
 /** `work`, or sooner when `signal` aborts: a run waiting on a preload is still one that can be cancelled (review of da64b88). */
 async function untilAborted(work, signal) {
     if (!signal) {
@@ -87,16 +111,23 @@ export function preloadWaliModule(url, integrity) {
 export class BrowserWaliWorkerProgram {
     filesystem;
     program;
+    /** Host continuations outlive a retired guest image until its successor finishes. */
+    childRuns = new Set();
     capabilities = Object.freeze({ filesystemPolicy: true });
     /** Started by the first run, so a program the page offers and never runs costs no worker. */
     worker;
     pending;
     stdin;
+    terminalInput;
     terminalSize = { columns: 80, rows: 24 };
     detachWorker;
     execPool;
     ownsExecPool = false;
     workerLeased = false;
+    kernelNetwork;
+    releaseKernelNetwork;
+    kernelFilesystem;
+    releaseKernelFilesystem;
     forkWorkers = new Map();
     forkCleanup = new Map();
     forkPool;
@@ -173,6 +204,26 @@ export class BrowserWaliWorkerProgram {
             this.execPool = new WaliExecPool();
             execPools.set(this.waitOwner.table, this.execPool);
         }
+        this.kernelNetwork = kernelNetworks.get(kernel);
+        if (!this.kernelNetwork || this.kernelNetwork.isDisposed) {
+            this.kernelNetwork = new WaliKernelNetwork();
+            kernelNetworks.set(kernel, this.kernelNetwork);
+        }
+        this.releaseKernelNetwork = this.kernelNetwork.retain(error => {
+            this.pending?.reject(error);
+            this.finishPending();
+            this.resetWorker();
+        });
+        this.kernelFilesystem = kernelFilesystems.get(kernel);
+        if (!this.kernelFilesystem || this.kernelFilesystem.isDisposed) {
+            this.kernelFilesystem = new WaliKernelFilesystem();
+            kernelFilesystems.set(kernel, this.kernelFilesystem);
+        }
+        this.releaseKernelFilesystem = this.kernelFilesystem.retain(error => {
+            this.pending?.reject(error);
+            this.finishPending();
+            this.resetWorker();
+        });
         // Started here so its boot overlaps the run's preparation.
         this.worker ??= this.createWorker();
         this.preparing = true;
@@ -210,7 +261,7 @@ export class BrowserWaliWorkerProgram {
             if (layer?.vanished) {
                 const vanished = new Set(layer.vanished);
                 image = { files: image.files.filter((entry) => !vanished.has(entry.path)) };
-                delete layer.vanished;
+                // The cached layer is immutable and may already serve another run.
             }
             // The host's own layers are described by size in the image and the base,
             // as a store's files are: the program holds them, and a file it did not
@@ -259,6 +310,7 @@ export class BrowserWaliWorkerProgram {
             const size = options.terminal ?? this.terminalSize;
             stdin.resize(size.columns, size.rows);
             this.stdin = stdin;
+            this.terminalInput = options[waliTerminalInput] ?? (options.terminal ? stdin.buffer : undefined);
             const signalState = createWaliSignalState();
             return await new Promise((resolve, reject) => {
                 // What `kill` sent (the abort reason's `signal`; an abort that names
@@ -280,7 +332,15 @@ export class BrowserWaliWorkerProgram {
                 const survives = (signal) => {
                     if (signal === 9)
                         return false;
-                    const disposition = new WaliSignals(signalState).raise(signal);
+                    if (signal === 19) {
+                        new WaliSignals(signalState).raise(signal);
+                        kernel.stop(processPid, signal);
+                        return true;
+                    }
+                    // Default-ignored signals also remain pending while blocked. Explicit
+                    // SIG_IGN is still discarded by raise; unblocked defaults act now.
+                    const disposition = new WaliSignals(signalState).raise(signal, 0, 0, 0, "masked");
+                    this.waitOwner?.table.notifyProcess(processPid);
                     if (disposition === "default" && defaultStops(signal))
                         kernel.stop(processPid, signal);
                     return disposition !== "default" || !defaultTerminates(signal);
@@ -343,6 +403,7 @@ export class BrowserWaliWorkerProgram {
                     childPidAllocator: lineage?.childPidAllocator ?? kernel.allocator,
                     id,
                     ...(options.descriptorTable ? { descriptorTable: options.descriptorTable } : {}),
+                    ...(options[waliExecCompletion] ? { execCompletion: options[waliExecCompletion] } : {}),
                     url: this.program.url,
                     ...(this.program.integrity ? { integrity: this.program.integrity } : {}),
                     ...(() => {
@@ -366,6 +427,8 @@ export class BrowserWaliWorkerProgram {
                         } } : {}),
                     ...(loopbackChannel ? { loopbackPort: loopbackChannel.port2 } : {}),
                     stdin: stdin.buffer,
+                    ...(this.terminalInput ? { terminalStdin: this.terminalInput } : {}),
+                    ...(options.terminal?.write ? { terminalOutput: true } : {}),
                     terminal: options.terminal !== undefined,
                     filesystem,
                     ...(store ? { store: { projectId: store } } : {}),
@@ -383,7 +446,7 @@ export class BrowserWaliWorkerProgram {
                         if (!active || active.id !== id)
                             return;
                         if (event.data.type === "spawn") {
-                            void this.spawnChild({ ...event.data, id, type: "spawn" }, active);
+                            this.launchChild({ ...event.data, id, type: "spawn" }, active);
                         }
                         else
                             void this.handleMessage({ ...event.data, id });
@@ -411,7 +474,9 @@ export class BrowserWaliWorkerProgram {
                                 active.options.onDiagnostic?.(event.data.message);
                                 return;
                             }
-                            if (event.data.type === "stdout")
+                            if (event.data.type === "terminal-output")
+                                active.options.terminal?.write?.(new TextDecoder().decode(event.data.bytes));
+                            else if (event.data.type === "stdout")
                                 this.emitStdout(active, event.data.bytes);
                             else
                                 this.emitStderr(active, new TextDecoder().decode(event.data.bytes));
@@ -598,6 +663,14 @@ export class BrowserWaliWorkerProgram {
         const pending = this.pending;
         if (!pending || message.id !== pending.id)
             return;
+        if (message.type === "network-service") {
+            this.kernelNetwork.connect(message.reply);
+            return;
+        }
+        if (message.type === "filesystem-service") {
+            this.kernelFilesystem.connect(message.reply);
+            return;
+        }
         if (message.type === "compiled") {
             const key = compiledKey(this.program.url, this.program.integrity);
             if (key)
@@ -616,6 +689,10 @@ export class BrowserWaliWorkerProgram {
             this.emitStdout(pending, message.chunk);
             return;
         }
+        if (message.type === "terminal-output") {
+            pending.options.terminal?.write?.(new TextDecoder().decode(message.chunk));
+            return;
+        }
         if (message.type === "stderr") {
             this.emitStderr(pending, message.chunk);
             return;
@@ -625,8 +702,15 @@ export class BrowserWaliWorkerProgram {
             return;
         }
         if (message.type === "process") {
-            const result = this.processOwner?.table.call(message.callerPid, message.operation, message.first, message.second) ?? -3;
+            const table = this.processOwner?.table;
+            const settings = message.operation === "termios"
+                ? table?.terminalSettings(message.callerPid, message.first === 1, message.second, message.data ?? new Uint8Array())
+                : undefined;
+            const result = message.operation === "termios" ? settings?.result ?? -3
+                : table?.call(message.callerPid, message.operation, message.first, message.second) ?? -3;
             const reply = new Int32Array(message.reply);
+            if (settings?.result === 0 && settings.settings)
+                new Uint8Array(message.reply, 8).set(settings.settings);
             Atomics.store(reply, 1, result);
             Atomics.store(reply, 0, 1);
             Atomics.notify(reply, 0);
@@ -637,7 +721,7 @@ export class BrowserWaliWorkerProgram {
             return;
         }
         if (message.type === "spawn") {
-            void this.spawnChild(message, pending);
+            this.launchChild(message, pending);
             return;
         }
         if (message.type === "kill") {
@@ -654,7 +738,8 @@ export class BrowserWaliWorkerProgram {
             return;
         }
         console.log("[wali-boot]", JSON.stringify({ stage: "result-received", run: this.traceId, at: Date.now() }));
-        const safeFilesystem = this.program.sanitizeFilesystem
+        const delegated = pending.options.descriptorTable !== undefined;
+        const safeFilesystem = !delegated && this.program.sanitizeFilesystem
             ? await this.program.sanitizeFilesystem(message.filesystem)
             : message.filesystem;
         if (message.filesystemFinalized)
@@ -663,19 +748,36 @@ export class BrowserWaliWorkerProgram {
         console.log("[wali-boot]", JSON.stringify({ stage: "filesystem-settled", run: this.traceId, at: Date.now() }));
         if (this.pending !== pending)
             return;
+        if (message.result?.replaced) {
+            // Return the old worker now, while its host continuation awaits the
+            // successor. A backend caller may terminate this program in finally;
+            // do not resolve that caller until the exec chain has closed its pipes.
+            this.resetWorker(true, true);
+            await Promise.all([...this.childRuns]);
+            if (this.pending !== pending)
+                return;
+        }
         // A threaded process commits its final delta on the ordered update port.
         // Its full snapshot may predate a peer import acknowledged on that port;
         // diffing it against the advanced base would manufacture a deletion.
-        const patch = message.filesystemFinalized ? { files: [], removed: [] }
+        // Exec/fork images that inherit the owner cannot replay their private
+        // artifact snapshot over writes the owner has already published.
+        const patch = message.filesystemFinalized || delegated ? { files: [], removed: [] }
             : this.withoutHostTrees(createProcessFilesystemPatch(pending.filesystemBase, safeFilesystem, { written: true }));
-        if (!message.filesystemFinalized)
-            applyProcessFilesystemPatch(this.filesystem, patch, pending.filesystemBase);
+        if (!message.filesystemFinalized && !delegated) {
+            try {
+                applyProcessFilesystemPatch(this.filesystem, patch, pending.filesystemBase);
+            }
+            catch (error) {
+                throw new WaliFilesystemCommitError("WALI exit filesystem commit failed", error);
+            }
+        }
         try {
             await this.program.onFilesystemCommit?.(this.filesystem, patch);
         }
         catch (error) {
             this.finishPending();
-            pending.reject(new Error(`WALI filesystem durability barrier failed: ${error instanceof Error ? error.message : String(error)}`));
+            pending.reject(new WaliFilesystemCommitError(`WALI filesystem durability barrier failed: ${error instanceof Error ? error.message : String(error)}`, error));
             return;
         }
         this.finishPending();
@@ -683,7 +785,7 @@ export class BrowserWaliWorkerProgram {
         // this image's listeners and children before a different image borrows
         // the worker; a caller's finally/terminate then has no lease to cancel.
         if (!this.ownsExecPool)
-            this.resetWorker(message.result !== undefined);
+            this.resetWorker(message.result !== undefined, message.result?.replaced === true);
         console.log("[wali-boot]", JSON.stringify({ stage: "done", run: this.traceId, at: Date.now() }));
         if (message.result)
             pending.resolve({ ...message.result, stdout: pending.stdout, stderr: pending.stderr });
@@ -711,7 +813,7 @@ export class BrowserWaliWorkerProgram {
         }) : Promise.resolve();
         let ended = false;
         let processImage = 0;
-        const finish = async (signal) => {
+        const finish = async (signal, replaced = false) => {
             if (ended)
                 return;
             ended = true;
@@ -734,15 +836,20 @@ export class BrowserWaliWorkerProgram {
                 publishProcessCompletion({ ...message, processIdentity: identity });
                 releaseWaliSharedBuffers(message.bufferLease);
             }
-            else
+            else {
                 pool.release(worker);
+                if (!replaced) {
+                    publishProcessCompletion({ ...message, processIdentity: identity });
+                    releaseWaliSharedBuffers(message.bufferLease);
+                }
+            }
             table?.removeImage(agent.image);
         };
         const receive = (event) => {
             if (this.forkWorkers.get(message.pid) !== worker)
                 return;
             if (event.data.type === "fork-done") {
-                void finish();
+                void finish(undefined, event.data.replaced);
                 return;
             }
             if (event.data.type === "stderr" && event.data.chunk.includes("could not allocate memory")) {
@@ -765,7 +872,14 @@ export class BrowserWaliWorkerProgram {
         processImage = owner.table.image(message.pid, signal => {
             if (ended)
                 return;
-            const disposition = signal === 9 ? "default" : new WaliSignals(message.forkState.signalState).raise(signal);
+            if (signal === 19) {
+                new WaliSignals(message.forkState.signalState).raise(signal);
+                owner.table.stop(message.pid, signal);
+                return;
+            }
+            const disposition = signal === 9 ? "default"
+                : new WaliSignals(message.forkState.signalState).raise(signal, 0, 0, 0, "masked");
+            table?.notifyProcess(message.pid);
             if (disposition === "default" && defaultStops(signal))
                 owner.table.stop(message.pid, signal);
             if (disposition === "default" && defaultTerminates(signal))
@@ -775,7 +889,23 @@ export class BrowserWaliWorkerProgram {
         worker.addEventListener("error", failed);
         const descriptorTable = { ...message.descriptorTable };
         delete descriptorTable.releasePort;
-        worker.postMessage({ ...message, processIdentity: identity, descriptorTable, waitAgent: agent }, [descriptorTable.port, message.forkState.memory]);
+        // The child's reactor channel travels with the fork: a request for it
+        // would be one more round trip through this thread before the child runs.
+        const networkServicePort = this.kernelNetwork?.open();
+        worker.postMessage({ ...message, processIdentity: identity, descriptorTable, waitAgent: agent,
+            ...(networkServicePort ? { networkServicePort } : {}) }, [descriptorTable.port, message.forkState.memory, ...waliJumpTransfer(message.forkState.jumps),
+            ...(networkServicePort ? [networkServicePort] : [])]);
+    }
+    launchChild(message, pending) {
+        const work = this.spawnChild(message, pending);
+        this.childRuns.add(work);
+        void work.finally(() => this.childRuns.delete(work)).catch(error => {
+            if (this.pending !== pending)
+                return;
+            pending.reject(error);
+            this.finishPending();
+            this.resetWorker();
+        });
     }
     async spawnChild(message, pending) {
         const table = this.waitOwner?.table;
@@ -803,6 +933,7 @@ export class BrowserWaliWorkerProgram {
         const descriptorTable = message.descriptorTable && {
             port: message.descriptorTable.port, control: message.descriptorTable.control,
             payload: message.descriptorTable.payload,
+            ...(message.descriptorTable.descriptorLimits ? { descriptorLimits: message.descriptorTable.descriptorLimits } : {}),
             ...(message.descriptorTable.sharedPipes ? { sharedPipes: message.descriptorTable.sharedPipes } : {}),
         };
         let released;
@@ -814,6 +945,7 @@ export class BrowserWaliWorkerProgram {
         let stderrWrites = Promise.resolve();
         let stdoutStreamed = false;
         let stderrStreamed = false;
+        let replaced = false;
         // The child's patch is a diff of the tree before and after it ran; the
         // diff needs sizes and times, and only the entries it names need bytes.
         const metadataSnapshot = () => readBrowserFileSystemSnapshot(this.filesystem, "/", { metadataRoots: ["/"] });
@@ -874,18 +1006,33 @@ export class BrowserWaliWorkerProgram {
             const safePatch = this.withoutHostTrees(this.program.sanitizeFilesystemPatch
                 ? await this.program.sanitizeFilesystemPatch(message.filesystemPatch)
                 : message.filesystemPatch);
-            applyProcessFilesystemPatch(this.filesystem, safePatch, pending.filesystemBase);
-            pending.filesystemBase.apply(safePatch);
+            // A descriptor handoff already flushed the owner before exec/spawn.
+            // The old image's private snapshot cannot compete with that owner.
+            if (!message.descriptorTable) {
+                try {
+                    applyProcessFilesystemPatch(this.filesystem, safePatch, pending.filesystemBase);
+                }
+                catch (error) {
+                    throw new WaliFilesystemCommitError("WALI spawn filesystem commit failed", error);
+                }
+                pending.filesystemBase.apply(safePatch);
+            }
             childFilesystem = await metadataSnapshot();
             trace("spawn-patched");
             const stdinStream = message.stdin ? streamBrowserPipe(message.stdin, controller.signal) : undefined;
             const spawned = browserCommand(message);
-            const result = await backend.run(spawned.command, {
+            const runOptions = {
+                ...(this.terminalInput ? { [waliTerminalInput]: this.terminalInput } : {}),
                 [kernelProcessOwner]: { table: owner.table, identity },
                 ...(table ? { [waliWaitOwner]: { table, agent } } : {}),
                 [browserProcessLineage]: { pid: message.pid, parentPid: message.parentPid, childPidAllocator: message.childPidAllocator },
                 ...(filesystemPolicy ? { filesystemPolicy } : {}),
                 ...(descriptorTable ? { descriptorTable } : {}),
+                ...(message.replaceImage ? { [waliExecCompletion]: {
+                        control: message.control, response: message.response,
+                        ...(message.bufferLease ? { bufferLease: message.bufferLease } : {}),
+                        processIdentity: identity,
+                    } } : {}),
                 cwd: message.cwd,
                 ...(pending.options.terminal ? { terminal: pending.options.terminal } : {}),
                 ...(spawned.executablePath ? { executablePath: spawned.executablePath } : {}),
@@ -895,7 +1042,9 @@ export class BrowserWaliWorkerProgram {
                 ...(message.stdout ? { onStdoutBytes: stdoutBytes } : {}),
                 onStdout: stdout,
                 onStderr: stderr,
-            });
+            };
+            const result = await backend.run(spawned.command, runOptions);
+            replaced = result.replaced === true;
             // Tabnode streams long-running commands, but may only return buffered
             // output for short commands. Deliver exactly one form to the child pipe.
             if (result.stdout && !stdoutStreamed)
@@ -905,7 +1054,10 @@ export class BrowserWaliWorkerProgram {
             trace("spawn-ran");
             await Promise.all([stdoutWrites, stderrWrites]);
             await releaseDescriptors();
-            encodeProcessPatch(message, await patchAgainst(childFilesystem), result.exitCode);
+            // exec transferred this same completion record. The successor is its
+            // only producer; publishing here would reap a still-running process.
+            if (!replaced)
+                encodeProcessPatch(message, await patchAgainst(childFilesystem), result.exitCode);
             trace("spawn-returned");
         }
         catch (error) {
@@ -914,7 +1066,12 @@ export class BrowserWaliWorkerProgram {
                 && controller.signal.reason?.handled !== true;
             const signal = typeof delivered === "number" && Number.isInteger(delivered) && delivered > 0 && delivered <= 64
                 ? delivered : cancellation ? abortSignalNumber(controller.signal.reason) : undefined;
-            if (signal === undefined) {
+            const kernelFailure = isFilesystemCommitError(error);
+            if (signal === undefined && kernelFailure) {
+                pending.options.onDiagnostic?.(`[WALI filesystem] ${error instanceof Error ? error.message : String(error)}`);
+                await Promise.allSettled([stdoutWrites, stderrWrites]);
+            }
+            else if (signal === undefined) {
                 const text = `${error instanceof Error ? error.message : String(error)}\n`;
                 stderr(text);
                 await stderrWrites;
@@ -925,7 +1082,7 @@ export class BrowserWaliWorkerProgram {
                 await Promise.allSettled([stdoutWrites, stderrWrites]);
             }
             await releaseDescriptors();
-            encodeProcessPatch(message, await patchAgainst(childFilesystem), signal === undefined ? 127 : 128 + signal, signal);
+            encodeProcessPatch(message, kernelFailure ? { files: [], removed: [] } : await patchAgainst(childFilesystem), signal === undefined ? 127 : 128 + signal, signal);
         }
         finally {
             table?.removeImage(agent.image);
@@ -935,7 +1092,8 @@ export class BrowserWaliWorkerProgram {
             closeExternalPipe(message.stdin);
             closeExternalPipe(message.stdout);
             closeExternalPipe(message.stderr);
-            releaseWaliSharedBuffers(message.bufferLease);
+            if (!replaced)
+                releaseWaliSharedBuffers(message.bufferLease);
         }
     }
     async applyLiveFilesystemPatch(id, message) {
@@ -963,6 +1121,10 @@ export class BrowserWaliWorkerProgram {
             this.scheduleFilesystemImport(pending);
             return;
         }
+        // An inherited owner's updates arrive on that owner's port, not this
+        // image's bootstrap port. Imported/checkpoint acknowledgements still run.
+        if (pending.options.descriptorTable && message.type === "filesystem")
+            return;
         try {
             if (message.type === "import-error")
                 throw new Error(message.message);
@@ -1007,7 +1169,7 @@ export class BrowserWaliWorkerProgram {
                 return;
             this.finishPending();
             this.resetWorker();
-            pending.reject(new Error(`WALI filesystem update could not be applied: ${error instanceof Error ? error.message : String(error)}`));
+            pending.reject(new WaliFilesystemCommitError(`WALI filesystem update could not be applied: ${error instanceof Error ? error.message : String(error)}`, error));
             return;
         }
         try {
@@ -1120,6 +1282,10 @@ export class BrowserWaliWorkerProgram {
             if (this.waitOwner)
                 execPools.delete(this.waitOwner.table);
         }
+        this.releaseKernelNetwork?.();
+        this.releaseKernelNetwork = undefined;
+        this.releaseKernelFilesystem?.();
+        this.releaseKernelFilesystem = undefined;
         this.pending?.resolveFilesystemFinalization();
         this.pending?.removeAbortListener();
         this.pending?.releaseLoopback();
@@ -1130,6 +1296,7 @@ export class BrowserWaliWorkerProgram {
         this.waitOwner = undefined;
         this.stdin?.close();
         this.stdin = undefined;
+        this.terminalInput = undefined;
         for (const port of this.processPorts)
             port.close();
         this.processPorts = [];
@@ -1166,14 +1333,19 @@ export class BrowserWaliWorkerProgram {
         }
         this.urlScanTail = text.slice(-2048);
     }
-    resetWorker(reusable = false) {
-        for (const finish of this.forkCleanup.values())
-            finish();
-        this.forkCleanup.clear();
-        this.forkWorkers.clear();
-        for (const controller of this.childControllers.values())
-            controller.abort();
-        this.childControllers.clear();
+    resetWorker(reusable = false, preserveChildren = false) {
+        // Image replacement retires a worker, not its process's children or the
+        // successor now running through spawnChild. Their owner callbacks remain
+        // alive until their normal completion; cancellation still tears them down.
+        if (!preserveChildren) {
+            for (const finish of this.forkCleanup.values())
+                finish();
+            this.forkCleanup.clear();
+            this.forkWorkers.clear();
+            for (const controller of this.childControllers.values())
+                controller.abort();
+            this.childControllers.clear();
+        }
         // A retained program object must not retain its retired worker realm.
         // The next run starts lazily; late events are rejected by createWorker.
         const worker = this.worker;
@@ -1211,6 +1383,12 @@ function abortSignalNumber(reason) {
  * shell, not what the line runs, so it does not go with it.
  */
 function browserCommand(message) {
+    // execve already resolved an image. Its argv is data, including argv[0];
+    // it must not be renamed or interpreted as another shell command.
+    if (message.replaceImage)
+        return {
+            command: message.argv.map(shellQuote).join(" "), executablePath: message.executablePath,
+        };
     const [program = "", ...args] = message.argv;
     const executable = message.executablePath || program;
     const basename = executable.slice(executable.lastIndexOf("/") + 1);