@nimbus-sh/worker 0.6.0 → 0.7.0

package/dist/runtime/node-shims.js

@@ -123,6 +123,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
@@ -470,6 +573,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.
@@ -2339,8 +2469,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 ──
@@ -3101,9 +3237,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);
@@ -4195,6 +4330,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 };
+  },
 };
 
 // ═══════════════════════════════════════════════════════════════════════
@@ -4631,27 +4866,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) {
@@ -4683,8 +4925,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));
       },
@@ -4832,7 +5073,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;
             }
@@ -5201,11 +5444,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.
@@ -5423,7 +5666,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;
@@ -5448,7 +5695,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 {}
       });
@@ -5519,7 +5766,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);
@@ -5710,7 +5958,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);
 }
@@ -6845,6 +7093,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/dist/runtime/opencode-facet-runner.js

@@ -938,7 +938,7 @@ async function __ocDrainVfsWrites() {
     stderr += trace + "\\n";
     exitCode = 1;
     if (__ocResident) {
-      try { await __supervisor.stderr(trace + "\\n"); } catch {}
+      try { await __supervisor.stderr(new TextEncoder().encode(trace + "\\n")); } catch {}
     }
   }
 }
@@ -1093,7 +1093,7 @@ function __ocEmitMemDiag(tag) {
     // RPC that lands in the process log even when the chain is wedged —
     // discriminates a dead event loop from a wedged outbound chain.
     if (tag === "p" && __supervisor) {
-      try { __supervisor.stderr("[oc-mem-direct]" + __line).catch(() => {}); } catch {}
+      try { __supervisor.stderr(new TextEncoder().encode("[oc-mem-direct]" + __line)).catch(() => {}); } catch {}
     }
   } finally {
     __ocDiag.busy = false;

package/dist/session/helpers.d.ts

@@ -127,6 +127,28 @@ export declare function _classifyCommand(name: string): {
  * Returns the detected bundler bin name (e.g. "vite") or null.
  */
 export declare function detectBundlerBin(script: string): string | null;
+/**
+ * Whether `npm run <scriptName>` (or `npm start`/`npm test`) should refuse
+ * before dispatch because the resolved script invokes `next` on a
+ * subcommand Nimbus cannot run: `dev`, `start`, `build`, or `export` all
+ * need the same missing pipeline — webpack/Turbopack bundling,
+ * child_process.fork with v8-IPC, custom http.Server semantics.
+ *
+ * Returns the blocked subcommand ('dev'|'start'|'build'|'export') or null.
+ * `--force` / `--allow-next` in the script args bypasses the refusal.
+ * scriptName 'dev'/'start' on a next-depending package refuses even when
+ * the script body doesn't name `next` (custom dev servers), matching the
+ * pre-extension dev/start-only behavior.
+ */
+export declare function refusedNextSubcommand(scriptName: string, script: string, pkg: {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}, scriptArgs: readonly string[]): 'dev' | 'start' | 'build' | 'export' | null;
+/**
+ * The refusal message for `refusedNextSubcommand` — identical blockers and
+ * escape hatch for every blocked subcommand.
+ */
+export declare const NEXT_REFUSAL_MESSAGE: string;
 /**
  * Check whether a project directory has installed dependencies.
  *
@@ -140,4 +162,20 @@ export declare function checkNodeModulesGuard(vfs: CredentialedVfs, projectRoot:
     missing: boolean;
     depCount: number;
 };
+/**
+ * Bound for the `vite build` esbuild bundle step (init.ts). Demo-app
+ * builds take seconds; anything past this is a stall, not a build.
+ */
+export declare const VITE_BUILD_TIMEOUT_MS = 120000;
+/**
+ * G5: race an unbounded await against a loud timeout.
+ *
+ * The timeout does not cancel `work` (there is nothing to cancel an
+ * in-isolate esbuild bundle with) — it stops *waiting* and rejects
+ * with an error that names what was attempted and how long it ran,
+ * so a stalled build surfaces as a timeout error instead of silence.
+ * The timer handle never escapes the executor, so there is nothing
+ * to null-check: settle clears it on every path.
+ */
+export declare function withLoudTimeout<T>(work: Promise<T>, timeoutMs: number, what: string): Promise<T>;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/session/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/session/helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;CAC9B,GAAG,MAAM,CAiHT;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,UAehC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAI5F,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,aAQjC,CAAC;AACH,eAAO,MAAM,iCAAiC,aAG5C,CAAC;AAEH;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAoBzF;AAED;;;;;;;;;;;GAWG;AAiBH,eAAO,MAAM,kCAAkC,UAQ9C,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAwC5F;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,aAS3B,CAAC;AACH,eAAO,MAAM,gBAAgB,aAS3B,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,cAAc,GAAG,cAAc,GAAG,SAAS,CAAA;CAAE,GAAG,IAAI,CAU3G;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiB9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,eAAe,EACpB,WAAW,EAAE,MAAM,GAClB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAiBxC"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/session/helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;CAC9B,GAAG,MAAM,CAiHT;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,UAehC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAI5F,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,aAQjC,CAAC;AACH,eAAO,MAAM,iCAAiC,aAG5C,CAAC;AAEH;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAoBzF;AAED;;;;;;;;;;;GAWG;AAiBH,eAAO,MAAM,kCAAkC,UAQ9C,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAwC5F;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,aAS3B,CAAC;AACH,eAAO,MAAM,gBAAgB,aAS3B,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,cAAc,GAAG,cAAc,GAAG,SAAS,CAAA;CAAE,GAAG,IAAI,CAU3G;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiB9D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,EACxF,UAAU,EAAE,SAAS,MAAM,EAAE,GAC5B,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,IAAI,CAkB7C;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,QAQuC,CAAC;AAEzE;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,eAAe,EACpB,WAAW,EAAE,MAAM,GAClB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAiBxC;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,SAAU,CAAC;AAE7C;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAChB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,CAAC,CAaZ"}

package/dist/session/helpers.js

@@ -430,6 +430,58 @@ export function detectBundlerBin(script) {
     }
     return null;
 }
