@nimbus-sh/worker 0.6.0 → 0.7.0

package/public/_assets/runtime/{node-shims-9e1380d9ee430fcc.js → node-shims-8f8c64edd2a1f0f5.js}

@@ -58,6 +58,109 @@ async function __nimbusUseRpcResultUnref(promise, use) {
   finally { __nimbusDisposeRpcResult(value); }
 }
 
+// ═══════════════════════════════════════════════════════════════════════
+// ──  Precompiled wasm ───────────────────────────────────────────────
+// A wasm image can only become a WebAssembly.Module through the Worker
+// Loader's module map; new WebAssembly.Module(bytes) at request time is
+// refused by the runtime. A launch whose closure carries an image (its VFS
+// path, or its content digest for an image inlined as base64) gets it
+// compiled at load and parked here. fs.readFileSync tags the bytes it hands
+// out for such a path, and the WebAssembly seam below answers a compile of
+// tagged or digest-matched bytes with the module the loader already built —
+// so a package's own new WebAssembly.Module(readFileSync(__dirname + '/x.wasm'))
+// works unchanged.
+const __nimbusPrecompiledWasm = globalThis.__nimbusPrecompiledWasm instanceof Map
+  ? globalThis.__nimbusPrecompiledWasm : new Map();
+const __nimbusWasmModuleTag = Symbol.for("nimbus.precompiledWasmModule");
+/**
+ * Precompiled modules keyed by a digest of their BYTES, for an image that
+ * never passes through the filesystem.
+ *
+ * Vite inlines es-module-lexer's parser as a base64 literal in its own source
+ * and compiles it at module top level — from a cell that is request time, and
+ * the runtime refuses it. There is no path to tag, so the launch registers
+ * the image by content instead and the seam recognises the same bytes when
+ * they arrive.
+ */
+const __nimbusPrecompiledWasmByDigest = globalThis.__nimbusPrecompiledWasmByDigest instanceof Map
+  ? globalThis.__nimbusPrecompiledWasmByDigest : new Map();
+/**
+ * A synchronous content key: length and FNV-1a over every byte.
+ *
+ * Synchronous because new WebAssembly.Module(bytes) is, and SubtleCrypto is
+ * not. Collisions do not matter for correctness the way they would in a
+ * security check: the set is the handful of images one launch registered, and
+ * the length is part of the key.
+ */
+function __nimbusWasmDigest(bytes) {
+  const view = bytes instanceof Uint8Array
+    ? bytes
+    : (bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : null);
+  if (!view) return null;
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < view.length; i++) {
+    hash ^= view[i];
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return view.length + ":" + hash.toString(16);
+}
+(() => {
+  const WA = globalThis.WebAssembly;
+  if (!WA || WA.__nimbusPrecompiledSeam) return;
+  const RealModule = WA.Module;
+  const tagged = (bytes) => {
+    if (!bytes || typeof bytes !== "object") return undefined;
+    const byTag = bytes[__nimbusWasmModuleTag];
+    if (byTag !== undefined) return byTag;
+    if (__nimbusPrecompiledWasmByDigest.size === 0) return undefined;
+    const digest = __nimbusWasmDigest(bytes);
+    return digest === null ? undefined : __nimbusPrecompiledWasmByDigest.get(digest);
+  };
+  // The runtime compiles wasm only while the loader stages a module map; a
+  // compile from bytes at any later point is refused with a message that names
+  // neither the module nor the reason it cannot work. Say both: the caller is
+  // an installed package whose image has to travel as a map member (the
+  // closure walk registers it), or be inlined in module text the loader
+  // itself evaluates.
+  const refusal = (e, bytes) => {
+    const size = (bytes && typeof bytes === "object" && typeof bytes.byteLength === "number") ? bytes.byteLength : 0;
+    const where = globalThis.__currentModulePath ? " while loading " + globalThis.__currentModulePath : "";
+    return new Error(
+      "Nimbus: WebAssembly cannot be compiled from bytes here" + where + " (" + size + " bytes): "
+      + ((e && e.message) || String(e))
+      + ". The runtime compiles wasm only when the module loader stages it, so the image must ride in the "
+      + "process's module map — a launch names one via the closure's wasmImages — rather than be compiled at runtime."
+      + " Images this launch does carry: " + (__nimbusPrecompiledWasm.size + __nimbusPrecompiledWasmByDigest.size) + ".",
+    );
+  };
+  const Module = function Module(bytes) {
+    const compiled = tagged(bytes);
+    if (compiled !== undefined) return compiled;
+    try { return new RealModule(bytes); } catch (e) { throw refusal(e, bytes); }
+  };
+  Module.prototype = RealModule.prototype;
+  for (const k of ["exports", "imports", "customSections"]) Module[k] = RealModule[k];
+  Object.defineProperty(WA, "Module", { value: Module, writable: true, configurable: true });
+  const realCompile = WA.compile.bind(WA);
+  WA.compile = (bytes) => {
+    const compiled = tagged(bytes);
+    if (compiled !== undefined) return Promise.resolve(compiled);
+    return realCompile(bytes).catch((e) => { throw refusal(e, bytes); });
+  };
+  const realInstantiate = WA.instantiate.bind(WA);
+  WA.instantiate = (source, imports) => {
+    const compiled = tagged(source);
+    if (compiled !== undefined) {
+      return realInstantiate(compiled, imports).then((instance) => ({ module: compiled, instance }));
+    }
+    // A Module source instantiates; only BYTES are a compile, and only those
+    // can be refused for it.
+    if (source instanceof RealModule) return realInstantiate(source, imports);
+    return realInstantiate(source, imports).catch((e) => { throw refusal(e, source); });
+  };
+  WA.__nimbusPrecompiledSeam = true;
+})();
+
 // ═══════════════════════════════════════════════════════════════════════
 // ──  fetch default User-Agent ───────────────────────────────────────
 // workerd's global fetch sends no User-Agent by default, but Node's
