@nimbus-sh/core 0.6.0 → 0.7.0

package/dist/workspace/nimbus-workspace.d.ts

@@ -27,8 +27,11 @@ import type { CommandResult, RunOptions, SandboxFs } from '../substrate/lifo/san
 import type { ITerminal } from '../substrate/lifo/terminal/ITerminal.js';
 import { SqliteVFS } from '../vfs/sqlite-vfs.js';
 import type { SqlDatabase, TransactionHost } from '../runtime/os-contracts.js';
+import { SessionProcessSupervisor } from '../runtime/session-process-supervisor.js';
 import type { FacetHost } from '../runtime/facet-host.js';
 import { type RuntimePackage } from '../runtime/runtime-package.js';
+import { type CtxExports, type FabricComposition } from '@nimbus-sh/platform/composition.js';
+import { type SupervisorOpEnvelope, type SupervisorOpHandler } from './supervisor-op.js';
 export interface NimbusWorkspaceOptions {
     /** The host's SQLite. In a Durable Object: `ctx.storage.sql`. */
     readonly sql: SqlDatabase;
@@ -106,6 +109,15 @@ export interface NimbusWorkspaceOptions {
      * carry REPLs and a resident-process substrate this cannot reach.
      */
     readonly facets?: FacetHost;
+    /** Isolate-wide fabric composition, including the hosting namespace. */
+    readonly fabric?: FabricComposition;
+    /** Explicit exports override the bag on the transaction host. */
+    readonly ctxExports?: CtxExports;
+    /** The process table that allocated supervisor-binding pids. */
+    readonly processes?: SessionProcessSupervisor;
+    readonly processOutput?: (stream: 'stdout' | 'stderr', pid: number, data: string) => void;
+    /** Host operations, including overrides for host-specific accounting. */
+    readonly supervisorOps?: Readonly<Record<string, SupervisorOpHandler>>;
 }
 /**
  * A durable filesystem and a shell over it.
@@ -120,6 +132,7 @@ export interface NimbusWorkspaceOptions {
  */
 export declare class NimbusWorkspace {
     private readonly sql;
+    private readonly supervisorOps;
     /**
      * Credentialed and mount-aware. Acts as the session user, never as the
      * kernel: a pid-less caller must not gain more authority than the shell it
@@ -142,6 +155,8 @@ export declare class NimbusWorkspace {
     private constructor();
     static create(options: NimbusWorkspaceOptions): Promise<NimbusWorkspace>;
     exec(command: string, options?: RunOptions): Promise<CommandResult>;
+    /** The hosting object forwards its supervisorOp RPC to this method. */
+    supervisorOp(envelope: SupervisorOpEnvelope): Promise<unknown>;
     /**
      * Apply the login files, and begin reading the terminal when there is one.
      *

package/dist/workspace/nimbus-workspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nimbus-workspace.d.ts","sourceRoot":"","sources":["../../src/workspace/nimbus-workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,mCAAmC,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AACzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAE7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAI9E,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AAC/F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,EAAE,SAAS,EAAqB,MAAM,sBAAsB,CAAC;AAMpE,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAG/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAK1D,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAKxF,MAAM,WAAW,sBAAsB;IACrC,iEAAiE;IACjE,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,eAAe,CAAC;IACxC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC;IACzB;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,kDAAkD;IAClD,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IACzC;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC9C;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;CAC7B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,eAAe;IA4BxB,OAAO,CAAC,QAAQ,CAAC,GAAG;IA3BtB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAErC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;IAE/C,OAAO;WAoBM,MAAM,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,eAAe,CAAC;IAwD9E,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC;IAInE;;;;;;OAMG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B;;;;;;OAMG;IACH,KAAK,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAK3D;;;;;;;OAOG;IACH,OAAO,IAAI,IAAI;CAKhB;AAwJD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAoElF"}
+{"version":3,"file":"nimbus-workspace.d.ts","sourceRoot":"","sources":["../../src/workspace/nimbus-workspace.ts"],"names":[],"mappings":"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"}

package/dist/workspace/nimbus-workspace.js

@@ -34,6 +34,8 @@ import { rehydrateInstalledRuntimesView, } from '../runtime/installed-runtimes.j
 import { seedRuntimePackage } from '../runtime/runtime-package.js';
 import { registerUnixCommands } from '../shell/unix-commands.js';
 import { installPathExecResolver } from '../shell/exec-dispatch.js';
+import { adoptCtxExports, composeFabric } from '@nimbus-sh/platform/composition.js';
+import { createSupervisorOpHandler } from './supervisor-op.js';
 /**
  * A durable filesystem and a shell over it.
  *
@@ -47,6 +49,7 @@ import { installPathExecResolver } from '../shell/exec-dispatch.js';
  */
 export class NimbusWorkspace {
     sql;
+    supervisorOps;
     /**
      * Credentialed and mount-aware. Acts as the session user, never as the
      * kernel: a pid-less caller must not gain more authority than the shell it
@@ -66,8 +69,9 @@ export class NimbusWorkspace {
      */
     env;
     commands;
-    constructor(vfs, kernel, shell, registry, env, sql) {
+    constructor(vfs, kernel, shell, registry, env, sql, supervisorOps) {
         this.sql = sql;
+        this.supervisorOps = supervisorOps;
         this.vfs = vfs;
         this.kernel = kernel;
         this.shell = shell;
@@ -80,6 +84,12 @@ export class NimbusWorkspace {
         this.fs = new SandboxFsImpl(kernel.vfs.as(CRED_SESSION_USER), () => shell.getCwd());
     }
     static async create(options) {
+        if (options.fabric)
+            composeFabric(options.fabric);
+        const exports = options.ctxExports
+            ?? options.transactions?.exports;
+        if (exports)
+            adoptCtxExports(exports);
         const vfs = options.vfs ?? openFilesystem(options);
         const mounts = options.mounts ?? DEFAULT_MOUNT_POINTS;
         seedBaseFilesystem(vfs, mounts);
@@ -118,11 +128,18 @@ export class NimbusWorkspace {
                 home,
             });
         }
-        return new NimbusWorkspace(vfs, kernel, shell, registry, env, options.sql);
+        const supervisorOps = createSupervisorOpHandler({
+            vfs, processes: options.processes, output: options.processOutput, extend: options.supervisorOps,
+        });
+        return new NimbusWorkspace(vfs, kernel, shell, registry, env, options.sql, supervisorOps);
     }
     exec(command, options) {
         return this.commands.run(command, options);
     }
+    /** The hosting object forwards its supervisorOp RPC to this method. */
+    supervisorOp(envelope) {
+        return this.supervisorOps(envelope);
+    }
     /**
      * Apply the login files, and begin reading the terminal when there is one.
      *
@@ -243,7 +260,7 @@ async function registerWasmRuntimes(deps) {
         getEsbuild: () => {
             if (!esbuild) {
                 esbuild = import('../runtime/esbuild-service.js')
-                    .then((module) => new module.EsbuildService(deps.vfs));
+                    .then((module) => new module.EsbuildService(deps.vfs.as(CRED_KERNEL)));
             }
             return esbuild;
         },

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

@@ -0,0 +1,23 @@
+import type { SqliteVFS } from '../vfs/sqlite-vfs.js';
+import type { SessionProcessSupervisor } from '../runtime/session-process-supervisor.js';
+/** Identity comes from the supervisor binding, never from facet arguments. */
+export interface SupervisorOpEnvelope {
+    readonly op: string;
+    readonly args?: readonly unknown[];
+    readonly pid?: number;
+    readonly writerId?: string;
+    readonly mutationOwner?: string;
+    readonly stream?: ReadableStream<Uint8Array>;
+}
+export type SupervisorOpHandler = (envelope: SupervisorOpEnvelope) => unknown;
+export interface SupervisorOpDeps {
+    readonly vfs: SqliteVFS;
+    /** Absent a process table, operations use the unprivileged session user. */
+    readonly processes?: SessionProcessSupervisor;
+    readonly output?: (stream: 'stdout' | 'stderr', pid: number, data: string) => void;
+    /** Host handlers override defaults, for example to account for stream drains. */
+    readonly extend?: Readonly<Record<string, SupervisorOpHandler>>;
+}
+/** One dispatch method lets any host serve its workspace to process facets. */
+export declare function createSupervisorOpHandler(deps: SupervisorOpDeps): (envelope: SupervisorOpEnvelope) => Promise<unknown>;
+//# sourceMappingURL=supervisor-op.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor-op.d.ts","sourceRoot":"","sources":["../../src/workspace/supervisor-op.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAItD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AAEzF,8EAA8E;AAC9E,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACnC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;CAC9C;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,QAAQ,EAAE,oBAAoB,KAAK,OAAO,CAAC;AAE9E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,CAAC,EAAE,wBAAwB,CAAC;IAC9C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnF,iFAAiF;IACjF,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;CACjE;AAiCD,+EAA+E;AAC/E,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,gBAAgB,GACrB,CAAC,QAAQ,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAuDtD"}

package/dist/workspace/supervisor-op.js

@@ -0,0 +1,92 @@
+import { CRED_SESSION_USER } from '../runtime/os-contracts.js';
+import { SqliteRuntimeFsBridge } from '../runtime/sqlite-runtime-fs-bridge.js';
+import { getSymlinkRegistry } from '../vfs/symlink-registry.js';
+function stringArg(envelope, index) {
+    const value = envelope.args?.[index];
+    if (typeof value !== 'string') {
+        throw new Error(`supervisor op ${envelope.op}: argument ${index} must be a string`);
+    }
+    return value;
+}
+function numberArg(envelope, index) {
+    const value = envelope.args?.[index];
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new Error(`supervisor op ${envelope.op}: argument ${index} must be a number`);
+    }
+    return value;
+}
+function contentArg(envelope, index) {
+    const value = envelope.args?.[index];
+    if (typeof value === 'string' || value instanceof Uint8Array)
+        return value;
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    throw new Error(`supervisor op ${envelope.op}: argument ${index} must be bytes or text`);
+}
+function credFor(deps, pid) {
+    if (pid === undefined)
+        return CRED_SESSION_USER;
+    if (!Number.isInteger(pid) || pid <= 0) {
+        throw new Error('supervisor op: filesystem operation requires a valid process pid');
+    }
+    return deps.processes ? deps.processes.cred(pid) : CRED_SESSION_USER;
+}
+/** One dispatch method lets any host serve its workspace to process facets. */
+export function createSupervisorOpHandler(deps) {
+    const bridges = new Map();
+    const bridgeFor = (pid) => {
+        const key = pid ?? 0;
+        const credentialed = deps.vfs.as(credFor(deps, pid));
+        const held = bridges.get(key);
+        if (held) {
+            held.updateCredential(credentialed);
+            return held;
+        }
+        const built = new SqliteRuntimeFsBridge(credentialed, deps.vfs);
+        bridges.set(key, built);
+        return built;
+    };
+    const ops = {
+        readFile: async (e) => {
+            const bytes = await bridgeFor(e.pid).readFile(stringArg(e, 0));
+            return bytes === null ? null : new TextDecoder().decode(bytes);
+        },
+        readFileBytes: (e) => bridgeFor(e.pid).readFile(stringArg(e, 0)),
+        stat: (e) => bridgeFor(e.pid).stat(stringArg(e, 0)),
+        lstat: (e) => bridgeFor(e.pid).stat(stringArg(e, 0), { followSymlinks: false }),
+        exists: async (e) => (await bridgeFor(e.pid).stat(stringArg(e, 0))) !== null,
+        readdir: (e) => bridgeFor(e.pid).readdir(stringArg(e, 0)),
+        readlink: (e) => bridgeFor(e.pid).readlink(stringArg(e, 0)),
+        fsReadRange: (e) => bridgeFor(e.pid).readRange(stringArg(e, 0), numberArg(e, 1), numberArg(e, 2)),
+        fsReadRangeUncached: (e) => bridgeFor(e.pid).readRange(stringArg(e, 0), numberArg(e, 1), numberArg(e, 2), { cached: false }),
+        fsRevision: (e) => bridgeFor(e.pid).revision(e.args?.[0] === undefined ? undefined : stringArg(e, 0)),
+        hasLegacySymlinkUnder: (e) => getSymlinkRegistry(deps.vfs).hasAtOrBelow(stringArg(e, 0)),
+        writeFile: (e) => bridgeFor(e.pid).writeFile(stringArg(e, 0), contentArg(e, 1)),
+        mkdir: (e) => bridgeFor(e.pid).mkdir(stringArg(e, 0), { recursive: true }),
+        rmdir: (e) => bridgeFor(e.pid).rmdir(stringArg(e, 0)),
+        unlink: (e) => bridgeFor(e.pid).unlink(stringArg(e, 0)),
+        rename: (e) => bridgeFor(e.pid).rename(stringArg(e, 0), stringArg(e, 1)),
+        symlink: (e) => bridgeFor(e.pid).symlink(stringArg(e, 0), stringArg(e, 1)),
+        chmod: (e) => bridgeFor(e.pid).chmod(stringArg(e, 0), numberArg(e, 1)),
+        utimes: (e) => bridgeFor(e.pid).utimes(stringArg(e, 0), numberArg(e, 1), numberArg(e, 2)),
+        fsTruncate: (e) => bridgeFor(e.pid).truncate(stringArg(e, 0), numberArg(e, 1)),
+        writeBatchStream: (e) => {
+            if (!e.stream)
+                throw new Error('supervisor op writeBatchStream: no stream');
+            return deps.vfs.as(credFor(deps, e.pid)).writeStream(e.stream, { mutationOwner: e.mutationOwner });
+        },
+        stdout: (e) => { deps.output?.('stdout', e.pid ?? 0, stringArg(e, 0)); },
+        stderr: (e) => { deps.output?.('stderr', e.pid ?? 0, stringArg(e, 0)); },
+    };
+    const extend = deps.extend ?? {};
+    return async (envelope) => {
+        if (!envelope || typeof envelope.op !== 'string') {
+            throw new Error('supervisor op: envelope names no operation');
+        }
+        const handler = Object.hasOwn(extend, envelope.op) ? extend[envelope.op]
+            : Object.hasOwn(ops, envelope.op) ? ops[envelope.op] : undefined;
+        if (!handler)
+            throw new Error(`supervisor op: '${envelope.op}' is not served by this host`);
+        return handler(envelope);
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimbus-sh/core",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Backend-agnostic half of Nimbus — the durable filesystem, the shell, and the OS/process contracts, over a host-supplied SQL port.",
   "keywords": [
     "filesystem",
@@ -55,7 +55,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@nimbus-sh/platform": "^0.1.0",
+    "@nimbus-sh/platform": "^0.2.0",
     "@renovatebot/pep440": "^5.0.0",
     "acorn": "^8.15.0",
     "acorn-walk": "^8.3.5",

package/src/_shared/byte-stream.ts

@@ -18,10 +18,11 @@
 /**
  * A command's output destination.
  *
- * `writeBytes` is present on sinks that store bytes verbatim (files). Sinks
- * that are inherently textual — the terminal, shell pipes — omit it and
- * receive decoded text instead. This is a real capability difference, not a
- * fallback: a terminal has no way to hold a byte that is not text.
+ * `writeBytes` is present on sinks that store bytes verbatim — files,
+ * `/dev/null`, and shell pipes, which carry the producer's exact bytes.
+ * Sinks without it take decoded text instead. This is a real capability
+ * difference, not a fallback: a terminal has no way to hold a byte that is
+ * not text.
  */
 export interface ByteSink {
   write(text: string): void;

package/src/_shared/real-node-imports.ts

@@ -38,6 +38,13 @@
  *                         constructed Session's connect/post are inert.
  *                         Tools (e.g. nuxi) that open a Session purely
  *                         for optional profiling degrade cleanly.
+ *   - node:zlib         — full surface: every *Sync variant, brotli/zstd,
+ *                         crc32, constants, and streaming create* factories
+ *                         (probe-verified 2026-08-23 at compat date
+ *                         2026-04-01). Forwarded verbatim by the zlib
+ *                         block in node-shims.ts; results are the host
+ *                         realm's own Buffers, which the widened
+ *                         __BufferMod.isBuffer recognizes.
  */
 
 export function getRealNodeImportsCode(): string {
@@ -49,5 +56,6 @@ import * as __real_diagnostics_channel from 'node:diagnostics_channel';
 import * as __real_repl from 'node:repl';
 import * as __real_vm from 'node:vm';
 import * as __real_inspector from 'node:inspector';
+import * as __real_zlib from 'node:zlib';
 `.trim();
 }

package/src/_shared/tarball.ts

@@ -1,5 +1,5 @@
 /**
- * tarball.ts — a whole tarball, in memory, as a path→bytes map.
+ * Tarball extraction for streaming installers and buffered archive consumers.
  *
  * The streaming primitives it walks with (`parseTarHeader`, `streamTarEntries`,
  * `readableStreamToAsyncIterable`) live in `./tarball-stream.ts` — a
@@ -7,10 +7,8 @@
  * into a string the loader pool injects into dynamic workers, where an import
  * would not resolve.
  *
- * This half is for a caller that already holds the bytes: `gem install`, which
- * fetches a `.gem` (a tar holding a gzipped tar) and needs both layers open at
- * once. An installer streaming a tarball it is still downloading should drive
- * `streamTarEntries` itself and never hold the whole thing.
+ * Installers use writeTarballStream. extractTarball retains a map for callers
+ * such as gem install, which must open an archive nested inside another one.
  */
 
 import {
@@ -18,6 +16,59 @@ import {
   readableStreamToAsyncIterable,
 } from './tarball-stream.js';
 
+export interface TarballWriteTarget {
+  exists(path: string): boolean;
+  mkdir(path: string, options?: { recursive?: boolean }): void;
+  writeFile(path: string, data: Uint8Array | string): unknown;
+}
+
+export interface TarballWriteResult {
+  /** Regular files written, including the manifest. */
+  files: number;
+  /** Total decompressed bytes written. */
+  bytes: number;
+}
+
+const PACKAGE_MANIFEST = 'package.json';
+
+/**
+ * Stream a gzipped npm archive into a package directory. Entry names are
+ * already canonical and prefix-stripped by streamTarEntries. Hold only the
+ * current entry and the manifest; write the manifest last so a failed install
+ * is not mistaken for a complete package on retry. Filesystem failures reject.
+ */
+export async function writeTarballStream(
+  body: ReadableStream<Uint8Array>,
+  targetDir: string,
+  vfs: TarballWriteTarget,
+): Promise<TarballWriteResult> {
+  const ensureDir = (path: string): void => {
+    if (!vfs.exists(path)) vfs.mkdir(path, { recursive: true });
+  };
+  ensureDir(targetDir);
+  let files = 0;
+  let bytes = 0;
+  let manifest: Uint8Array | null = null;
+  const entries = streamTarEntries(
+    readableStreamToAsyncIterable(body.pipeThrough(new DecompressionStream('gzip'))),
+  );
+  for await (const entry of entries) {
+    if (entry.name === PACKAGE_MANIFEST) {
+      manifest = entry.data;
+      continue;
+    }
+    const fullPath = `${targetDir}/${entry.name}`;
+    const cut = fullPath.lastIndexOf('/');
+    if (cut > 0) ensureDir(fullPath.slice(0, cut));
+    await vfs.writeFile(fullPath, entry.data);
+    files++;
+    bytes += entry.data.length;
+  }
+  if (!manifest) throw new Error(`tarball for ${targetDir} carried no ${PACKAGE_MANIFEST}`);
+  await vfs.writeFile(`${targetDir}/${PACKAGE_MANIFEST}`, manifest);
+  return { files: files + 1, bytes: bytes + manifest.length };
+}
+
 /** Extract every regular file. Gzipped input is decompressed first. */
 export async function extractTarball(
   tarball: ArrayBuffer,

package/src/_shared/vfs-write-ledger.ts

@@ -317,26 +317,32 @@ async function __nimbusPersistVfsWrite(supervisor, path, content, snapshot) {
 }
 
 /**
- * Write back everything parked, keeping any failure for the exit drain.
+ * Write back the cells parked at THIS instant, and only those.
  *
- * The write-back sites that are not the exit drain — the debounce below and
- * the RELEASE barrier ahead of egress — have no caller who could act on a
- * failure: there is no user frame to throw into, and rejecting the fetch that
- * happened to trigger the flush would blame the wrong operation. Retaining
- * the failure in the channel \`__nimbusDrainVfsMutations\` already drains means
- * the exit path still reports it, so a lost write is loud exactly once and
- * never silent.
+ * Bounded on purpose, and deliberately not routed through
+ * \`__nimbusDrainVfsWrites\`, whose \`while (pending > 0)\` waits for the mutation
+ * queue to be EMPTY. That wait is correct at process exit, where no new writes
+ * are coming. Anywhere else it is a livelock: a facet unpacking a tarball adds
+ * mutations faster than the loop retires them, so the loop never returns.
+ * Sited ahead of egress — where it was — that stopped the request from ever
+ * leaving the facet, and \`npx sv create\` ran, printed its intro, and then
+ * never reported an exit at all. A barrier may delay a request; it may not
+ * wait on a condition a busy process never reaches.
+ *
+ * Failures are retained rather than thrown. The two callers — the debounce
+ * below, and the RELEASE barrier ahead of egress — have no frame that could
+ * act on one: rejecting the fetch that happened to trigger the flush would
+ * blame the wrong operation. The exit drain reports what is retained, so a
+ * lost write is loud exactly once and never silent.
  */
 async function __nimbusFlushVfsWriteBack(supervisor) {
   if (!supervisor) return;
-  try {
-    await __nimbusDrainVfsWrites(supervisor);
-  } catch (error) {
-    if (!__nimbusHasPendingVfsMutationFailure) {
-      __nimbusHasPendingVfsMutationFailure = true;
-      __nimbusPendingVfsMutationFailure = error;
-    }
-  }
+  const paths = Object.keys(__vfsWrites);
+  if (paths.length === 0) return;
+  await Promise.allSettled(paths.map((path) => __nimbusFlushVfsWrite(
+    path,
+    (content, snapshot) => __nimbusPersistVfsWrite(supervisor, path, content, snapshot),
+  )));
 }
 
 /**

package/src/runtime/comment-strip.ts

@@ -27,47 +27,66 @@
  * so it's a minor wasted-work cost — see IMPORT_RE header comment in
  * `require-resolver.ts:84-86`.
  *
+ * Memory: the output is assembled from slices of the input — one per
+ * comment-free span — and joined once. It used to be built one character
+ * at a time with `out += c`, which every JS engine represents as a rope
+ * of one node per append: ~30 bytes of heap per character of output, all
+ * of it live until the string is first read. The require walk runs this
+ * over every file in the closure, and on typescript's 6.15 MB `lib/_tsc.js`
+ * that rope measured 174 MB (V8) / 172 MB (JSC) against a 128 MB isolate —
+ * the session Durable Object was killed inside `tsc`'s spawn before the
+ * facet existed. A span-sliced build holds the input, the output and a
+ * short array of slices, and nothing else.
+ *
  * TODO(CLN-X): when the `src/runtime/esbuild-service.ts` anti-touch
  * window opens, unify with the canonical
  * `stripCommentsAndStrings(src)` helper there. Both implement the
  * same logical pass over comments; only the string/regex-literal
  * handling differs.
  */
+const SLASH = 0x2f;
+const STAR = 0x2a;
+const NEWLINE = 0x0a;
+
 export function stripCommentsForImports(src: string): string {
-  let out = '';
-  let i = 0;
   const N = src.length;
+  const parts: string[] = [];
+  // Start of the comment-free span not yet copied to `parts`.
+  let spanStart = 0;
+  let i = 0;
   while (i < N) {
-    const c = src[i];
-    // Line comment: `//` to end-of-line.
-    if (c === '/' && src[i + 1] === '/') {
-      out += ' ';
+    if (src.charCodeAt(i) !== SLASH) { i++; continue; }
+    const next = src.charCodeAt(i + 1);
+    // Line comment: `//` to end-of-line, replaced by one space. The
+    // newline is not part of the comment and stays in the next span.
+    if (next === SLASH) {
+      parts.push(src.slice(spanStart, i), ' ');
       i += 2;
-      while (i < N && src[i] !== '\n') i++;
-      // Newline preserved by falling through; do NOT consume it.
+      while (i < N && src.charCodeAt(i) !== NEWLINE) i++;
+      spanStart = i;
       continue;
     }
-    // Block comment: `/*` to `*/`.
-    if (c === '/' && src[i + 1] === '*') {
+    // Block comment: `/*` to `*/`, replaced by its own newlines (so line
+    // numbers stay aligned) and one space. An unterminated one runs to
+    // the end of input and gets no closing space.
+    if (next === STAR) {
+      parts.push(src.slice(spanStart, i));
       i += 2;
+      let newlines = 0;
+      let closed = false;
       while (i < N) {
-        if (src[i] === '\n') {
-          // Preserve newlines so line numbers stay aligned.
-          out += '\n';
-          i++;
-          continue;
-        }
-        if (src[i] === '*' && src[i + 1] === '/') {
-          i += 2;
-          out += ' ';
-          break;
-        }
+        const c = src.charCodeAt(i);
+        if (c === NEWLINE) newlines++;
+        else if (c === STAR && src.charCodeAt(i + 1) === SLASH) { i += 2; closed = true; break; }
         i++;
       }
+      if (newlines > 0) parts.push('\n'.repeat(newlines));
+      if (closed) parts.push(' ');
+      spanStart = i;
       continue;
     }
-    out += c;
     i++;
   }
-  return out;
+  parts.push(src.slice(spanStart));
+  return parts.join('');
 }