@nimbus-sh/worker 0.6.0 → 0.8.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

@@ -818,15 +818,15 @@ let __ntC = 0, __qmC = 0;
 let __fetchC = 0;
 // WebAssembly.Memory.grow probe: total grows / pages, last grower's stack.
 let __wgC = 0, __wgP = 0, __wgLast = "";
-const __queueRpcWrite = (method, s) => {
+const __queueRpcWrite = (method, bytes) => {
   if (!__supervisor) return;
-  __rpcQc += 1; __rpcQb += s.length;
+  __rpcQc += 1; __rpcQb += bytes.byteLength;
   const __task = __rpcWriteChain
-    .then(() => __supervisor[method](s))
+    .then(() => __supervisor[method](bytes))
     .catch(() => {});
   __rpcWriteChain = __task.then(() => {}, () => {});
   __pendingWrites.add(__task);
-  const __len = s.length;
+  const __len = bytes.byteLength;
   __task.finally(() => { __rpcSc += 1; __rpcSb += __len; __chainSettleAt = Date.now(); __pendingWrites.delete(__task); });
   __ocFlowDiag();
 };
@@ -860,30 +860,30 @@ if (__ocResident) {
   // stream would grow without bound over a resident process's lifetime.
   process.stdout.write = (d, enc, cb) => {
     if (typeof enc === "function") cb = enc;
-    const s = String(d);
-    stdout = __ocTail(stdout, s);
-    __queueRpcWrite("stdout", s);
+    const b = __nimbusOutBytes(d, enc);
+    stdout = __ocTail(stdout, __nimbusOutText("stdout", b));
+    __queueRpcWrite("stdout", b);
     if (typeof cb === "function") queueMicrotask(cb);
     return true;
   };
   process.stderr.write = (d, enc, cb) => {
     if (typeof enc === "function") cb = enc;
-    const s = String(d);
-    stderr = __ocTail(stderr, s);
-    __queueRpcWrite("stderr", s);
+    const b = __nimbusOutBytes(d, enc);
+    stderr = __ocTail(stderr, __nimbusOutText("stderr", b));
+    __queueRpcWrite("stderr", b);
     if (typeof cb === "function") queueMicrotask(cb);
     return true;
   };
 } else {
   process.stdout.write = (d, enc, cb) => {
     if (typeof enc === "function") cb = enc;
-    stdout += String(d);
+    stdout += __nimbusOutText("stdout", __nimbusOutBytes(d, enc));
     if (typeof cb === "function") queueMicrotask(cb);
     return true;
   };
   process.stderr.write = (d, enc, cb) => {
     if (typeof enc === "function") cb = enc;
-    stderr += String(d);
+    stderr += __nimbusOutText("stderr", __nimbusOutBytes(d, enc));
     if (typeof cb === "function") queueMicrotask(cb);
     return true;
   };
@@ -898,8 +898,8 @@ const __ocFmt = (...a) => a.map((x) => {
 // event loop — the only channel that still reports from a CPU-bound spin.
 const __realConsoleError = console.error.bind(console);
 if (__ocResident) {
-  console.log = (...a) => { const s = __ocFmt(...a) + "\\n"; stdout = __ocTail(stdout, s); __queueRpcWrite("stdout", s); };
-  console.error = (...a) => { const s = __ocFmt(...a) + "\\n"; stderr = __ocTail(stderr, s); __queueRpcWrite("stderr", s); };
+  console.log = (...a) => { const s = __ocFmt(...a) + "\\n"; stdout = __ocTail(stdout, s); __queueRpcWrite("stdout", __nimbusOutEnc.encode(s)); };
+  console.error = (...a) => { const s = __ocFmt(...a) + "\\n"; stderr = __ocTail(stderr, s); __queueRpcWrite("stderr", __nimbusOutEnc.encode(s)); };
 } else {
   console.log = (...a) => { stdout += __ocFmt(...a) + "\\n"; };
   console.error = (...a) => { stderr += __ocFmt(...a) + "\\n"; };
@@ -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;