@volter/tabnode 0.5.47 → 0.5.49

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);
@@ -32494,6 +32561,124 @@ function guestFetch(process2, fallback) {
     return owner === null ? dispatch() : enterRun(owner, dispatch);
   };
 }
+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 _a2;
+  const Native = target.Response;
+  if (typeof Native !== "function" || Native[INSTALLED]) return;
+  const proto = Native.prototype;
+  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;
+  const nativeClone = proto.clone;
+  if (!nativeHeaders) return;
+  const kept = /* @__PURE__ */ new WeakMap();
+  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, [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 i2 = 0; i2 < str.length; i2++) {
@@ -33692,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;
@@ -33892,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);
@@ -33983,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;
@@ -34901,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;
@@ -34947,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;
@@ -35045,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);
@@ -40103,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));
@@ -40126,6 +40391,9 @@ forGuestRealm(() => {
     takeFromHost(globalThis, "Request", NodeRequest);
   }
 });
+forGuestRealm(() => {
+  installNodeResponse(globalThis);
+});
 forGuestRealm(() => {
   const kIsClosedPromise = Symbol.for("nodejs.webstream.isClosedPromise");
   const Native = globalThis.ReadableStream;
@@ -40428,7 +40696,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-4iI8R3l-.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/dist/node-response.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Install the corrected constructor on `target` (the realm's global object),
+ * over the `Response` it has. Every property it changes is remembered for the
+ * host to have back (`restoreHostGlobals`); a realm that has it already is left.
+ */
+export declare function installNodeResponse(target: {
+    Response?: typeof Response;
+}): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.5.47",
+  "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);
+}