@@ -405,6 +508,33 @@ const __BufferMod = (() => {
   return B;
 })();
 
+// ═══════════════════════════════════════════════════════════════════════
+// ──  Process output is bytes ─────────────────────────────────────────
+// ═══════════════════════════════════════════════════════════════════════
+// A process's stdout and stderr are byte streams: esbuild's service protocol
+// is binary packets, and so is any program piping an image or an archive.
+// The relay to the supervisor carries Uint8Array; a text producer encodes
+// at its own edge, and the facet's REPORTED result — the `stdout`/`stderr`
+// strings the wrapper declares — decodes at its edge with one streaming
+// decoder per stream, so a multibyte character split across two writes
+// still reads as one character.
+const __nimbusOutEnc = new TextEncoder();
+const __nimbusOutDec = { stdout: new TextDecoder("utf-8"), stderr: new TextDecoder("utf-8") };
+/** `process.stdout.write(d, enc)` payload as bytes. */
+function __nimbusOutBytes(d, enc) {
+  if (d instanceof Uint8Array) return d;
+  if (typeof d === "string") {
+    return typeof enc === "string" && enc !== "utf8" && enc !== "utf-8"
+      ? __BufferMod.from(d, enc)
+      : __nimbusOutEnc.encode(d);
+  }
+  return __nimbusOutEnc.encode(String(d));
+}
+/** Decode one stream's bytes into its text accumulator, streaming. */
+function __nimbusOutText(streamName, bytes) {
+  return __nimbusOutDec[streamName === "stderr" ? "stderr" : "stdout"].decode(bytes, { stream: true });
+}
+
 /**
  * What the resident set holds under a directory prefix — the ONE question the
  * shims ask of it that a plain object cannot answer cheaply.
@@ -2274,8 +2404,14 @@ const __fsMod = (() => {
       return _asString(content);
     }
     // No encoding requested — produce a Buffer-shaped Uint8Array.
-    if (_isBytes(content)) return __BufferMod.from(content);
-    return __BufferMod.from(content);
+    const bytes = __BufferMod.from(content);
+    // A wasm image the launch compiled through the module map is tagged on
+    // the way out, so the WebAssembly seam below can answer the package's own
+    // new WebAssembly.Module(readFileSync(...)) with the compiled module —
+    // request-time compilation from bytes is refused by the runtime.
+    const precompiled = __nimbusPrecompiledWasm.get(_strip(absPath));
+    if (precompiled !== undefined) bytes[__nimbusWasmModuleTag] = precompiled;
+    return bytes;
   }
 
   // ── writeFileSync ──
@@ -3036,9 +3172,8 @@ const __fsMod = (() => {
   function writeSync(fd, data, a, b, c) {
     const n = Number(fd);
     if (n === 1 || n === 2) {
-      // The stream shim stringifies whatever it is given, so decode first.
       const bytes = _normWriteArgs(data, a, b, c).bytes;
-      (n === 2 ? __processMod.stderr : __processMod.stdout).write(_dec.decode(bytes));
+      (n === 2 ? __processMod.stderr : __processMod.stdout).write(bytes);
       return bytes.byteLength;
     }
     if (n === 0) throw _fsErr("EBADF", "write", fd);
@@ -5483,6 +5618,106 @@ const __utilMod = {
     }
     return opens + String(text) + closes;
   },
+  // util.parseArgs({ args, options, strict, allowPositionals, allowNegative })
+  // — Node 18.3+. The CLI argument parser modern npm bins reach for instead
+  // of a dependency: json-server's lib/bin.js destructures it at module
+  // init, so its absence crashed the bin at "parseArgs is not a function"
+  // before --version could answer. Node's contract, minus the tokens
+  // debugging output:
+  //   - --name, --name=value, --name value for string options;
+  //   - -s, -s value, -svalue, and grouped booleans -abc for shorts;
+  //   - --no-name sets a boolean false when allowNegative is on;
+  //   - -- ends option parsing, the rest are positionals;
+  //   - strict (default true) throws Node's own error codes for an unknown
+  //     option, a string option with no value, or a positional when they
+  //     are not allowed; lax mode records unknown options as booleans.
+  parseArgs: (config) => {
+    const cfg = config || {};
+    const args = Array.isArray(cfg.args) ? cfg.args.slice() : (__processMod.argv || []).slice(2);
+    const options = cfg.options || {};
+    const strict = cfg.strict !== false;
+    const allowPositionals = cfg.allowPositionals === undefined ? !strict : !!cfg.allowPositionals;
+    const allowNegative = !!cfg.allowNegative;
+    const values = {};
+    const positionals = [];
+    const err = (code, message) => { const e = new TypeError(message); e.code = code; return e; };
+    const shortToLong = {};
+    for (const [name, spec] of Object.entries(options)) {
+      if (!spec || (spec.type !== "string" && spec.type !== "boolean")) {
+        throw err("ERR_INVALID_ARG_TYPE", "The \"options." + name + ".type\" property must be one of: 'string', 'boolean'.");
+      }
+      if (spec.short) shortToLong[spec.short] = name;
+      if (spec.default !== undefined) values[name] = spec.default;
+    }
+    const store = (name, value) => {
+      const spec = options[name];
+      if (spec && spec.multiple) {
+        if (!Array.isArray(values[name]) || (spec.default !== undefined && values[name] === spec.default)) values[name] = [];
+        values[name].push(value);
+      } else {
+        values[name] = value;
+      }
+    };
+    const optionValue = (name, inlineValue, next, raw) => {
+      const spec = options[name];
+      if (!spec) {
+        if (strict) throw err("ERR_PARSE_ARGS_UNKNOWN_OPTION", "Unknown option '" + raw + "'." + (allowPositionals ? " To specify a positional argument starting with a '-', place it at the end of the command after '--', as in '-- \"" + raw + "\"'." : ""));
+        if (inlineValue !== undefined) return { value: inlineValue, consumed: 0 };
+        return { value: true, consumed: 0 };
+      }
+      if (spec.type === "boolean") {
+        if (inlineValue !== undefined && strict) throw err("ERR_PARSE_ARGS_INVALID_OPTION_VALUE", "Option '" + raw + "' does not take an argument.");
+        return { value: inlineValue !== undefined ? inlineValue : true, consumed: 0 };
+      }
+      if (inlineValue !== undefined) return { value: inlineValue, consumed: 0 };
+      if (next === undefined || (strict && next.startsWith("-") && next !== "-")) {
+        if (strict) throw err("ERR_PARSE_ARGS_INVALID_OPTION_VALUE", "Option '" + raw + " <value>' argument missing");
+        return { value: undefined, consumed: 0 };
+      }
+      return { value: next, consumed: 1 };
+    };
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "--") { positionals.push(...args.slice(i + 1)); break; }
+      if (arg.startsWith("--") && arg.length > 2) {
+        const eq = arg.indexOf("=");
+        let name = eq === -1 ? arg.slice(2) : arg.slice(2, eq);
+        const inline = eq === -1 ? undefined : arg.slice(eq + 1);
+        if (allowNegative && name.startsWith("no-") && options[name.slice(3)] && options[name.slice(3)].type === "boolean") {
+          store(name.slice(3), false);
+          continue;
+        }
+        const r = optionValue(name, inline, args[i + 1], "--" + name);
+        store(name, r.value);
+        i += r.consumed;
+        continue;
+      }
+      if (arg.startsWith("-") && arg.length > 1 && arg !== "-") {
+        // Short: -s, -s value, -svalue (string) or grouped -abc (booleans).
+        const first = arg[1];
+        const long = shortToLong[first] || first;
+        const spec = options[long];
+        if (spec && spec.type === "string") {
+          const inline = arg.length > 2 ? arg.slice(2) : undefined;
+          const r = optionValue(long, inline, args[i + 1], "-" + first);
+          store(long, r.value);
+          i += r.consumed;
+          continue;
+        }
+        for (const ch of arg.slice(1)) {
+          const l = shortToLong[ch] || ch;
+          const r = optionValue(l, undefined, undefined, "-" + ch);
+          store(l, r.value);
+        }
+        continue;
+      }
+      if (!allowPositionals) {
+        throw err("ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL", "Unexpected argument '" + arg + "'. This command does not take positional arguments");
+      }
+      positionals.push(arg);
+    }
+    return { values, positionals };
+  },
 };
 
 // ═══════════════════════════════════════════════════════════════════════
@@ -5919,27 +6154,34 @@ const __childProcessMod = (() => {
   const HAS_SUPERVISOR = !!(__supervisor && typeof __supervisor.cpSpawn === "function");
 
   /**
-   * Child stdout/stderr. Defaults to utf8 so consumers see strings (the
-   * common cross-spawn / husky pattern); callers override via
-   * .setEncoding('hex'), .setEncoding(null), etc. Flowing-mode resumption
-   * and encoding are the Readable base class's job — see streams.ts.
+   * Child stdout/stderr. Bytes, as Node's: a 'data' listener sees a Buffer
+   * until the consumer calls .setEncoding(), which is how a binary protocol
+   * (esbuild's service) reads its packets and how a text consumer opts into
+   * text. It used to default to utf8 for the cross-spawn / husky pattern;
+   * that pattern reads `String(chunk)` and works on a Buffer, and the
+   * default turned every byte above 0x7f into U+FFFD for everyone else.
+   * Flowing-mode resumption and encoding are the Readable base class's job —
+   * see streams.ts.
    */
   function _makeReadable() {
-    return new __streamMod.PassThrough({ encoding: "utf8" });
+    return new __streamMod.PassThrough();
   }
 
   /**
    * Create a workerd-Writable backed by cpStdinWrite RPC.
-   * Decodes Uint8Array chunks to UTF-8 strings before pushing to RPC
-   * (workerd's Writable encodes string→bytes internally; we need to
-   * round-trip back to a string for the supervisor's stdin queue).
+   *
+   * A child's stdin is BYTES. esbuild's service protocol is binary packets,
+   * and so is anything piping an image or an archive to a child. The relay
+   * used to decode each chunk to a UTF-8 string here, which turned every
+   * byte sequence that is not valid UTF-8 into U+FFFD — unrecoverable, and
+   * measured at twice the length for a buffer covering all 256 values. The
+   * queue and the RPC carry Uint8Array now; text callers encode at this
+   * edge, which is the only place that knows it had text.
    */
