@nimbus-sh/worker 0.9.0 → 0.11.0

package/dist/session/rpc.js

@@ -24,14 +24,17 @@
 import { enc, StreamTextDecoders } from '@nimbus-sh/core/_shared/bytes.js';
 import { normalizeTerminalNewlines } from '@nimbus-sh/core/_shared/terminal.js';
 import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
-import { getInnerDoClass } from '@nimbus-sh/fabric/inner-do-registry.js';
+import { getInnerDoClass, noteInnerDoFacetOpened } from '@nimbus-sh/fabric/inner-do-registry.js';
 import { NpmCache } from '../npm/cache.js';
-import { EsbuildService } from '@nimbus-sh/core/runtime/esbuild-service.js';
+import { supervisorEsbuildService } from '../facets/esbuild-transform.js';
 import { notifyTerminalEvent } from '../runtime/process-logs-api.js';
 import { IsolatePool } from '@nimbus-sh/fabric/isolate-pool.js';
 import { residentBootSpecSchema, } from '@nimbus-sh/fabric/process-fabric.js';
 import { processes, } from '@nimbus-sh/fabric/workerd-facet-host.js';
 import { supervisorEntrypoint } from '@nimbus-sh/fabric/composition.js';
+import { residentFacetOf } from '@nimbus-sh/fabric/workerd-facet-host.js';
+import { readHydrating } from '@nimbus-sh/core/workspace/supervisor-op.js';
+import { isVfsError } from '@nimbus-sh/core/vfs/vfs-error.js';
 import { headerPairs, isolateToken, } from '@nimbus-sh/fabric/process-host.js';
 import { OpencodeStageSpecSchema } from '../facets/opencode-staging.js';
 import { recordFailure, getLastRpcFrame, getLastFacetId, } from '@nimbus-sh/platform/oom-discriminator.js';
@@ -174,7 +177,12 @@ export async function _rpcInnerDoFetch(self, req) {
         };
     }
     const facetName = 'innerDO-' + req.bindingName + '-' + req.id;
