@volter/tabnode 0.5.47 → 0.5.49

package/dist/assets/{runtime-worker-4iI8R3l-.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,
@@ -32270,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;
@@ -32279,9 +32341,132 @@ 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);
   };
 }
+const INSTALLED = Symbol.for("tabnode.response.keepsSetCookie");
+function withCookies(own, given) {
+  const headers = new Headers(own);
+  if (!given) return headers;
+  const cookies = [];
+  if (typeof given.getSetCookie === "function") cookies.push(...given.getSetCookie());
+  else given.forEach((value, name) => {
+    if (name === "set-cookie") cookies.push(value);
+  });
+  if (cookies.length) {
+    headers.delete("set-cookie");
+    for (const cookie of cookies) headers.append("set-cookie", cookie);
+  }
+  const cookie2 = given.get("set-cookie2");
+  if (cookie2 !== null) headers.set("set-cookie2", cookie2);
+  return headers;
+}
+function givenHeaders(init) {
+  const headers = init == null ? void 0 : init.headers;
+  return headers === void 0 || headers === null ? void 0 : new Headers(headers);
+}
+function withHeaders(init, headers) {
+  const status = init == null ? void 0 : init.status;
+  const statusText = init == null ? void 0 : init.statusText;
+  return {
+    headers,
+    ...status === void 0 ? {} : { status },
+    ...statusText === void 0 ? {} : { statusText }
+  };
+}
+function installNodeResponse(target) {
+  var _a3;
+  const Native = target.Response;
+  if (typeof Native !== "function" || Native[INSTALLED]) return;
+  const proto = Native.prototype;
+  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;
+  const nativeClone = proto.clone;
+  if (!nativeHeaders) return;
+  const kept = /* @__PURE__ */ new WeakMap();
+  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, [nodeResponseBody(body), given ? withHeaders(init, given) : init], new.target === NodeResponse ? Native : new.target);
+    kept.set(response, withCookies(nativeHeaders.call(response), given));
+    return response;
+  };
+  NodeResponse.prototype = proto;
+  Object.defineProperty(NodeResponse, "length", { value: 0, configurable: true });
+  Object.defineProperty(NodeResponse, INSTALLED, { value: true });
+  Object.setPrototypeOf(NodeResponse, Object.getPrototypeOf(Native));
+  Object.defineProperty(NodeResponse, "json", {
+    value: function json(data2, init) {
+      const given = givenHeaders(init);
+      const response = Native.json(data2, given ? withHeaders(init, given) : init);
+      kept.set(response, withCookies(nativeHeaders.call(response), given));
+      return response;
+    },
+    writable: true,
+    configurable: true
+  });
+  Object.defineProperty(NodeResponse, "redirect", { value: function redirect(url2, status) {
+    return Native.redirect(url2, status);
+  }, writable: true, configurable: true });
+  Object.defineProperty(NodeResponse, "error", { value: function error() {
+    return Native.error();
+  }, writable: true, configurable: true });
+  defineOnHost(proto, "headers", {
+    get() {
+      return kept.get(this) ?? nativeHeaders.call(this);
+    },
+    enumerable: true,
+    configurable: true
+  });
+  defineOnHost(proto, "constructor", { value: NodeResponse, writable: true, enumerable: false, configurable: true });
+  defineOnHost(proto, "clone", {
+    value: function clone() {
+      const copy2 = nativeClone.call(this);
+      const headers = kept.get(this);
+      if (headers) kept.set(copy2, new Headers(headers));
+      return copy2;
+    },
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+  const changedType = (response) => {
+    const headers = kept.get(response);
+    if (!headers) return void 0;
+    const current3 = headers.get("content-type");
+    return current3 === nativeHeaders.call(response).get("content-type") ? void 0 : current3;
+  };
+  defineOnHost(proto, "formData", {
+    value: async function formData() {
+      const type2 = changedType(this);
+      if (type2 === void 0) return nativeFormData.call(this);
+      const bytes2 = await nativeArrayBuffer.call(this);
+      return nativeFormData.call(Reflect.construct(Native, [bytes2, type2 === null ? {} : { headers: { "content-type": type2 } }]));
+    },
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+  defineOnHost(proto, "blob", {
+    value: async function blob() {
+      const type2 = changedType(this);
+      if (type2 === void 0) return nativeBlob.call(this);
+      return new Blob([await nativeArrayBuffer.call(this)], type2 === null ? {} : { type: type2 });
+    },
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+  takeFromHost(target, "Response", NodeResponse);
+}
 function simpleHash(str) {
   let hash2 = 0;
   for (let i10 = 0; i10 < str.length; i10++) {
@@ -74097,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;
@@ -74278,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);
@@ -74346,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;
@@ -75244,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;
@@ -75290,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;
@@ -75388,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);
@@ -80438,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));
@@ -80461,6 +80726,9 @@ forGuestRealm(() => {
     takeFromHost(globalThis, "Request", NodeRequest);
   }
 });
+forGuestRealm(() => {
+  installNodeResponse(globalThis);
+});
 forGuestRealm(() => {
   const kIsClosedPromise = Symbol.for("nodejs.webstream.isClosedPromise");
   const Native = globalThis.ReadableStream;

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. */