-  function _toUtf8(chunk) {
-    if (typeof chunk === "string") return chunk;
-    if (chunk instanceof Uint8Array) {
-      try { return new TextDecoder("utf-8").decode(chunk); } catch { return String(chunk); }
-    }
-    return String(chunk);
+  function _toBytes(chunk) {
+    if (chunk instanceof Uint8Array) return chunk;
+    if (typeof chunk === "string") return new TextEncoder().encode(chunk);
+    return new TextEncoder().encode(String(chunk));
   }
   function _queueStdinWrite(child, data) {
     if (!child.pid) {
@@ -5971,8 +6213,7 @@ const __childProcessMod = (() => {
   function _makeWritable(child) {
     const w = new __streamMod.Writable({
       write(chunk, enc, cb) {
-        const s = _toUtf8(chunk);
-        _queueStdinWrite(child, s)
+        _queueStdinWrite(child, _toBytes(chunk))
           .then(() => cb())
           .catch((e) => cb(e));
       },
@@ -6120,7 +6361,9 @@ const __childProcessMod = (() => {
         if (r && Array.isArray(r.chunks) && r.chunks.length > 0) {
           backoff = 100;  // reset — child is producing
           for (const c of r.chunks) {
-            stream.write(c.data);
+            // The queue hands back bytes; a Readable given a string would
+            // encode it again.
+            stream.write(__BufferMod.from(c.data));
             if (typeof c.seq === "number" && c.seq > sinceSeqRef.value) {
               sinceSeqRef.value = c.seq;
             }
@@ -6489,11 +6732,11 @@ const __childProcessMod = (() => {
             __supervisor.cpDrainOutput(pid),
             (result) => result,
           );
-          if (r && r.stdout && child.stdout) {
-            try { child.stdout.write(r.stdout); } catch {}
+          if (r && r.stdout && r.stdout.byteLength > 0 && child.stdout) {
+            try { child.stdout.write(__BufferMod.from(r.stdout)); } catch {}
           }
-          if (r && r.stderr && child.stderr) {
-            try { child.stderr.write(r.stderr); } catch {}
+          if (r && r.stderr && r.stderr.byteLength > 0 && child.stderr) {
+            try { child.stderr.write(__BufferMod.from(r.stderr)); } catch {}
           }
           // Force-close streams so listeners receive 'end'. The 'end'
           // event listeners in _makeChild flip _stdoutEnded/_stderrEnded.
@@ -6711,7 +6954,11 @@ function __makeProcessStdin() {
           throw new __ProcessExit(code);
         }
       }
-      if (packet && packet.data) r.write(packet.data);
+      // The queue hands back bytes; a Readable given a string would encode
+      // it again.
+      if (packet && packet.data && packet.data.byteLength > 0) {
+        r.write(__BufferMod.from(packet.data));
+      }
       if (packet && packet.ended) {
         r.end();
         break;
@@ -6736,7 +6983,7 @@ function __makeProcessStdin() {
         }
         const trace = (e && e.stack) || (e && e.message) || String(e);
         stderr += trace + "\n";
-        try { __nimbusUseRpcResult(__supervisor.stderr(trace + "\n"), () => undefined).catch(() => {}); } catch {}
+        try { __nimbusUseRpcResult(__supervisor.stderr(__nimbusOutEnc.encode(trace + "\n")), () => undefined).catch(() => {}); } catch {}
         try { __nimbusUseRpcResult(__supervisor.reportExit(1, trace + "\n"), () => undefined).catch(() => {}); } catch {}
         try { r.end(); } catch {}
       });
@@ -6807,7 +7054,8 @@ function __makeProcessOutputStream(streamName) {
     errored: null,
     write(d, enc, cb) {
       if (typeof enc === "function") cb = enc;
-      const s = String(d);
+      // The reported result is text; decode the bytes at this edge only.
+      const s = __nimbusOutText(streamName, __nimbusOutBytes(d, enc));
       if (streamName === "stderr") stderr += s;
       else stdout += s;
       if (typeof cb === "function") queueMicrotask(cb);
@@ -6998,7 +7246,7 @@ function __nimbusFailUnhandledAsync(error, kind) {
   const line = label + __nimbusRuntimeErrorTrace(error) + "\n";
   stderr += line;
   if (__supervisor && typeof __supervisor.stderr === "function") {
-    try { __nimbusUseRpcResult(__supervisor.stderr(line), () => undefined).catch(() => {}); } catch {}
+    try { __nimbusUseRpcResult(__supervisor.stderr(__nimbusOutEnc.encode(line)), () => undefined).catch(() => {}); } catch {}
   }
   __nimbusReportProcessExit(1, line);
 }
@@ -8133,6 +8381,34 @@ builtins["node:util/types"] = builtins["util/types"];
 // skips it via the same FACET_PROVIDED_PACKAGES list.
 builtins.undici = __undiciMod;
 
+/**
+ * A cell's dynamic import() call.
+ *
+ * A cell is compiled with new Function, so an import() left in its body
+ * is the RUNTIME's: it resolves against the module map and hands back the
+ * platform's own builtins, not this process's. Real Vite reaches
+ * node:http that way (config.js:14968), got a server whose listen bound no
+ * port here, and the facet exited with no handles the moment boot returned.
+ *
+ * The ESM→CJS rewriter routes those calls here with the cell's own
+ * require, so resolution is the one the process already has. The result is
+ * shaped as a module namespace, since import() resolves to one and callers
+ * destructure named exports off it.
+ */
+globalThis.__nimbusCellImport = (req, id) => Promise.resolve().then(() => {
+  const loaded = req(id);
+  if (loaded && (loaded.__esModule || loaded[Symbol.toStringTag] === "Module")) return loaded;
+  // A CJS module's exports ARE the namespace's named exports, with the whole
+  // object as the default export — what an ESM importer of a CJS module sees.
+  if (loaded && (typeof loaded === "object" || typeof loaded === "function")) {
+    const ns = Object.create(null);
+    for (const key of Object.keys(loaded)) ns[key] = loaded[key];
+    if (!("default" in ns)) ns.default = loaded;
+    Object.defineProperty(ns, Symbol.toStringTag, { value: "Module" });
+    return ns;
+  }
+  return { default: loaded };
+});
 // ═══════════════════════════════════════════════════════════════════════
 // ──  require() — full Node.js module resolution ─────────────────────
 // ═══════════════════════════════════════════════════════════════════════

package/public/index.html

@@ -677,7 +677,7 @@
       <div class="terminal-frame">
         <div class="terminal-chrome">
           <span class="tc-dot r"></span><span class="tc-dot y"></span><span class="tc-dot g"></span>
-          <span class="tc-title">nimbus — ~/app</span>
+          <span class="tc-title">nimbus — ~/example-app</span>
         </div>
         <pre class="terminal-body" id="demo-body"></pre>
       </div>

package/scripts/bundle-facet-workers.mjs

@@ -297,7 +297,7 @@ async function main() {
     ' * helpers by name.',
     ' *',
     ' * Tar-stream symbols: parseTarHeader, streamTarEntries,',
-    ' *   readableStreamToAsyncIterable, MAX_FILE_BYTES.',
+    ' *   streamPackageEntries, readableStreamToAsyncIterable, MAX_FILE_BYTES.',
     ' * W7-frame symbols:   encodeWriteBatchStream, decodeWriteBatchStream,',
     ' *   W7_MAGIC, W7_MAX_RECORD_BYTES.',
     ' *',

package/scripts/bundle-npm-cjs.mjs

@@ -13,7 +13,7 @@
  * Solution: bundle the common CJS packages at build time into ESM
  * artifacts, emit them as LOADER modules alongside plugin-react,
  * and rewrite the Vite resolver's output so that
- *   /home/user/app/node_modules/react/index.js
+ *   /home/user/example-app/node_modules/react/index.js
  * maps to the pre-bundled
  *   cirrus-npm/react.js
  * at facet load time.
@@ -350,7 +350,7 @@ async function main() {
  * (react, react-dom, scheduler). Ships as a static Worker asset alongside
  * cirrus-plugin-react.
  * Consumed by src/cirrus-real.ts — injected as LOADER modules, and
- * the Vite resolver's output (e.g. /home/user/app/node_modules/react/index.js)
+ * the Vite resolver's output (e.g. /home/user/example-app/node_modules/react/index.js)
  * is rewritten to point at one of these bundles at request time.
  */
 

package/dist/facets/on-demand-bundle-gate.d.ts

@@ -1,65 +0,0 @@
-/**
- * OnDemandBundleGate — memory-bounded admission control for on-demand
- * /@modules/ bundling.
- *
- * Why this exists
- * ───────────────
- * The dev server bundles user packages on demand by building a file
- * "slice" in the supervisor heap (up to SLICE_CAP_BYTES ≈ 28 MiB) and
- * shipping it to a facet isolate over RPC. The facet RPC round-trip is
- * the dominant wall time; the supervisor just holds the slice array
- * alive until the clone completes. A fresh React app first-load requests
- * many distinct /@modules/ concurrently, so the naive path either:
- *   - builds all slices at once → peak heap = N × 28 MiB → supervisor
- *     OOM on a shared DO isolate (the install-time pre-bundler proved
- *     concurrency=2 of max slices crashes a Mossaic-scale isolate), or
- *   - serializes everything behind one slot → multi-second first load.
- *
- * This gate threads the needle: it bounds the TOTAL slice BYTES resident
- * at once (not a count), so many SMALL slices' RPC round-trips overlap
- * while a single LARGE slice still serializes the rest — peak resident
- * slice bytes never exceed `budgetBytes`, which is set to one slice cap.
- *
- * How it bounds peak heap
- * ───────────────────────
- *   - Only ONE slice is ever mid-BUILD (a build lock): the slice array
- *     does not exist until built, so we can't reserve its real size up
- *     front. Serializing the (fast, synchronous) build means at most one
- *     un-accounted slice exists at any instant.
- *   - The moment a build finishes, the caller `admit(realBytes)`s: that
- *     reserves the slice's actual size against the byte budget (blocking
- *     if the budget is full) and only THEN releases the build lock for
- *     the next builder.
- *   - Reserved bytes are released when the caller's work (the facet
- *     submit) settles.
- *
- * Invariant: at any instant, Σ(reserved bytes of in-flight submits) +
- * (one building slice, already counted the moment it admits) ≤
- * budgetBytes. With budgetBytes = SLICE_CAP_BYTES the peak matches the
- * single-slot serialization it replaces — no heap regression — while
- * small slices proceed concurrently.
- */
-export declare class OnDemandBundleGate {
-    private readonly budgetBytes;
-    private buildLock;
-    private reservedBytes;
-    /** FIFO queue of callers blocked on byte-budget headroom. */
-    private byteWaiters;
-    constructor(budgetBytes: number);
-    /**
-     * Run a build-then-submit job under the gate.
-     *
-     * `job` receives an `admit(bytes)` callback it MUST call exactly once,
-     * after its slice is built and its real byte size is known, before the
-     * long-running submit. `admit` reserves the bytes and releases the
-     * build lock so the next job can start building. Jobs that bail before
-     * building a slice (early return / error) simply never call `admit`;
-     * the build lock is released when `job` settles either way.
-     */
-    run<T>(job: (admit: (bytes: number) => Promise<void>) => Promise<T>): Promise<T>;
-    private acquireBytes;
-    private releaseBytes;
-    /** Test/diagnostic snapshot. */
-    get inFlightBytes(): number;
-}
-//# sourceMappingURL=on-demand-bundle-gate.d.ts.map

package/dist/facets/on-demand-bundle-gate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"on-demand-bundle-gate.d.ts","sourceRoot":"","sources":["../../src/facets/on-demand-bundle-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,kBAAkB;IAMjB,OAAO,CAAC,QAAQ,CAAC,WAAW;IALxC,OAAO,CAAC,SAAS,CAAoC;IACrD,OAAO,CAAC,aAAa,CAAK;IAC1B,6DAA6D;IAC7D,OAAO,CAAC,WAAW,CAAqD;gBAE3C,WAAW,EAAE,MAAM;IAIhD;;;;;;;;;OASG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IA8BtF,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,YAAY;IAepB,gCAAgC;IAChC,IAAI,aAAa,IAAI,MAAM,CAA+B;CAC3D"}