-    const facet = self.ctx.facets.get(facetName, async () => ({
+    const ctx = self.ctx;
+    if (noteInnerDoFacetOpened(ctx, req.bindingName, facetName)) {
+        // Each build of the inner worker is a new class; get() with it on a facet still running an older one resets this object.
+        ctx.facets.abort(facetName, new Error('Nimbus: this inner Durable Object restarts on the current build'));
+    }
+    const facet = ctx.facets.get(facetName, async () => ({
         class: cls,
         id: req.id, // FacetStartupOptions.id — inner DO sees this as its ctx.id
     }));
@@ -260,12 +268,6 @@ export async function _rpcLstat(self, path, pid, cred) {
 export async function _rpcChmod(self, path, mode, pid, cred) {
     await self.supervisorOp({ op: 'chmod', args: [path, mode], pid, cred });
 }
-export async function _rpcAccess(self, path, mode, pid) {
-    await self.supervisorBridge(pid).access(path, mode);
-}
-export async function _rpcChown(self, path, uid, gid, pid, options) {
-    await self.supervisorBridge(pid).chown(path, uid, gid, options);
-}
 export async function _rpcSetUmask(self, mask, pid) {
     return self.processes.setUmask(processPid(pid), mask);
 }
@@ -282,13 +284,28 @@ export async function _rpcRename(self, from, to, pid, cred) {
     await self.supervisorOp({ op: 'rename', args: [from, to], pid, cred });
 }
 const FsRangeOffsetSchema = z.number().int().min(0).finite();
-const FsReadBatchArgsSchema = z.array(z.object({
+/** A range of a file: what `fsReadRange` reads. */
+const FsReadBatchRangeSchema = z.object({
     path: z.string().min(1),
     offset: FsRangeOffsetSchema,
     length: FsRangeOffsetSchema.max(FS_READ_BATCH_REQUEST_BYTES),
     expectedEpoch: z.string().optional(),
     expectedRevision: FsRangeOffsetSchema.optional(),
-})).min(1).max(FS_READ_BATCH_PATH_LIMIT);
+});
+/**
+ * A path's own metadata, not followed through a symlink: what `lstat`
+ * answers. Strict, so a request naming a range too is read as the range.
+ */
+const FsReadBatchLstatSchema = z.object({
+    path: z.string().min(1),
+    lstat: z.literal(true),
+}).strict();
+const FsReadBatchArgsSchema = z.array(z.union([FsReadBatchLstatSchema, FsReadBatchRangeSchema]))
+    .min(1).max(FS_READ_BATCH_PATH_LIMIT);
+/** The file bytes a batch request may return: its range's length; an lstat, none. */
+export function fsReadBatchRequestBytes(request) {
+    return 'length' in request ? request.length : 0;
+}
 const FsWriteRangeArgsSchema = z.object({
     path: z.string(),
     offset: FsRangeOffsetSchema,
@@ -313,6 +330,13 @@ const FsTruncateArgsSchema = z.object({
 const FsAcquireArgsSchema = z.object({
     epoch: z.string().max(64).nullable(),
     cursor: z.number().int().min(0),
+    options: z.object({
+        namespace: z.boolean().optional(),
+        push: z.object({
+            roots: z.array(z.string().max(4096)).max(64),
+            exclude: z.array(z.string().max(255)).max(64).optional(),
+        }).strict().optional(),
+    }).strict().optional(),
 });
 // Also facet-supplied, so also untrusted. `after` is a resume key from a
 // previous page and is bounded like any other path; `limit` is clamped rather
@@ -369,9 +393,97 @@ export async function _rpcWsClose(self, id, code, reason, pid) {
  * survive structured clone across the RPC boundary, so a cursor carried that
  * way would silently arrive as undefined.
  */
-export async function _rpcFsAcquire(self, epoch, cursor, pid) {
-    const args = FsAcquireArgsSchema.parse({ epoch, cursor });
-    return self.supervisorBridge(pid).acquire(args.epoch, args.cursor);
+export async function _rpcFsAcquire(self, epoch, cursor, options, pid) {
+    const args = FsAcquireArgsSchema.parse({ epoch, cursor, options: options ?? undefined });
+    return self.supervisorBridge(pid).acquire(args.epoch, args.cursor, args.options);
+}
+const FsStorageGrantArgsSchema = z.object({
+    facet: z.string().min(1),
+    bytes: z.number().int().min(0),
+    databaseSize: z.number().min(0),
+});
+/**
+ * N18: a process's facet store asks for room to grow, reporting what its
+ * database measures. The ledger's row for the facet first takes the
+ * measurement where it is over the record (overshoot), then admits `bytes`
+ * more under the facet's name; refused, nothing is granted and the store
+ * keeps what it has (reading the rest through the session).
+ */
+export async function _rpcFsStorageGrant(self, facet, bytes, databaseSize, pid) {
+    const args = FsStorageGrantArgsSchema.parse({ facet, bytes, databaseSize });
+    const owner = self.ctx !== undefined && pid !== undefined ? residentFacetOf(self.ctx, pid) : undefined;
+    if (owner !== undefined && owner !== args.facet) {
+        throw new Error(`EPERM: process ${pid} lives in facet ${owner}, not ${args.facet}`);
+    }
+    const ledger = self.sqliteFs?.ledger;
+    if (ledger === undefined)
+        return { granted: 0 };
+    const recorded = ledger.view().facets[args.facet] ?? 0;
+    if (args.databaseSize > recorded)
+        ledger.report(args.facet, args.databaseSize);
+    if (args.bytes === 0)
+        return { granted: 0 };
+    try {
+        ledger.fill(args.facet, args.bytes);
+        return { granted: args.bytes };
+    }
+    catch (error) {
+        if (isVfsError(error, 'ENOSPC'))
+            return { granted: 0 };
+        throw error;
+    }
+}
+/**
+ * The ACQUIRE a delivery carries, so the process it is delivered to applies
+ * it instead of asking.
+ *
+ * A stdin packet, a child's output or exit, a request routed to a port: the
+ * supervisor hands each of these to a process, and the process may not run
+ * the code they wake until it has applied everything written before them
+ * (protocol §3, §5.6). Asking costs a round trip per delivery, which an
+ * attached terminal pays on every keystroke. But the supervisor is already
+ * answering: `args` are what the process would pass to fsAcquire, and
+ * `answer` is exactly what fsAcquire answers for them, computed here, after
+ * the thing delivered was queued. Every write that preceded it is in the
+ * answer, and the delivery carries it, so it cannot be lost or reordered
+ * apart from it.
+ *
+ * One format with fsAcquire's own: the same arguments, checked by the same
+ * schema, answered by the same function. Undefined when there is no answer
+ * to carry — the process sent no arguments it can be answered for, or this
+ * one could not be computed — and the process then asks, as it always has,
+ * where a failure is counted and handled. It is never a reason to fail the
+ * delivery: that would lose a dequeued keystroke or a routed request.
+ */
+export async function _acquireOnDelivery(self, args, pid) {
+    const parsed = FsAcquireArgsSchema.safeParse(args);
+    if (!parsed.success)
+        return undefined;
+    const caller = pid !== undefined && pid > 0 ? pid : undefined;
+    try {
+        return {
+            args: parsed.data,
+            answer: await _rpcFsAcquire(self, parsed.data.epoch, parsed.data.cursor, parsed.data.options, caller),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The ACQUIRE a request routed to `pid`'s port carries. The supervisor, not
+ * the process, starts a request, so it holds no cursor of the process's to
+ * answer from, and answers from its own: "nothing since now". The process can
+ * use that only when it is already there, which is protocol §9.2's
+ * one-integer piggyback — true for any request no write preceded since the
+ * process last caught up — and otherwise asks.
+ */
+export function _acquireForRoutedRequest(self, pid) {
+    self.ensureSqliteFs();
+    const vfs = self.sqliteFs;
+    if (!vfs)
+        return Promise.resolve(undefined);
+    return _acquireOnDelivery(self, { epoch: vfs.epoch, cursor: vfs.revision() }, pid);
 }
 /**
  * Enumerate the session filesystem for a process, one bounded page at a time.
@@ -388,10 +500,11 @@ export async function _rpcFsReadRange(self, path, offset, length, pid, cred) {
     return self.supervisorOp({ op: 'fsReadRange', args: [path, offset, length], pid, cred });
 }
 /**
- * Read many ranges in ONE round trip.
+ * Read many ranges, and lstat many paths, in ONE round trip.
  *
- * Every entry is the same read `_rpcFsReadRange` performs, through the same
- * process credential and the same live bridge, in request order. A batch is
+ * Every entry is the same read `_rpcFsReadRange` performs, or the same stat
+ * the `lstat` op performs, through the same process credential and the same
+ * live bridge, in request order. A batch is
  * therefore exactly as authoritative as the individual reads it replaces —
  * it takes no snapshot and consults nothing the single-read path would not.
  * What it saves is round trips, which is the whole cost of a read.
@@ -407,7 +520,7 @@ export async function _rpcFsReadRange(self, path, offset, length, pid, cred) {
  */
 export async function _rpcFsReadBatch(self, requests, pid) {
     const args = FsReadBatchArgsSchema.parse(requests);
-    const requestedBytes = args.reduce((total, request) => total + request.length, 0);
+    const requestedBytes = args.reduce((total, request) => total + fsReadBatchRequestBytes(request), 0);
     if (requestedBytes > FS_READ_BATCH_REQUEST_BYTES) {
         throw new RangeError(`filesystem read batch requests ${requestedBytes} bytes across ${args.length} ranges, `
             + `over the ${FS_READ_BATCH_REQUEST_BYTES}-byte limit`);
@@ -418,6 +531,8 @@ export async function _rpcFsReadBatch(self, requests, pid) {
     const fs = self.supervisorBridge(pid);
     let residentBytes = 0;
     for (const request of args) {
+        if (!('length' in request))
+            continue;
         try {
             residentBytes += await rangeReadBytes(fs, request.path, request.offset, request.length);
         }
@@ -427,9 +542,17 @@ export async function _rpcFsReadBatch(self, requests, pid) {
         const entries = [];
         for (const request of args) {
             try {
-                entries.push({ bytes: await fs.readRange(request.path, request.offset, request.length, {
+                // The lstat op's own call (supervisor-op.ts): the same answer,
+                // `null` for a path that is not there, carried in this trip.
+                if (!('length' in request)) {
+                    entries.push({ stat: (await fs.stat(request.path, { followSymlinks: false })) ?? null });
+                    continue;
+                }
+                // N17: bytes still being imported are waited for, not failed.
+                const hydrated = (path) => (typeof self.getFilesystemAuthority === 'function' ? self.getFilesystemAuthority().hydrated(path) : Promise.resolve());
+                entries.push({ bytes: await readHydrating(hydrated, async () => fs.readRange(request.path, request.offset, request.length, {
                         expectedEpoch: request.expectedEpoch, expectedRevision: request.expectedRevision,
-                    }) });
+                    })) });
             }
             catch (error) {
                 entries.push({ error: readBatchEntryError(error) });
@@ -489,9 +612,6 @@ export async function _rpcHmrRelay(self, clientId, msg) {
         return;
     self.cirrusReal.hmr.relayToBrowser(clientId, msg);
 }
-export async function _rpcUnlink(self, path, pid) {
-    await self.supervisorOp({ op: 'unlink', args: [path], pid });
-}
 /**
  * Bulk-write files and directories via one transactionSync().
  * Called from facets that accumulate writes locally (git clone/fetch/pull,
@@ -582,7 +702,7 @@ export async function _rpcWriteBatchStream(self, stream, mutationOwner, pid) {
  * resolver-facet to flush a wave of resolved packages back to the
  * supervisor without per-entry round-trips.
  *
- * Payload is the array of RegistryCacheEntry shapes from src/npm-cache.ts.
+ * Payload is the array of RegistryCacheEntry shapes from src/npm/cache.ts.
  * Returns { written, failed } so the facet can surface partial-write
  * warnings to the install log.
  */
@@ -683,7 +803,11 @@ function shouldMirrorProcessOutputToShell(self, pid) {
     // the prompt).
     if (!entry)
         return false;
-    return entry.attachedTty !== true;
+    // An exited process's straggling writes (a timer still firing in its facet)
+    // would land after the shell's prompt.
+    if (entry.state !== 'running')
+        return false;
+    return entry.attachedTty !== true && entry.foreground !== true;
 }
 /**
  * Called by facets from their `finally` block after I/O has drained.
@@ -693,7 +817,7 @@ function shouldMirrorProcessOutputToShell(self, pid) {
  *
  * Idempotent — double-call is a no-op (ProcessLogStore.markExit guards).
  */
-export async function _rpcReportExit(self, pid, code, tail) {
+export async function _rpcReportExit(self, pid, code, tail, residencyMisses, profileUnread) {
     if (pid <= 0)
         return; // Ignore the pid-0 sentinel.
     // Prior-generation straggler unwinding after an instance reset: this
@@ -729,8 +853,10 @@ export async function _rpcReportExit(self, pid, code, tail) {
     if (self.processes.getExit(pid))
         return;
     self.processes.markExit(pid, code);
+    // The reads this session served the process, taken whatever the manager does with them.
+    const served = self.servedReads?.take(pid) ?? new Set();
     try {
-        self.facetManager?.noteProcessReportedExit?.(pid, code);
+        self.facetManager?.noteProcessReportedExit?.(pid, code, residencyMisses, { served, profileUnread: profileUnread ?? null });
     }
     catch {
         try {
@@ -967,7 +1093,7 @@ export async function _rpcTransform(self, code, loader) {
         self.ensureSqliteFs();
         if (!self.sqliteFs)
             throw new Error('Session VFS is not initialized');
-        self.esbuildService = new EsbuildService(self.sqliteFs.as(CRED_KERNEL));
+        self.esbuildService = supervisorEsbuildService(self.ctx, self.env, self.getFilesystemAuthority().namespaceFs(CRED_KERNEL));
     }
     try {
         const result = await self.esbuildService.transform(code, {
@@ -1022,7 +1148,17 @@ export async function _rpcCpStdinEnd(self, childPid) {
     const fpm = self._ensureFacetProcessManager();
     fpm.stdinEnd(childPid);
 }
-export async function _rpcCpReadStdin(self, childPid, waitMs) {
+/**
+ * `reply`, carrying the ACQUIRE for the caller (`_acquireOnDelivery`) when it
+ * delivers anything. An empty poll wakes no code, so it is answered bare.
+ */
+async function withDeliveredAcquire(self, reply, delivers, acquire, pid) {
+    if (!delivers)
+        return reply;
+    const acquired = await _acquireOnDelivery(self, acquire, pid);
+    return acquired ? { ...reply, acquired } : reply;
+}
+export async function _rpcCpReadStdin(self, childPid, waitMs, acquire, pid) {
     // Prior-generation straggler: its ProcessInputStore died with the old
     // instance. Deliver a kill so the facet's stdin pump unwinds immediately
     // with explicit semantics (__ProcessExit(137) → reportExit → the honest
@@ -1030,18 +1166,25 @@ export async function _rpcCpReadStdin(self, childPid, waitMs) {
     if (isPriorGenerationPid(self, childPid)) {
         return { signal: 'SIGKILL', ended: true };
     }
+    let packet;
     if (self.processes.hasInput(childPid)) {
         // The interactive input store holds text packets; the child's stdin
         // pump takes bytes, so this text producer encodes at its edge.
-        const packet = await self.processes.readInput(childPid, waitMs);
-        return { ...packet, data: enc.encode(packet.data) };
+        const input = await self.processes.readInput(childPid, waitMs);
+        packet = { ...input, data: enc.encode(input.data) };
     }
-    const fpm = self._ensureFacetProcessManager();
-    return fpm.cpReadStdin(childPid, waitMs);
+    else {
+        const fpm = self._ensureFacetProcessManager();
+        packet = await fpm.cpReadStdin(childPid, waitMs);
+    }
+    const delivers = packet.ended || packet.signal !== undefined || packet.resize !== undefined
+        || packet.data.byteLength > 0;
+    return withDeliveredAcquire(self, packet, delivers, acquire, pid);
 }
-export async function _rpcCpReadOutput(self, childPid, fd, sinceSeq, waitMs) {
+export async function _rpcCpReadOutput(self, childPid, fd, sinceSeq, waitMs, acquire, pid) {
     const fpm = self._ensureFacetProcessManager();
-    return fpm.readOutput(childPid, fd, sinceSeq, waitMs);
+    const output = await fpm.readOutput(childPid, fd, sinceSeq, waitMs);
+    return withDeliveredAcquire(self, output, output.chunks.length > 0 || output.closed, acquire, pid);
 }
 export async function _rpcCpDrainOutput(self, childPid) {
     const fpm = self._ensureFacetProcessManager();
@@ -1051,9 +1194,10 @@ export async function _rpcCpKill(self, childPid, signal) {
     const fpm = self._ensureFacetProcessManager();
     return fpm.kill(childPid, signal);
 }
-export async function _rpcCpWait(self, childPid, waitMs) {
+export async function _rpcCpWait(self, childPid, waitMs, acquire, pid) {
     const fpm = self._ensureFacetProcessManager();
-    return fpm.wait(childPid, waitMs);
+    const status = await fpm.wait(childPid, waitMs);
+    return withDeliveredAcquire(self, status, status.done, acquire, pid);
 }
 /**
  * child-process isolation gap #1: dispatch a single cp.spawn request inline using the
@@ -1189,6 +1333,7 @@ export async function _rpcFanoutExecute(self, fnSource, args, poolOpts = {}) {
         // back to ctx.id.toString() — the legacy behavior, correct for
         // single-DO callers.
         supervisorDoIdOverride: poolOpts.coordinatorDoId,
+        supervisorRoute: poolOpts.coordinatorRoute,
         supervisorPid: poolOpts.supervisorPid,
     });
     try {
@@ -1224,10 +1369,18 @@ const ResidentBootSpecSchema = residentBootSpecSchema(OpencodeStageSpecSchema);
 const HostProcessOptsSchema = z.object({
     /** Full doId of the coordinator session (SUPERVISOR routing target). */
     coordinatorDoId: z.string().min(1),
+    /** The coordinator's route, minted into the process's SUPERVISOR binding. */
+    route: z.object({
+        supervisorEntrypoint: z.string().min(1),
+        hostNamespace: z.string().min(1),
+        hostDispatchMethod: z.string().min(1),
+    }).optional(),
     /** Supervisor-assigned pid of the process entry on the coordinator. */
     pid: z.number().int().positive(),
     /** Trusted identity of this concrete resident-host incarnation. */
     writerId: z.string().uuid(),
+    /** The coordinator instance's delivery incarnation, for the process's SUPERVISOR binding. */
+    hostIncarnation: z.string().uuid().optional(),
     /** Keyed dynamic-worker identity on THIS peer's loader. */
     workerKey: z.string().min(1),
     /** Unforgeable capability for the fetch-semantic WebSocket hop. */
@@ -1264,9 +1417,9 @@ const HOSTED_RECORD_WAIT_MS = 30_000;
  */
 const RESIDENT_READ_RANGE_BYTES = 4 * 1024 * 1024;
 function peerDiskReader(supervisor) {
-    const supervisorRpc = supervisorEntrypoint();
+    const supervisorRpc = supervisorEntrypoint(undefined, supervisor.route?.supervisorEntrypoint);
     if (!supervisorRpc) {
-        throw new Error('Nimbus: ctx.exports.SupervisorRPC unavailable');
+        throw new Error(`Nimbus: ctx.exports.${supervisor.route?.supervisorEntrypoint ?? 'SupervisorRPC'} unavailable`);
     }
     const fs = supervisorRpc({ props: supervisor });
     return { readFile: (path) => readSupervisorFile(fs, path) };
@@ -1366,6 +1519,8 @@ export async function _rpcHostProcess(self, boot, opts) {
         doId: hostOpts.coordinatorDoId,
         pid: hostOpts.pid,
         writerId: hostOpts.writerId,
+        route: hostOpts.route,
+        ...(hostOpts.hostIncarnation === undefined ? {} : { hostIncarnation: hostOpts.hostIncarnation }),
     };
     let cancel = () => { };
     const cancelled = new Promise((resolve) => { cancel = resolve; });

package/dist/session/start-real-vite.js

@@ -16,7 +16,7 @@
  * such session was unrecoverable after eviction.
  */
 import { CRED_KERNEL } from '@nimbus-sh/core/runtime/os-contracts.js';
-import { EsbuildService } from '@nimbus-sh/core/runtime/esbuild-service.js';
+import { supervisorEsbuildService } from '../facets/esbuild-transform.js';
 import { rewriteCirrusViteConfigBundle } from '@nimbus-sh/core/runtime/cirrus-vite-config-rewriter.js';
 import { CirrusReal } from '../facets/cirrus-real.js';
 import { makeLongRunningPortStub } from '@nimbus-sh/core/runtime/long-running-handle.js';
@@ -53,7 +53,7 @@ export async function startRealVite(self, opts) {
         if (cfgPath) {
             try {
                 if (!self.esbuildService)
-                    self.esbuildService = new EsbuildService(kernelFs);
+                    self.esbuildService = supervisorEsbuildService(self.ctx, self.env, self.getFilesystemAuthority().namespaceFs(CRED_KERNEL));
                 const bundleResult = await self.esbuildService.build([cfgPath], {
                     bundle: true,
                     format: 'esm',

package/dist/session/state-store.d.ts

@@ -8,7 +8,7 @@
  * isolate memory: the LIFO Shell instance owned cwd + env vars; the
  * LIFO Kernel owned mount points; the WebSocketTerminal had no
  * persistence at all. A wsClose / wsError nulled all three
- * (src/nimbus-session-ws.ts:165-167, :221-223), and the next /ws
+ * (src/session/ws.ts), and the next /ws
  * upgrade rebuilt them from defaults. Result: cwd reset to ~,
  * env vars lost, scrollback gone, MOTD reprinted — the user-
  * visible Bug C symptom.
@@ -27,7 +27,6 @@
  *     — generic key/value bag for primitives. Today stores 'cwd'
  *       and 'env' (the env is JSON-serialised). One row per key.
  *
- *   nimbus_kernel_mounts (mount_point TEXT PRIMARY KEY)
  *     — explicit mount-point list (B'.2). Empty until B'.2 lands.
  *
  *   nimbus_terminal_scrollback (seq INTEGER PRIMARY KEY, ts INTEGER, data TEXT)
@@ -158,21 +157,6 @@ export declare function clearSessionState(ctx: any): void;
  *  recorder to populate snapshotKeysRehydrated. Cheap; bounded by
  *  the small key set above. */
 export declare function countSessionStateKeys(ctx: any): number;
-/**
- * Load the persisted mount-point list. Returns a plain string[] of
- * mount point names (without leading slash — same shape as
- * DEFAULT_MOUNT_POINTS). Empty array when no rows exist.
- */
-export declare function loadKernelMounts(ctx: any): string[];
-/**
- * Persist a mount-point list. Idempotent — replaces the entire
- * nimbus_kernel_mounts contents in a single transaction. Caller
- * provides the full desired set; we don't merge with existing rows.
- *
- * `mounts` should be plain names without leading slash
- * ('bin', 'etc', ...) — same shape DEFAULT_MOUNT_POINTS uses.
- */
-export declare function persistKernelMounts(ctx: any, mounts: string[]): void;
 /**
  * Append one coalesced output frame. Inserts a row, then evicts the
  * oldest rows until total bytes ≤ SCROLLBACK_MAX_BYTES.

package/dist/session/state-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state-store.d.ts","sourceRoot":"","sources":["../../src/session/state-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH;;;;;;;;iDAQiD;AACjD,eAAO,MAAM,qBAAqB,QAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;qEAyBqE;AACrE,eAAO,MAAM,oBAAoB,QAAc,CAAC;AAChD;;;;;;aAMa;AACb,eAAO,MAAM,0BAA0B,QAAa,CAAC;AAErD;mCACmC;AACnC,eAAO,MAAM,OAAO,QAAQ,CAAC;AAC7B,eAAO,MAAM,YAAY,QAAQ,CAAC;AAClC,eAAO,MAAM,eAAe,gBAAgB,CAAC;AAE7C,2EAA2E;AAC3E,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACnC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;iDAE6C;IAC7C,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAiCvD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,kBAAkB,CAqC3D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,GAAG,EACR,KAAK,EAAE;IAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;CAAE,GAChE,IAAI,CA6BN;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAQ5D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAOhD;AAED;;+BAE+B;AAC/B,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAQtD;AAaD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,EAAE,CAWnD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAcpE;AAwBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CA6E3E;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAW/C;AAED,mEAAmE;AACnE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,GAAG;IAC5C,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;CAC/C,CAaA"}
+{"version":3,"file":"state-store.d.ts","sourceRoot":"","sources":["../../src/session/state-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;iDAQiD;AACjD,eAAO,MAAM,qBAAqB,QAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;qEAyBqE;AACrE,eAAO,MAAM,oBAAoB,QAAc,CAAC;AAChD;;;;;;aAMa;AACb,eAAO,MAAM,0BAA0B,QAAa,CAAC;AAErD;mCACmC;AACnC,eAAO,MAAM,OAAO,QAAQ,CAAC;AAC7B,eAAO,MAAM,YAAY,QAAQ,CAAC;AAClC,eAAO,MAAM,eAAe,gBAAgB,CAAC;AAE7C,2EAA2E;AAC3E,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACnC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;iDAE6C;IAC7C,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CA+BvD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,kBAAkB,CAqC3D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,GAAG,EACR,KAAK,EAAE;IAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;CAAE,GAChE,IAAI,CA6BN;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAQ5D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAMhD;AAED;;+BAE+B;AAC/B,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAQtD;AAwBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CA6E3E;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAW/C;AAED,mEAAmE;AACnE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,GAAG;IAC5C,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;CAC/C,CAaA"}

package/dist/session/state-store.js

@@ -8,7 +8,7 @@
  * isolate memory: the LIFO Shell instance owned cwd + env vars; the
  * LIFO Kernel owned mount points; the WebSocketTerminal had no
  * persistence at all. A wsClose / wsError nulled all three
- * (src/nimbus-session-ws.ts:165-167, :221-223), and the next /ws
+ * (src/session/ws.ts), and the next /ws
  * upgrade rebuilt them from defaults. Result: cwd reset to ~,
  * env vars lost, scrollback gone, MOTD reprinted — the user-
  * visible Bug C symptom.
@@ -27,7 +27,6 @@
  *     — generic key/value bag for primitives. Today stores 'cwd'
  *       and 'env' (the env is JSON-serialised). One row per key.
  *
- *   nimbus_kernel_mounts (mount_point TEXT PRIMARY KEY)
  *     — explicit mount-point list (B'.2). Empty until B'.2 lands.
  *
  *   nimbus_terminal_scrollback (seq INTEGER PRIMARY KEY, ts INTEGER, data TEXT)
@@ -102,11 +101,11 @@ export function ensureSessionStateSchema(ctx) {
     const sql = ctx?.storage?.sql;
     if (!sql)
         return;
+    // The kernel's mount list, retired with the kernel filesystem.
+    sql.exec('DROP TABLE IF EXISTS nimbus_kernel_mounts');
     sql.exec('CREATE TABLE IF NOT EXISTS nimbus_session_kv (' +
         'k TEXT PRIMARY KEY, ' +
         'v TEXT NOT NULL)');
-    sql.exec('CREATE TABLE IF NOT EXISTS nimbus_kernel_mounts (' +
-        'mount_point TEXT PRIMARY KEY)');
     sql.exec('CREATE TABLE IF NOT EXISTS nimbus_terminal_scrollback (' +
         'seq INTEGER PRIMARY KEY AUTOINCREMENT, ' +
         'ts INTEGER NOT NULL, ' +
@@ -243,7 +242,6 @@ export function clearSessionState(ctx) {
         return;
     ensureSessionStateSchema(ctx);
     sql.exec('DELETE FROM nimbus_session_kv');
-    sql.exec('DELETE FROM nimbus_kernel_mounts');
     sql.exec('DELETE FROM nimbus_terminal_scrollback');
 }
 /** Count rows in nimbus_session_kv — used by the recovery_event
@@ -259,54 +257,6 @@ export function countSessionStateKeys(ctx) {
     }
     return 0;
 }
-// ── Kernel mount tree [B'.2] ───────────────────────────────────────────
-//
-// The kernel mount list lives in nimbus_kernel_mounts. Today the list
-// is exactly DEFAULT_MOUNT_POINTS (a static constant in src/constants.ts),
-// so persistence is functionally redundant — every initSession would
-// rebuild the same list from the constant. The architectural reason to
-// route mount-list reads through SQL anyway is to give a future
-// custom-mount feature a stable storage surface: when `mount /r2-cache`
-// is added later, it just inserts a row, and the rehydrate path picks
-// it up without any further refactor.
-/**
- * Load the persisted mount-point list. Returns a plain string[] of
- * mount point names (without leading slash — same shape as
- * DEFAULT_MOUNT_POINTS). Empty array when no rows exist.
- */
-export function loadKernelMounts(ctx) {
-    const sql = ctx?.storage?.sql;
-    if (!sql)
-        return [];
-    ensureSessionStateSchema(ctx);
-    const out = [];
-    for (const row of sql.exec('SELECT mount_point FROM nimbus_kernel_mounts ORDER BY mount_point ASC')) {
-        out.push(String(row.mount_point));
-    }
-    return out;
-}
-/**
- * Persist a mount-point list. Idempotent — replaces the entire
- * nimbus_kernel_mounts contents in a single transaction. Caller
- * provides the full desired set; we don't merge with existing rows.
- *
- * `mounts` should be plain names without leading slash
- * ('bin', 'etc', ...) — same shape DEFAULT_MOUNT_POINTS uses.
- */
-export function persistKernelMounts(ctx, mounts) {
-    const sql = ctx?.storage?.sql;
-    if (!sql)
-        return;
-    ensureSessionStateSchema(ctx);
-    // Replace-all semantics: clear, then insert. The whole table is
-    // bounded by O(10) rows so a full rewrite per persist is cheap.
-    sql.exec('DELETE FROM nimbus_kernel_mounts');
-    for (const mp of mounts) {
-        if (typeof mp !== 'string' || mp.length === 0)
-            continue;
-        sql.exec('INSERT OR REPLACE INTO nimbus_kernel_mounts (mount_point) VALUES (?)', mp);
-    }
-}
 // ── Terminal scrollback [B'.3] ─────────────────────────────────────────
 //
 // Every coalesced WS `output` frame (post-flush) is appended as one

package/dist/session/supervisor-op.d.ts

@@ -17,6 +17,7 @@
  */
 import { type SupervisorOpBridgeStore, type SupervisorOpEnvelope, type SupervisorOpHost } from '@nimbus-sh/core/workspace/supervisor-op.js';
 import type { RuntimeFsBridge, NimbusFilesystemAuthority } from '@nimbus-sh/core/runtime/os-contracts.js';
+import type { SupervisorDeliveries } from '@nimbus-sh/core/workspace/supervisor-delivery.js';
 import type { SqliteVFS } from '@nimbus-sh/core/vfs/sqlite-vfs.js';
 import type { SessionProcessSupervisor } from '@nimbus-sh/core/runtime/session-process-supervisor.js';
 /**
@@ -33,6 +34,12 @@ export interface SessionSupervisorHost {
         filesystem: NimbusFilesystemAuthority;
     } | null;
     getFilesystemAuthority?(): NimbusFilesystemAuthority;
+    /**
+     * This instance's receipts for mutations its processes deliver exactly
+     * once, opened with `openSupervisorDeliveries(ctx)` before anything is
+     * spawned. Absent, the session serves no delivered mutation.
+     */
+    readonly supervisorDeliveries?: SupervisorDeliveries;
     _rpcStdout(pid: number, data: Uint8Array): Promise<void>;
     _rpcStderr(pid: number, data: Uint8Array): Promise<void>;
 }

package/dist/session/supervisor-op.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"supervisor-op.d.ts","sourceRoot":"","sources":["../../src/session/supervisor-op.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAGL,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EAEzB,KAAK,gBAAgB,EAGtB,MAAM,4CAA4C,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAC1G,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AAGtG;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,cAAc,IAAI,IAAI,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,wBAAwB,CAAC;IAC7C,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,UAAU,EAAE,yBAAyB,CAAA;KAAE,GAAG,IAAI,CAAC;IAC7E,sBAAsB,CAAC,IAAI,yBAAyB,CAAC;IACrD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D;AACD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACxE,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,KAAK,eAAe,CAAC;IACnD,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAQD,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,qBAAqB,EAC3B,KAAK,CAAC,EAAE,uBAAuB,EAC/B,OAAO,CAAC,EAAE,gBAAgB,GACzB,oBAAoB,CA8CtB"}
+{"version":3,"file":"supervisor-op.d.ts","sourceRoot":"","sources":["../../src/session/supervisor-op.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAGL,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EAEzB,KAAK,gBAAgB,EAGtB,MAAM,4CAA4C,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAC1G,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kDAAkD,CAAC;AAC7F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AAGtG;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,cAAc,IAAI,IAAI,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,wBAAwB,CAAC;IAC7C,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,UAAU,EAAE,yBAAyB,CAAA;KAAE,GAAG,IAAI,CAAC;IAC7E,sBAAsB,CAAC,IAAI,yBAAyB,CAAC;IACrD;;;;OAIG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IACrD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D;AACD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACxE,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,KAAK,eAAe,CAAC;IACnD,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAQD,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,qBAAqB,EAC3B,KAAK,CAAC,EAAE,uBAAuB,EAC/B,OAAO,CAAC,EAAE,gBAAgB,GACzB,oBAAoB,CAmDtB"}

package/dist/session/supervisor-op.js

@@ -70,6 +70,11 @@ export function buildSessionSupervisorOps(host, store, methods) {
         // Every native read holds a lease for the payload it can answer with.
         readLease: withReadAllocation,
         extend,
+        deliveries: host.supervisorDeliveries,
     });
-    return { dispatch, bridge: store.bridge, forget: store.forget, dispose: store.dispose };
+    const forget = (pid) => {
+        host.supervisorDeliveries?.forget(pid);
+        return store.forget(pid);
+    };
+    return { dispatch, bridge: store.bridge, forget, dispose: store.dispose };
 }