+/**
+ * Whether `npm run <scriptName>` (or `npm start`/`npm test`) should refuse
+ * before dispatch because the resolved script invokes `next` on a
+ * subcommand Nimbus cannot run: `dev`, `start`, `build`, or `export` all
+ * need the same missing pipeline — webpack/Turbopack bundling,
+ * child_process.fork with v8-IPC, custom http.Server semantics.
+ *
+ * Returns the blocked subcommand ('dev'|'start'|'build'|'export') or null.
+ * `--force` / `--allow-next` in the script args bypasses the refusal.
+ * scriptName 'dev'/'start' on a next-depending package refuses even when
+ * the script body doesn't name `next` (custom dev servers), matching the
+ * pre-extension dev/start-only behavior.
+ */
+export function refusedNextSubcommand(scriptName, script, pkg, scriptArgs) {
+    if (scriptArgs.includes('--force') || scriptArgs.includes('--allow-next'))
+        return null;
+    if (!(pkg.dependencies?.next || pkg.devDependencies?.next))
+        return null;
+    if (scriptName === 'dev' || scriptName === 'start')
+        return scriptName;
+    // For other script names the script body must actually invoke a blocked
+    // next subcommand. Tokens: skip env assignments and cross-env/env/npx.
+    const tokens = (script || '').trim().split(/\s+/);
+    let i = 0;
+    while (i < tokens.length) {
+        const t = tokens[i];
+        if (/^[A-Z_][A-Z0-9_]*=/.test(t) || t === 'cross-env' || t === 'env' || t === 'npx') {
+            i++;
+            continue;
+        }
+        break;
+    }
+    const bin = (tokens[i] || '').replace(/^\.\/node_modules\/\.bin\//, '');
+    if (bin !== 'next' && !bin.startsWith('next.'))
+        return null;
+    const sub = tokens[i + 1];
+    if (sub === 'dev' || sub === 'start' || sub === 'build' || sub === 'export')
+        return sub;
+    return null;
+}
+/**
+ * The refusal message for `refusedNextSubcommand` — identical blockers and
+ * escape hatch for every blocked subcommand.
+ */
+export const NEXT_REFUSAL_MESSAGE = '\x1b[31m✘\x1b[0m \x1b[1mNext.js is not supported in Nimbus.\x1b[0m\n' +
+    '   Specific blockers:\n' +
+    "     1. \x1b[2mchild_process.fork\x1b[0m IPC uses v8-serializer (Nimbus ships JSON projection).\n" +
+    '     2. webpack / Turbopack bundlers are not integrated with the pre-bundle pipeline.\n' +
+    '     3. Custom \x1b[2mhttp.Server\x1b[0m semantics (keep-alive, raw sockets) are facet-incompatible.\n' +
+    '\n' +
+    '   Workaround: run the Next.js project outside Nimbus (or a hosted runtime),\n' +
+    '   or pass \x1b[36m--allow-next\x1b[0m to bypass at your own risk.\n';
 /**
  * Check whether a project directory has installed dependencies.
  *
@@ -462,3 +514,27 @@ export function checkNodeModulesGuard(vfs, projectRoot) {
         return { missing: false, depCount: 0 };
     }
 }
+/**
+ * Bound for the `vite build` esbuild bundle step (init.ts). Demo-app
+ * builds take seconds; anything past this is a stall, not a build.
+ */
+export const VITE_BUILD_TIMEOUT_MS = 120_000;
+/**
+ * G5: race an unbounded await against a loud timeout.
+ *
+ * The timeout does not cancel `work` (there is nothing to cancel an
+ * in-isolate esbuild bundle with) — it stops *waiting* and rejects
+ * with an error that names what was attempted and how long it ran,
+ * so a stalled build surfaces as a timeout error instead of silence.
+ * The timer handle never escapes the executor, so there is nothing
+ * to null-check: settle clears it on every path.
+ */
+export function withLoudTimeout(work, timeoutMs, what) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(`${what} produced no result after ${(timeoutMs / 1000).toFixed(0)}s — ` +
+                'stopped waiting (the work may still finish in the background; re-run to retry).'));
+        }, timeoutMs);
+        work.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
+    });
+}

