pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/extensions/agent-browser/lib/input-modes/script-child.js

@@ -1,396 +0,0 @@
-import { spawn } from "node:child_process";
-import { redactSensitiveText } from "../runtime.js";
-import { validateAgentBrowserScriptBrowserParams } from "./script-validation.js";
-import { describeScriptError, isScriptChildMessage, normalizeBrowserEnvelope, rejectedCallEnvelope, SCRIPT_FINAL_OUTPUT_MAX_BYTES, SCRIPT_IPC_CUMULATIVE_MAX_BYTES, SCRIPT_IPC_MESSAGE_MAX_BYTES, SCRIPT_MAX_CALLS, } from "./script-protocol.js";
-function waitForChildExit(child) {
-    if (child.exitCode !== null || child.signalCode !== null) {
-        return Promise.resolve();
-    }
-    return new Promise((resolve) => {
-        child.once("exit", () => resolve());
-        child.once("error", () => resolve());
-    });
-}
-function terminateChild(child) {
-    child.stdin.destroy();
-    if (child.exitCode === null && child.signalCode === null) {
-        child.kill("SIGTERM");
-    }
-    return setTimeout(() => {
-        if (child.exitCode === null && child.signalCode === null) {
-            child.kill("SIGKILL");
-        }
-    }, 250);
-}
-async function settleWithin(promise, timeoutMs) {
-    let timer;
-    await Promise.race([
-        promise.catch(() => {
-            // Dispatch failures are returned as observations; this wait only bounds child exit.
-        }),
-        new Promise((resolve) => {
-            timer = setTimeout(resolve, timeoutMs);
-        }),
-    ]);
-    if (timer !== undefined) {
-        clearTimeout(timer);
-    }
-}
-function emissionData(emissions) {
-    if (emissions.length === 0) {
-        return undefined;
-    }
-    return emissions.length === 1 ? emissions[0] : emissions;
-}
-function serializeFinalOutput(value) {
-    if (value === undefined) {
-        return;
-    }
-    return JSON.stringify(value);
-}
-// One owner for child events, ordered dispatch, abort, and final reaping.
-class ScriptChildRun {
-    options;
-    child;
-    childExit;
-    resultPromise;
-    resolveResult;
-    stdoutBuffer = Buffer.alloc(0);
-    stderrBytes = 0;
-    cumulativeBytes = 0;
-    callCount = 0;
-    rejectedCallCount = 0;
-    ready = false;
-    stopping = false;
-    activeCallController;
-    emissions = [];
-    steps = [];
-    failures = [];
-    messages = [];
-    draining = false;
-    drainPromise = Promise.resolve();
-    timeout;
-    constructor(options, nodePath, workerPath) {
-        this.options = options;
-        this.child = spawn(nodePath, [
-            "--permission",
-            "--max-old-space-size=64",
-            workerPath,
-            String(SCRIPT_IPC_MESSAGE_MAX_BYTES),
-            String(SCRIPT_IPC_CUMULATIVE_MAX_BYTES),
-        ], { env: {}, stdio: ["pipe", "pipe", "pipe"] });
-        this.child.stdin.on("error", () => {
-            // The write callback and child lifecycle report pipe failure; consume the stream event.
-        });
-        this.resultPromise = new Promise((resolve) => {
-            this.resolveResult = resolve;
-        });
-        this.childExit = waitForChildExit(this.child);
-    }
-    run(timeoutMs) {
-        this.options.signal?.addEventListener("abort", this.abortListener, { once: true });
-        this.timeout = setTimeout(() => {
-            this.failFromEvent(`Script execution timed out after ${timeoutMs}ms.`, "timeout", {
-                timedOut: true,
-            });
-        }, timeoutMs);
-        this.child.stdout.on("data", (chunk) => {
-            this.receiveStdout(chunk);
-        });
-        this.child.stderr.on("data", (chunk) => {
-            this.stderrBytes += chunk.length;
-            if (this.stderrBytes > SCRIPT_IPC_MESSAGE_MAX_BYTES && !this.stopping) {
-                this.failFromEvent("Sandbox stderr limit exceeded.", "upstream-error");
-            }
-        });
-        this.child.once("error", () => {
-            if (!this.stopping) {
-                this.failFromEvent("Unable to start the script sandbox.", "upstream-error");
-            }
-        });
-        this.child.once("exit", () => {
-            if (!this.stopping) {
-                this.failFromEvent("Script sandbox exited before completion.", "upstream-error");
-            }
-        });
-        return this.resultPromise;
-    }
-    abortListener = () => {
-        const timedOut = this.options.signal?.reason instanceof Error &&
-            this.options.signal.reason.name === "TimeoutError";
-        this.failFromEvent(timedOut ? "Browser code deadline exceeded." : "Browser code was aborted.", timedOut ? "timeout" : "aborted", timedOut ? { timedOut: true } : { aborted: true });
-    };
-    result() {
-        return {
-            callCount: this.callCount,
-            emitCount: this.emissions.length,
-            failures: this.failures,
-            ok: true,
-            rejectedCallCount: this.rejectedCallCount,
-            steps: this.steps,
-        };
-    }
-    async send(message) {
-        const line = `${JSON.stringify(message)}\n`;
-        this.countBytes(Buffer.byteLength(line, "utf8"));
-        await new Promise((resolve, reject) => {
-            this.child.stdin.write(line, (error) => {
-                if (error !== undefined && error !== null) {
-                    reject(error);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    countBytes(bytes) {
-        if (bytes > SCRIPT_IPC_MESSAGE_MAX_BYTES ||
-            this.cumulativeBytes + bytes > SCRIPT_IPC_CUMULATIVE_MAX_BYTES) {
-            throw new Error("Script IPC limit exceeded.");
-        }
-        this.cumulativeBytes += bytes;
-    }
-    async finish(result, waitForDrain) {
-        if (this.stopping) {
-            return;
-        }
-        this.stopping = true;
-        if (this.timeout !== undefined) {
-            clearTimeout(this.timeout);
-        }
-        this.options.signal?.removeEventListener("abort", this.abortListener);
-        this.activeCallController?.abort(result.timedOut === true
-            ? new DOMException("Browser code deadline exceeded.", "TimeoutError")
-            : this.options.signal?.reason);
-        const killTimer = terminateChild(this.child);
-        try {
-            // The caller holds the browser lease until dispatch actually settles.
-            if (waitForDrain) {
-                await this.drainPromise;
-            }
-            await settleWithin(this.childExit, 1_000);
-        }
-        finally {
-            clearTimeout(killTimer);
-        }
-        this.resolveResult(result);
-    }
-    fail(error, failureCategory, flags = {}, waitForDrain = false) {
-        const result = this.result();
-        return this.finish({
-            ...result,
-            ...flags,
-            ...(this.emissions.length > 0 ? { data: emissionData(this.emissions) } : {}),
-            error,
-            failureCategory,
-            ok: false,
-        }, waitForDrain);
-    }
-    failFromEvent(message, category, flags = {}) {
-        this.fail(message, category, flags, true).catch((failure) => {
-            // This event-owned shutdown must settle the public result even if reaping fails.
-            this.resolveResult({
-                ...this.result(),
-                ...flags,
-                ok: false,
-                failureCategory: category,
-                error: `${message} ${failure instanceof Error ? failure.message : "Sandbox cleanup failed."}`,
-            });
-        });
-    }
-    async drainMessages() {
-        if (this.draining) {
-            return;
-        }
-        this.draining = true;
-        try {
-            while (!this.stopping && this.messages.length > 0) {
-                const message = this.messages.shift();
-                if (message === undefined) {
-                    break;
-                }
-                // Every reply/emit depends on the preceding message and browser dispatch.
-                // oxlint-disable-next-line no-await-in-loop
-                await this.handleMessage(message);
-            }
-        }
-        finally {
-            this.draining = false;
-            if (!this.stopping && this.messages.length > 0) {
-                this.scheduleDrain();
-            }
-        }
-    }
-    async handleMessage(message) {
-        if (message.type === "ready") {
-            if (this.ready) {
-                await this.fail("Sandbox sent a duplicate ready message.", "upstream-error");
-                return;
-            }
-            this.ready = true;
-            try {
-                await this.send({ code: this.options.code, type: "start" });
-            }
-            catch {
-                await this.fail("Unable to start the script sandbox.", "upstream-error");
-            }
-            return;
-        }
-        if (!this.ready) {
-            await this.fail("Sandbox sent a message before it was ready.", "upstream-error");
-            return;
-        }
-        switch (message.type) {
-            case "emit":
-                if (!Object.hasOwn(message, "value")) {
-                    await this.fail("emit(value) requires a JSON-serializable value; undefined and functions are not supported.", "validation-error");
-                }
-                else {
-                    this.emissions.push(message.value);
-                }
-                return;
-            case "image":
-                await this.emitImage(message.value);
-                return;
-            case "complete":
-                await this.complete(message);
-                return;
-            case "call":
-                await this.browserCall(message);
-                return;
-        }
-    }
-    async emitImage(value) {
-        try {
-            if (this.options.emitImage === undefined) {
-                throw new Error("Image emission is unavailable.");
-            }
-            await this.options.emitImage(value);
-        }
-        catch (error) {
-            await this.fail(error instanceof Error ? error.message : "Invalid image handle.", "validation-error");
-        }
-    }
-    async complete(message) {
-        if (message.error !== undefined) {
-            await this.fail(describeScriptError(message.error), "script-error");
-            return;
-        }
-        let data = emissionData(this.emissions);
-        if (this.emissions.length === 0 && message.hasValue === true) {
-            data = message.value;
-        }
-        let serialized;
-        try {
-            serialized = serializeFinalOutput(data);
-        }
-        catch {
-            await this.fail("Final script output must be JSON-serializable.", "validation-error");
-            return;
-        }
-        if (serialized !== undefined &&
-            Buffer.byteLength(serialized, "utf8") > SCRIPT_FINAL_OUTPUT_MAX_BYTES) {
-            await this.fail(`Final script output exceeds ${SCRIPT_FINAL_OUTPUT_MAX_BYTES} bytes.`, "validation-error");
-            return;
-        }
-        await this.finish({ ...this.result(), data }, false);
-    }
-    async dispatch(params) {
-        const validated = validateAgentBrowserScriptBrowserParams(params);
-        if (validated.params === undefined) {
-            this.rejectedCallCount += 1;
-            return rejectedCallEnvelope(validated.error ?? "Invalid script browser call.");
-        }
-        this.activeCallController = new AbortController();
-        try {
-            return normalizeBrowserEnvelope(await this.options.dispatch(validated.params, this.activeCallController.signal));
-        }
-        catch (error) {
-            return rejectedCallEnvelope(redactSensitiveText(error instanceof Error
-                ? error.message
-                : "The browser executor failed while dispatching this call."));
-        }
-        finally {
-            this.activeCallController = undefined;
-        }
-    }
-    async browserCall(message) {
-        this.callCount += 1;
-        if (this.callCount > SCRIPT_MAX_CALLS) {
-            await this.fail(`Script browser call limit exceeded (${SCRIPT_MAX_CALLS}).`, "validation-error");
-            return;
-        }
-        const envelope = await this.dispatch(message.params);
-        this.steps.push({
-            failureCategory: envelope.failureCategory,
-            index: this.callCount - 1,
-            ok: envelope.success,
-            resultCategory: envelope.resultCategory,
-            successCategory: envelope.successCategory,
-            summary: envelope.summary ??
-                (typeof envelope.error === "string" ? envelope.error : "Browser call completed."),
-        });
-        if (!envelope.success) {
-            this.failures.push({ ...envelope, index: this.callCount - 1 });
-        }
-        if (this.stopping) {
-            return;
-        }
-        try {
-            await this.send({ envelope, id: message.id, type: "response" });
-        }
-        catch {
-            await this.fail("Unable to return a browser result within the code IPC limit. Narrow the native extraction or use agent_browser with outputPath; already-dispatched effects are not rolled back.", "upstream-error");
-        }
-    }
-    scheduleDrain() {
-        if (this.draining || this.stopping) {
-            return;
-        }
-        this.drainPromise = this.drainMessages().catch((error) => {
-            // Unexpected drain failures still go through the same child termination owner.
-            return this.fail(error instanceof Error ? error.message : "Sandbox message dispatch failed.", "upstream-error");
-        });
-    }
-    receiveStdout(chunk) {
-        if (this.stopping) {
-            return;
-        }
-        this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, chunk]);
-        if (this.stdoutBuffer.length > SCRIPT_IPC_MESSAGE_MAX_BYTES) {
-            this.failFromEvent("Script IPC message limit exceeded.", "validation-error");
-            return;
-        }
-        for (;;) {
-            const newline = this.stdoutBuffer.indexOf(10);
-            if (newline < 0) {
-                break;
-            }
-            const lineBuffer = this.stdoutBuffer.subarray(0, newline);
-            this.stdoutBuffer = this.stdoutBuffer.subarray(newline + 1);
-            try {
-                this.countBytes(lineBuffer.length + 1);
-            }
-            catch {
-                this.failFromEvent("Script IPC limit exceeded.", "validation-error");
-                return;
-            }
-            try {
-                const parsed = JSON.parse(lineBuffer.toString("utf8"));
-                if (!isScriptChildMessage(parsed)) {
-                    throw new Error("invalid message");
-                }
-                this.messages.push(parsed);
-            }
-            catch {
-                this.failFromEvent("Sandbox returned an invalid IPC message.", "upstream-error");
-                return;
-            }
-        }
-        this.scheduleDrain();
-    }
-}
-export function runScriptChild(options, nodePath, workerPath, timeoutMs) {
-    return new ScriptChildRun(options, nodePath, workerPath).run(timeoutMs);
-}

package/dist/extensions/agent-browser/lib/input-modes/script-protocol.js

@@ -1,86 +0,0 @@
-import { isRecord } from "../parsing.js";
-export const SCRIPT_IPC_MESSAGE_MAX_BYTES = 1 * 1_024 * 1_024;
-export const SCRIPT_IPC_CUMULATIVE_MAX_BYTES = 8 * 1_024 * 1_024;
-export const SCRIPT_FINAL_OUTPUT_MAX_BYTES = 64 * 1_024;
-export const SCRIPT_MAX_CALLS = 25;
-export function isScriptChildMessage(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    switch (value.type) {
-        case "ready":
-        case "emit":
-        case "image":
-            return true;
-        case "call":
-            return typeof value.id === "number" && Number.isSafeInteger(value.id) && value.id > 0;
-        case "complete":
-            return ((value.error === undefined || isRecord(value.error)) &&
-                (value.hasValue === undefined || typeof value.hasValue === "boolean"));
-        default:
-            return false;
-    }
-}
-export function describeScriptError(error) {
-    const name = typeof error.name === "string" && error.name.length > 0 ? error.name.slice(0, 80) : "Error";
-    const message = typeof error.message === "string" && error.message.length > 0
-        ? error.message.replace(/[\r\n]+/g, " ").slice(0, 400)
-        : "Script execution failed.";
-    return `${name}: ${message}`;
-}
-export function rejectedCallEnvelope(error) {
-    return {
-        data: null,
-        error,
-        failureCategory: "validation-error",
-        success: false,
-        resultCategory: "failure",
-        summary: error,
-    };
-}
-function failureCategory(value) {
-    const categories = [
-        "aborted",
-        "artifact-missing",
-        "cleanup-failed",
-        "confirmation-required",
-        "download-not-verified",
-        "missing-binary",
-        "parse-failure",
-        "policy-blocked",
-        "qa-failure",
-        "selector-not-found",
-        "selector-unsupported",
-        "script-error",
-        "stale-ref",
-        "tab-drift",
-        "tab-gone",
-        "timeout",
-        "upstream-error",
-        "validation-error",
-    ];
-    return categories.find((category) => category === value);
-}
-function successCategory(value) {
-    const categories = [
-        "artifact-pending",
-        "artifact-saved",
-        "artifact-unverified",
-        "completed",
-        "inspection",
-    ];
-    return categories.find((category) => category === value);
-}
-export function normalizeBrowserEnvelope(value) {
-    if (!isRecord(value) ||
-        typeof value.success !== "boolean" ||
-        !["success", "failure"].includes(value.resultCategory)) {
-        return rejectedCallEnvelope("The browser executor returned an invalid code observation.");
-    }
-    return {
-        ...value,
-        failureCategory: failureCategory(value.failureCategory),
-        successCategory: successCategory(value.successCategory),
-        summary: typeof value.summary === "string" ? value.summary : undefined,
-    };
-}

package/dist/extensions/agent-browser/lib/input-modes/script-types.js

@@ -1 +0,0 @@
-export {};

package/dist/extensions/agent-browser/lib/input-modes/script-validation.js

@@ -1,60 +0,0 @@
-import { isRecord } from "../parsing.js";
-import { extractExplicitNamespace, extractExplicitSessionName, scanUpstreamGlobalFlagOccurrences, } from "../argv-grammar.js";
-import { extractUpstreamCommandTokens } from "../argv-descriptor.js";
-import { getUpstreamEffectiveBatchSteps } from "../orchestration/batch-stdin.js";
-import { isCloseAllCommand } from "../command-taxonomy.js";
-import { validateToolArgs } from "../runtime.js";
-import { isStringArray } from "./shared.js";
-function isOptionalTimeout(value) {
-    return (value === undefined || (typeof value === "number" && Number.isSafeInteger(value) && value > 0));
-}
-export function validateAgentBrowserScriptBrowserParams(input) {
-    if (!isRecord(input)) {
-        return { error: "script browser(params) requires an object." };
-    }
-    const unsupportedField = Object.keys(input).find((field) => !["args", "stdin", "timeoutMs"].includes(field));
-    if (unsupportedField !== undefined) {
-        return {
-            error: `script browser(params) does not support ${unsupportedField}; use only args, stdin, and timeoutMs.`,
-        };
-    }
-    const { args, stdin, timeoutMs } = input;
-    if (!isStringArray(args) || args.length === 0) {
-        return { error: "script browser(params).args must be a non-empty string array." };
-    }
-    if (stdin !== undefined && typeof stdin !== "string") {
-        return { error: "script browser(params).stdin must be a string when provided." };
-    }
-    if (!isOptionalTimeout(timeoutMs)) {
-        return { error: "script browser(params).timeoutMs must be a positive integer when provided." };
-    }
-    const error = validateToolArgs(args);
-    return error !== undefined ? { error } : { params: { args, stdin, timeoutMs } };
-}
-function normalizeNamespace(namespace) {
-    return namespace === "" ? undefined : namespace;
-}
-export function bindBrowserCodeCall(params, identity) {
-    const args = [...params.args];
-    const explicitSession = extractExplicitSessionName(args);
-    const namespaceFlags = scanUpstreamGlobalFlagOccurrences(args, "--namespace");
-    const explicitNamespace = extractExplicitNamespace(args);
-    if ((explicitSession !== undefined && explicitSession !== identity.sessionName) ||
-        (namespaceFlags.length > 0 &&
-            normalizeNamespace(explicitNamespace) !== normalizeNamespace(identity.namespace))) {
-        throw new Error("A code call uses one browser identity. Set session/namespace on agent_browser_code to choose another browser.");
-    }
-    const tokens = extractUpstreamCommandTokens(args);
-    if (isCloseAllCommand(tokens) ||
-        getUpstreamEffectiveBatchSteps(tokens, params.stdin).some(isCloseAllCommand)) {
-        throw new Error("Run namespace-wide close --all directly with agent_browser, outside a session-scoped code call.");
-    }
-    return {
-        ...params,
-        args: [
-            ...(namespaceFlags.length === 0 ? ["--namespace", identity.namespace ?? ""] : []),
-            ...(explicitSession === undefined ? ["--session", identity.sessionName] : []),
-            ...args,
-        ],
-    };
-}

package/dist/extensions/agent-browser/lib/input-modes/script.js

@@ -1,108 +0,0 @@
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import which from "which";
-import { AGENT_BROWSER_CODE_MAX_TIMEOUT_MS } from "./types.js";
-import { runScriptChild } from "./script-child.js";
-export { bindBrowserCodeCall, validateAgentBrowserScriptBrowserParams, } from "./script-validation.js";
-export { SCRIPT_FINAL_OUTPUT_MAX_BYTES as AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES, SCRIPT_IPC_MESSAGE_MAX_BYTES as AGENT_BROWSER_SCRIPT_IPC_MESSAGE_MAX_BYTES, SCRIPT_MAX_CALLS as AGENT_BROWSER_SCRIPT_MAX_CALLS, } from "./script-protocol.js";
-export const AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES = 64 * 1_024;
-export const AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS = 120_000;
-export const AGENT_BROWSER_SCRIPT_NAMESPACE = "";
-const SCRIPT_SESSION_NAME_PATTERN = /^piab-script-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-/** A Bun-compiled Pi executable is not a Node runtime and rejects Node permission flags. */
-export function resolveScriptChildNodePath(options) {
-    if (options.runtime.bun === undefined) {
-        return options.execPath;
-    }
-    const nodePath = options.whichNode();
-    if (nodePath === null) {
-        throw new Error("agent_browser_code requires a `node` runtime on PATH when pi runs on a Bun binary.");
-    }
-    return nodePath;
-}
-function resolveScriptWorkerPath() {
-    let currentDir = dirname(fileURLToPath(import.meta.url));
-    while (!existsSync(join(currentDir, "package.json"))) {
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            throw new Error("Unable to resolve the pi-agent-browser-native package root.");
-        }
-        currentDir = parentDir;
-    }
-    const workerPath = join(currentDir, "dist", "extensions", "agent-browser", "script-worker.js");
-    if (!existsSync(workerPath)) {
-        throw new Error("Compiled script worker is missing; run npm run build or reinstall pi-agent-browser-native.");
-    }
-    return workerPath;
-}
-export function createAgentBrowserScriptCloseArgs(sessionName) {
-    return ["--namespace", AGENT_BROWSER_SCRIPT_NAMESPACE, "--session", sessionName, "close"];
-}
-export function isAgentBrowserScriptSessionName(value) {
-    return typeof value === "string" && SCRIPT_SESSION_NAME_PATTERN.test(value);
-}
-function invalidRun(error, failureCategory, aborted) {
-    return {
-        ...(aborted === true ? { aborted } : {}),
-        callCount: 0,
-        emitCount: 0,
-        error,
-        failureCategory,
-        ok: false,
-        rejectedCallCount: 0,
-        steps: [],
-    };
-}
-function sourceError(code) {
-    if (typeof code !== "string") {
-        return "script must be a string.";
-    }
-    if (Buffer.byteLength(code, "utf8") > AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES) {
-        return `script must be ${AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES} bytes or less.`;
-    }
-    return undefined;
-}
-function timeoutError(timeoutMs) {
-    if (!Number.isSafeInteger(timeoutMs) ||
-        timeoutMs <= 0 ||
-        timeoutMs > AGENT_BROWSER_CODE_MAX_TIMEOUT_MS) {
-        return `script timeoutMs must be between 1 and ${AGENT_BROWSER_CODE_MAX_TIMEOUT_MS}.`;
-    }
-    return undefined;
-}
-export async function runAgentBrowserScript(options) {
-    const error = sourceError(options.code);
-    if (error !== undefined) {
-        return invalidRun(error, "validation-error");
-    }
-    const timeoutMs = options.timeoutMs ?? AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS;
-    const invalidTimeout = timeoutError(timeoutMs);
-    if (invalidTimeout !== undefined) {
-        return invalidRun(invalidTimeout, "validation-error");
-    }
-    if (options.signal?.aborted === true) {
-        return invalidRun("Script execution was aborted.", "aborted", true);
-    }
-    let workerPath;
-    let childNodePath;
-    try {
-        workerPath = resolveScriptWorkerPath();
-    }
-    catch (failure) {
-        return invalidRun(failure instanceof Error ? failure.message : "Compiled script worker is missing.", "missing-binary");
-    }
-    try {
-        childNodePath = resolveScriptChildNodePath({
-            runtime: { bun: process.versions.bun },
-            execPath: process.execPath,
-            whichNode: () => which.sync("node", { nothrow: true }),
-        });
-    }
-    catch (failure) {
-        return invalidRun(failure instanceof Error
-            ? failure.message
-            : "No Node runtime is available for the code child.", "missing-binary");
-    }
-    return runScriptChild(options, childNodePath, workerPath, timeoutMs);
-}