@nimbus-sh/worker 0.5.0 → 0.7.0

package/dist/session/rpc.js

@@ -21,13 +21,12 @@
  * these ~3 sites would each need ctx threaded through; cast at boundary
  * is acceptable per plan §IX recommendation 1.
  */
-import { enc, dec } from '@nimbus-sh/core/_shared/bytes.js';
+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 { NpmCache } from '../npm/cache.js';
 import { EsbuildService } from '@nimbus-sh/core/runtime/esbuild-service.js';
-import { SqliteRuntimeFsBridge } from '@nimbus-sh/core/runtime/sqlite-runtime-fs-bridge.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';
@@ -39,12 +38,11 @@ import { recordFailure, getLastRpcFrame, getLastFacetId, } from '@nimbus-sh/plat
 import { classifyError } from '@nimbus-sh/platform/oom-classify.js';
 import { acquireSupervisorReadAllocation, } from '@nimbus-sh/platform/heavy-alloc-coord.js';
 import { rpcPayloadEnd, rpcPayloadStart, } from '@nimbus-sh/platform/diag-counters.js';
-import { CRED_KERNEL, CRED_SESSION_USER, } from '@nimbus-sh/core/runtime/os-contracts.js';
-import { getSymlinkRegistry } from '@nimbus-sh/core/vfs/symlink-registry.js';
+import { CRED_KERNEL, CRED_SESSION_USER, requireVfsCred, } from '@nimbus-sh/core/runtime/os-contracts.js';
 import { MAX_RPC_SAFE_PAYLOAD_BYTES } from '@nimbus-sh/platform/limits.js';
 import { FS_LIST_PAGE_LIMIT, FS_READ_BATCH_PATH_LIMIT, FS_READ_BATCH_REQUEST_BYTES, } from '@nimbus-sh/core/constants.js';
 import { routeSessionLoopback } from './loopback.js';