package/dist/session/init-phases.d.ts

@@ -88,6 +88,6 @@ export declare function joinExistingSession(self: {
     };
     _b4Phase: SessionState | null;
     _b4WarmJoinCount: number;
-}, ws: WebSocket, appendScrollback: (ctx: any, data: string, atMs: number) => void, loadScrollback: (ctx: any) => string): void;
+}, ws: WebSocket, tee: (frame: string) => void, loadScrollback: (ctx: any) => string): void;
 export {};
 //# sourceMappingURL=init-phases.d.ts.map

package/dist/session/init-phases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init-phases.d.ts","sourceRoot":"","sources":["../../src/session/init-phases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAElG,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE7E;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE;IAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,EACtD,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,GACd,IAAI,CAcN;AAED,KAAK,iBAAiB,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;AAE3D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,gBAAgB,CAAC;CACxB,EAAE,OAAO,EAAE,SAAS,SAAS,EAAE,EAAE,GAAG,GAAE,MAAmB,GAAG,iBAAiB,CAG7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE;IACJ,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE;QAAE,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACpG,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,gBAAgB,EAAE,MAAM,CAAC;CAC1B,EACD,EAAE,EAAE,SAAS,EACb,gBAAgB,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,EAChE,cAAc,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GACnC,IAAI,CAsCN"}
+{"version":3,"file":"init-phases.d.ts","sourceRoot":"","sources":["../../src/session/init-phases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAElG,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE7E;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE;IAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,EACtD,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,GACd,IAAI,CAcN;AAED,KAAK,iBAAiB,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;AAE3D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,gBAAgB,CAAC;CACxB,EAAE,OAAO,EAAE,SAAS,SAAS,EAAE,EAAE,GAAG,GAAE,MAAmB,GAAG,iBAAiB,CAG7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE;IACJ,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE;QAAE,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACpG,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,gBAAgB,EAAE,MAAM,CAAC;CAC1B,EACD,EAAE,EAAE,SAAS,EACb,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EAC5B,cAAc,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GACnC,IAAI,CAiCN"}

package/dist/session/init-phases.js

@@ -91,7 +91,7 @@ export function classifyWsUpgrade(self, sockets, now = Date.now()) {
  * needed here; init-phases.ts shouldn't grow a circular dep on
  * nimbus-session-internal.
  */
-export function joinExistingSession(self, ws, appendScrollback, loadScrollback) {
+export function joinExistingSession(self, ws, tee, loadScrollback) {
     // Phase R — pure SQL reads. No-op on warm rejoin (live state is
     // already correct in self.shell / self.terminal). Recorded in the
     // ring for symmetry with cold init.
@@ -101,17 +101,7 @@ export function joinExistingSession(self, ws, appendScrollback, loadScrollback)
     // the same WebSocketTerminal instance is preserved (we mutate
     // its internal ws ref via attach()).
     setPhase(self, 'wire', 'warm-rejoin');
-    self.terminal.attach(ws, (frame) => {
-        try {
-            appendScrollback(self.ctx, frame, Date.now());
-        }
-        catch (e) {
-            try {
-                console.warn("[B'.3] appendScrollback failed:", e?.message || e);
-            }
-            catch { }
-        }
-    });
+    self.terminal.attach(ws, tee);
     // Replay scrollback to the new ws so the user sees the prior
     // session's terminal contents. Same shape as cold-init's replay
     // when persisted state exists.