@volter/tabnode 0.5.48 → 0.5.49

package/dist/assets/{runtime-worker-B-BP9mj-.js → runtime-worker-C1IV4qnr.js}

@@ -5425,7 +5425,7 @@ function parse(urlString, parseQueryString = false, slashesDenoteHost = false) {
       hostname: null,
       hash: __hash,
       search: __search,
-      query: parseQueryString ? Object.fromEntries(new URLSearchParams(__search || "")) : __search ? __search.slice(1) : null,
+      query: parseQueryString ? Object.fromEntries(new URLSearchParams$1(__search || "")) : __search ? __search.slice(1) : null,
       pathname: __pathname || null,
       path: __pathname + (__search || "") || null,
       href: urlString
@@ -5499,7 +5499,7 @@ function format(urlObject) {
     if (typeof urlObject.query === "string") {
       result += "?" + urlObject.query;
     } else {
-      const params = new URLSearchParams();
+      const params = new URLSearchParams$1();
       for (const [key, value] of Object.entries(urlObject.query)) {
         if (Array.isArray(value)) {
           for (const v2 of value) {
@@ -5528,7 +5528,7 @@ function resolve$2(from, to2) {
   }
 }
 const URL$1 = globalThis.URL;
-const URLSearchParams = globalThis.URLSearchParams;
+const URLSearchParams$1 = globalThis.URLSearchParams;
 function fileURLToPath(url2) {
   const urlObj = typeof url2 === "string" ? new globalThis.URL(url2) : url2;
   if (urlObj.protocol !== "file:") {
@@ -5551,7 +5551,7 @@ var url$1 = {
   format,
   resolve: resolve$2,
   URL: URL$1,
-  URLSearchParams,
+  URLSearchParams: URLSearchParams$1,
   URLPattern: URLPattern$1,
   fileURLToPath,
   pathToFileURL
@@ -5560,7 +5560,7 @@ var urlShim = /* @__PURE__ */ Object.freeze({
   __proto__: null,
   URL: URL$1,
   URLPattern: URLPattern$1,
-  URLSearchParams,
+  URLSearchParams: URLSearchParams$1,
   default: url$1,
   fileURLToPath,
   format,
@@ -21191,10 +21191,17 @@ var implementation$1 = function bind2(that) {
 var implementation = implementation$1;
 var functionBind = Function.prototype.bind || implementation;
 var functionCall = Function.prototype.call;
-var functionApply = Function.prototype.apply;
+var functionApply;
+var hasRequiredFunctionApply;
+function requireFunctionApply() {
+  if (hasRequiredFunctionApply) return functionApply;
+  hasRequiredFunctionApply = 1;
+  functionApply = Function.prototype.apply;
+  return functionApply;
+}
 var reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
 var bind$2 = functionBind;
-var $apply$1 = functionApply;
+var $apply$1 = requireFunctionApply();
 var $call$2 = functionCall;
 var $reflectApply = reflectApply;
 var actualApply = $reflectApply || bind$2.call($call$2, $apply$1);
@@ -21314,7 +21321,7 @@ var hasSymbols = requireHasSymbols()();
 var getProto = requireGetProto();
 var $ObjectGPO = requireObject_getPrototypeOf();
 var $ReflectGPO = requireReflect_getPrototypeOf();
-var $apply = functionApply;
+var $apply = requireFunctionApply();
 var $call = functionCall;
 var needsEval = {};
 var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array);
@@ -21955,7 +21962,7 @@ function requireApplyBind() {
   if (hasRequiredApplyBind) return applyBind;
   hasRequiredApplyBind = 1;
   var bind3 = functionBind;
-  var $apply2 = functionApply;
+  var $apply2 = requireFunctionApply();
   var actualApply$1 = actualApply;
   applyBind = function applyBind2() {
     return actualApply$1(bind3, $apply2, arguments);
@@ -32263,6 +32270,68 @@ function guestPromise(owner) {
   }
   return constructor;
 }
+const kIsDisturbed = Symbol.for("nodejs.stream.disturbed");
+function isAsyncIterableBody(body) {
+  if (body === null || typeof body !== "object") return false;
+  if (typeof ReadableStream === "function" && body instanceof ReadableStream) return false;
+  if (typeof Blob === "function" && body instanceof Blob) return false;
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return false;
+  if (typeof FormData === "function" && body instanceof FormData) return false;
+  if (body instanceof URLSearchParams) return false;
+  return typeof body[Symbol.asyncIterator] === "function";
+}
+function refuseDisturbed(body) {
+  const stream = body;
+  const disturbed = stream[kIsDisturbed] !== void 0 ? Boolean(stream[kIsDisturbed]) : Boolean(stream.readableDidRead || stream.readableAborted);
+  if (disturbed || stream.locked === true) throw new TypeError("Response body object should not be disturbed or locked");
+}
+function streamFrom(iterable) {
+  let iterator;
+  return new ReadableStream({
+    async start() {
+      iterator = iterable[Symbol.asyncIterator]();
+    },
+    async pull(controller) {
+      for (; ; ) {
+        const { done, value } = await iterator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        const bytes2 = Buffer$9.isBuffer(value) ? value : Buffer$9.from(value);
+        if (bytes2.byteLength) {
+          controller.enqueue(new Uint8Array(bytes2));
+          return;
+        }
+      }
+    },
+    async cancel() {
+      var _a3;
+      await ((_a3 = iterator == null ? void 0 : iterator.return) == null ? void 0 : _a3.call(iterator));
+    }
+  }, { highWaterMark: 0 });
+}
+const REQUEST_INIT_MEMBERS = ["method", "headers", "referrer", "referrerPolicy", "mode", "credentials", "cache", "redirect", "integrity", "keepalive", "signal", "window", "duplex", "priority"];
+function withNodeRequestBody(init) {
+  if (!init) return init;
+  const body = init.body;
+  if (!isAsyncIterableBody(body)) return init;
+  refuseDisturbed(body);
+  const copy2 = {};
+  for (const member of Object.keys(init)) if (member !== "body") copy2[member] = init[member];
+  for (const member of REQUEST_INIT_MEMBERS) {
+    if (member in copy2) continue;
+    const value = init[member];
+    if (value !== void 0) copy2[member] = value;
+  }
+  copy2.body = streamFrom(body);
+  return copy2;
+}
+function nodeResponseBody(body) {
+  if (!isAsyncIterableBody(body)) return body;
+  refuseDisturbed(body);
+  return streamFrom(body);
+}
 const staticRequestBodies = /* @__PURE__ */ new WeakSet();
 function rememberRequestBodySource(request, input, init) {
   if (!request.body) return;
@@ -32272,6 +32341,11 @@ function rememberRequestBodySource(request, input, init) {
 }
 function guestFetch(process2, fallback) {
   return function fetch2(input, init) {
+    try {
+      init = withNodeRequestBody(init);
+    } catch (error) {
+      return Promise.reject(error);
+    }
     return fallback.call(globalThis, input, init);
   };
 }
@@ -32310,7 +32384,8 @@ function installNodeResponse(target) {
   const Native = target.Response;
   if (typeof Native !== "function" || Native[INSTALLED]) return;
   const proto = Native.prototype;
-  const nativeHeaders = (_a3 = Object.getOwnPropertyDescriptor(proto, "headers")) == null ? void 0 : _a3.get;
+  let nativeHeaders;
+  for (let at3 = proto; at3 && !nativeHeaders; at3 = Object.getPrototypeOf(at3)) nativeHeaders = (_a3 = Object.getOwnPropertyDescriptor(at3, "headers")) == null ? void 0 : _a3.get;
   const nativeFormData = proto.formData;
   const nativeBlob = proto.blob;
   const nativeArrayBuffer = proto.arrayBuffer;
@@ -32320,7 +32395,7 @@ function installNodeResponse(target) {
   const NodeResponse = function Response2(body, init) {
     if (!new.target) throw new TypeError("Class constructor Response cannot be invoked without 'new'");
     const given = givenHeaders(init);
-    const response = Reflect.construct(Native, [body, given ? withHeaders(init, given) : init], new.target === NodeResponse ? Native : new.target);
+    const response = Reflect.construct(Native, [nodeResponseBody(body), given ? withHeaders(init, given) : init], new.target === NodeResponse ? Native : new.target);
     kept.set(response, withCookies(nativeHeaders.call(response), given));
     return response;
   };
@@ -74207,6 +74282,63 @@ function installShellJobs(bash, host) {
     if (shell.jobs.size === 0) shells$1.delete(id2);
     return { stdout: held.stdout, stderr: held.stderr + stderr, exitCode: status };
   }));
+  for (const shell of ["sh", "bash"]) {
+    bash.registerCommand(uA(shell, async (args, ctx) => {
+      var _a3;
+      const exec = ctx.exec;
+      if (!exec) return { stdout: "", stderr: `bash: ${shell}: needs a shell that can run a script
+`, exitCode: 1 };
+      let script;
+      let zero2;
+      let positional;
+      let sourced;
+      let at3 = 0;
+      while (at3 < args.length && /^[-+][a-bd-zA-Z]+$/u.test(args[at3])) at3++;
+      args = args.slice(at3);
+      if (args[0] === "-c" && args.length >= 2) {
+        script = args[1];
+        zero2 = args[2] ?? shell;
+        positional = args.slice(3);
+      } else if (args.length === 0) {
+        if (!((_a3 = ctx.stdin) == null ? void 0 : _a3.trim())) return { stdout: "", stderr: "", exitCode: 0 };
+        script = ctx.stdin;
+        zero2 = shell;
+        positional = [];
+      } else {
+        const path2 = ctx.fs.resolvePath(ctx.cwd, args[0]);
+        try {
+          script = String(await ctx.fs.readFile(path2));
+        } catch {
+          return { stdout: "", stderr: `${shell}: ${args[0]}: No such file or directory
+`, exitCode: 127 };
+        }
+        zero2 = args[0];
+        positional = args.slice(1);
+        sourced = path2;
+      }
+      if (script.startsWith("#!")) {
+        const newline = script.indexOf("\n");
+        if (newline !== -1) script = script.slice(newline + 1);
+      }
+      const env = { ...ctx.exportedEnv ?? {}, "0": zero2, "#": String(positional.length), "@": positional.join(" "), "*": positional.join(" ") };
+      positional.forEach((word, index2) => {
+        env[String(index2 + 1)] = word;
+      });
+      const token = ctx.env.get(PROCESS_TOKEN_ENV);
+      if (token) env[PROCESS_TOKEN_ENV] = token;
+      if (sourced !== void 0) script = `. ${sourced.replace(/'/gu, "'\\''").replace(/^(.*)$/su, "'$1'")}`;
+      const result = await exec(script, { env, cwd: ctx.cwd, stdin: ctx.stdin, signal: ctx.signal });
+      return { stdout: result.stdout ?? "", stderr: result.stderr ?? "", exitCode: result.exitCode ?? 0 };
+    }));
+  }
+  bash.registerCommand(uA("exec", async (args, ctx) => {
+    if (args.length === 0) return { stdout: "", stderr: "", exitCode: 0 };
+    if (!ctx.exec) return { stdout: "", stderr: "bash: exec: needs a shell that can run a line\n", exitCode: 1 };
+    const line = args.map((word) => /^[A-Za-z0-9_./:=@%+,-]+$/u.test(word) ? word : `'${word.replace(/'/gu, "'\\''")}'`).join(" ");
+    const env = Object.fromEntries(ctx.env);
+    const result = await ctx.exec(line, { env, cwd: ctx.cwd, replaceEnv: true });
+    return { stdout: result.stdout ?? "", stderr: result.stderr ?? "", exitCode: result.exitCode ?? 0 };
+  }));
   bash.registerCommand(uA("kill", async (args) => {
     let signal = "SIGTERM";
     let index2 = 0;
@@ -74388,6 +74520,18 @@ function registerRunStreams(token, streams2) {
 }
 function releaseRunStreams(token) {
   _runStreams.delete(token);
+  shellRuns.delete(token);
+  hostedNodes.delete(token);
+}
+const shellRuns = /* @__PURE__ */ new Set();
+const hostedNodes = /* @__PURE__ */ new Set();
+function nestedNodeToken(parentToken, args, cwd) {
+  var _a3;
+  const token = `child-${__nextChildRun++}`;
+  setRunPid(token, mintPid(), ((_a3 = runPid(parentToken)) == null ? void 0 : _a3.pid) ?? 0, { argv: ["node", ...args], ...cwd ? { cwd } : {} });
+  const parentStreams = runStreamsFor(parentToken);
+  if (parentStreams) registerRunStreams(token, parentStreams);
+  return token;
 }
 function runStreamsFor(token) {
   return _runStreams.get(token);
@@ -74456,19 +74600,26 @@ function initChildProcess(vfs2) {
     if (!tree2) {
       return { stdout: "", stderr: "VFS not initialized\n", exitCode: 1 };
     }
-    const runToken = runTokenOf(ctx);
+    const parentToken = runTokenOf(ctx);
+    const nested = parentToken !== null && (shellRuns.has(parentToken) || hostedNodes.has(parentToken));
+    const runToken = nested ? nestedNodeToken(parentToken, args, ctx.cwd) : parentToken;
     const streams2 = runToken === null ? void 0 : runStreamsFor(runToken);
     const processHost = nodeProcessHostFor();
     if (processHost && runToken !== null) {
-      return runHostedNode(processHost, {
-        token: runToken,
-        argv: [...args],
-        cwd: ctx.cwd,
-        filesystem: tree2,
-        env: guestEnvironmentOf(ctx),
-        ...typeof ctx.stdin === "string" ? { stdin: ctx.stdin } : {},
-        ...streams2 ? { streams: streams2 } : {}
-      });
+      if (!nested) hostedNodes.add(runToken);
+      try {
+        return await runHostedNode(processHost, {
+          token: runToken,
+          argv: [...args],
+          cwd: ctx.cwd,
+          filesystem: tree2,
+          env: guestEnvironmentOf(ctx),
+          ...typeof ctx.stdin === "string" ? { stdin: ctx.stdin } : {},
+          ...streams2 ? { streams: streams2 } : {}
+        });
+      } finally {
+        if (nested) releaseRunStreams(runToken);
+      }
     }
     const execArgv = [];
     let first = 0;
@@ -75354,6 +75505,7 @@ function existsInTree(path2) {
     return false;
   }
 }
+const SHELL_PROGRAMS = /* @__PURE__ */ new Set(["sh", "bash", "dash", "/bin/sh", "/bin/bash", "/usr/bin/sh", "/usr/bin/bash"]);
 function engineProgramFor(file, cwd) {
   const name = __substrateProgramName(file);
   if (!name.includes("/")) return name;
@@ -75400,6 +75552,7 @@ function startChildRun(request) {
   const controller = new AbortController();
   const pendingStdin = [];
   const admittedNode = nodeProcessHostInstalled();
+  shellRuns.add(token);
   const hostTerminal = request.terminal !== void 0 && hostExecutor() !== null && !admittedNode;
   let wakeInput;
   let liveInput = false;
@@ -75498,7 +75651,8 @@ function startChildRun(request) {
   const begin = () => {
     if (started || finished) return;
     started = true;
-    const engineFirst = !hostTerminal && programExists(request.file, request.cwd, request.env);
+    const shellChild = SHELL_PROGRAMS.has(engineProgramFor(request.file, request.cwd)) && hostExecutor() !== null;
+    const engineFirst = !hostTerminal && !shellChild && programExists(request.file, request.cwd, request.env);
     liveInput = !hostTerminal && !admittedNode && request.stdinIsPipe && !engineFirst;
     if (liveInput) {
       pendingStdin.unshift(...initialStdin);
@@ -80548,6 +80702,7 @@ forGuestRealm(() => {
     const kept = /* @__PURE__ */ new WeakMap();
     class NodeRequest extends Native {
       constructor(input, init) {
+        init = withNodeRequestBody(init);
         super(input, init);
         rememberRequestBodySource(this, input, init);
         const asked = new Headers((init == null ? void 0 : init.headers) ?? (input instanceof Native ? input.headers : void 0));

package/dist/fetch-transport.d.ts

@@ -1,4 +1,3 @@
-/** Host Fetch I/O uses the same process-owned liveness registry as sockets. */
 import type { Process } from './shims/process';
 export interface FetchActivity {
     /** One pending transport operation; the returned release is idempotent. */

package/dist/index.mjs

@@ -5132,7 +5132,7 @@ function parse$1(urlString, parseQueryString = false, slashesDenoteHost = false)
       hostname: null,
       hash: __hash,
       search: __search,
-      query: parseQueryString ? Object.fromEntries(new URLSearchParams(__search || "")) : __search ? __search.slice(1) : null,
+      query: parseQueryString ? Object.fromEntries(new URLSearchParams$1(__search || "")) : __search ? __search.slice(1) : null,
       pathname: __pathname || null,
       path: __pathname + (__search || "") || null,
       href: urlString
@@ -5206,7 +5206,7 @@ function format$1(urlObject) {
     if (typeof urlObject.query === "string") {
       result += "?" + urlObject.query;
     } else {
-      const params = new URLSearchParams();
+      const params = new URLSearchParams$1();
       for (const [key, value] of Object.entries(urlObject.query)) {
         if (Array.isArray(value)) {
           for (const v of value) {
@@ -5235,7 +5235,7 @@ function resolve$2(from, to) {
   }
 }
 const URL$1 = globalThis.URL;
-const URLSearchParams = globalThis.URLSearchParams;
+const URLSearchParams$1 = globalThis.URLSearchParams;
 function fileURLToPath(url2) {
   const urlObj = typeof url2 === "string" ? new globalThis.URL(url2) : url2;
   if (urlObj.protocol !== "file:") {
@@ -5258,7 +5258,7 @@ const url$1 = {
   format: format$1,
   resolve: resolve$2,
   URL: URL$1,
-  URLSearchParams,
+  URLSearchParams: URLSearchParams$1,
   URLPattern: URLPattern$1,
   fileURLToPath,
   pathToFileURL
@@ -5267,7 +5267,7 @@ const urlShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   __proto__: null,
   URL: URL$1,
   URLPattern: URLPattern$1,
-  URLSearchParams,
+  URLSearchParams: URLSearchParams$1,
   default: url$1,
   fileURLToPath,
   format: format$1,
@@ -32424,6 +32424,68 @@ function guestPromise(owner) {
   }
   return constructor;
 }
+const kIsDisturbed = Symbol.for("nodejs.stream.disturbed");
+function isAsyncIterableBody(body) {
+  if (body === null || typeof body !== "object") return false;
+  if (typeof ReadableStream === "function" && body instanceof ReadableStream) return false;
+  if (typeof Blob === "function" && body instanceof Blob) return false;
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return false;
+  if (typeof FormData === "function" && body instanceof FormData) return false;
+  if (body instanceof URLSearchParams) return false;
+  return typeof body[Symbol.asyncIterator] === "function";
+}
+function refuseDisturbed(body) {
+  const stream = body;
+  const disturbed = stream[kIsDisturbed] !== void 0 ? Boolean(stream[kIsDisturbed]) : Boolean(stream.readableDidRead || stream.readableAborted);
+  if (disturbed || stream.locked === true) throw new TypeError("Response body object should not be disturbed or locked");
+}
+function streamFrom(iterable) {
+  let iterator;
+  return new ReadableStream({
+    async start() {
+      iterator = iterable[Symbol.asyncIterator]();
+    },
+    async pull(controller) {
+      for (; ; ) {
+        const { done, value } = await iterator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        const bytes2 = Buffer$9.isBuffer(value) ? value : Buffer$9.from(value);
+        if (bytes2.byteLength) {
+          controller.enqueue(new Uint8Array(bytes2));
+          return;
+        }
+      }
+    },
+    async cancel() {
+      var _a2;
+      await ((_a2 = iterator == null ? void 0 : iterator.return) == null ? void 0 : _a2.call(iterator));
+    }
+  }, { highWaterMark: 0 });
+}
+const REQUEST_INIT_MEMBERS = ["method", "headers", "referrer", "referrerPolicy", "mode", "credentials", "cache", "redirect", "integrity", "keepalive", "signal", "window", "duplex", "priority"];
+function withNodeRequestBody(init) {
+  if (!init) return init;
+  const body = init.body;
+  if (!isAsyncIterableBody(body)) return init;
+  refuseDisturbed(body);
+  const copy2 = {};
+  for (const member of Object.keys(init)) if (member !== "body") copy2[member] = init[member];
+  for (const member of REQUEST_INIT_MEMBERS) {
+    if (member in copy2) continue;
+    const value = init[member];
+    if (value !== void 0) copy2[member] = value;
+  }
+  copy2.body = streamFrom(body);
+  return copy2;
+}
+function nodeResponseBody(body) {
+  if (!isAsyncIterableBody(body)) return body;
+  refuseDisturbed(body);
+  return streamFrom(body);
+}
 let transport;
 const staticRequestBodies = /* @__PURE__ */ new WeakSet();
 function rememberRequestBodySource(request, input, init) {
@@ -32478,14 +32540,19 @@ function activity(owner, cancel) {
 function guestFetch(process2, fallback) {
   return function fetch2(input, init) {
     const adapter = transport;
-    if (!adapter) return fallback.call(globalThis, input, init);
-    const owner = __tokenForProcess(process2);
+    const owner = adapter ? __tokenForProcess(process2) : null;
     const ended = () => {
       var _a2;
       return owner !== null && ((_a2 = __runFor(owner)) == null ? void 0 : _a2.process) !== process2;
     };
     const stopped2 = () => new DOMException("The requesting process has ended.", "AbortError");
-    if (ended()) return Promise.reject(stopped2());
+    if (adapter && ended()) return Promise.reject(stopped2());
+    try {
+      init = withNodeRequestBody(init);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    if (!adapter) return fallback.call(globalThis, input, init);
     const context2 = { begin(cancel) {
       if (ended()) throw stopped2();
       return activity(owner, cancel);
@@ -32529,7 +32596,8 @@ function installNodeResponse(target) {
   const Native = target.Response;
   if (typeof Native !== "function" || Native[INSTALLED]) return;
   const proto = Native.prototype;
-  const nativeHeaders = (_a2 = Object.getOwnPropertyDescriptor(proto, "headers")) == null ? void 0 : _a2.get;
+  let nativeHeaders;
+  for (let at2 = proto; at2 && !nativeHeaders; at2 = Object.getPrototypeOf(at2)) nativeHeaders = (_a2 = Object.getOwnPropertyDescriptor(at2, "headers")) == null ? void 0 : _a2.get;
   const nativeFormData = proto.formData;
   const nativeBlob = proto.blob;
   const nativeArrayBuffer = proto.arrayBuffer;
@@ -32539,7 +32607,7 @@ function installNodeResponse(target) {
   const NodeResponse = function Response(body, init) {
     if (!new.target) throw new TypeError("Class constructor Response cannot be invoked without 'new'");
     const given = givenHeaders(init);
-    const response = Reflect.construct(Native, [body, given ? withHeaders(init, given) : init], new.target === NodeResponse ? Native : new.target);
+    const response = Reflect.construct(Native, [nodeResponseBody(body), given ? withHeaders(init, given) : init], new.target === NodeResponse ? Native : new.target);
     kept.set(response, withCookies(nativeHeaders.call(response), given));
     return response;
   };
@@ -33809,6 +33877,63 @@ function installShellJobs(bash, host2) {
     if (shell.jobs.size === 0) shells$1.delete(id);
     return { stdout: held.stdout, stderr: held.stderr + stderr, exitCode: status };
   }));
+  for (const shell of ["sh", "bash"]) {
+    bash.registerCommand(defineCommand(shell, async (args, ctx) => {
+      var _a2;
+      const exec = ctx.exec;
+      if (!exec) return { stdout: "", stderr: `bash: ${shell}: needs a shell that can run a script
+`, exitCode: 1 };
+      let script;
+      let zero2;
+      let positional;
+      let sourced;
+      let at2 = 0;
+      while (at2 < args.length && /^[-+][a-bd-zA-Z]+$/u.test(args[at2])) at2++;
+      args = args.slice(at2);
+      if (args[0] === "-c" && args.length >= 2) {
+        script = args[1];
+        zero2 = args[2] ?? shell;
+        positional = args.slice(3);
+      } else if (args.length === 0) {
+        if (!((_a2 = ctx.stdin) == null ? void 0 : _a2.trim())) return { stdout: "", stderr: "", exitCode: 0 };
+        script = ctx.stdin;
+        zero2 = shell;
+        positional = [];
+      } else {
+        const path2 = ctx.fs.resolvePath(ctx.cwd, args[0]);
+        try {
+          script = String(await ctx.fs.readFile(path2));
+        } catch {
+          return { stdout: "", stderr: `${shell}: ${args[0]}: No such file or directory
+`, exitCode: 127 };
+        }
+        zero2 = args[0];
+        positional = args.slice(1);
+        sourced = path2;
+      }
+      if (script.startsWith("#!")) {
+        const newline = script.indexOf("\n");
+        if (newline !== -1) script = script.slice(newline + 1);
+      }
+      const env = { ...ctx.exportedEnv ?? {}, "0": zero2, "#": String(positional.length), "@": positional.join(" "), "*": positional.join(" ") };
+      positional.forEach((word, index2) => {
+        env[String(index2 + 1)] = word;
+      });
+      const token = ctx.env.get(PROCESS_TOKEN_ENV);
+      if (token) env[PROCESS_TOKEN_ENV] = token;
+      if (sourced !== void 0) script = `. ${sourced.replace(/'/gu, "'\\''").replace(/^(.*)$/su, "'$1'")}`;
+      const result = await exec(script, { env, cwd: ctx.cwd, stdin: ctx.stdin, signal: ctx.signal });
+      return { stdout: result.stdout ?? "", stderr: result.stderr ?? "", exitCode: result.exitCode ?? 0 };
+    }));
+  }
+  bash.registerCommand(defineCommand("exec", async (args, ctx) => {
+    if (args.length === 0) return { stdout: "", stderr: "", exitCode: 0 };
+    if (!ctx.exec) return { stdout: "", stderr: "bash: exec: needs a shell that can run a line\n", exitCode: 1 };
+    const line = args.map((word) => /^[A-Za-z0-9_./:=@%+,-]+$/u.test(word) ? word : `'${word.replace(/'/gu, "'\\''")}'`).join(" ");
+    const env = Object.fromEntries(ctx.env);
+    const result = await ctx.exec(line, { env, cwd: ctx.cwd, replaceEnv: true });
+    return { stdout: result.stdout ?? "", stderr: result.stderr ?? "", exitCode: result.exitCode ?? 0 };
+  }));
   bash.registerCommand(defineCommand("kill", async (args) => {
     let signal = "SIGTERM";
     let index2 = 0;
@@ -34009,6 +34134,18 @@ function registerRunStreams(token, streams2) {
 }
 function releaseRunStreams(token) {
   _runStreams.delete(token);
+  shellRuns.delete(token);
+  hostedNodes.delete(token);
+}
+const shellRuns = /* @__PURE__ */ new Set();
+const hostedNodes = /* @__PURE__ */ new Set();
+function nestedNodeToken(parentToken, args, cwd) {
+  var _a2;
+  const token = `child-${__nextChildRun++}`;
+  setRunPid(token, mintPid(), ((_a2 = runPid(parentToken)) == null ? void 0 : _a2.pid) ?? 0, { argv: ["node", ...args], ...cwd ? { cwd } : {} });
+  const parentStreams = runStreamsFor(parentToken);
+  if (parentStreams) registerRunStreams(token, parentStreams);
+  return token;
 }
 function runStreamsFor(token) {
   return _runStreams.get(token);
@@ -34100,19 +34237,26 @@ function initChildProcess(vfs2) {
     if (!tree2) {
       return { stdout: "", stderr: "VFS not initialized\n", exitCode: 1 };
     }
-    const runToken = runTokenOf(ctx);
+    const parentToken = runTokenOf(ctx);
+    const nested = parentToken !== null && (shellRuns.has(parentToken) || hostedNodes.has(parentToken));
+    const runToken = nested ? nestedNodeToken(parentToken, args, ctx.cwd) : parentToken;
     const streams2 = runToken === null ? void 0 : runStreamsFor(runToken);
     const processHost = nodeProcessHostFor(runToken);
     if (processHost && runToken !== null) {
-      return runHostedNode(processHost, {
-        token: runToken,
-        argv: [...args],
-        cwd: ctx.cwd,
-        filesystem: tree2,
-        env: guestEnvironmentOf(ctx),
-        ...typeof ctx.stdin === "string" ? { stdin: ctx.stdin } : {},
-        ...streams2 ? { streams: streams2 } : {}
-      });
+      if (!nested) hostedNodes.add(runToken);
+      try {
+        return await runHostedNode(processHost, {
+          token: runToken,
+          argv: [...args],
+          cwd: ctx.cwd,
+          filesystem: tree2,
+          env: guestEnvironmentOf(ctx),
+          ...typeof ctx.stdin === "string" ? { stdin: ctx.stdin } : {},
+          ...streams2 ? { streams: streams2 } : {}
+        });
+      } finally {
+        if (nested) releaseRunStreams(runToken);
+      }
     }
     const execArgv = [];
     let first = 0;
@@ -35018,6 +35162,7 @@ function existsInTree(path2) {
     return false;
   }
 }
+const SHELL_PROGRAMS = /* @__PURE__ */ new Set(["sh", "bash", "dash", "/bin/sh", "/bin/bash", "/usr/bin/sh", "/usr/bin/bash"]);
 function engineProgramFor(file, cwd) {
   const name = __substrateProgramName(file);
   if (!name.includes("/")) return name;
@@ -35064,6 +35209,7 @@ function startChildRun(request) {
   const controller = new AbortController();
   const pendingStdin = [];
   const admittedNode = nodeProcessHostInstalled() && engineProgramFor(request.file, request.cwd) === "node";
+  if (!admittedNode) shellRuns.add(token);
   const hostTerminal = request.terminal !== void 0 && hostExecutor() !== null && !admittedNode;
   let wakeInput;
   let liveInput = false;
@@ -35162,7 +35308,8 @@ function startChildRun(request) {
   const begin = () => {
     if (started2 || finished) return;
     started2 = true;
-    const engineFirst = !hostTerminal && programExists(request.file, request.cwd, request.env);
+    const shellChild = SHELL_PROGRAMS.has(engineProgramFor(request.file, request.cwd)) && hostExecutor() !== null;
+    const engineFirst = !hostTerminal && !shellChild && programExists(request.file, request.cwd, request.env);
     liveInput = !hostTerminal && !admittedNode && request.stdinIsPipe && !engineFirst;
     if (liveInput) {
       pendingStdin.unshift(...initialStdin);
@@ -40220,6 +40367,7 @@ forGuestRealm(() => {
     const kept = /* @__PURE__ */ new WeakMap();
     class NodeRequest extends Native {
       constructor(input, init) {
+        init = withNodeRequestBody(init);
         super(input, init);
         rememberRequestBodySource(this, input, init);
         const asked = new Headers((init == null ? void 0 : init.headers) ?? (input instanceof Native ? input.headers : void 0));
@@ -40548,7 +40696,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-B-BP9mj-.js",
+        "/assets/runtime-worker-C1IV4qnr.js",
         import.meta.url
       ),
       { type: "module" }

package/dist/node-body.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The init with an async-iterable body read as a stream, or the init itself.
+ * The body is read once; the replacement is built member by member (an init
+ * may carry its members on getters of its prototype, as a `Request` passed as
+ * an init does), with the init's own other members as they are.
+ */
+export declare function withNodeRequestBody<T extends RequestInit | undefined>(init: T): T;
+/** A response body as undici takes it: an async iterable read as a stream, anything else as given. */
+export declare function nodeResponseBody(body: unknown): unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.5.48",
+  "version": "0.5.49",
   "description": "Node's own library, in a browser tab.",
   "type": "module",
   "license": "MIT",

package/src/fetch-transport.ts

@@ -1,4 +1,5 @@
 /** Host Fetch I/O uses the same process-owned liveness registry as sockets. */
+import { withNodeRequestBody } from './node-body';
 import type { Process } from './shims/process';
 import { __tokenForProcess, __runFor, enterRun, type ProcessToken } from './process-tokens';
 import { registerHandle, __adoptHandle, refHandle, unrefHandle, releaseHandle } from './node-lib/binding/handles';
@@ -83,11 +84,14 @@ function activity(owner: ProcessToken | null, cancel: () => void): FetchActivity
 export function guestFetch(process: Process, fallback: typeof globalThis.fetch): typeof globalThis.fetch {
   return function fetch(input, init) {
     const adapter = transport;
-    if (!adapter) return fallback.call(globalThis, input, init);
-    const owner = __tokenForProcess(process);
+    const owner = adapter ? __tokenForProcess(process) : null;
     const ended = () => owner !== null && __runFor(owner)?.process !== process;
     const stopped = () => new DOMException('The requesting process has ended.', 'AbortError');
-    if (ended()) return Promise.reject(stopped());
+    if (adapter && ended()) return Promise.reject(stopped());
+    // A stream body is read as undici reads it, whichever door the fetch
+    // leaves by; a body undici refuses rejects the fetch, as Node's does.
+    try { init = withNodeRequestBody(init); } catch (error) { return Promise.reject(error); }
+    if (!adapter) return fallback.call(globalThis, input, init);
     const context: FetchTransportContext = { begin(cancel) {
       if (ended()) throw stopped();
       return activity(owner, cancel);

package/src/node-body.ts

@@ -0,0 +1,88 @@
+/**
+ * A body as Node's fetch (undici's `extractBody`) accepts it: besides what a
+ * browser takes, any async iterable (a Node `Readable`, an `http.IncomingMessage`,
+ * an async generator) is read as a stream of its chunks, each a `Buffer`,
+ * a typed array or a string (UTF-8). A browser's `Request` and `Response` take
+ * such an object for a string: `new Request(url, { method: 'POST', body:
+ * incomingMessage, duplex: 'half' })` has the body "[object Object]". Next's
+ * App Router builds every route handler's request exactly that way (its
+ * request adapter passes the Node request as the body, "handled by undici"),
+ * so every POST a route handler read was that string, and NextAuth's
+ * credentials callback found no CSRF token in it.
+ *
+ * Only such a body is changed; every other init is handed on untouched.
+ */
+import { Buffer } from './node-lib/buffer-module';
+
+/** The mark Node's streams carry once read (`internal/streams/utils`, `kIsDisturbed`). */
+const kIsDisturbed = Symbol.for('nodejs.stream.disturbed');
+
+function isAsyncIterableBody(body: unknown): body is AsyncIterable<unknown> {
+  if (body === null || typeof body !== 'object') return false;
+  if (typeof ReadableStream === 'function' && body instanceof ReadableStream) return false;
+  if (typeof Blob === 'function' && body instanceof Blob) return false;
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return false;
+  if (typeof FormData === 'function' && body instanceof FormData) return false;
+  if (body instanceof URLSearchParams) return false;
+  return typeof (body as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator] === 'function';
+}
+
+/** Node's `isDisturbed`, and undici's refusal of a body already read or locked. */
+function refuseDisturbed(body: object): void {
+  const stream = body as { locked?: unknown; readableDidRead?: unknown; readableAborted?: unknown; [kIsDisturbed]?: unknown };
+  const disturbed = stream[kIsDisturbed] !== undefined ? Boolean(stream[kIsDisturbed]) : Boolean(stream.readableDidRead || stream.readableAborted);
+  if (disturbed || stream.locked === true) throw new TypeError('Response body object should not be disturbed or locked');
+}
+
+/**
+ * undici's `ReadableStreamFrom`: the iterator made when the stream starts,
+ * each chunk `Buffer.from`'d as Node's is (a chunk `Buffer.from` refuses
+ * errors the stream), an empty chunk passed over for the next, and the
+ * iterator returned, with no argument, on cancel.
+ */
+function streamFrom(iterable: AsyncIterable<unknown>): ReadableStream<Uint8Array> {
+  let iterator: AsyncIterator<unknown> | undefined;
+  return new ReadableStream<Uint8Array>({
+    async start() { iterator = iterable[Symbol.asyncIterator](); },
+    async pull(controller) {
+      for (;;) {
+        const { done, value } = await iterator!.next();
+        if (done) { controller.close(); return; }
+        const bytes = (Buffer.isBuffer(value) ? value : (Buffer.from as (chunk: unknown) => Uint8Array)(value)) as Uint8Array;
+        if (bytes.byteLength) { controller.enqueue(new Uint8Array(bytes)); return; }
+      }
+    },
+    async cancel() { await iterator?.return?.(); },
+  }, { highWaterMark: 0 });
+}
+
+const REQUEST_INIT_MEMBERS = ['method', 'headers', 'referrer', 'referrerPolicy', 'mode', 'credentials', 'cache', 'redirect', 'integrity', 'keepalive', 'signal', 'window', 'duplex', 'priority'] as const;
+
+/**
+ * The init with an async-iterable body read as a stream, or the init itself.
+ * The body is read once; the replacement is built member by member (an init
+ * may carry its members on getters of its prototype, as a `Request` passed as
+ * an init does), with the init's own other members as they are.
+ */
+export function withNodeRequestBody<T extends RequestInit | undefined>(init: T): T {
+  if (!init) return init;
+  const body = (init as RequestInit).body as unknown;
+  if (!isAsyncIterableBody(body)) return init;
+  refuseDisturbed(body);
+  const copy: Record<string, unknown> = {};
+  for (const member of Object.keys(init)) if (member !== 'body') copy[member] = (init as Record<string, unknown>)[member];
+  for (const member of REQUEST_INIT_MEMBERS) {
+    if (member in copy) continue;
+    const value = (init as Record<string, unknown>)[member];
+    if (value !== undefined) copy[member] = value;
+  }
+  copy.body = streamFrom(body);
+  return copy as T;
+}
+
+/** A response body as undici takes it: an async iterable read as a stream, anything else as given. */
+export function nodeResponseBody(body: unknown): unknown {
+  if (!isAsyncIterableBody(body)) return body;
+  refuseDisturbed(body);
+  return streamFrom(body);
+}

package/src/node-response.ts

@@ -1,4 +1,5 @@
 import { defineOnHost, takeFromHost } from './host-globals';
+import { nodeResponseBody } from './node-body';
 
 /**
  * A web `Response` that keeps its `Set-Cookie` headers, as Node's does.
@@ -76,7 +77,9 @@ export function installNodeResponse(target: { Response?: typeof Response }): voi
   const Native = target.Response as ResponseConstructor | undefined;
   if (typeof Native !== 'function' || Native[INSTALLED]) return;
   const proto = Native.prototype;
-  const nativeHeaders = Object.getOwnPropertyDescriptor(proto, 'headers')?.get;
+  // The getter is the prototype's own in a browser; found up the chain wherever it is.
+  let nativeHeaders: (() => unknown) | undefined;
+  for (let at: object | null = proto; at && !nativeHeaders; at = Object.getPrototypeOf(at)) nativeHeaders = Object.getOwnPropertyDescriptor(at, 'headers')?.get;
   const nativeFormData = proto.formData;
   const nativeBlob = proto.blob;
   const nativeArrayBuffer = proto.arrayBuffer;
@@ -87,7 +90,7 @@ export function installNodeResponse(target: { Response?: typeof Response }): voi
   const NodeResponse = function Response(this: unknown, body?: BodyInit | null, init?: ResponseInit): Response {
     if (!new.target) throw new TypeError("Class constructor Response cannot be invoked without 'new'");
     const given = givenHeaders(init);
-    const response = Reflect.construct(Native, [body, given ? withHeaders(init, given) : init], (new.target as unknown) === NodeResponse ? Native : new.target) as Response;
+    const response = Reflect.construct(Native, [nodeResponseBody(body) as BodyInit | null | undefined, given ? withHeaders(init, given) : init], (new.target as unknown) === NodeResponse ? Native : new.target) as Response;
     kept.set(response, withCookies(nativeHeaders.call(response) as Headers, given));
     return response;
   } as unknown as ResponseConstructor;

package/src/runtime.ts

@@ -9,6 +9,7 @@ import { VirtualFS } from './virtual-fs';
 import { guestPromise, intrinsicPromise } from './promise-ownership';
 import { guestFetch, rememberRequestBodySource } from './fetch-transport';
 import { installNodeResponse } from './node-response';
+import { withNodeRequestBody } from './node-body';
 import { forGuestRealm, installGuestRealm, takeFromHost, defineOnHost, heldWork } from './host-globals';
 import type { IRuntime, IExecuteResult, IRuntimeOptions } from './runtime-interface';
 import type { PackageJson } from './types/package-json';
@@ -2953,6 +2954,8 @@ forGuestRealm(() => {
     const kept = new WeakMap<object, Headers>();
     class NodeRequest extends Native {
       constructor(input: RequestInfo | URL, init?: RequestInit) {
+        // An async-iterable body (a Node stream) is read as undici reads it.
+        init = withNodeRequestBody(init);
         super(input as RequestInfo, init);
         rememberRequestBodySource(this, input, init);
         const asked = new Headers(init?.headers ?? (input instanceof Native ? (input as Request).headers : undefined));

package/src/shims/child_process.ts

@@ -268,6 +268,22 @@ export function registerRunStreams(token: ProcessToken, streams: RunStreams): vo
 /** Forget a run that has ended. */
 export function releaseRunStreams(token: ProcessToken): void {
   _runStreams.delete(token);
+  shellRuns.delete(token);
+  hostedNodes.delete(token);
+}
+
+/** Runs whose program is a shell or another non-node program: a `node` they run is their child. */
+const shellRuns = new Set<ProcessToken>();
+/** Runs that are themselves a hosted `node`: a further `node` under them is a child. */
+const hostedNodes = new Set<ProcessToken>();
+
+/** A child identity for a `node` a run's shell runs: its own token and pid under the run's, on the run's streams. */
+function nestedNodeToken(parentToken: ProcessToken, args: readonly string[], cwd: string | undefined): ProcessToken {
+  const token: ProcessToken = `child-${__nextChildRun++}`;
+  setRunPid(token, mintPid(), runPid(parentToken)?.pid ?? 0, { argv: ['node', ...args], ...(cwd ? { cwd } : {}) });
+  const parentStreams = runStreamsFor(parentToken);
+  if (parentStreams) registerRunStreams(token, parentStreams);
+  return token;
 }
 
 /** What the host gave the named run, while it lasts. */
@@ -429,14 +445,30 @@ export function initChildProcess(vfs: VirtualFS): void {
 
     // Capture this run's name, streams and cancellation before another Node
     // entry can start. Forks and shell entries reach this same dispatch seam.
-    const runToken = runTokenOf(ctx);
+    const parentToken = runTokenOf(ctx);
+    // A `node` a shell runs is a process of its own unless it is the run
+    // itself: the first `node` of a run that is not a shell's child is the
+    // run (the CMD `node server.js`, the page's `node -e`), and every other
+    // one, a line of a start script, the second command of a `-c` line, a
+    // step of a `sh file` child, gets a child token under the run's pid,
+    // the run's streams, and its own admission at the host. Admitted under
+    // the shell's own token, its exit was read as the shell's: a script
+    // ended at its first `node` line with nothing after it (measured
+    // 2026-09-28: `sh start.sh` printed its first step and stopped).
+    const nested = parentToken !== null && (shellRuns.has(parentToken) || hostedNodes.has(parentToken));
+    const runToken = nested ? nestedNodeToken(parentToken!, args, ctx.cwd) : parentToken;
     const streams = runToken === null ? undefined : runStreamsFor(runToken);
     const processHost = nodeProcessHostFor(runToken);
     if (processHost && runToken !== null) {
-      return runHostedNode(processHost, {
-        token: runToken, argv: [...args], cwd: ctx.cwd, filesystem: tree, env: guestEnvironmentOf(ctx),
-        ...(typeof ctx.stdin === 'string' ? { stdin: ctx.stdin } : {}), ...(streams ? { streams } : {}),
-      });
+      if (!nested) hostedNodes.add(runToken);
+      try {
+        return await runHostedNode(processHost, {
+          token: runToken, argv: [...args], cwd: ctx.cwd, filesystem: tree, env: guestEnvironmentOf(ctx),
+          ...(typeof ctx.stdin === 'string' ? { stdin: ctx.stdin } : {}), ...(streams ? { streams } : {}),
+        });
+      } finally {
+        if (nested) releaseRunStreams(runToken);
+      }
     }
 
     // Node reads its own options before the script: `node --turbo-fast-api-calls
@@ -1719,6 +1751,9 @@ function existsInTree(path: string): boolean {
  * a program the engine can run; the engine's own `node`, written to
  * `/usr/local/bin/node` when the shim is initialized, is one of those.
  */
+/** The shells a script or a `-c` line runs under; a child of these goes to the host when there is one. */
+const SHELL_PROGRAMS = new Set(['sh', 'bash', 'dash', '/bin/sh', '/bin/bash', '/usr/bin/sh', '/usr/bin/bash']);
+
 function engineProgramFor(file: string, cwd?: string): string {
   const name = __substrateProgramName(file);
   if (!name.includes('/')) return name;
@@ -1794,6 +1829,7 @@ function startChildRun(request: RunRequest): StartedRun {
   // A host terminal consumes input incrementally. The old string-only
   // route dropped every keystroke that arrived after a child was launched.
   const admittedNode = nodeProcessHostInstalled() && engineProgramFor(request.file, request.cwd) === 'node';
+  if (!admittedNode) shellRuns.add(token);
   const hostTerminal = request.terminal !== undefined && hostExecutor() !== null && !admittedNode;
   let wakeInput: (() => void) | undefined;
   /**
@@ -1904,7 +1940,14 @@ function startChildRun(request: RunRequest): StartedRun {
   const begin = (): void => {
     if (started || finished) return;
     started = true;
-    const engineFirst = !hostTerminal && programExists(request.file, request.cwd, request.env);
+    // A shell a hosted program spawns (`sh start.sh`, `sh -c '…'`) runs at
+    // the host when there is one, not in this worker's own bash: the host is
+    // where the programs the page registered live (`npx` under /usr/bin),
+    // and where a `node` inside the script is given a named run. Run here,
+    // the script's `node` found no name and was refused, and its `npx` was
+    // not found at all.
+    const shellChild = SHELL_PROGRAMS.has(engineProgramFor(request.file, request.cwd)) && hostExecutor() !== null;
+    const engineFirst = !hostTerminal && !shellChild && programExists(request.file, request.cwd, request.env);
     liveInput = !hostTerminal && !admittedNode && request.stdinIsPipe && !engineFirst;
     if (liveInput) {
       pendingStdin.unshift(...initialStdin);

package/src/shims/shell-jobs.ts

@@ -386,6 +386,78 @@ export function installShellJobs(bash: Bash, host: ShellJobsHost): void {
     return { stdout: held.stdout, stderr: held.stderr + stderr, exitCode: status };
   }));
 
+  // `sh file`, `sh -c line` and `sh` on stdin: the shell's own ran the script
+  // with the caller's exported variables alone, and a run's name travels in
+  // a variable the shell never exports, so a `node` on any line of a script
+  // found no named run and was refused ("Isolated Node execution requires a
+  // named run", a start script in browser-substrate's tab, 2026-09-28). The
+  // script is run as the shell's own would run it, with the name carried.
+  for (const shell of ['sh', 'bash'] as const) {
+    bash.registerCommand(defineCommand(shell, async (args, ctx) => {
+      const exec = ctx.exec;
+      if (!exec) return { stdout: '', stderr: `bash: ${shell}: needs a shell that can run a script\n`, exitCode: 1 };
+      let script: string;
+      let zero: string;
+      let positional: string[];
+      let sourced: string | undefined;
+      // Options before the script (`sh -e start.sh`, `bash -eu -c …`) are the
+      // shell's own; they are passed over rather than read as the file's name.
+      let at = 0;
+      while (at < args.length && /^[-+][a-bd-zA-Z]+$/u.test(args[at]!)) at++;
+      args = args.slice(at);
+      if (args[0] === '-c' && args.length >= 2) {
+        script = args[1]!;
+        zero = args[2] ?? shell;
+        positional = args.slice(3);
+      } else if (args.length === 0) {
+        if (!ctx.stdin?.trim()) return { stdout: '', stderr: '', exitCode: 0 };
+        script = ctx.stdin;
+        zero = shell;
+        positional = [];
+      } else {
+        const path = ctx.fs.resolvePath(ctx.cwd, args[0]!);
+        try { script = String(await ctx.fs.readFile(path)); }
+        catch { return { stdout: '', stderr: `${shell}: ${args[0]}: No such file or directory\n`, exitCode: 127 }; }
+        zero = args[0]!;
+        positional = args.slice(1);
+        sourced = path;
+      }
+      if (script.startsWith('#!')) {
+        const newline = script.indexOf('\n');
+        if (newline !== -1) script = script.slice(newline + 1);
+      }
+      const env: Record<string, string> = { ...(ctx.exportedEnv ?? {}), '0': zero, '#': String(positional.length), '@': positional.join(' '), '*': positional.join(' ') };
+      positional.forEach((word, index) => { env[String(index + 1)] = word; });
+      const token = ctx.env.get(PROCESS_TOKEN_ENV);
+      if (token) env[PROCESS_TOKEN_ENV] = token;
+      // A file is sourced by one statement of the nested run rather than run
+      // as the nested run's own script: a nested script of several lines
+      // stopped after its first hosted `node` in a tab (2026-09-28), while
+      // the same lines sourced from one statement ran whole. The shebang
+      // line is a comment to the shell that sources it.
+      if (sourced !== undefined) script = `. ${sourced.replace(/'/gu, "'\\''").replace(/^(.*)$/su, "'$1'")}`;
+      const result = await exec(script, { env, cwd: ctx.cwd, stdin: ctx.stdin, signal: (ctx as { signal?: AbortSignal }).signal });
+      return { stdout: result.stdout ?? '', stderr: result.stderr ?? '', exitCode: result.exitCode ?? 0 };
+    }));
+  }
+  // `exec command…` runs the command in the script's place, with the
+  // script's environment and its run's name, and answers with its status.
+  // The shell's own `exec` ran a builtin but a program the engine defines,
+  // `node`, ran nothing: a start script's `exec node server.js` ended with
+  // no server and no word. This one hands the line back to the shell, which
+  // is where `node`, `npm` and the host's programs are found. The shell is
+  // not replaced: a line after `exec` runs once the command ends, where
+  // bash would never reach it. A start script's `exec` is its last line, a
+  // server that does not end.
+  bash.registerCommand(defineCommand('exec', async (args, ctx) => {
+    if (args.length === 0) return { stdout: '', stderr: '', exitCode: 0 };
+    if (!ctx.exec) return { stdout: '', stderr: 'bash: exec: needs a shell that can run a line\n', exitCode: 1 };
+    const line = args.map((word) => /^[A-Za-z0-9_./:=@%+,-]+$/u.test(word) ? word : `'${word.replace(/'/gu, "'\\''")}'`).join(' ');
+    const env: Record<string, string> = Object.fromEntries(ctx.env);
+    const result = await ctx.exec(line, { env, cwd: ctx.cwd, replaceEnv: true });
+    return { stdout: result.stdout ?? '', stderr: result.stderr ?? '', exitCode: result.exitCode ?? 0 };
+  }));
+
   bash.registerCommand(defineCommand('kill', async (args) => {
     let signal = 'SIGTERM';
     let index = 0;