-import { clearPortCapability } from './port-capability.js';
+import { registerServingPort } from './serving-port.js';
 import { normalizeVfsPath, parentVfsPath } from '@nimbus-sh/core/vfs/path.js';
 import { z } from 'zod/v4';
 const WriteBatchInodeSchema = z.object({
@@ -68,11 +66,6 @@ const WriteBatchPayloadSchema = z.object({
     chunks: z.array(WriteBatchChunkSchema).default([]),
     deletePaths: z.array(z.string()).optional(),
 }).passthrough();
-/**
- * Bridge key for the pid-less (host caller) filesystem view. ProcessTable
- * allocates pids from 1 upwards, so 0 can never collide with a process.
- */
-const HOST_CALLER_KEY = 0;
 function processPid(pid) {
     if (!Number.isInteger(pid) || typeof pid !== 'number' || pid <= 0) {
         throw new Error('filesystem RPC requires a valid process pid');
@@ -88,30 +81,24 @@ function processPid(pid) {
  * binding, the remote `/rpc` dispatcher, the static asset server — and those
  * act as the unprivileged session user, the same identity `exec` runs as.
  * A supplied-but-invalid pid still throws: only an absent pid is a host call.
+ *
+ * A host call may name the credential it acts as (`cred`) — the same
+ * `SqliteVFS.as(cred)` view an in-process caller has, reached over the RPC
+ * surface. That is the embedder's trusted surface: the SDK over the DO
+ * binding hands it through `files.as(cred)`; the remote `/rpc` dispatcher
+ * refuses it, exactly as it refuses `cred` on exec, because a token
+ * authenticates a session and not a user inside it. Absent, every file op
+ * keeps the identity it has always had. A pid and a cred together are
+ * refused, so a process can never widen its own identity.
  */
-function callerCred(self, pid) {
-    return pid === undefined ? CRED_SESSION_USER : self.processes.cred(processPid(pid));
-}
-function processVfs(self, pid) {
-    self.ensureSqliteFs();
-    return self.sqliteFs.as(callerCred(self, pid));
-}
-function runtimeFs(self, pid) {
-    const key = pid === undefined ? HOST_CALLER_KEY : processPid(pid);
-    const vfs = processVfs(self, pid);
-    if (!self.runtimeFsBridges)
-        self.runtimeFsBridges = new Map();
-    let bridge = self.runtimeFsBridges.get(key);
-    if (!bridge) {
-        bridge = new SqliteRuntimeFsBridge(vfs, self.sqliteFs);
-        self.runtimeFsBridges.set(key, bridge);
-    }
-    else {
-        bridge.updateCredential(vfs);
-    }
-    return bridge;
-}
-function checkedReadPayloadBytes(bytes) {
+function callerCred(self, pid, cred) {
+    if (pid === undefined)
+        return cred === undefined ? CRED_SESSION_USER : requireVfsCred(cred, 'filesystem RPC');
+    if (cred !== undefined)
+        throw new Error('filesystem RPC: a process acts as its own credential; cred cannot ride a pid');
+    return self.processes.cred(processPid(pid));
+}
+export function checkedReadPayloadBytes(bytes) {
     if (!Number.isSafeInteger(bytes) || bytes < 0) {
         throw new RangeError(`filesystem RPC read size must be a non-negative safe integer: ${bytes}`);
     }
@@ -129,13 +116,13 @@ function checkedReadPayloadBytes(bytes) {
  * `stat` here is a local SQLite lookup inside the DO — the same one
  * `_rpcReadFile` makes for the same reason — not a second round trip.
  */
-async function rangeReadBytes(fs, path, offset, length) {
+export async function rangeReadBytes(fs, path, offset, length) {
     const stat = await fs.stat(path);
     if (!stat)
         return 0;
     return Math.max(0, Math.min(length, stat.size - offset));
 }
-async function withReadAllocation(bytes, read) {
+export async function withReadAllocation(bytes, read) {
     const payloadBytes = checkedReadPayloadBytes(bytes);
     if (payloadBytes === 0)
         return read();
@@ -149,27 +136,21 @@ async function withReadAllocation(bytes, read) {
         lease.release();
     }
 }
-export async function _rpcReadFile(self, path, pid) {
-    const fs = runtimeFs(self, pid);
-    const stat = await fs.stat(path);
-    if (!stat)
-        return null;
-    return withReadAllocation(stat.size, async () => {
-        const bytes = await fs.readFile(path);
-        return bytes ? dec.decode(bytes) : null;
-    });
+/**
+ * `files.readFile` — the read with the supervisor's allocation lease.
+ * The body lives in `buildSessionSupervisorOps`'s `readFile` override so
+ * direct `_rpc*` calls and the supervisor envelope share it.
+ */
+export async function _rpcReadFile(self, path, pid, cred) {
+    return self.supervisorOp({ op: 'readFile', args: [path], pid, cred });
 }
 /**
  * Read a file as raw bytes (Uint8Array). Used by git network facet for
  * binary .git/objects/** and packfile reads, where TextDecoder/TextEncoder
  * round-tripping through readFile (string) would corrupt bytes.
  */
-export async function _rpcReadFileBytes(self, path, pid) {
-    const fs = runtimeFs(self, pid);
-    const stat = await fs.stat(path);
-    if (!stat)
-        return null;
-    return withReadAllocation(stat.size, () => fs.readFile(path));
+export async function _rpcReadFileBytes(self, path, pid, cred) {
+    return self.supervisorOp({ op: 'readFileBytes', args: [path], pid, cred });
 }
 /**
  * Phase-3 inner-DO fetch dispatcher. Called by NimbusDOStub.fetch()
@@ -234,14 +215,11 @@ export async function _rpcInnerDoFetch(self, req) {
         };
     }
 }
-export async function _rpcWriteFile(self, path, content, pid) {
-    // binary-fs wave: SqliteVFS.writeFile already accepts string | Uint8Array
-    // (sqlite-vfs.ts:937), so we forward the content shape unchanged. RPC
-    // structured-clone preserves Uint8Array across the boundary; structured-
-    // clone doesn't accept Buffer subclass instances, so fs.writeFileSync on
-    // a Buffer flows through node-shims.ts:writeFileSync which stores it as
-    // a plain Uint8Array on the cell — the shape that arrives here.
-    return runtimeFs(self, pid).writeFile(path, content);
+export async function _rpcWriteFile(self, path, content, pid, cred) {
+    // binary-fs wave: the bridge's writeFile already accepts
+    // string | Uint8Array — the shape arrives unchanged across structured
+    // clone.
+    return self.supervisorOp({ op: 'writeFile', args: [path, content], pid, cred });
 }
 /**
  * Write one host-governed file at a session root and let ordinary Unix
@@ -274,54 +252,53 @@ export async function _rpcWriteProtectedRootFile(self, rootPath, path, content)
     fs.chown(protectedPath, CRED_KERNEL.uid, CRED_KERNEL.gid);
     fs.chmod(protectedPath, 0o444);
 }
-export async function _rpcStat(self, path, pid) {
-    return runtimeFs(self, pid).stat(path);
+export async function _rpcStat(self, path, pid, cred) {
+    return self.supervisorOp({ op: 'stat', args: [path], pid, cred });
 }
-export async function _rpcLstat(self, path, pid) {
-    return runtimeFs(self, pid).stat(path, { followSymlinks: false });
+export async function _rpcLstat(self, path, pid, cred) {
+    return self.supervisorOp({ op: 'lstat', args: [path], pid, cred });
 }
 export async function _rpcHasLegacySymlinkUnder(self, path, pid) {
-    runtimeFs(self, pid);
-    return getSymlinkRegistry(self.sqliteFs).hasAtOrBelow(path);
+    return self.supervisorOp({ op: 'hasLegacySymlinkUnder', args: [path], pid });
 }
 export async function _rpcUtimes(self, path, atimeMs, mtimeMs, pid) {
-    await runtimeFs(self, pid).utimes(path, atimeMs, mtimeMs);
+    await self.supervisorOp({ op: 'utimes', args: [path, atimeMs, mtimeMs], pid });
 }
-export async function _rpcChmod(self, path, mode, pid) {
-    await runtimeFs(self, pid).chmod(path, mode);
+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 runtimeFs(self, pid).access(path, mode);
+    await self.supervisorBridge(pid).access(path, mode);
 }
 export async function _rpcChown(self, path, uid, gid, pid, options) {
-    await runtimeFs(self, pid).chown(path, uid, gid, options);
+    await self.supervisorBridge(pid).chown(path, uid, gid, options);
 }
 export async function _rpcSetUmask(self, mask, pid) {
     return self.processes.setUmask(processPid(pid), mask);
 }
-export async function _rpcReaddir(self, path, pid) {
-    return runtimeFs(self, pid).readdir(path);
+export async function _rpcReaddir(self, path, pid, cred) {
+    return self.supervisorOp({ op: 'readdir', args: [path], pid, cred });
 }
-export async function _rpcExists(self, path, pid) {
-    return (await runtimeFs(self, pid).stat(path)) !== null;
+export async function _rpcExists(self, path, pid, cred) {
+    return self.supervisorOp({ op: 'exists', args: [path], pid, cred });
 }
-export async function _rpcMkdir(self, path, pid) {
-    await runtimeFs(self, pid).mkdir(path, { recursive: true });
+export async function _rpcMkdir(self, path, pid, cred) {
+    await self.supervisorOp({ op: 'mkdir', args: [path], pid, cred });
 }
 export async function _rpcRmdir(self, path, pid) {
-    await runtimeFs(self, pid).rmdir(path);
+    await self.supervisorOp({ op: 'rmdir', args: [path], pid });
 }
-export async function _rpcRename(self, from, to, pid) {
-    await runtimeFs(self, pid).rename(from, to);
+export async function _rpcRename(self, from, to, pid, cred) {
+    await self.supervisorOp({ op: 'rename', args: [from, to], pid, cred });
 }
 export async function _rpcReadlink(self, path, pid) {
-    return runtimeFs(self, pid).readlink(path);
+    return self.supervisorOp({ op: 'readlink', args: [path], pid });
 }
 export async function _rpcSymlink(self, target, path, pid) {
-    await runtimeFs(self, pid).symlink(target, path);
+    await self.supervisorOp({ op: 'symlink', args: [target, path], pid });
 }
 const FsRangeOffsetSchema = z.number().int().min(0).finite();
-const FsReadRangeArgsSchema = z.object({
+export const FsReadRangeArgsSchema = z.object({
     path: z.string(),
     offset: FsRangeOffsetSchema,
     length: FsRangeOffsetSchema,
@@ -366,7 +343,7 @@ const FsListArgsSchema = z.object({
     limit: z.number().int().min(1).max(FS_LIST_PAGE_LIMIT).nullable(),
 });
 export async function _rpcFsRevision(self, path, pid) {
-    return runtimeFs(self, pid).revision(typeof path === 'string' ? path : undefined);
+    return self.supervisorOp({ op: 'fsRevision', args: [path], pid });
 }
 /**
  * The facet's WebSocket relay. A facet does not open its own sockets: the
@@ -416,23 +393,21 @@ export async function _rpcWsClose(self, id, code, reason, pid) {
  */
 export async function _rpcFsAcquire(self, epoch, cursor, pid) {
     const args = FsAcquireArgsSchema.parse({ epoch, cursor });
-    return runtimeFs(self, pid).acquire(args.epoch, args.cursor);
+    return self.supervisorBridge(pid).acquire(args.epoch, args.cursor);
 }
 /**
  * Enumerate the session filesystem for a process, one bounded page at a time.
  *
- * Goes through `runtimeFs(self, pid)` like every other fs RPC, so the listing
+ * Goes through `self.supervisorBridge(pid)` like every other fs RPC, so the listing
  * is filtered by the calling process's own credential rather than the kernel's
  * — a process must not learn of a path it could not stat.
  */
 export async function _rpcFsList(self, after, limit, pid) {
     const args = FsListArgsSchema.parse({ after: after ?? null, limit: limit ?? null });
-    return runtimeFs(self, pid).list(args.after, args.limit ?? undefined);
+    return self.supervisorBridge(pid).list(args.after, args.limit ?? undefined);
 }
-export async function _rpcFsReadRange(self, path, offset, length, pid) {
-    const args = FsReadRangeArgsSchema.parse({ path, offset, length });
-    const fs = runtimeFs(self, pid);
-    return withReadAllocation(await rangeReadBytes(fs, args.path, args.offset, args.length), () => fs.readRange(args.path, args.offset, args.length));
+export async function _rpcFsReadRange(self, path, offset, length, pid, cred) {
+    return self.supervisorOp({ op: 'fsReadRange', args: [path, offset, length], pid, cred });
 }
 /**
  * The same read, through the same process credential and the same bridge, with
@@ -449,9 +424,7 @@ export async function _rpcFsReadRange(self, path, offset, length, pid) {
  * substrate that was supposed to relieve the coordinator damages it instead.
  */
 export async function _rpcFsReadRangeUncached(self, path, offset, length, pid) {
-    const args = FsReadRangeArgsSchema.parse({ path, offset, length });
-    const fs = runtimeFs(self, pid);
-    return withReadAllocation(await rangeReadBytes(fs, args.path, args.offset, args.length), () => fs.readRange(args.path, args.offset, args.length, { cached: false }));
+    return self.supervisorOp({ op: 'fsReadRangeUncached', args: [path, offset, length], pid });
 }
 /**
  * Read many ranges in ONE round trip.
@@ -481,7 +454,7 @@ export async function _rpcFsReadBatch(self, requests, pid) {
     // Sizing pass. A path this process may not stat contributes nothing and
     // still gets its own entry below — denying one path must not deny the
     // batch, which is what N separate reads would have done.
-    const fs = runtimeFs(self, pid);
+    const fs = self.supervisorBridge(pid);
     let residentBytes = 0;
     for (const request of args) {
         try {
@@ -520,7 +493,7 @@ function readBatchEntryError(error) {
 }
 export async function _rpcFsWriteRange(self, path, offset, bytes, pid) {
     const args = FsWriteRangeArgsSchema.parse({ path, offset });
-    return runtimeFs(self, pid).writeRange(args.path, args.offset, normalizeWriteBatchChunkData(bytes));
+    return self.supervisorBridge(pid).writeRange(args.path, args.offset, normalizeWriteBatchChunkData(bytes));
 }
 export async function _rpcFsAppend(self, path, writerId, moduleId, operationId, bytes, pid) {
     const args = FsAppendArgsSchema.parse({ path, writerId, moduleId, operationId });
@@ -532,7 +505,7 @@ export async function _rpcFsAppend(self, path, writerId, moduleId, operationId,
     const data = normalizeWriteBatchChunkData(bytes);
     const digestBytes = new Uint8Array(await crypto.subtle.digest('SHA-256', data));
     const digest = Array.from(digestBytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
-    return runtimeFs(self, pid).appendOnce(args.path, processId, args.writerId, args.moduleId, sequence, digest, data);
+    return self.supervisorBridge(pid).appendOnce(args.path, processId, args.writerId, args.moduleId, sequence, digest, data);
 }
 export async function _rpcFsAppendAck(self, writerId, moduleId, operationId, pid) {
     const args = FsAppendAckArgsSchema.parse({ writerId, moduleId, operationId });
@@ -541,17 +514,16 @@ export async function _rpcFsAppendAck(self, writerId, moduleId, operationId, pid
         throw new Error('filesystem append operation exceeds the safe integer range');
     }
     const processId = processPid(pid);
-    await runtimeFs(self, processId).acknowledgeAppend(processId, args.writerId, args.moduleId, sequence);
+    await self.supervisorBridge(processId).acknowledgeAppend(processId, args.writerId, args.moduleId, sequence);
 }
 export async function _rpcFsTruncate(self, path, size, pid) {
-    const args = FsTruncateArgsSchema.parse({ path, size });
-    await runtimeFs(self, pid).truncate(args.path, args.size);
+    await self.supervisorOp({ op: 'fsTruncate', args: [path, size], pid });
 }
 export async function _rpcFsOpen(self, path, flags, pid) {
-    return runtimeFs(self, pid).open(path, flags || {});
+    return self.supervisorBridge(pid).open(path, flags || {});
 }
 export async function _rpcFsRead(self, handleId, offset, length, pid) {
-    return withReadAllocation(length, () => runtimeFs(self, pid).read(handleId, offset, length));
+    return withReadAllocation(length, () => self.supervisorBridge(pid).read(handleId, offset, length));
 }
 export async function _rpcFsWrite(self, handleId, offset, bytes, pid) {
     let data;
@@ -561,10 +533,10 @@ export async function _rpcFsWrite(self, handleId, offset, bytes, pid) {
         data = new Uint8Array(bytes);
     else
         data = new Uint8Array(bytes || []);
-    return runtimeFs(self, pid).write(handleId, offset, data);
+    return self.supervisorBridge(pid).write(handleId, offset, data);
 }
 export async function _rpcFsClose(self, handleId, pid) {
-    await runtimeFs(self, pid).close(handleId);
+    await self.supervisorBridge(pid).close(handleId);
 }
 /**
  * Called by CirrusHmrRPC.hmrSend. Runs in the DO's own context so
@@ -577,7 +549,7 @@ export async function _rpcHmrRelay(self, clientId, msg) {
     self.cirrusReal.hmr.relayToBrowser(clientId, msg);
 }
 export async function _rpcUnlink(self, path, pid) {
-    await runtimeFs(self, pid).unlink(path);
+    await self.supervisorOp({ op: 'unlink', args: [path], pid });
 }
 /**
  * Bulk-write files and directories via one transactionSync().
@@ -601,7 +573,7 @@ export async function _rpcWriteBatch(self, payload, pid) {
         chunkId: c.chunkId,
         data: normalizeWriteBatchChunkData(c.data),
     }));
-    return processVfs(self, pid).writeBatch({
+    return self.sqliteFs.as(callerCred(self, pid)).writeBatch({
         inodes,
         chunks,
         deletePaths,
@@ -660,10 +632,8 @@ export async function _rpcWriteBatchStream(self, stream, mutationOwner, pid) {
     // total writeBatchStream RPCs at the coordinator (vs 620+ pre-fix).
     // Workerd's input-gate queue depth on the coordinator stays well
     // under the queue-age threshold without any user-space semaphore.
-    const decodeDrainStartedAt = performance.now();
-    return processVfs(self, pid).writeStream(stream, {
-        decodeDrainStartedAt,
-        mutationOwner,
+    return self.supervisorOp({
+        op: 'writeBatchStream', stream, mutationOwner, pid,
     });
 }
 /**
@@ -695,6 +665,17 @@ function isPriorGenerationPid(self, pid) {
     return pid > 0 && pid <= self.processes.pidBase;
 }
 export const PRIOR_GENERATION_EXIT_REASON = 'process lost: instance reset';
+/**
+ * A process's output arrives as bytes: the relay from the facet carries
+ * Uint8Array so a binary protocol or an image survives it. The two text
+ * consumers here decode at their own edge — the log ring inside
+ * `appendOutputBytes`, and the terminal tee through these per-(pid, stream)
+ * streaming decoders, dropped when the process reports its exit.
+ */
+const _terminalTeeDecoders = new StreamTextDecoders();
+function decodeForTerminal(pid, stream, data) {
+    return _terminalTeeDecoders.decode(`${pid}:${stream}`, data);
+}
 export async function _rpcStdout(self, pid, data) {
     // Prior-generation straggler (facet outlived a DO instance reset): drop —
     // its output must not merge into this generation's logs or shell.
@@ -707,9 +688,11 @@ export async function _rpcStdout(self, pid, data) {
     // un-traceable facets.
     try {
         if (pid > 0)
-            self.processes.appendOutput(pid, 'stdout', data);
+            self.processes.appendOutputBytes(pid, 'stdout', data);
         if (self.terminal && shouldMirrorProcessOutputToShell(self, pid)) {
-            self.terminal.write(normalizeTerminalNewlines(data));
+            const text = decodeForTerminal(pid, 'stdout', data);
+            if (text.length > 0)
+                self.terminal.write(normalizeTerminalNewlines(text));
         }
     }
     catch (e) {
@@ -730,11 +713,13 @@ export async function _rpcStderr(self, pid, data) {
         return;
     try {
         if (pid > 0)
-            self.processes.appendOutput(pid, 'stderr', data);
+            self.processes.appendOutputBytes(pid, 'stderr', data);
         // Terminal gets red wrapping; the ring buffer keeps it raw so the
         // stream tag can drive color decisions at replay time.
         if (self.terminal && shouldMirrorProcessOutputToShell(self, pid)) {
-            self.terminal.write(`\x1b[31m${normalizeTerminalNewlines(data)}\x1b[0m`);
+            const text = decodeForTerminal(pid, 'stderr', data);
+            if (text.length > 0)
+                self.terminal.write(`\x1b[31m${normalizeTerminalNewlines(text)}\x1b[0m`);
         }
     }
     catch (e) {
@@ -782,6 +767,12 @@ export async function _rpcReportExit(self, pid, code, tail) {
         self.processes.closeInput(pid);
     }
     catch { }
+    for (const stream of ['stdout', 'stderr']) {
+        const rest = _terminalTeeDecoders.drop(`${pid}:${stream}`);
+        if (rest.length > 0 && self.terminal && shouldMirrorProcessOutputToShell(self, pid)) {
+            self.terminal.write(normalizeTerminalNewlines(rest));
+        }
+    }
     // A relayed socket is held open by the supervisor on the process's behalf,
     // so it does not die when the facet does. Nothing else would ever close
     // it, and a live one keeps buffering into the supervisor's heap.
@@ -789,7 +780,7 @@ export async function _rpcReportExit(self, pid, code, tail) {
         self.webSocketRelay?.closeForPid(pid);
     }
     catch { }
-    self.runtimeFsBridges?.delete(pid);
+    self.supervisorForgetBridge?.(pid);
     if (tail)
         self.processes.appendOutput(pid, 'stderr', tail);
     // Guard against double-reporting: if we've already recorded exit
@@ -951,7 +942,7 @@ export function _reportExternalExit(self, pid, code, reason) {
         self.webSocketRelay?.closeForPid(pid);
     }
     catch { }
-    self.runtimeFsBridges?.delete(pid);
+    self.supervisorForgetBridge?.(pid);
     if (reason) {
         self.processes.appendOutput(pid, 'stderr', `[process killed: ${reason}]\n`);
     }
@@ -1005,23 +996,21 @@ export async function _rpcPrefetch(self, cwd, entryCode) {
     // want to refresh the bundle mid-execution; today only the
     // SupervisorRPC.prefetch surface exposes it externally.
     self.ensureSqliteFs();
-    const { prefetchForRequire } = await import('@nimbus-sh/core/runtime/require-resolver.js');
-    return prefetchForRequire(self.sqliteFs, entryCode, cwd).bundle;
+    // Dynamic import stays: keeps the resolver out of this module's eager
+    // graph (the original reason for the lazy load above).
+    const { prefetchForRequire, ClosureBoundExceededError } = await import('@nimbus-sh/core/runtime/require-resolver.js');
+    const outcome = prefetchForRequire(self.sqliteFs, entryCode, cwd);
+    if ('kind' in outcome)
+        throw new ClosureBoundExceededError(outcome);
+    return outcome.bundle;
 }
 export async function _rpcRegisterPort(self, pid, port) {
     // Port registration stores the facet association — the actual facet stub
-    // is stored by FacetManager separately. Registration goes through the
-    // manager so a pid binding a reserved port inherits the reservation's
-    // durable contract: its journal row is stamped with the port's owner and
-    // the stored capability is re-adopted rather than retired.
-    if (self.facetManager) {
-        await self.facetManager.registerPort(pid, port);
-        return;
-    }
-    // No facet manager yet means nothing resident is running — a bare
-    // registration retires the previous occupant's preview capability.
-    await clearPortCapability(self, port);
-    self.portRegistry.register(port, pid);
+    // is stored by FacetManager separately. The same registration every
+    // serving process uses: through the manager, so the pid's identity —
+    // its journal row, or the process table — decides whether a reservation's
+    // capability is re-adopted or retired.
+    await registerServingPort(self, pid, port);
 }
 export async function _rpcUnregisterPort(self, port) {
     self.portRegistry.unregister(port);
@@ -1062,14 +1051,29 @@ export async function _rpcCpSpawn(self, req) {
     const fpm = self._ensureFacetProcessManager();
     return fpm.spawn(req);
 }
+/**
+ * A child's stdin is bytes: esbuild's service protocol is binary packets,
+ * and so is any pipe carrying an image or an archive. The facet queue and
+ * this contract carry Uint8Array; the interactive input store is a text
+ * channel fed by a terminal, so it decodes at its own edge with a streaming
+ * decoder held per child, which keeps a multibyte character split across two
+ * writes correct.
+ */
+const _cpStdinDecoders = new Map();
 export async function _rpcCpStdinWrite(self, childPid, data) {
     if (self.processes.hasInput(childPid)) {
-        return self.processes.writeInput(childPid, data);
+        let decoder = _cpStdinDecoders.get(childPid);
+        if (!decoder) {
+            decoder = new TextDecoder('utf-8');
+            _cpStdinDecoders.set(childPid, decoder);
+        }
+        return self.processes.writeInput(childPid, decoder.decode(data, { stream: true }));
     }
     const fpm = self._ensureFacetProcessManager();
     return fpm.stdinWrite(childPid, data);
 }
 export async function _rpcCpStdinEnd(self, childPid) {
+    _cpStdinDecoders.delete(childPid);
     if (self.processes.hasInput(childPid)) {
         self.processes.endInput(childPid);
         return;
@@ -1086,7 +1090,10 @@ export async function _rpcCpReadStdin(self, childPid, waitMs) {
         return { signal: 'SIGKILL', ended: true };
     }
     if (self.processes.hasInput(childPid)) {
-        return self.processes.readInput(childPid, waitMs);
+        // 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 fpm = self._ensureFacetProcessManager();
     return fpm.cpReadStdin(childPid, waitMs);

package/dist/session/serving-port.d.ts

@@ -0,0 +1,27 @@
+/**
+ * session/serving-port.ts — how a process that serves a port is registered.
+ *
+ * One path for every serving pid, whether the facet manager launched it (a
+ * node/runtime resident with a journal row) or the session runs it in
+ * process (the Cirrus Vite shim, real-vite, `vite preview`, a builtin that
+ * adopted a shell wrapper pid). The manager's registration stamps the
+ * journal row when there is one, reads the process table's identity when
+ * there is not, and re-adopts a reservation the identity owns instead of
+ * retiring its capability — which is what lets a dev server exposed under a
+ * name come back on the same shared link after a restart or a hibernation.
+ *
+ * The bare registration below is only for a session that has no manager at
+ * all; every DO route that serves a port stands one up first.
+ */
+import type { PortRegistry } from '@nimbus-sh/core/runtime/port-registry.js';
+import { type PortCapabilityHost } from './port-capability.js';
+export interface ServingPortHost {
+    ctx: PortCapabilityHost['ctx'];
+    portRegistry: PortRegistry;
+    facetManager: {
+        registerPort(pid: number, port: number): Promise<void>;
+    } | null;
+    ensureFacetManager?(): void;
+}
+export declare function registerServingPort(self: ServingPortHost, pid: number, port: number): Promise<void>;
+//# sourceMappingURL=serving-port.d.ts.map

package/dist/session/serving-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serving-port.d.ts","sourceRoot":"","sources":["../../src/session/serving-port.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAC7E,OAAO,EAAuB,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAEpF,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC/B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE;QAAE,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC;IAChF,kBAAkB,CAAC,IAAI,IAAI,CAAC;CAC7B;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUzG"}

package/dist/session/serving-port.js

@@ -0,0 +1,27 @@
+/**
+ * session/serving-port.ts — how a process that serves a port is registered.
+ *
+ * One path for every serving pid, whether the facet manager launched it (a
+ * node/runtime resident with a journal row) or the session runs it in
+ * process (the Cirrus Vite shim, real-vite, `vite preview`, a builtin that
+ * adopted a shell wrapper pid). The manager's registration stamps the
+ * journal row when there is one, reads the process table's identity when
+ * there is not, and re-adopts a reservation the identity owns instead of
+ * retiring its capability — which is what lets a dev server exposed under a
+ * name come back on the same shared link after a restart or a hibernation.
+ *
+ * The bare registration below is only for a session that has no manager at
+ * all; every DO route that serves a port stands one up first.
+ */
+import { clearPortCapability } from './port-capability.js';
+export async function registerServingPort(self, pid, port) {
+    self.ensureFacetManager?.();
+    if (self.facetManager) {
+        await self.facetManager.registerPort(pid, port);
+        return;
+    }
+    // No manager means nothing resident is running — a bare registration
+    // retires the previous occupant's preview capability.
+    await clearPortCapability(self, port);
+    self.portRegistry.register(port, pid);
+}

package/dist/session/start-real-vite.d.ts

@@ -26,6 +26,18 @@ export interface StartRealViteOptions {
     /** Directory the user's vite.config.{ts,js,mjs} is searched in (the shell
      *  cwd at start). Persisted so restore can re-bundle it. */
     configDir: string;
+    /**
+     * The process-table cwd+argv the dev server's pid is given — what the app
+     * verbs derive its identity from. The `vite` builtin passes the wrapper
+     * pid's own (or the argv it was invoked with); restore passes what was
+     * persisted, so the restored server is the same application. Absent for
+     * configs written before identity was persisted: those keep the bare
+     * `[]` at the root, the same across every restore.
+     */
+    identity?: {
+        cwd: string;
+        argv: string[];
+    };
     /** Optional abort signal threaded into the heavy-alloc gate. */
     signal?: AbortSignal;
     /** Called with a human message if vite.config pre-bundling fails (so the

package/dist/session/start-real-vite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start-real-vite.d.ts","sourceRoot":"","sources":["../../src/session/start-real-vite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAMtD,MAAM,WAAW,oBAAoB;IACnC,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB;gEAC4D;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;4EACwE;IACxE,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3C;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,UAAU,CAAC;IACvB,+EAA+E;IAC/E,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,8CAA8C;IAC9C,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA8GvG"}
+{"version":3,"file":"start-real-vite.d.ts","sourceRoot":"","sources":["../../src/session/start-real-vite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAMtD,MAAM,WAAW,oBAAoB;IACnC,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB;gEAC4D;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAC3C,gEAAgE;IAChE,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;4EACwE;IACxE,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3C;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,UAAU,CAAC;IACvB,+EAA+E;IAC/E,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,8CAA8C;IAC9C,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA8GvG"}