@secure-exec/browser 0.0.0-agentos-dylib-base.edaa4a4

package/dist/wasi-polyfill.js

@@ -0,0 +1,2154 @@
+// @generated by packages/browser/scripts/generate-wasi-polyfill.mjs
+// Source: crates/execution/assets/runners/wasi-module.js (the single shared
+// WASI preview1 runner). DO NOT EDIT BY HAND. Run `pnpm generate:wasi-polyfill`.
+export const BROWSER_WASI_POLYFILL_CODE = `
+		globalThis.__agentOsWasiHost = {
+			requireBuiltin: (name) =>
+				globalThis.require(String(name).replace(/^node:/, "")),
+			syncReadLimitBytes: 16777216,
+		};
+		const Buffer =
+			(typeof globalThis !== "undefined" && globalThis.Buffer) ||
+			(class __AgentOsWasiBuffer extends Uint8Array {
+				static alloc(size) { return new __AgentOsWasiBuffer(size >>> 0); }
+				static allocUnsafe(size) { return new __AgentOsWasiBuffer(size >>> 0); }
+				static isBuffer(value) { return value instanceof Uint8Array; }
+				static byteLength(value, encoding) {
+					if (value instanceof Uint8Array) return value.length;
+					if (encoding === "base64") return Math.floor((String(value).replace(/=+$/, "").length * 3) / 4);
+					if (encoding === "hex") return String(value).length >> 1;
+					return new TextEncoder().encode(String(value)).length;
+				}
+				static from(value, encodingOrOffset, length) {
+					if (typeof value === "string") {
+						const encoding = encodingOrOffset || "utf8";
+						if (encoding === "base64") {
+							const binary = atob(value);
+							const out = new __AgentOsWasiBuffer(binary.length);
+							for (let i = 0; i < binary.length; i += 1) out[i] = binary.charCodeAt(i) & 0xff;
+							return out;
+						}
+						if (encoding === "hex") {
+							const clean = String(value);
+							const out = new __AgentOsWasiBuffer(clean.length >> 1);
+							for (let i = 0; i < out.length; i += 1) out[i] = parseInt(clean.substr(i * 2, 2), 16);
+							return out;
+						}
+						const encoded = new TextEncoder().encode(value);
+						const out = new __AgentOsWasiBuffer(encoded.length);
+						out.set(encoded);
+						return out;
+					}
+					if (value instanceof ArrayBuffer) {
+						const offset = encodingOrOffset || 0;
+						const len = length === undefined ? value.byteLength - offset : length;
+						const view = new Uint8Array(value, offset, len);
+						const out = new __AgentOsWasiBuffer(view.length);
+						out.set(view);
+						return out;
+					}
+					if (ArrayBuffer.isView(value)) {
+						const view = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+						const out = new __AgentOsWasiBuffer(view.length);
+						out.set(view);
+						return out;
+					}
+					const arr = Array.from(value || []);
+					const out = new __AgentOsWasiBuffer(arr.length);
+					for (let i = 0; i < arr.length; i += 1) out[i] = arr[i] & 0xff;
+					return out;
+				}
+				static concat(list, totalLength) {
+					const chunks = Array.from(list || []);
+					if (totalLength === undefined) {
+						totalLength = 0;
+						for (const chunk of chunks) totalLength += chunk.length;
+					}
+					const out = new __AgentOsWasiBuffer(totalLength >>> 0);
+					let offset = 0;
+					for (const chunk of chunks) {
+						if (offset >= out.length) break;
+						const slice = offset + chunk.length > out.length ? chunk.subarray(0, out.length - offset) : chunk;
+						out.set(slice, offset);
+						offset += slice.length;
+					}
+					return out;
+				}
+				toString(encoding, start, end) {
+					const view = this.subarray(start || 0, end === undefined ? this.length : end);
+					if (encoding === "base64") {
+						let binary = "";
+						for (let i = 0; i < view.length; i += 1) binary += String.fromCharCode(view[i]);
+						return btoa(binary);
+					}
+					if (encoding === "hex") {
+						let hex = "";
+						for (let i = 0; i < view.length; i += 1) hex += view[i].toString(16).padStart(2, "0");
+						return hex;
+					}
+					return new TextDecoder().decode(view);
+				}
+			});
+if (typeof globalThis !== "undefined" && typeof globalThis.__agentOsWasiModule === "undefined") {
+  // Per-backend host seam (C / convergence): native populates it from its own
+  // host globals (the \`|| __agentOs*\` fallbacks below); a non-native backend
+  // (the browser converged worker) can pre-set \`globalThis.__agentOsWasiHost\`
+  // with browser-provided equivalents so this same preview1 runner is shared.
+  const __agentOsWasiHost =
+    (typeof globalThis.__agentOsWasiHost === "object" &&
+      globalThis.__agentOsWasiHost) ||
+    {};
+  const __agentOsWasiRequireBuiltin =
+    __agentOsWasiHost.requireBuiltin ||
+    (typeof __agentOsRequireBuiltin !== "undefined"
+      ? __agentOsRequireBuiltin
+      : (name) => globalThis.require(name));
+  const __agentOsFs = () => __agentOsWasiRequireBuiltin("node:fs");
+  const __agentOsPath = () => __agentOsWasiRequireBuiltin("node:path");
+  const __agentOsCrypto = () => __agentOsWasiRequireBuiltin("node:crypto");
+  // Stdio sync-RPC bridge + fd-handle lookup come from the host seam (a
+  // non-native backend supplies browser equivalents); native falls back to its
+  // own host globals so behavior is unchanged.
+  // Lazy resolvers: the native host globals are populated AFTER this module is
+  // defined (per-execution), so resolve at call time, not at module-load.
+  const __agentOsWasiSyncRpc = () =>
+    __agentOsWasiHost.syncRpc ||
+    (typeof globalThis.__agentOsSyncRpc !== "undefined"
+      ? globalThis.__agentOsSyncRpc
+      : undefined);
+  const __agentOsWasiLookupFdHandle = () =>
+    __agentOsWasiHost.lookupFdHandle ||
+    (typeof globalThis.lookupFdHandle === "function"
+      ? globalThis.lookupFdHandle
+      : undefined);
+  const __agentOsWasiErrnoSuccess = 0;
+  const __agentOsWasiErrnoAcces = 2;
+  const __agentOsWasiErrnoBadf = 8;
+  const __agentOsWasiErrnoExist = 20;
+  const __agentOsWasiErrnoFault = 21;
+  const __agentOsWasiErrnoInval = 28;
+  const __agentOsWasiErrnoIo = 29;
+  const __agentOsWasiErrnoNoent = 44;
+  const __agentOsWasiErrnoNosys = 52;
+  const __agentOsWasiErrnoNotdir = 54;
+  const __agentOsWasiErrnoPipe = 64;
+  const __agentOsWasiErrnoRofs = 69;
+  const __agentOsWasiErrnoXdev = 18;
+  const __agentOsWasiFiletypeUnknown = 0;
+  const __agentOsWasiFiletypeCharacterDevice = 2;
+  const __agentOsWasiFiletypeDirectory = 3;
+  const __agentOsWasiFiletypeRegularFile = 4;
+  const __agentOsWasiFiletypeSymbolicLink = 7;
+  const __agentOsWasiLookupSymlinkFollow = 1;
+  const __agentOsWasiOpenCreate = 1;
+  const __agentOsWasiOpenDirectory = 2;
+  const __agentOsWasiOpenExclusive = 4;
+  const __agentOsWasiOpenTruncate = 8;
+  const __agentOsWasiRightFdWrite = 1n << 6n;
+  const __agentOsWasiDefaultRightsBase = 0xffffffffffffffffn;
+  const __agentOsWasiDefaultRightsInheriting = 0xffffffffffffffffn;
+  const __agentOsWasiWhenceSet = 0;
+  const __agentOsWasiWhenceCur = 1;
+  const __agentOsWasiWhenceEnd = 2;
+  // Read cap: a non-native backend provides it via the seam; native uses its
+  // build-substituted constant. The ternary short-circuits so the native-only
+  // placeholder token is never evaluated when the seam supplies a number.
+  const __agentOsWasmSyncReadLimitBytes =
+    typeof __agentOsWasiHost.syncReadLimitBytes === "number"
+      ? __agentOsWasiHost.syncReadLimitBytes
+      : 16777216;
+  const __agentOsKernelStdioSyncRpcEnabled = () =>
+    process?.env?.AGENT_OS_WASI_STDIO_SYNC_RPC === "1";
+  const __agentOsWasiDebugEnabled = () => process?.env?.AGENT_OS_WASM_WASI_DEBUG === "1";
+  const __agentOsWasiDebug = (message) => {
+    if (!__agentOsWasiDebugEnabled() || typeof process?.stderr?.write !== "function") {
+      return;
+    }
+    try {
+      process.stderr.write(\`[secure-exec-wasi] \${message}\\n\`);
+    } catch {
+      // Ignore debug logging failures.
+    }
+  };
+
+  class WASI {
+    constructor(options = {}) {
+      this.args = Array.isArray(options.args) ? options.args.map((value) => String(value)) : [];
+      this.env =
+        options.env && typeof options.env === "object"
+          ? Object.fromEntries(
+              Object.entries(options.env).map(([key, value]) => [String(key), String(value)]),
+            )
+          : {};
+      this.preopens = options.preopens && typeof options.preopens === "object" ? options.preopens : {};
+      this.returnOnExit = options.returnOnExit === true;
+      this.instance = null;
+      this.nextFd = 3;
+      this.fdTable = new Map([
+        [0, { kind: "stdin", fdFlags: 0 }],
+        [1, { kind: "stdout", fdFlags: 0 }],
+        [2, { kind: "stderr", fdFlags: 0 }],
+      ]);
+      for (const [guestPath, spec] of Object.entries(this.preopens)) {
+        const normalized = this._normalizePreopenSpec(spec);
+        if (!normalized) {
+          continue;
+        }
+        this.fdTable.set(this.nextFd++, {
+          kind: "preopen",
+          guestPath: String(guestPath),
+          hostPath: normalized.hostPath,
+          readOnly: normalized.readOnly,
+          rightsBase: normalized.rightsBase,
+          rightsInheriting: normalized.rightsInheriting,
+          fdFlags: 0,
+        });
+      }
+      this.wasiImport = {
+        args_get: (...args) => this._argsGet(...args),
+        args_sizes_get: (...args) => this._argsSizesGet(...args),
+        clock_time_get: (...args) => this._clockTimeGet(...args),
+        clock_res_get: (...args) => this._clockResGet(...args),
+        environ_get: (...args) => this._environGet(...args),
+        environ_sizes_get: (...args) => this._environSizesGet(...args),
+        fd_close: (...args) => this._fdClose(...args),
+        fd_fdstat_get: (...args) => this._fdFdstatGet(...args),
+        fd_fdstat_set_flags: (...args) => this._fdFdstatSetFlags(...args),
+        fd_filestat_get: (...args) => this._fdFilestatGet(...args),
+        fd_filestat_set_size: (...args) => this._fdFilestatSetSize(...args),
+        fd_prestat_dir_name: (...args) => this._fdPrestatDirName(...args),
+        fd_prestat_get: (...args) => this._fdPrestatGet(...args),
+        fd_pread: (...args) => this._fdPread(...args),
+        fd_pwrite: (...args) => this._fdPwrite(...args),
+        fd_readdir: (...args) => this._fdReaddir(...args),
+        fd_read: (...args) => this._fdRead(...args),
+        fd_seek: (...args) => this._fdSeek(...args),
+        fd_sync: (...args) => this._fdSync(...args),
+        fd_tell: (...args) => this._fdTell(...args),
+        fd_write: (...args) => this._fdWrite(...args),
+        path_create_directory: (...args) => this._pathCreateDirectory(...args),
+        path_filestat_get: (...args) => this._pathFilestatGet(...args),
+        path_link: (...args) => this._pathLink(...args),
+        path_open: (...args) => this._pathOpen(...args),
+        path_readlink: (...args) => this._pathReadlink(...args),
+        path_remove_directory: (...args) => this._pathRemoveDirectory(...args),
+        path_rename: (...args) => this._pathRename(...args),
+        path_symlink: (...args) => this._pathSymlink(...args),
+        path_unlink_file: (...args) => this._pathUnlinkFile(...args),
+        poll_oneoff: (...args) => this._pollOneoff(...args),
+        proc_exit: (...args) => this._procExit(...args),
+        random_get: (...args) => this._randomGet(...args),
+        sched_yield: (...args) => this._schedYield(...args),
+      };
+    }
+
+    start(instance) {
+      this.instance = instance;
+      try {
+        if (typeof instance?.exports?._start === "function") {
+          instance.exports._start();
+        }
+        return 0;
+      } catch (error) {
+        if (error && error.__agentOsWasiExit === true) {
+          return Number(error.code) >>> 0;
+        }
+        throw error;
+      }
+    }
+
+    _memoryView() {
+      const memory = this.instance?.exports?.memory;
+      if (!(memory instanceof WebAssembly.Memory)) {
+        throw new Error("WASI memory export is unavailable");
+      }
+      return new DataView(memory.buffer);
+    }
+
+    _memoryBytes() {
+      const memory = this.instance?.exports?.memory;
+      if (!(memory instanceof WebAssembly.Memory)) {
+        throw new Error("WASI memory export is unavailable");
+      }
+      return new Uint8Array(memory.buffer);
+    }
+
+    _boundedIovLength(iovs, iovsLen) {
+      const view = this._memoryView();
+      let length = 0;
+      for (let index = 0; index < (Number(iovsLen) >>> 0); index += 1) {
+        const entryOffset = (Number(iovs) >>> 0) + index * 8;
+        length += view.getUint32(entryOffset + 4, true);
+        if (length > __agentOsWasmSyncReadLimitBytes) {
+          throw new RangeError(
+            \`WASI read iov length \${length} exceeds \${__agentOsWasmSyncReadLimitBytes}\`,
+          );
+        }
+      }
+      return length >>> 0;
+    }
+
+    _normalizeRights(value, fallback) {
+      try {
+        return BigInt(value);
+      } catch {
+        return fallback;
+      }
+    }
+
+    _normalizePreopenSpec(value) {
+      // Path-model seam (convergence item C): native maps guest paths to HOST
+      // paths (its preopen specs carry \`hostPath\`); a non-native backend with no
+      // host paths (the browser, whose \`require("fs")\` IS the kernel VFS) can
+      // supply \`__agentOsWasiHost.normalizePreopen\` to treat the guest/VFS path
+      // as the "hostPath" identity, so the same runner serves both.
+      if (typeof __agentOsWasiHost.normalizePreopen === "function") {
+        const seamNormalized = __agentOsWasiHost.normalizePreopen(value, {
+          defaultRightsBase: __agentOsWasiDefaultRightsBase,
+          defaultRightsInheriting: __agentOsWasiDefaultRightsInheriting,
+          normalizeRights: (rights, fallback) =>
+            this._normalizeRights(rights, fallback),
+        });
+        return seamNormalized ?? null;
+      }
+      if (typeof value === "string") {
+        return {
+          hostPath: String(value),
+          readOnly: false,
+          rightsBase: __agentOsWasiDefaultRightsBase,
+          rightsInheriting: __agentOsWasiDefaultRightsInheriting,
+        };
+      }
+      if (!value || typeof value !== "object" || typeof value.hostPath !== "string") {
+        return null;
+      }
+      return {
+        hostPath: String(value.hostPath),
+        readOnly: value.readOnly === true,
+        rightsBase: this._normalizeRights(
+          value.rightsBase,
+          __agentOsWasiDefaultRightsBase,
+        ),
+        rightsInheriting: this._normalizeRights(
+          value.rightsInheriting,
+          __agentOsWasiDefaultRightsInheriting,
+        ),
+      };
+    }
+
+    _descriptorRightsBase(entry) {
+      return this._normalizeRights(
+        entry?.rightsBase,
+        __agentOsWasiDefaultRightsBase,
+      );
+    }
+
+    _descriptorRightsInheriting(entry) {
+      return this._normalizeRights(
+        entry?.rightsInheriting,
+        __agentOsWasiDefaultRightsInheriting,
+      );
+    }
+
+    _hasWriteRights(rights) {
+      try {
+        return (BigInt(rights) & __agentOsWasiRightFdWrite) !== 0n;
+      } catch {
+        return true;
+      }
+    }
+
+    _writeUint32(ptr, value) {
+      try {
+        this._memoryView().setUint32(Number(ptr) >>> 0, Number(value) >>> 0, true);
+        return __agentOsWasiErrnoSuccess;
+      } catch {
+        __agentOsWasiDebug(\`writeUint32 failed ptr=\${Number(ptr)} value=\${Number(value)}\`);
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _writeUint64(ptr, value) {
+      try {
+        this._memoryView().setBigUint64(Number(ptr) >>> 0, BigInt(value), true);
+        return __agentOsWasiErrnoSuccess;
+      } catch {
+        __agentOsWasiDebug(\`writeUint64 failed ptr=\${Number(ptr)} value=\${String(value)}\`);
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _writeBytes(ptr, bytes) {
+      try {
+        this._memoryBytes().set(bytes, Number(ptr) >>> 0);
+        return __agentOsWasiErrnoSuccess;
+      } catch {
+        __agentOsWasiDebug(\`writeBytes failed ptr=\${Number(ptr)} len=\${bytes?.length ?? 0}\`);
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _readBytes(ptr, len) {
+      const start = Number(ptr) >>> 0;
+      const end = start + (Number(len) >>> 0);
+      return Buffer.from(this._memoryBytes().slice(start, end));
+    }
+
+    _readString(ptr, len) {
+      return this._readBytes(ptr, len).toString("utf8");
+    }
+
+    _decodeSyncRpcBytes(value) {
+      if (value == null) {
+        return null;
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+        return value;
+      }
+      if (value instanceof Uint8Array) {
+        return Buffer.from(value);
+      }
+      if (ArrayBuffer.isView(value)) {
+        return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+      }
+      if (value instanceof ArrayBuffer) {
+        return Buffer.from(value);
+      }
+      if (
+        value &&
+        typeof value === "object" &&
+        value.__agentOsType === "bytes" &&
+        typeof value.base64 === "string"
+      ) {
+        return Buffer.from(value.base64, "base64");
+      }
+      return null;
+    }
+
+    _dequeuePipeBytes(pipe, maxBytes) {
+      if (!pipe || !Array.isArray(pipe.chunks) || pipe.chunks.length === 0) {
+        return Buffer.alloc(0);
+      }
+
+      let remaining = Math.max(0, Number(maxBytes) >>> 0);
+      if (remaining === 0) {
+        return Buffer.alloc(0);
+      }
+
+      const parts = [];
+      while (remaining > 0 && pipe.chunks.length > 0) {
+        const chunk = pipe.chunks[0];
+        if (!chunk || chunk.length === 0) {
+          pipe.chunks.shift();
+          continue;
+        }
+
+        if (chunk.length <= remaining) {
+          parts.push(chunk);
+          pipe.chunks.shift();
+          remaining -= chunk.length;
+          continue;
+        }
+
+        parts.push(chunk.subarray(0, remaining));
+        pipe.chunks[0] = chunk.subarray(remaining);
+        remaining = 0;
+      }
+
+      return Buffer.concat(parts);
+    }
+
+    _enqueuePipeBytes(pipe, bytes) {
+      if (!pipe || !Array.isArray(pipe.chunks)) {
+        return;
+      }
+      const chunk = Buffer.from(bytes ?? []);
+      if (chunk.length === 0) {
+        return;
+      }
+      pipe.chunks.push(chunk);
+    }
+
+    _pipeHasReaders(pipe) {
+      return (
+        (pipe?.readHandleCount ?? 0) > 0 ||
+        (pipe?.consumers?.size ?? 0) > 0
+      );
+    }
+
+    _flushPipeConsumers(pipe) {
+      if (
+        !pipe ||
+        typeof pipe.consumers?.entries !== "function" ||
+        !Array.isArray(pipe.chunks) ||
+        pipe.chunks.length === 0 ||
+        typeof globalThis?.__agentOsSyncRpc?.callSync !== "function"
+      ) {
+        return false;
+      }
+
+      let flushed = false;
+      while (pipe.chunks.length > 0) {
+        const chunk = pipe.chunks.shift();
+        if (!chunk || chunk.length === 0) {
+          continue;
+        }
+
+        for (const [consumerKey, consumer] of Array.from(pipe.consumers.entries())) {
+          if (!consumer || typeof consumer.childId !== "string") {
+            pipe.consumers.delete(consumerKey);
+            continue;
+          }
+          try {
+            __agentOsWasiSyncRpc().callSync("child_process.write_stdin", [
+              consumer.childId,
+              chunk,
+            ]);
+            flushed = true;
+          } catch {
+            pipe.consumers.delete(consumerKey);
+          }
+        }
+      }
+
+      return flushed;
+    }
+
+    _closePipeConsumers(pipe) {
+      if (
+        !pipe ||
+        typeof pipe.consumers?.entries !== "function" ||
+        typeof globalThis?.__agentOsSyncRpc?.callSync !== "function"
+      ) {
+        return false;
+      }
+
+      let closed = false;
+      for (const [consumerKey, consumer] of Array.from(pipe.consumers.entries())) {
+        if (!consumer || typeof consumer.childId !== "string") {
+          pipe.consumers.delete(consumerKey);
+          continue;
+        }
+        try {
+          __agentOsWasiSyncRpc().callSync("child_process.close_stdin", [
+            consumer.childId,
+          ]);
+          closed = true;
+        } catch {
+          // Ignore close errors during teardown.
+        }
+        pipe.consumers.delete(consumerKey);
+      }
+
+      return closed;
+    }
+
+    _pumpPipeProducers(pipe, waitMs) {
+      if (
+        !pipe ||
+        typeof pipe.producers?.entries !== "function" ||
+        typeof globalThis?.__agentOsSyncRpc?.callSync !== "function"
+      ) {
+        return false;
+      }
+
+      let processed = false;
+      for (const [producerKey, producer] of Array.from(pipe.producers.entries())) {
+        if (!producer || typeof producer.childId !== "string") {
+          pipe.producers.delete(producerKey);
+          continue;
+        }
+
+        let event = null;
+        try {
+          event = __agentOsWasiSyncRpc().callSync("child_process.poll", [
+            producer.childId,
+            Math.max(0, Number(waitMs) >>> 0),
+          ]);
+        } catch {
+          pipe.producers.delete(producerKey);
+          continue;
+        }
+
+        if (!event) {
+          continue;
+        }
+
+        processed = true;
+        const streamType =
+          producer.stream === "stderr" ? "stderr" : producer.stream === "stdout" ? "stdout" : null;
+        if ((event.type === "stdout" || event.type === "stderr") && event.type === streamType) {
+          const chunk = this._decodeSyncRpcBytes(event.data);
+          if (chunk && chunk.length > 0) {
+            pipe.chunks.push(Buffer.from(chunk));
+          }
+          continue;
+        }
+
+        if (event.type === "exit") {
+          pipe.producers.delete(producerKey);
+          if (pipe.producers.size === 0 && (pipe.writeHandleCount ?? 0) === 0) {
+            this._closePipeConsumers(pipe);
+          }
+          continue;
+        }
+      }
+
+      return processed;
+    }
+
+    _collectIovs(iovs, iovsLen) {
+      const totalLength = this._boundedIovLength(iovs, iovsLen);
+      const view = this._memoryView();
+      const chunks = [];
+      for (let index = 0; index < (Number(iovsLen) >>> 0); index += 1) {
+        const entryOffset = (Number(iovs) >>> 0) + index * 8;
+        const ptr = view.getUint32(entryOffset, true);
+        const len = view.getUint32(entryOffset + 4, true);
+        chunks.push(this._readBytes(ptr, len));
+      }
+      return Buffer.concat(chunks, totalLength);
+    }
+
+    _writeToIovs(iovs, iovsLen, bytes) {
+      const view = this._memoryView();
+      const memory = this._memoryBytes();
+      let sourceOffset = 0;
+      for (let index = 0; index < (Number(iovsLen) >>> 0) && sourceOffset < bytes.length; index += 1) {
+        const entryOffset = (Number(iovs) >>> 0) + index * 8;
+        const ptr = view.getUint32(entryOffset, true);
+        const len = view.getUint32(entryOffset + 4, true);
+        const chunk = bytes.subarray(sourceOffset, sourceOffset + len);
+        memory.set(chunk, Number(ptr) >>> 0);
+        sourceOffset += chunk.length;
+      }
+      return sourceOffset;
+    }
+
+    _stringTable(values) {
+      return values.map((value) => Buffer.from(\`\${String(value)}\\0\`, "utf8"));
+    }
+
+    _writeStringTable(values, offsetsPtr, bufferPtr) {
+      try {
+        const view = this._memoryView();
+        const memory = this._memoryBytes();
+        let cursor = Number(bufferPtr) >>> 0;
+        for (let index = 0; index < values.length; index += 1) {
+          const bytes = values[index];
+          view.setUint32((Number(offsetsPtr) >>> 0) + index * 4, cursor, true);
+          memory.set(bytes, cursor);
+          cursor += bytes.length;
+        }
+        return __agentOsWasiErrnoSuccess;
+      } catch {
+        __agentOsWasiDebug(
+          \`writeStringTable failed offsetsPtr=\${Number(offsetsPtr)} bufferPtr=\${Number(bufferPtr)} count=\${values.length}\`,
+        );
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _filetypeForStats(stats) {
+      if (!stats) {
+        return __agentOsWasiFiletypeUnknown;
+      }
+      if (typeof stats.isDirectory === "function" && stats.isDirectory()) {
+        return __agentOsWasiFiletypeDirectory;
+      }
+      if (typeof stats.isFile === "function" && stats.isFile()) {
+        return __agentOsWasiFiletypeRegularFile;
+      }
+      if (typeof stats.isSymbolicLink === "function" && stats.isSymbolicLink()) {
+        return __agentOsWasiFiletypeSymbolicLink;
+      }
+      if (typeof stats.isCharacterDevice === "function" && stats.isCharacterDevice()) {
+        return __agentOsWasiFiletypeCharacterDevice;
+      }
+      return __agentOsWasiFiletypeUnknown;
+    }
+
+    _fdFiletype(entry) {
+      if (!entry) {
+        return __agentOsWasiFiletypeUnknown;
+      }
+      if (
+        entry.kind === "stdin" ||
+        entry.kind === "stdout" ||
+        entry.kind === "stderr"
+      ) {
+        return __agentOsWasiFiletypeCharacterDevice;
+      }
+      if (entry.kind === "preopen" || entry.kind === "directory") {
+        return __agentOsWasiFiletypeDirectory;
+      }
+      if (entry.kind === "symlink") {
+        return __agentOsWasiFiletypeSymbolicLink;
+      }
+      return __agentOsWasiFiletypeRegularFile;
+    }
+
+    _mapFsError(error) {
+      switch (error?.code) {
+        case "EACCES":
+        case "EPERM":
+          return __agentOsWasiErrnoAcces;
+        case "ENOENT":
+          return __agentOsWasiErrnoNoent;
+        case "ENOTDIR":
+          return __agentOsWasiErrnoNotdir;
+        case "EEXIST":
+          return __agentOsWasiErrnoExist;
+        case "EINVAL":
+          return __agentOsWasiErrnoInval;
+        case "EROFS":
+          return __agentOsWasiErrnoRofs;
+        case "EXDEV":
+          return __agentOsWasiErrnoXdev;
+        default:
+          return __agentOsWasiErrnoIo;
+      }
+    }
+
+    _descriptorEntry(fd) {
+      return this.fdTable.get(Number(fd) >>> 0) ?? null;
+    }
+
+    _localFdHandle(fd) {
+      const entry = this._descriptorEntry(fd);
+      if (!entry || typeof entry.realFd !== "number") {
+        return null;
+      }
+      return {
+        kind: "host-passthrough",
+        targetFd: entry.realFd,
+        displayFd: Number(fd) >>> 0,
+        refCount: 1,
+        open: true,
+        readOnly: entry.readOnly === true,
+      };
+    }
+
+    _externalFdHandle(fd) {
+      const descriptor = Number(fd) >>> 0;
+      const localHandle = this._localFdHandle(descriptor);
+      if (localHandle) {
+        return localHandle;
+      }
+      try {
+        if (typeof lookupFdHandle === "function") {
+          return lookupFdHandle(descriptor) ?? null;
+        }
+      } catch {
+        // Fall through to other lookup paths.
+      }
+      try {
+        const __agentOsWasiFdHandleFn = __agentOsWasiLookupFdHandle();
+        if (typeof __agentOsWasiFdHandleFn === "function") {
+          return __agentOsWasiFdHandleFn(descriptor) ?? null;
+        }
+      } catch {
+        // Ignore missing global bridge helpers.
+      }
+      return null;
+    }
+
+    _descriptorHostPath(entry) {
+      if (!entry) {
+        return null;
+      }
+      if (typeof entry.hostPath === "string") {
+        return entry.hostPath;
+      }
+      if (typeof entry.realFd === "number") {
+        return __agentOsFs().readlinkSync(\`/proc/self/fd/\${entry.realFd}\`);
+      }
+      return null;
+    }
+
+    _descriptorFsPath(entry) {
+      if (!entry) {
+        return null;
+      }
+      if (typeof entry.hostPath === "string" && entry.hostPath.length > 0) {
+        return entry.hostPath;
+      }
+      if (typeof entry.guestPath === "string" && entry.guestPath.length > 0) {
+        return entry.guestPath;
+      }
+      return null;
+    }
+
+    _sidecarManagedProcess() {
+      if (
+        typeof globalThis.__agentOsWasmInternalEnv?.AGENT_OS_SANDBOX_ROOT ===
+          "string" &&
+        globalThis.__agentOsWasmInternalEnv.AGENT_OS_SANDBOX_ROOT.length > 0
+      ) {
+        return true;
+      }
+      return (
+        typeof process?.env?.AGENT_OS_SANDBOX_ROOT === "string" &&
+        process.env.AGENT_OS_SANDBOX_ROOT.length > 0
+      );
+    }
+
+    _descriptorDirectoryFsPath(entry) {
+      if (
+        (entry?.kind === "preopen" || entry?.kind === "directory") &&
+        this._sidecarManagedProcess()
+      ) {
+        return this._descriptorGuestPath(entry);
+      }
+      return this._descriptorFsPath(entry);
+    }
+
+    _descriptorGuestPath(entry) {
+      if (!entry) {
+        return null;
+      }
+      const guestPath = typeof entry.guestPath === "string" ? entry.guestPath : null;
+      if (guestPath === ".") {
+        return this._currentGuestCwd();
+      }
+      if (typeof guestPath === "string" && guestPath.length > 0) {
+        return __agentOsPath().posix.normalize(guestPath);
+      }
+      return null;
+    }
+
+    _descriptorPreopenName(entry) {
+      if (!entry) {
+        return null;
+      }
+      const guestPath = typeof entry.guestPath === "string" ? entry.guestPath : null;
+      if (guestPath === ".") {
+        return this._descriptorGuestPath(entry);
+      }
+      if (typeof guestPath === "string" && guestPath.length > 0) {
+        return __agentOsPath().posix.normalize(guestPath);
+      }
+      return null;
+    }
+
+    _currentDirectoryPreopen() {
+      for (const entry of this.fdTable.values()) {
+        if (entry?.kind === "preopen" && entry.guestPath === ".") {
+          return entry;
+        }
+      }
+      return null;
+    }
+
+    _descriptorPathBase(entry, target) {
+      const baseGuestPath = this._descriptorGuestPath(entry);
+      if (typeof baseGuestPath !== "string") {
+        return null;
+      }
+      return {
+        entry,
+        guestPath: baseGuestPath,
+        hostPath: typeof entry?.hostPath === "string" ? entry.hostPath : null,
+      };
+    }
+
+    _hostPathExists(hostPath) {
+      try {
+        __agentOsFs().statSync(hostPath);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+
+    _currentGuestCwd() {
+      const pwd =
+        typeof this.env?.PWD === "string" && this.env.PWD.startsWith("/")
+          ? this.env.PWD
+          : typeof this.env?.HOME === "string" && this.env.HOME.startsWith("/")
+            ? this.env.HOME
+            : "/";
+      return __agentOsPath().posix.normalize(pwd);
+    }
+
+    _resolveHostMappingForGuestPath(guestPath) {
+      const normalized = __agentOsPath().posix.normalize(guestPath);
+      const mappings = [];
+      for (const entry of this.fdTable.values()) {
+        if (entry?.kind !== "preopen" || typeof entry.hostPath !== "string") {
+          continue;
+        }
+        const guestRoot = this._descriptorGuestPath(entry);
+        if (typeof guestRoot !== "string") {
+          continue;
+        }
+        mappings.push({
+          guestRoot,
+          hostPath: entry.hostPath,
+          readOnly: entry.readOnly === true,
+        });
+      }
+      mappings.sort((left, right) => right.guestRoot.length - left.guestRoot.length);
+
+      for (const mapping of mappings) {
+        const matchesRoot = mapping.guestRoot === "/" && normalized.startsWith("/");
+        const matchesNested =
+          normalized === mapping.guestRoot ||
+          normalized.startsWith(\`\${mapping.guestRoot}/\`);
+        if (!matchesRoot && !matchesNested) {
+          continue;
+        }
+        const suffix =
+          normalized === mapping.guestRoot
+            ? ""
+            : mapping.guestRoot === "/"
+              ? normalized.slice(1)
+              : normalized.slice(mapping.guestRoot.length + 1);
+        return {
+          hostPath: suffix
+            ? __agentOsPath().join(mapping.hostPath, ...suffix.split("/"))
+            : mapping.hostPath,
+          readOnly: mapping.readOnly,
+        };
+      }
+
+      return null;
+    }
+
+    _resolveHostPathForGuestPath(guestPath) {
+      return this._resolveHostMappingForGuestPath(guestPath)?.hostPath ?? null;
+    }
+
+    _rootRelativeTargetPrefersCwd(target) {
+      const normalizedTarget = __agentOsPath().posix.normalize(target || ".");
+      if (normalizedTarget !== ".") {
+        return false;
+      }
+      return !this._rootRelativeTargetMatchesAbsoluteArg(target);
+    }
+
+    _rootRelativeTargetMatchesAbsoluteArg(target) {
+      const rootGuestPath = __agentOsPath().posix.resolve("/", target);
+      return this.args
+        .slice(1)
+        .some(
+          (arg) =>
+            typeof arg === "string" &&
+            arg.startsWith("/") &&
+            __agentOsPath().posix.normalize(arg) === rootGuestPath,
+        );
+    }
+
+    _resolveRootRelativePath(target, preferCreateParent = false) {
+      const rootGuestPath = __agentOsPath().posix.resolve("/", target);
+      const rootMapping = this._resolveHostMappingForGuestPath(rootGuestPath);
+      const rootHostPath = rootMapping?.hostPath ?? null;
+      const cwdGuestPath = this._currentGuestCwd();
+      if (cwdGuestPath !== "/") {
+        const cwdGuestTarget = __agentOsPath().posix.resolve(cwdGuestPath, target);
+        const cwdMapping = this._resolveHostMappingForGuestPath(cwdGuestTarget);
+        const cwdHostTarget = cwdMapping?.hostPath ?? null;
+        if (
+          typeof cwdHostTarget === "string" &&
+          (
+            (preferCreateParent && !this._rootRelativeTargetMatchesAbsoluteArg(target)) ||
+            this._rootRelativeTargetPrefersCwd(target) ||
+            (
+              this._hostPathExists(cwdHostTarget) &&
+              !(typeof rootHostPath === "string" && this._hostPathExists(rootHostPath))
+            )
+          )
+        ) {
+          return {
+            guestPath: cwdGuestTarget,
+            hostPath: cwdHostTarget,
+            readOnly: cwdMapping?.readOnly === true,
+          };
+        }
+      }
+      return {
+        guestPath: rootGuestPath,
+        hostPath: rootHostPath,
+        readOnly: rootMapping?.readOnly === true,
+      };
+    }
+
+    _resolveDescriptorPath(fd, pathPtr, pathLen, options = {}) {
+      const entry = this._descriptorEntry(fd);
+      if (!entry) {
+        return { error: __agentOsWasiErrnoBadf };
+      }
+      const target = this._readString(pathPtr, pathLen);
+      const base = this._descriptorPathBase(entry, target);
+      if (!base || typeof base.guestPath !== "string") {
+        return { error: __agentOsWasiErrnoBadf };
+      }
+      const guestPath = target.startsWith("/")
+        ? __agentOsPath().posix.normalize(target)
+        : __agentOsPath().posix.resolve(base.guestPath, target);
+      const mapped =
+        base.guestPath === "/" && !target.startsWith("/")
+          ? this._resolveRootRelativePath(
+              target,
+              options.preferCreateParent === true,
+            )
+          : {
+              guestPath,
+              ...(
+                this._resolveHostMappingForGuestPath(guestPath) ??
+                { hostPath: null, readOnly: false }
+              ),
+            };
+      const hostPath = mapped.hostPath;
+      if (typeof hostPath !== "string") {
+        return { error: __agentOsWasiErrnoNoent };
+      }
+      return {
+        error: __agentOsWasiErrnoSuccess,
+        guestPath: mapped.guestPath,
+        hostPath,
+        readOnly: mapped.readOnly === true,
+      };
+    }
+
+    _resolvedFsPath(resolved) {
+      if (this._sidecarManagedProcess() && typeof resolved?.guestPath === "string") {
+        return resolved.guestPath;
+      }
+      return resolved?.hostPath ?? null;
+    }
+
+    _writeFilestat(statPtr, stats, fallbackType) {
+      try {
+        const view = this._memoryView();
+        const offset = Number(statPtr) >>> 0;
+        const filetype = stats ? this._filetypeForStats(stats) : fallbackType;
+        view.setBigUint64(offset, 0n, true);
+        view.setBigUint64(offset + 8, BigInt(stats?.ino ?? 0), true);
+        view.setUint8(offset + 16, filetype);
+        view.setBigUint64(offset + 24, BigInt(stats?.nlink ?? 1), true);
+        view.setBigUint64(offset + 32, BigInt(stats?.size ?? 0), true);
+        view.setBigUint64(offset + 40, BigInt(Math.trunc((stats?.atimeMs ?? 0) * 1000000)), true);
+        view.setBigUint64(offset + 48, BigInt(Math.trunc((stats?.mtimeMs ?? 0) * 1000000)), true);
+        view.setBigUint64(offset + 56, BigInt(Math.trunc((stats?.ctimeMs ?? 0) * 1000000)), true);
+        return __agentOsWasiErrnoSuccess;
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _argsSizesGet(argcPtr, argvBufSizePtr) {
+      const values = this._stringTable(this.args);
+      const total = values.reduce((sum, value) => sum + value.length, 0);
+      const argcStatus = this._writeUint32(argcPtr, values.length);
+      if (argcStatus !== __agentOsWasiErrnoSuccess) {
+        return argcStatus;
+      }
+      return this._writeUint32(argvBufSizePtr, total);
+    }
+
+    _argsGet(argvPtr, argvBufPtr) {
+      return this._writeStringTable(this._stringTable(this.args), argvPtr, argvBufPtr);
+    }
+
+    _environEntries() {
+      return Object.entries(this.env).map(([key, value]) => \`\${key}=\${value}\`);
+    }
+
+    _environSizesGet(countPtr, bufSizePtr) {
+      const values = this._stringTable(this._environEntries());
+      const total = values.reduce((sum, value) => sum + value.length, 0);
+      const countStatus = this._writeUint32(countPtr, values.length);
+      if (countStatus !== __agentOsWasiErrnoSuccess) {
+        return countStatus;
+      }
+      return this._writeUint32(bufSizePtr, total);
+    }
+
+    _environGet(environPtr, environBufPtr) {
+      return this._writeStringTable(
+        this._stringTable(this._environEntries()),
+        environPtr,
+        environBufPtr,
+      );
+    }
+
+    _clockTimeGet(_clockId, _precision, resultPtr) {
+      return this._writeUint64(resultPtr, BigInt(Date.now()) * 1000000n);
+    }
+
+    _clockResGet(_clockId, resultPtr) {
+      return this._writeUint64(resultPtr, 1000000n);
+    }
+
+    _fdWrite(fd, iovs, iovsLen, nwrittenPtr) {
+      try {
+        const bytes = this._collectIovs(iovs, iovsLen);
+        const descriptor = Number(fd) >>> 0;
+        const handle = this._externalFdHandle(descriptor);
+        if (handle?.kind === "pipe-write" && handle.pipe) {
+          if (bytes.length > 0 && !this._pipeHasReaders(handle.pipe)) {
+            return __agentOsWasiErrnoPipe;
+          }
+          this._enqueuePipeBytes(handle.pipe, bytes);
+          this._flushPipeConsumers(handle.pipe);
+          return this._writeUint32(nwrittenPtr, bytes.length);
+        }
+        if (
+          (handle?.kind === "passthrough" || handle?.kind === "host-passthrough") &&
+          typeof handle.targetFd === "number"
+        ) {
+          if (handle.readOnly === true) {
+            return __agentOsWasiErrnoRofs;
+          }
+          if (descriptor === 1 || descriptor === 2) {
+            const sidecarManagedProcess =
+              typeof process?.env?.AGENT_OS_SANDBOX_ROOT === "string" &&
+              process.env.AGENT_OS_SANDBOX_ROOT.length > 0;
+            const useKernelStdioSyncRpc =
+              sidecarManagedProcess || __agentOsKernelStdioSyncRpcEnabled();
+            if (useKernelStdioSyncRpc) {
+              const written = Number(
+                __agentOsWasiSyncRpc().callSync("__kernel_stdio_write", [descriptor, bytes]),
+              ) >>> 0;
+              return this._writeUint32(nwrittenPtr, written);
+            }
+          }
+          const written = __agentOsFs().writeSync(
+            handle.targetFd,
+            bytes,
+            0,
+            bytes.length,
+            null,
+          );
+          return this._writeUint32(nwrittenPtr, written);
+        }
+        if (handle?.kind === "guest-file" && typeof handle.targetFd === "number") {
+          const position = handle.append ? null : (handle.position ?? 0);
+          const written = __agentOsFs().writeSync(
+            handle.targetFd,
+            bytes,
+            0,
+            bytes.length,
+            position,
+          );
+          if (handle.append) {
+            handle.position = Number(__agentOsFs().fstatSync(handle.targetFd).size ?? 0);
+          } else {
+            handle.position = (handle.position ?? 0) + written;
+          }
+          return this._writeUint32(nwrittenPtr, written);
+        }
+        const entry = this.fdTable.get(descriptor);
+        if (!entry) {
+          return __agentOsWasiErrnoBadf;
+        }
+        if (entry.kind === "stdout") {
+          const sidecarManagedProcess =
+            typeof process?.env?.AGENT_OS_SANDBOX_ROOT === "string" &&
+            process.env.AGENT_OS_SANDBOX_ROOT.length > 0;
+          const useKernelStdioSyncRpc =
+            sidecarManagedProcess || __agentOsKernelStdioSyncRpcEnabled();
+          const written = useKernelStdioSyncRpc
+            ? Number(__agentOsWasiSyncRpc().callSync("__kernel_stdio_write", [1, bytes])) >>> 0
+            : (process.stdout.write(bytes), bytes.length);
+          return this._writeUint32(nwrittenPtr, written);
+        }
+        if (entry.kind === "stderr") {
+          const sidecarManagedProcess =
+            typeof process?.env?.AGENT_OS_SANDBOX_ROOT === "string" &&
+            process.env.AGENT_OS_SANDBOX_ROOT.length > 0;
+          const useKernelStdioSyncRpc =
+            sidecarManagedProcess || __agentOsKernelStdioSyncRpcEnabled();
+          const written = useKernelStdioSyncRpc
+            ? Number(__agentOsWasiSyncRpc().callSync("__kernel_stdio_write", [2, bytes])) >>> 0
+            : (process.stderr.write(bytes), bytes.length);
+          return this._writeUint32(nwrittenPtr, written);
+        }
+        if (entry.readOnly === true) {
+          return __agentOsWasiErrnoRofs;
+        }
+        if (entry.kind === "file") {
+          const position = typeof entry.offset === "number" ? entry.offset : null;
+          const written = __agentOsFs().writeSync(
+            entry.realFd,
+            bytes,
+            0,
+            bytes.length,
+            position,
+          );
+          if (typeof entry.offset === "number") {
+            entry.offset += written;
+          }
+          return this._writeUint32(nwrittenPtr, written);
+        }
+        return __agentOsWasiErrnoBadf;
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _fdPwrite(fd, iovs, iovsLen, offset, nwrittenPtr) {
+      try {
+        const bytes = this._collectIovs(iovs, iovsLen);
+        const descriptor = Number(fd) >>> 0;
+        const handle = this._externalFdHandle(descriptor);
+        if (
+          (handle?.kind === "passthrough" || handle?.kind === "host-passthrough") &&
+          typeof handle.targetFd === "number"
+        ) {
+          if (handle.readOnly === true) {
+            return __agentOsWasiErrnoRofs;
+          }
+          const written = __agentOsFs().writeSync(
+            handle.targetFd,
+            bytes,
+            0,
+            bytes.length,
+            Number(offset) >>> 0,
+          );
+          return this._writeUint32(nwrittenPtr, written);
+        }
+        const entry = this.fdTable.get(descriptor);
+        if (!entry || entry.kind !== "file") {
+          return __agentOsWasiErrnoBadf;
+        }
+        if (entry.readOnly === true) {
+          return __agentOsWasiErrnoRofs;
+        }
+        const written = __agentOsFs().writeSync(
+          entry.realFd,
+          bytes,
+          0,
+          bytes.length,
+          Number(offset) >>> 0,
+        );
+        return this._writeUint32(nwrittenPtr, written);
+      } catch {
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _fdPread(fd, iovs, iovsLen, offset, nreadPtr) {
+      try {
+        const descriptor = Number(fd) >>> 0;
+        const explicitOffset = Number(offset) >>> 0;
+        const totalLength = this._boundedIovLength(iovs, iovsLen);
+        const buffer = Buffer.alloc(totalLength);
+        const handle = this._externalFdHandle(descriptor);
+        if (
+          (handle?.kind === "passthrough" || handle?.kind === "host-passthrough") &&
+          typeof handle.targetFd === "number"
+        ) {
+          const bytesRead = __agentOsFs().readSync(
+            handle.targetFd,
+            buffer,
+            0,
+            totalLength,
+            explicitOffset,
+          );
+          const written = this._writeToIovs(iovs, iovsLen, buffer.subarray(0, bytesRead));
+          return this._writeUint32(nreadPtr, written);
+        }
+        const entry = this.fdTable.get(descriptor);
+        if (!entry || entry.kind !== "file") {
+          return __agentOsWasiErrnoBadf;
+        }
+        const bytesRead = __agentOsFs().readSync(
+          entry.realFd,
+          buffer,
+          0,
+          totalLength,
+          explicitOffset,
+        );
+        const written = this._writeToIovs(iovs, iovsLen, buffer.subarray(0, bytesRead));
+        return this._writeUint32(nreadPtr, written);
+      } catch {
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _fdRead(fd, iovs, iovsLen, nreadPtr) {
+      try {
+        const descriptor = Number(fd) >>> 0;
+        const handle = this._externalFdHandle(descriptor);
+        if (handle?.kind === "pipe-read" && handle.pipe) {
+          const totalLength = this._boundedIovLength(iovs, iovsLen);
+          while (handle.pipe.chunks.length === 0) {
+            if (handle.pipe.writeHandleCount === 0 && handle.pipe.producers.size === 0) {
+              return this._writeUint32(nreadPtr, 0);
+            }
+            this._pumpPipeProducers(handle.pipe, 10);
+          }
+          const chunk = this._dequeuePipeBytes(handle.pipe, totalLength);
+          const written = this._writeToIovs(iovs, iovsLen, chunk);
+          return this._writeUint32(nreadPtr, written);
+        }
+        const entry = this.fdTable.get(descriptor);
+        if (!entry) {
+          return __agentOsWasiErrnoBadf;
+        }
+        if (entry.kind === "stdin") {
+          const totalLength = this._boundedIovLength(iovs, iovsLen);
+          const syncRpc =
+            typeof globalThis?.__agentOsSyncRpc?.callSync === "function"
+              ? __agentOsWasiSyncRpc()
+              : null;
+          const sidecarManagedProcess =
+            typeof process?.env?.AGENT_OS_SANDBOX_ROOT === "string" &&
+            process.env.AGENT_OS_SANDBOX_ROOT.length > 0;
+          if (syncRpc && (sidecarManagedProcess || __agentOsKernelStdioSyncRpcEnabled())) {
+            try {
+              let chunk = null;
+              while (true) {
+                const response = syncRpc.callSync("__kernel_stdin_read", [totalLength, 10]);
+                if (
+                  response &&
+                  typeof response === "object" &&
+                  typeof response.dataBase64 === "string"
+                ) {
+                  chunk = Buffer.from(response.dataBase64, "base64");
+                  break;
+                }
+                if (response && typeof response === "object" && response.done === true) {
+                  chunk = Buffer.alloc(0);
+                  break;
+                }
+                if (
+                  typeof Atomics?.wait === "function" &&
+                  typeof syntheticWaitArray !== "undefined"
+                ) {
+                  Atomics.wait(syntheticWaitArray, 0, 0, 10);
+                }
+              }
+              if (!chunk || chunk.length === 0) {
+                return this._writeUint32(nreadPtr, 0);
+              }
+              const written = this._writeToIovs(iovs, iovsLen, chunk);
+              return this._writeUint32(nreadPtr, written);
+            } catch {
+              // Fall back to direct stdin reads when the sync bridge is unavailable
+              // in the standalone runner bootstrap.
+            }
+          }
+          const buffer = Buffer.alloc(totalLength);
+          const directStdinFd =
+            (handle?.kind === "passthrough" || handle?.kind === "host-passthrough") &&
+            typeof handle.targetFd === "number"
+              ? handle.targetFd
+              : typeof process?.stdin?.fd === "number"
+                ? process.stdin.fd
+                : 0;
+          const bytesRead = __agentOsFs().readSync(
+            directStdinFd,
+            buffer,
+            0,
+            totalLength,
+            null,
+          );
+          const written = this._writeToIovs(iovs, iovsLen, buffer.subarray(0, bytesRead));
+          return this._writeUint32(nreadPtr, written);
+        }
+        if (
+          (handle?.kind === "passthrough" || handle?.kind === "host-passthrough") &&
+          typeof handle.targetFd === "number"
+        ) {
+          const totalLength = this._boundedIovLength(iovs, iovsLen);
+          const buffer = Buffer.alloc(totalLength);
+          const bytesRead = __agentOsFs().readSync(
+            handle.targetFd,
+            buffer,
+            0,
+            totalLength,
+            null,
+          );
+          const written = this._writeToIovs(iovs, iovsLen, buffer.subarray(0, bytesRead));
+          return this._writeUint32(nreadPtr, written);
+        }
+        if (entry.kind !== "file") {
+          return __agentOsWasiErrnoBadf;
+        }
+        const totalLength = this._boundedIovLength(iovs, iovsLen);
+        const buffer = Buffer.alloc(totalLength);
+        const position = typeof entry.offset === "number" ? entry.offset : null;
+        const bytesRead = __agentOsFs().readSync(
+          entry.realFd,
+          buffer,
+          0,
+          totalLength,
+          position,
+        );
+        if (typeof entry.offset === "number") {
+          entry.offset += bytesRead;
+        }
+        const written = this._writeToIovs(iovs, iovsLen, buffer.subarray(0, bytesRead));
+        return this._writeUint32(nreadPtr, written);
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _fdClose(fd) {
+      try {
+        const descriptor = Number(fd) >>> 0;
+        const entry = this.fdTable.get(descriptor);
+        if (!entry) {
+          return __agentOsWasiErrnoBadf;
+        }
+        const retainedDelegateRefs = (() => {
+          try {
+            if (typeof globalThis.__agentOsWasiDelegateFdRefCount === "function") {
+              return Number(globalThis.__agentOsWasiDelegateFdRefCount(descriptor)) || 0;
+            }
+          } catch {
+            // Fall through to the default close path.
+          }
+          return 0;
+        })();
+        if (entry.kind === "file" && retainedDelegateRefs <= 0) {
+          __agentOsFs().closeSync(entry.realFd);
+        }
+        if (descriptor > 2 && retainedDelegateRefs <= 0) {
+          this.fdTable.delete(descriptor);
+        }
+        return __agentOsWasiErrnoSuccess;
+      } catch {
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _fdSync(fd) {
+      try {
+        const descriptor = Number(fd) >>> 0;
+        const handle = this._externalFdHandle(descriptor);
+        if (
+          (handle?.kind === "passthrough" || handle?.kind === "host-passthrough") &&
+          typeof handle.targetFd === "number"
+        ) {
+          __agentOsFs().fsyncSync(handle.targetFd);
+          return __agentOsWasiErrnoSuccess;
+        }
+        const entry = this.fdTable.get(descriptor);
+        if (!entry || entry.kind !== "file" || typeof entry.realFd !== "number") {
+          return __agentOsWasiErrnoBadf;
+        }
+        __agentOsFs().fsyncSync(entry.realFd);
+        return __agentOsWasiErrnoSuccess;
+      } catch {
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _fdFdstatGet(fd, statPtr) {
+      try {
+        const entry = this._descriptorEntry(fd);
+        if (!entry) {
+          return __agentOsWasiErrnoBadf;
+        }
+        const view = this._memoryView();
+        const offset = Number(statPtr) >>> 0;
+        view.setUint8(offset, this._fdFiletype(entry));
+        view.setUint16(offset + 2, (Number(entry.fdFlags) >>> 0) & 0xffff, true);
+        view.setBigUint64(offset + 8, this._descriptorRightsBase(entry), true);
+        view.setBigUint64(offset + 16, this._descriptorRightsInheriting(entry), true);
+        return __agentOsWasiErrnoSuccess;
+      } catch {
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _fdFdstatSetFlags(fd, flags) {
+      try {
+        const entry = this._descriptorEntry(fd);
+        if (!entry) {
+          return __agentOsWasiErrnoBadf;
+        }
+        entry.fdFlags = (Number(flags) >>> 0) & 0xffff;
+        return __agentOsWasiErrnoSuccess;
+      } catch {
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _fdFilestatGet(fd, statPtr) {
+      try {
+        const entry = this._descriptorEntry(fd);
+        if (!entry) {
+          return __agentOsWasiErrnoBadf;
+        }
+        if (
+          entry.kind === "stdin" ||
+          entry.kind === "stdout" ||
+          entry.kind === "stderr"
+        ) {
+          return this._writeFilestat(statPtr, null, __agentOsWasiFiletypeCharacterDevice);
+        }
+        if (entry.kind === "preopen") {
+          const stats = __agentOsFs().statSync(entry.guestPath);
+          return this._writeFilestat(statPtr, stats, __agentOsWasiFiletypeDirectory);
+        }
+        const stats =
+          typeof entry.realFd === "number"
+            ? __agentOsFs().fstatSync(entry.realFd)
+            : __agentOsFs().statSync(this._descriptorFsPath(entry));
+        return this._writeFilestat(statPtr, stats, this._fdFiletype(entry));
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _fdFilestatSetSize(fd, size) {
+      try {
+        const entry = this._descriptorEntry(fd);
+        if (!entry || entry.kind !== "file" || typeof entry.realFd !== "number") {
+          return __agentOsWasiErrnoBadf;
+        }
+        if (entry.readOnly === true) {
+          return __agentOsWasiErrnoRofs;
+        }
+        __agentOsFs().ftruncateSync(entry.realFd, Number(size));
+        return __agentOsWasiErrnoSuccess;
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _fdSeek(fd, offset, whence, newOffsetPtr) {
+      try {
+        const entry = this._descriptorEntry(fd);
+        if (!entry || entry.kind !== "file" || typeof entry.realFd !== "number") {
+          return __agentOsWasiErrnoBadf;
+        }
+        const delta = Number(offset);
+        if (!Number.isFinite(delta)) {
+          return __agentOsWasiErrnoInval;
+        }
+        const currentOffset = typeof entry.offset === "number" ? entry.offset : 0;
+        let nextOffset = 0;
+        switch (Number(whence) >>> 0) {
+          case __agentOsWasiWhenceSet:
+            nextOffset = delta;
+            break;
+          case __agentOsWasiWhenceCur:
+            nextOffset = currentOffset + delta;
+            break;
+          case __agentOsWasiWhenceEnd: {
+            const stats = __agentOsFs().fstatSync(entry.realFd);
+            nextOffset = Number(stats?.size ?? 0) + delta;
+            break;
+          }
+          default:
+            return __agentOsWasiErrnoInval;
+        }
+        if (!Number.isFinite(nextOffset) || nextOffset < 0) {
+          return __agentOsWasiErrnoInval;
+        }
+        entry.offset = nextOffset;
+        return this._writeUint64(newOffsetPtr, BigInt(nextOffset));
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _fdTell(fd, offsetPtr) {
+      try {
+        const entry = this._descriptorEntry(fd);
+        if (!entry || entry.kind !== "file") {
+          return __agentOsWasiErrnoBadf;
+        }
+        const offset = typeof entry.offset === "number" ? entry.offset : 0;
+        return this._writeUint64(offsetPtr, BigInt(offset));
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _fdPrestatGet(fd, prestatPtr) {
+      try {
+        const entry = this._descriptorEntry(fd);
+        if (!entry || entry.kind !== "preopen") {
+          return __agentOsWasiErrnoBadf;
+        }
+        const guestPath = this._descriptorPreopenName(entry);
+        if (typeof guestPath !== "string") {
+          return __agentOsWasiErrnoBadf;
+        }
+        const view = this._memoryView();
+        const offset = Number(prestatPtr) >>> 0;
+        view.setUint8(offset, 0);
+        view.setUint32(offset + 4, Buffer.byteLength(guestPath), true);
+        return __agentOsWasiErrnoSuccess;
+      } catch {
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _fdPrestatDirName(fd, pathPtr, pathLen) {
+      try {
+        const entry = this._descriptorEntry(fd);
+        if (!entry || entry.kind !== "preopen") {
+          return __agentOsWasiErrnoBadf;
+        }
+        const guestPath = this._descriptorPreopenName(entry);
+        if (typeof guestPath !== "string") {
+          return __agentOsWasiErrnoBadf;
+        }
+        const bytes = Buffer.from(guestPath, "utf8");
+        if ((Number(pathLen) >>> 0) < bytes.length) {
+          return __agentOsWasiErrnoFault;
+        }
+        return this._writeBytes(pathPtr, bytes);
+      } catch {
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _fdReaddir(fd, bufPtr, bufLen, cookie, bufUsedPtr) {
+      try {
+        const entry = this._descriptorEntry(fd);
+        const fsPath = this._descriptorDirectoryFsPath(entry);
+        if (
+          !entry ||
+          (entry.kind !== "preopen" && entry.kind !== "directory") ||
+          typeof fsPath !== "string"
+        ) {
+          return __agentOsWasiErrnoBadf;
+        }
+        const dirents = __agentOsFs()
+          .readdirSync(fsPath, { withFileTypes: true })
+          .sort((left, right) => left.name.localeCompare(right.name));
+        const view = this._memoryView();
+        const memory = this._memoryBytes();
+        let offset = Number(bufPtr) >>> 0;
+        const limit = offset + (Number(bufLen) >>> 0);
+        let used = 0;
+        for (let index = Number(cookie) >>> 0; index < dirents.length; index += 1) {
+          const dirent = dirents[index];
+          const nameBytes = Buffer.from(dirent.name, "utf8");
+          const recordLen = 24 + nameBytes.length;
+          if (offset + recordLen > limit) {
+            break;
+          }
+          view.setBigUint64(offset, BigInt(index + 1), true);
+          view.setBigUint64(offset + 8, BigInt(index + 1), true);
+          view.setUint32(offset + 16, nameBytes.length, true);
+          view.setUint8(
+            offset + 20,
+            dirent.isDirectory()
+              ? __agentOsWasiFiletypeDirectory
+              : dirent.isSymbolicLink()
+                ? __agentOsWasiFiletypeSymbolicLink
+                : __agentOsWasiFiletypeRegularFile,
+          );
+          memory.set(nameBytes, offset + 24);
+          offset += recordLen;
+          used += recordLen;
+        }
+        return this._writeUint32(bufUsedPtr, used);
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _pathCreateDirectory(fd, pathPtr, pathLen) {
+      try {
+        const resolved = this._resolveDescriptorPath(fd, pathPtr, pathLen);
+        if (resolved.error !== __agentOsWasiErrnoSuccess) {
+          return resolved.error;
+        }
+        if (resolved.readOnly) {
+          return __agentOsWasiErrnoRofs;
+        }
+        __agentOsFs().mkdirSync(this._resolvedFsPath(resolved));
+        return __agentOsWasiErrnoSuccess;
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _pathLink(oldFd, _oldFlags, oldPathPtr, oldPathLen, newFd, newPathPtr, newPathLen) {
+      try {
+        const source = this._resolveDescriptorPath(oldFd, oldPathPtr, oldPathLen);
+        if (source.error !== __agentOsWasiErrnoSuccess) {
+          return source.error;
+        }
+        const destination = this._resolveDescriptorPath(newFd, newPathPtr, newPathLen);
+        if (destination.error !== __agentOsWasiErrnoSuccess) {
+          return destination.error;
+        }
+        if (source.readOnly || destination.readOnly) {
+          return __agentOsWasiErrnoRofs;
+        }
+        __agentOsFs().linkSync(this._resolvedFsPath(source), this._resolvedFsPath(destination));
+        return __agentOsWasiErrnoSuccess;
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _pathOpen(fd, _dirflags, pathPtr, pathLen, oflags, rightsBase, rightsInheriting, _fdflags, openedFdPtr) {
+      try {
+        const entry = this._descriptorEntry(fd);
+        if (
+          !entry ||
+          (entry.kind !== "preopen" && entry.kind !== "directory") ||
+          typeof entry.hostPath !== "string"
+        ) {
+          return __agentOsWasiErrnoBadf;
+        }
+        const requestedFlags = Number(oflags) >>> 0;
+        const createOrTruncate =
+          (requestedFlags & __agentOsWasiOpenCreate) !== 0 ||
+          (requestedFlags & __agentOsWasiOpenTruncate) !== 0;
+        const resolved = this._resolveDescriptorPath(fd, pathPtr, pathLen, {
+          preferCreateParent: createOrTruncate,
+        });
+        if (resolved.error !== __agentOsWasiErrnoSuccess) {
+          return resolved.error;
+        }
+        const guestPath = resolved.guestPath;
+        const fsPath = this._resolvedFsPath(resolved);
+        const openDirectory = (requestedFlags & __agentOsWasiOpenDirectory) !== 0;
+        const allowedRightsBase = this._descriptorRightsBase(entry);
+        const allowedRightsInheriting = this._descriptorRightsInheriting(entry);
+        const requestedRightsBase = this._normalizeRights(rightsBase, allowedRightsInheriting);
+        const requestedRightsInheriting = this._normalizeRights(
+          rightsInheriting,
+          allowedRightsInheriting,
+        );
+        if (
+          (requestedRightsBase & ~allowedRightsInheriting) !== 0n ||
+          (requestedRightsInheriting & ~allowedRightsInheriting) !== 0n
+        ) {
+          return __agentOsWasiErrnoAcces;
+        }
+        const requestedWriteAccess =
+          !openDirectory &&
+          (createOrTruncate || this._hasWriteRights(requestedRightsBase));
+        if (
+          requestedWriteAccess &&
+          !this._hasWriteRights(allowedRightsBase)
+        ) {
+          return __agentOsWasiErrnoAcces;
+        }
+        if (requestedWriteAccess && resolved.readOnly) {
+          return __agentOsWasiErrnoRofs;
+        }
+        const fsConstants = __agentOsFs().constants ?? {};
+        let openFlags = requestedWriteAccess
+          ? fsConstants.O_RDWR ?? 2
+          : fsConstants.O_RDONLY ?? 0;
+        if ((requestedFlags & __agentOsWasiOpenCreate) !== 0) {
+          openFlags |= fsConstants.O_CREAT ?? 64;
+        }
+        if ((requestedFlags & __agentOsWasiOpenExclusive) !== 0) {
+          openFlags |= fsConstants.O_EXCL ?? 128;
+        }
+        if ((requestedFlags & __agentOsWasiOpenTruncate) !== 0) {
+          openFlags |= fsConstants.O_TRUNC ?? 512;
+        }
+        if (openDirectory) {
+          openFlags |= fsConstants.O_DIRECTORY ?? 0;
+        }
+        if (createOrTruncate && !openDirectory) {
+          __agentOsFs().statSync(__agentOsPath().dirname(fsPath));
+        } else {
+          __agentOsFs().statSync(fsPath);
+        }
+        const realFd = __agentOsFs().openSync(fsPath, openFlags);
+        const stats =
+          createOrTruncate && !openDirectory
+            ? __agentOsFs().fstatSync(realFd)
+            : __agentOsFs().statSync(fsPath);
+        const openedFd = this.nextFd++;
+        this.fdTable.set(openedFd, {
+          kind: stats.isDirectory() ? "directory" : "file",
+          guestPath,
+          hostPath: fsPath,
+          readOnly: resolved.readOnly === true,
+          realFd,
+          offset: 0,
+          rightsBase: requestedRightsBase & allowedRightsInheriting,
+          rightsInheriting: requestedRightsInheriting & allowedRightsInheriting,
+          fdFlags: (Number(_fdflags) >>> 0) & 0xffff,
+        });
+        return this._writeUint32(openedFdPtr, openedFd);
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _pathSymlink(targetPtr, targetLen, fd, pathPtr, pathLen) {
+      try {
+        const resolved = this._resolveDescriptorPath(fd, pathPtr, pathLen);
+        if (resolved.error !== __agentOsWasiErrnoSuccess) {
+          return resolved.error;
+        }
+        if (resolved.readOnly) {
+          return __agentOsWasiErrnoRofs;
+        }
+        const target = this._readString(targetPtr, targetLen);
+        __agentOsFs().symlinkSync(target, this._resolvedFsPath(resolved));
+        return __agentOsWasiErrnoSuccess;
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _pathRemoveDirectory(fd, pathPtr, pathLen) {
+      try {
+        const resolved = this._resolveDescriptorPath(fd, pathPtr, pathLen);
+        if (resolved.error !== __agentOsWasiErrnoSuccess) {
+          return resolved.error;
+        }
+        if (resolved.readOnly) {
+          return __agentOsWasiErrnoRofs;
+        }
+        __agentOsFs().rmdirSync(this._resolvedFsPath(resolved));
+        return __agentOsWasiErrnoSuccess;
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _pathRename(oldFd, oldPathPtr, oldPathLen, newFd, newPathPtr, newPathLen) {
+      try {
+        const source = this._resolveDescriptorPath(oldFd, oldPathPtr, oldPathLen);
+        if (source.error !== __agentOsWasiErrnoSuccess) {
+          return source.error;
+        }
+        const destination = this._resolveDescriptorPath(newFd, newPathPtr, newPathLen);
+        if (destination.error !== __agentOsWasiErrnoSuccess) {
+          return destination.error;
+        }
+        if (source.readOnly || destination.readOnly) {
+          return __agentOsWasiErrnoRofs;
+        }
+        __agentOsFs().renameSync(this._resolvedFsPath(source), this._resolvedFsPath(destination));
+        return __agentOsWasiErrnoSuccess;
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _pathUnlinkFile(fd, pathPtr, pathLen) {
+      try {
+        const resolved = this._resolveDescriptorPath(fd, pathPtr, pathLen);
+        if (resolved.error !== __agentOsWasiErrnoSuccess) {
+          return resolved.error;
+        }
+        if (resolved.readOnly) {
+          return __agentOsWasiErrnoRofs;
+        }
+        __agentOsFs().unlinkSync(this._resolvedFsPath(resolved));
+        return __agentOsWasiErrnoSuccess;
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _pathFilestatGet(fd, flags, pathPtr, pathLen, statPtr) {
+      try {
+        const resolved = this._resolveDescriptorPath(fd, pathPtr, pathLen);
+        if (resolved.error !== __agentOsWasiErrnoSuccess) {
+          return resolved.error;
+        }
+        const follow = (Number(flags) & __agentOsWasiLookupSymlinkFollow) !== 0;
+        const stats = follow
+          ? __agentOsFs().statSync(this._resolvedFsPath(resolved))
+          : __agentOsFs().lstatSync(this._resolvedFsPath(resolved));
+        return this._writeFilestat(statPtr, stats, this._filetypeForStats(stats));
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _pathReadlink(fd, pathPtr, pathLen, bufPtr, bufLen, bufUsedPtr) {
+      try {
+        const resolved = this._resolveDescriptorPath(fd, pathPtr, pathLen);
+        if (resolved.error !== __agentOsWasiErrnoSuccess) {
+          return resolved.error;
+        }
+        const bytes = Buffer.from(__agentOsFs().readlinkSync(resolved.guestPath), "utf8");
+        const length = Math.min(bytes.length, Number(bufLen) >>> 0);
+        const writeStatus = this._writeBytes(bufPtr, bytes.subarray(0, length));
+        if (writeStatus !== __agentOsWasiErrnoSuccess) {
+          return writeStatus;
+        }
+        return this._writeUint32(bufUsedPtr, length);
+      } catch (error) {
+        return this._mapFsError(error);
+      }
+    }
+
+    _pollOneoff(inPtr, outPtr, nsubscriptions, neventsPtr) {
+      try {
+        const subscriptionCount = Number(nsubscriptions) >>> 0;
+        if (subscriptionCount === 0) {
+          return this._writeUint32(neventsPtr, 0);
+        }
+
+        const subscriptionSize = 48;
+        const eventSize = 32;
+        const kernelPollIn = 0x0001;
+        const kernelPollOut = 0x0004;
+        const kernelPollErr = 0x0008;
+        const kernelPollHup = 0x0010;
+        const view = this._memoryView();
+        const memory = this._memoryBytes();
+        const syncRpc =
+          typeof globalThis?.__agentOsSyncRpc?.callSync === "function"
+            ? __agentOsWasiSyncRpc()
+            : null;
+        const subscriptions = [];
+        let timeoutMs = null;
+
+        for (let index = 0; index < subscriptionCount; index += 1) {
+          const base = (Number(inPtr) >>> 0) + index * subscriptionSize;
+          const tag = view.getUint8(base + 8);
+          const userdata = memory.slice(base, base + 8);
+          if (tag === 0) {
+            const timeoutNs = view.getBigUint64(base + 24, true);
+            const relativeTimeoutMs = Number(timeoutNs / 1000000n);
+            timeoutMs =
+              timeoutMs == null ? relativeTimeoutMs : Math.min(timeoutMs, relativeTimeoutMs);
+            subscriptions.push({ kind: "clock", userdata });
+            continue;
+          }
+
+          if (tag !== 1 && tag !== 2) {
+            subscriptions.push({ kind: "unsupported", userdata });
+            continue;
+          }
+
+          const fd = view.getUint32(base + 16, true);
+          const descriptor = Number(fd) >>> 0;
+          const handle = this._externalFdHandle(descriptor);
+          const entry = this._descriptorEntry(descriptor);
+          let targetFd = null;
+          if (
+            (handle?.kind === "passthrough" || handle?.kind === "host-passthrough") &&
+            typeof handle.targetFd === "number"
+          ) {
+            targetFd = Number(handle.targetFd) >>> 0;
+          } else if (
+            entry?.kind === "stdin" ||
+            entry?.kind === "stdout" ||
+            entry?.kind === "stderr"
+          ) {
+            targetFd = descriptor;
+          }
+
+          subscriptions.push({
+            kind: tag === 1 ? "fd_read" : "fd_write",
+            fd: descriptor,
+            handle,
+            targetFd,
+            userdata,
+          });
+        }
+
+        const deadline = timeoutMs == null ? null : Date.now() + Math.max(0, timeoutMs);
+        const readyEvents = [];
+
+        while (readyEvents.length === 0) {
+          for (const subscription of subscriptions) {
+            if (subscription.kind === "fd_read" && subscription.handle?.kind === "pipe-read") {
+              const pipe = subscription.handle.pipe;
+              if (
+                pipe &&
+                (pipe.chunks.length > 0 ||
+                  (pipe.writeHandleCount === 0 && pipe.producers.size === 0))
+              ) {
+                readyEvents.push({
+                  userdata: subscription.userdata,
+                  error: __agentOsWasiErrnoSuccess,
+                  type: 1,
+                  nbytes: pipe.chunks[0]?.length ?? 0,
+                  flags: 0,
+                });
+              }
+              continue;
+            }
+
+            if (subscription.kind === "fd_write" && subscription.handle?.kind === "pipe-write") {
+              readyEvents.push({
+                userdata: subscription.userdata,
+                error: __agentOsWasiErrnoSuccess,
+                type: 2,
+                nbytes: 65536,
+                flags: 0,
+              });
+            }
+          }
+
+          if (readyEvents.length > 0) {
+            break;
+          }
+
+          const pollTargets = subscriptions
+            .filter(
+              (subscription) =>
+                (subscription.kind === "fd_read" || subscription.kind === "fd_write") &&
+                typeof subscription.targetFd === "number",
+            )
+            .map((subscription) => ({
+              fd: subscription.targetFd,
+              events: subscription.kind === "fd_read" ? kernelPollIn : kernelPollOut,
+            }));
+          const waitMs =
+            deadline == null ? 10 : Math.max(0, Math.min(10, deadline - Date.now()));
+
+          if (syncRpc && pollTargets.length > 0) {
+            let response = null;
+            try {
+              response = syncRpc.callSync("__kernel_poll", [pollTargets, waitMs]);
+            } catch (error) {
+              __agentOsWasiDebug(
+                \`poll_oneoff __kernel_poll failed: \${
+                  error instanceof Error ? error.message : String(error)
+                }\`,
+              );
+            }
+
+            const responseEntries = Array.isArray(response?.fds) ? response.fds : [];
+            for (const subscription of subscriptions) {
+              if (
+                (subscription.kind !== "fd_read" && subscription.kind !== "fd_write") ||
+                typeof subscription.targetFd !== "number"
+              ) {
+                continue;
+              }
+
+              const responseEntry = responseEntries.find(
+                (entry) => (Number(entry?.fd) >>> 0) === subscription.targetFd,
+              );
+              const revents = Number(responseEntry?.revents) >>> 0;
+              const interested =
+                subscription.kind === "fd_read"
+                  ? kernelPollIn | kernelPollErr | kernelPollHup
+                  : kernelPollOut | kernelPollErr | kernelPollHup;
+              if ((revents & interested) === 0) {
+                continue;
+              }
+
+              readyEvents.push({
+                userdata: subscription.userdata,
+                error: __agentOsWasiErrnoSuccess,
+                type: subscription.kind === "fd_read" ? 1 : 2,
+                nbytes: subscription.kind === "fd_read" ? 1 : 65536,
+                flags: 0,
+              });
+            }
+          }
+
+          if (readyEvents.length > 0) {
+            break;
+          }
+
+          let pumped = false;
+          for (const subscription of subscriptions) {
+            if (subscription.kind === "fd_read" && subscription.handle?.kind === "pipe-read") {
+              pumped = this._pumpPipeProducers(subscription.handle.pipe, 10) || pumped;
+            }
+          }
+
+          if (pumped) {
+            continue;
+          }
+
+          if (deadline != null && Date.now() >= deadline) {
+            break;
+          }
+
+          if (
+            pollTargets.length === 0 &&
+            typeof Atomics?.wait !== "function" &&
+            deadline == null
+          ) {
+            break;
+          }
+
+          if (
+            typeof Atomics?.wait === "function" &&
+            typeof syntheticWaitArray !== "undefined"
+          ) {
+            Atomics.wait(syntheticWaitArray, 0, 0, waitMs);
+          } else if (!syncRpc && pollTargets.length === 0) {
+            break;
+          }
+        }
+
+        if (
+          readyEvents.length === 0 &&
+          subscriptions.some((subscription) => subscription.kind === "clock")
+        ) {
+          const clockSubscription = subscriptions.find(
+            (subscription) => subscription.kind === "clock",
+          );
+          readyEvents.push({
+            userdata: clockSubscription.userdata,
+            error: __agentOsWasiErrnoSuccess,
+            type: 0,
+            nbytes: 0,
+            flags: 0,
+          });
+        }
+
+        for (let index = 0; index < readyEvents.length; index += 1) {
+          const base = (Number(outPtr) >>> 0) + index * eventSize;
+          const event = readyEvents[index];
+          memory.set(event.userdata, base);
+          view.setUint16(base + 8, event.error, true);
+          view.setUint8(base + 10, event.type);
+          view.setBigUint64(base + 16, BigInt(event.nbytes), true);
+          view.setUint16(base + 24, event.flags, true);
+        }
+
+        return this._writeUint32(neventsPtr, readyEvents.length);
+      } catch (error) {
+        __agentOsWasiDebug(
+          \`poll_oneoff failed: \${error instanceof Error ? error.message : String(error)}\`,
+        );
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _randomGet(bufPtr, bufLen) {
+      try {
+        const length = Number(bufLen) >>> 0;
+        const bytes = Buffer.allocUnsafe(length);
+        __agentOsCrypto().randomFillSync(bytes);
+        return this._writeBytes(bufPtr, bytes);
+      } catch {
+        return __agentOsWasiErrnoFault;
+      }
+    }
+
+    _schedYield() {
+      return __agentOsWasiErrnoSuccess;
+    }
+
+    _procExit(code) {
+      if (this.returnOnExit) {
+        const error = new Error(\`wasi exit(\${Number(code) >>> 0})\`);
+        error.__agentOsWasiExit = true;
+        error.code = Number(code) >>> 0;
+        throw error;
+      }
+      process.exit(Number(code) >>> 0);
+    }
+  }
+
+  Object.defineProperty(globalThis, "__agentOsWasiModule", {
+    configurable: true,
+    enumerable: false,
+    value: { WASI },
+    writable: true,
+  });
+}
+
+		// Re-export the shared runner WASI class as the browser wasi module.
+		module.exports = { WASI: globalThis.__agentOsWasiModule.WASI };
+		module.exports.default = { WASI: globalThis.__agentOsWasiModule.WASI };
+`;