rea-agents 6.3.0 → 6.5.0

package/dist/process/ArtifactAnalysisResources.js

@@ -0,0 +1,213 @@
+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
+import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
+import { readStableArtifact } from "../artifacts/readStableArtifact.js";
+import { AnalysisError, } from "../domain/analysisErrorBase.js";
+import { AnalysisCancelledError, AnalysisResourceConstraintError, AnalysisOutputError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
+import { err } from "../domain/result.js";
+import { readLinuxResourceLimits, } from "./LinuxResourceLimits.js";
+import { OwnedCommandFailure, ownedCommandResources } from "./OwnedCommand.js";
+/** Own admission, artifact descriptors, producer cleanup and private workspaces together. */
+export class ArtifactAnalysisResources {
+    providerId;
+    operation;
+    readArtifact;
+    readKernelLimits;
+    capacity;
+    #artifacts;
+    #pending = new Map();
+    #tail = Promise.resolve();
+    #busy = false;
+    #closed = false;
+    constructor(providerId, operation, readArtifact, readKernelLimits, capacity) {
+        this.providerId = providerId;
+        this.operation = operation;
+        this.readArtifact = readArtifact;
+        this.readKernelLimits = readKernelLimits;
+        this.capacity = capacity;
+        this.#artifacts = { scope: new ArtifactResourceScope(), operation };
+    }
+    run(work, signal, operation = this.operation) {
+        if (this.#closed || signal?.aborted)
+            return Promise.resolve(err(new AnalysisCancelledError(operation)));
+        if (this.#busy)
+            return Promise.resolve(err(new AnalysisResourceConstraintError(operation, "capacity", this.capacity.message, this.capacity.details)));
+        this.#busy = true;
+        const running = this.#tail
+            .then(() => this.#artifacts.scope.run(() => {
+            // Failed descriptor cleanup still belongs to the preceding request until
+            // this scope has drained it and admits acquisition for the new request.
+            this.#artifacts.operation = operation;
+            return work();
+        }))
+            .catch((cause) => err(this.#artifactFailure(cause)))
+            .finally(() => {
+            this.#busy = false;
+        });
+        this.#tail = running.then(() => undefined, () => undefined);
+        return running;
+    }
+    read(path, maximumBytes, signal) {
+        return this.readArtifact(path, maximumBytes, signal, undefined, this.#artifacts.scope);
+    }
+    readLimits(limits) {
+        return this.readKernelLimits(limits, this.#artifacts.scope);
+    }
+    retain(root, owner) {
+        this.#pending.set(root, {
+            owner,
+            operation: this.#pending.get(root)?.operation ?? this.#artifacts.operation,
+        });
+    }
+    get pendingPaths() {
+        return [...this.#pending.keys()].map((root) => root.path);
+    }
+    #resourcesFor(root) {
+        const ownership = this.#pending.get(root)?.owner?.launch.ownership;
+        return ownership === undefined
+            ? [root.path]
+            : ownedCommandResources(ownership, root.path);
+    }
+    get #pendingResources() {
+        return [...this.#pending.keys()].flatMap((root) => this.#resourcesFor(root));
+    }
+    async release() {
+        for (const [root, retained] of this.#pending) {
+            try {
+                const { owner } = retained;
+                if (owner !== undefined) {
+                    const stopped = await owner.stop();
+                    if (stopped.status === "incomplete") {
+                        const cleanup = stopped.cleanupResult;
+                        throw new ProviderCleanupError(this.providerId, this.#resourcesFor(root), {
+                            reason: stopped.reason,
+                            ...(cleanup?.failures === undefined
+                                ? {}
+                                : {
+                                    failures: cleanup.failures.map((failure) => ({
+                                        ...failure,
+                                    })),
+                                }),
+                            ...(cleanup?.unverified === undefined
+                                ? {}
+                                : {
+                                    unverified: cleanup.unverified.map((process) => ({
+                                        ...process,
+                                    })),
+                                }),
+                        }, { operation: retained.operation });
+                    }
+                    this.#pending.set(root, { ...retained, owner: undefined });
+                }
+                await root.close();
+                this.#pending.delete(root);
+            }
+            catch (cause) {
+                const diagnostics = cause instanceof ProviderCleanupError ? cause.diagnostics : undefined;
+                throw new ProviderCleanupError(this.providerId, this.#resourcesFor(root), {
+                    ...diagnostics,
+                    reason: cause instanceof ProviderCleanupError
+                        ? String(diagnostics?.reason ?? cause.message)
+                        : String(cause),
+                }, { operation: retained.operation, cause });
+            }
+        }
+    }
+    cleanupFailure(observation, cause, capturedOutput, operation = this.operation) {
+        return new ProviderCleanupError(this.providerId, observation.resources, {
+            reason: observation.reason,
+            ...(capturedOutput === undefined
+                ? {}
+                : { captured_output: { ...capturedOutput } }),
+        }, { operation, cause });
+    }
+    commandFailure(cause, limits, effectiveLimits, operation = this.operation) {
+        const capturedOutput = cause.snapshot === null
+            ? undefined
+            : {
+                stdout: cause.snapshot.stdout.text,
+                stderr: cause.snapshot.stderr.text,
+                truncated: cause.snapshot.diagnosticTruncated ?? false,
+                exit_code: cause.snapshot.exitCode ?? null,
+                signal: cause.snapshot.signal ?? null,
+            };
+        const detail = {
+            cause,
+            ...(capturedOutput === undefined ? {} : { capturedOutput }),
+        };
+        if (cause.reason === "cancelled")
+            return new AnalysisCancelledError(operation, detail);
+        if (cause.reason === "timeout")
+            return new AnalysisTimeoutError(operation, limits.command_timeout_ms, detail);
+        if (cause.reason === "output-limit")
+            return new AnalysisResourceConstraintError(operation, "memory", cause.message, { output_bytes: limits.output_bytes }, detail);
+        if (cause.reason === "process" &&
+            (cause.snapshot?.signal === "SIGXFSZ" ||
+                cause.snapshot?.signal === "SIGXCPU"))
+            return new AnalysisResourceConstraintError(operation, cause.snapshot.signal === "SIGXFSZ" ? "file-size" : "cpu", `Producer terminated with ${cause.snapshot.signal}; the signal's exact cause is not independently established.`, effectiveLimits === undefined ? null : { ...effectiveLimits }, detail);
+        return new AnalysisOutputError(operation, cause.message, detail);
+    }
+    async finish(result, observation, operation = this.operation) {
+        try {
+            await this.release();
+            return result;
+        }
+        catch (cause) {
+            const partialObservation = result.ok
+                ? observation(result.value)
+                : result.error.partialObservation;
+            const cleanupDiagnostics = cause instanceof ProviderCleanupError ? cause.diagnostics : undefined;
+            return err(new ProviderCleanupError(this.providerId, this.#pendingResources, {
+                ...cleanupDiagnostics,
+                reason: cause instanceof ProviderCleanupError
+                    ? String(cleanupDiagnostics?.reason ?? cause.message)
+                    : String(cause),
+                previous_error: result.ok
+                    ? null
+                    : projectAnalysisError(result.error),
+            }, {
+                operation,
+                cause,
+                ...(partialObservation === undefined ? {} : { partialObservation }),
+            }));
+        }
+    }
+    close() {
+        this.#closed = true;
+        const work = this.#tail.then(() => this.#closeResources());
+        this.#tail = work.catch(() => undefined);
+        return work;
+    }
+    async #closeResources() {
+        let descriptorFailure;
+        try {
+            await this.#artifacts.scope.close();
+        }
+        catch (cause) {
+            descriptorFailure = this.#artifactFailure(cause);
+        }
+        try {
+            await this.release();
+        }
+        catch (cause) {
+            if (descriptorFailure !== undefined && cause instanceof AnalysisError)
+                throw analysisErrorWithCleanupFailure(descriptorFailure, cause, this.#artifacts.operation);
+            throw cause;
+        }
+        if (descriptorFailure !== undefined)
+            throw descriptorFailure;
+    }
+    #artifactFailure(cause, operation = this.#artifacts.operation) {
+        if (cause instanceof AnalysisError)
+            return cause;
+        if (cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined)
+            return this.cleanupFailure(cause.cleanup, cause, undefined, operation);
+        return new ProviderAdapterError(this.providerId, operation, {
+            cause,
+            diagnostics: { stage: "artifact-resources", reason: String(cause) },
+        });
+    }
+}

package/dist/process/BoundedFileBytes.js

@@ -1,17 +1,40 @@
-/** Read through EOF, returning undefined on overflow; consume at most maxBytes + 1 bytes without closing the handle. */
-export const readBoundedFileBytes = async (handle, maxBytes) => {
+/** Read through EOF, returning undefined on overflow; leave the handle open. */
+export const readBoundedFileBytes = async (handle, maxBytes, signal, expectedSize) => {
     if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
         throw new RangeError("File byte limit must be a nonnegative safe integer");
-    const chunks = [];
-    const buffer = Buffer.allocUnsafe(Math.min(64 * 1_024, maxBytes + 1));
+    if (expectedSize !== undefined &&
+        (!Number.isSafeInteger(expectedSize) ||
+            expectedSize < 0 ||
+            expectedSize > maxBytes))
+        throw new RangeError("Expected file size must fit the byte limit");
+    if (expectedSize === undefined) {
+        const chunks = [];
+        const buffer = Buffer.allocUnsafe(Math.min(64 * 1_024, maxBytes + 1));
+        let total = 0;
+        for (;;) {
+            signal?.throwIfAborted();
+            const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, maxBytes - total + 1), null);
+            if (bytesRead === 0)
+                return Buffer.concat(chunks, total);
+            total += bytesRead;
+            if (total > maxBytes)
+                return undefined;
+            chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
+        }
+    }
+    const buffer = Buffer.allocUnsafe(expectedSize);
+    if (expectedSize === 0)
+        return buffer;
     let total = 0;
     for (;;) {
-        const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, maxBytes - total + 1), null);
+        signal?.throwIfAborted();
+        const { bytesRead } = await handle.read(buffer, total, expectedSize - total, null);
         if (bytesRead === 0)
-            return Buffer.concat(chunks, total);
+            return buffer.subarray(0, total);
         total += bytesRead;
         if (total > maxBytes)
             return undefined;
-        chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
+        if (total === expectedSize)
+            return buffer;
     }
 };

package/dist/process/CurrentEntrypointPath.js

@@ -0,0 +1,6 @@
+import { resolve } from "node:path";
+/** Absolute argv entrypoint, or undefined when the process did not supply one. */
+export const normalizeEntrypointPath = (entrypoint) => entrypoint === undefined || entrypoint.length === 0
+    ? undefined
+    : resolve(entrypoint);
+export const CURRENT_ENTRYPOINT_PATH = normalizeEntrypointPath(process.argv[1]);

package/dist/process/DarwinProcessRunTokenReader.js

@@ -1,11 +1,13 @@
 import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
+import { DEFAULT_SWIFTC_COMPILE_TIMEOUT_MS, providerStartupTimeoutSchema, } from "../config/providerStartupTimeout.js";
 import { safeParseJson } from "../domain/safeJson.js";
-import { execFileOutput } from "./ExecFileOutput.js";
+import { boundedUtf8Text } from "./boundedUtf8Text.js";
+import { execFileOutput, execFileOutputFailure } from "./ExecFileOutput.js";
 const responseSchema = z.strictObject({
     results: z.array(z.discriminatedUnion("state", [
         z.strictObject({
@@ -48,13 +50,99 @@ const sourceFiles = [
  * exits while a job can still write objects under TMPDIR.
  */
 export const SWIFTC_INTERRUPT = "SIGINT";
+/**
+ * Resolve the Darwin ownership-helper compile deadline from an explicit option
+ * or `REA_SWIFTC_COMPILE_TIMEOUT_MS`. The default matches the measured fresh
+ * Swift SDK cache on the supported Intel macOS VM (about 88s), so compilation
+ * stays bounded independently of short provider version probes. Invalid ambient
+ * values fall back to the default; `parseConfig` still rejects them at CLI/MCP
+ * admission.
+ */
+export const resolveSwiftcCompileTimeoutMs = (options = {}) => {
+    if (options.compileTimeoutMs !== undefined)
+        return options.compileTimeoutMs;
+    const raw = (options.environment ?? process.env)
+        .REA_SWIFTC_COMPILE_TIMEOUT_MS;
+    if (raw === undefined)
+        return DEFAULT_SWIFTC_COMPILE_TIMEOUT_MS;
+    const parsed = providerStartupTimeoutSchema.safeParse(raw);
+    return parsed.success ? parsed.data : DEFAULT_SWIFTC_COMPILE_TIMEOUT_MS;
+};
+/** Bound on compiler diagnostics embedded in the inspection failure text. */
+const STDERR_EXCERPT_LIMIT = 512;
 /** The native Darwin process-ownership reader could not be prepared. */
 export class DarwinProcessOwnershipInspectionError extends Error {
     constructor(message, options) {
-        super(message, options);
+        const { compilerOutcome, ...errorOptions } = options ?? {};
+        super(message, errorOptions);
         this.name = "DarwinProcessOwnershipInspectionError";
+        this.compilerOutcome = compilerOutcome;
     }
+    compilerOutcome;
 }
+const MAX_COMPILER_STDERR_BYTES = 8 * 1024;
+const compilerOutcome = (cause, timeoutMs) => {
+    const failure = execFileOutputFailure(cause);
+    if (failure === undefined)
+        return undefined;
+    const stderr = boundedUtf8Text(failure.stderr, MAX_COMPILER_STDERR_BYTES);
+    const outcome = failure.code === "ETIMEDOUT"
+        ? "timed_out"
+        : typeof failure.code === "number"
+            ? "exited"
+            : failure.signal !== null
+                ? "signaled"
+                : failure.code === "ENOENT"
+                    ? "spawn_failed"
+                    : "failed";
+    return {
+        outcome,
+        code: failure.code,
+        signal: failure.signal,
+        stderr: stderr.text,
+        stderrBytes: Buffer.byteLength(failure.stderr, "utf8"),
+        stderrTruncated: stderr.truncated,
+        outputTruncated: failure.outputTruncated,
+        killed: failure.killed,
+        ...(outcome === "timed_out" ? { timeoutMs } : {}),
+    };
+};
+const compilerOutcomeDescription = (outcome, fallbackCode) => {
+    if (outcome === undefined)
+        return `compiler result: ${String(fallbackCode)}`;
+    if (outcome.outcome === "exited")
+        return `compiler result: exit code ${String(outcome.code)}`;
+    if (outcome.outcome === "timed_out")
+        return `compiler result: timed out after ${String(outcome.timeoutMs)} ms`;
+    if (outcome.outcome === "signaled")
+        return `compiler result: stopped by signal ${outcome.signal ?? "an unknown signal"}`;
+    return `compiler result: ${String(outcome.code)}`;
+};
+const compilerInspectionError = (cause, timeoutMs, compiler) => {
+    const outcome = compilerOutcome(cause, timeoutMs);
+    const code = outcome?.code ?? "unknown";
+    const description = compilerOutcomeDescription(outcome, code);
+    const launcher = compiler.kind === "xcrun"
+        ? "xcrun"
+        : "the selected Swift compiler (REA_DARWIN_SWIFTC_PATH)";
+    const prefix = code === "ENOENT"
+        ? `macOS process ownership inspection requires the Apple Swift compiler via ${launcher}`
+        : `macOS process ownership helper compilation failed via ${launcher}`;
+    const stderr = boundedUtf8Text(outcome?.stderr ?? "", STDERR_EXCERPT_LIMIT);
+    const diagnostics = stderr.text.trim();
+    const truncated = stderr.truncated ||
+        outcome?.stderrTruncated === true ||
+        outcome?.outputTruncated === true;
+    const suffix = diagnostics
+        ? `: ${diagnostics}${truncated ? "… [diagnostics truncated]" : ""}`
+        : outcome === undefined
+            ? `: ${cause instanceof Error ? cause.message : String(cause)}`
+            : ": no compiler diagnostics were captured";
+    return new DarwinProcessOwnershipInspectionError(`${prefix} (${description})${suffix}`, {
+        cause,
+        ...(outcome === undefined ? {} : { compilerOutcome: outcome }),
+    });
+};
 const abortReason = (signal) => {
     if (signal.reason !== undefined)
         return signal.reason;
@@ -88,6 +176,12 @@ const waitForCompilation = async (promise, signal) => {
 };
 /** Compile and retain the narrow Darwin sysctl reader for this REA process. */
 export const createDarwinProcessRunTokenReader = (options = {}) => {
+    const compiler = options.compiler ?? {
+        kind: "xcrun",
+        executable: "/usr/bin/xcrun",
+    };
+    const compilerTimeoutMs = resolveSwiftcCompileTimeoutMs(options);
+    const moduleCachePath = options.moduleCachePath ?? "";
     let root;
     let executable;
     let compilation;
@@ -113,6 +207,10 @@ export const createDarwinProcessRunTokenReader = (options = {}) => {
     const runCompilation = async (signal) => {
         let operationRoot;
         try {
+            if (compiler.kind === "swiftc" &&
+                (!isAbsolute(compiler.executable) || !isAbsolute(compiler.sdkRoot))) {
+                throw new DarwinProcessOwnershipInspectionError("Direct Darwin helper compilation requires absolute REA_DARWIN_SWIFTC_PATH and SDKROOT paths selecting a compatible installed Swift compiler and macOS SDK.");
+            }
             operationRoot = await mkdtemp(join(tmpdir(), "rea-process-token-"));
             root = operationRoot;
             process.once("exit", cleanupAtExit);
@@ -128,11 +226,22 @@ export const createDarwinProcessRunTokenReader = (options = {}) => {
                 ...process.env,
                 TMPDIR: compilerTemporary,
             };
-            // Use Swift's reusable default cache for REA's internal helper compilation.
-            delete compilerEnvironment.CLANG_MODULE_CACHE_PATH;
+            const compilerArguments = compiler.kind === "xcrun" ? ["swiftc"] : ["-sdk", compiler.sdkRoot];
+            if (compiler.kind === "swiftc")
+                compilerEnvironment.SDKROOT = compiler.sdkRoot;
+            if (moduleCachePath === "") {
+                // Use Swift's reusable default cache for REA's internal helper compilation.
+                delete compilerEnvironment.CLANG_MODULE_CACHE_PATH;
+            }
+            else {
+                await mkdir(moduleCachePath, { recursive: true });
+                compilerArguments.push("-module-cache-path", moduleCachePath);
+                compilerEnvironment.CLANG_MODULE_CACHE_PATH = moduleCachePath;
+            }
+            compilerArguments.push(...sourceFiles, "-o", output);
             try {
-                await execFileOutput(options.xcrun ?? "/usr/bin/xcrun", ["swiftc", ...sourceFiles, "-o", output], {
-                    timeout: 60_000,
+                await execFileOutput(compiler.executable, compilerArguments, {
+                    timeout: compilerTimeoutMs,
                     maxBuffer: 1024 * 1024,
                     signal,
                     stopSignal: SWIFTC_INTERRUPT,
@@ -142,12 +251,7 @@ export const createDarwinProcessRunTokenReader = (options = {}) => {
             catch (cause) {
                 if (isExpectedAbort(cause, signal))
                     throw cause;
-                const code = cause instanceof Error && "code" in cause
-                    ? String(cause.code)
-                    : "unknown";
-                throw new DarwinProcessOwnershipInspectionError(code === "ENOENT"
-                    ? `macOS process ownership inspection requires the Apple Swift compiler via xcrun (compiler result: ${code})`
-                    : `macOS process ownership helper compilation failed via xcrun (compiler result: ${code}): ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+                throw compilerInspectionError(cause, compilerTimeoutMs, compiler);
             }
             if (signal.aborted || closed)
                 throw abortReason(signal);
@@ -223,12 +327,17 @@ export const createDarwinProcessRunTokenReader = (options = {}) => {
             }
         }
     };
-    const read = async (processes) => {
+    const read = async (processes, signal) => {
+        signal?.throwIfAborted();
         if (processes.length === 0)
             return new Map();
-        const binary = await compile();
+        const binary = await compile(signal);
         const pids = processes.map(({ pid }) => String(pid));
-        const { stdout } = await execFileOutput(binary, pids, { timeout: 15_000 });
+        const { stdout } = await execFileOutput(binary, pids, {
+            timeout: 15_000,
+            ...(signal === undefined ? {} : { signal }),
+        });
+        signal?.throwIfAborted();
         const decoded = safeParseJson(stdout);
         if (!decoded.ok)
             throw new Error(`macOS process token helper returned invalid JSON: ${decoded.error}`, { cause: decoded.cause });

package/dist/process/ExecFileBoundedOutput.js

@@ -0,0 +1,44 @@
+import { spawn } from "node:child_process";
+/** Drain both streams while retaining bounded head and tail evidence. */
+export const execFileBoundedOutput = (executable, args, options) => new Promise((resolve) => {
+    const child = spawn(executable, [...args], {
+        env: options.env,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    const headLimit = Math.ceil(options.limit / 2);
+    const tailLimit = options.limit - headLimit;
+    const stdout = { head: Buffer.alloc(0), tail: Buffer.alloc(0), total: 0 };
+    const stderr = { head: Buffer.alloc(0), tail: Buffer.alloc(0), total: 0 };
+    let outputTruncated = false;
+    const capture = (stream) => (chunk) => {
+        stream.total += chunk.length;
+        const headCount = Math.min(chunk.length, Math.max(0, headLimit - stream.head.length));
+        if (headCount > 0)
+            stream.head = Buffer.concat([
+                stream.head,
+                chunk.subarray(0, headCount),
+            ]);
+        const rest = chunk.subarray(headCount);
+        if (rest.length > 0 && tailLimit > 0)
+            stream.tail = Buffer.concat([stream.tail, rest]).subarray(-tailLimit);
+        if (stream.total > options.limit)
+            outputTruncated = true;
+    };
+    child.stdout.on("data", capture(stdout));
+    child.stderr.on("data", capture(stderr));
+    let spawnError;
+    child.on("error", (error) => {
+        spawnError = error;
+    });
+    child.on("close", (code, signal) => {
+        resolve({
+            exitCode: spawnError?.code ?? code ?? signal,
+            stdout: retainedOutput(stdout, options.limit),
+            stderr: retainedOutput(stderr, options.limit),
+            outputTruncated,
+        });
+    });
+});
+const retainedOutput = (stream, limit) => stream.total > limit
+    ? `${stream.head.toString("utf8")} … [output omitted] … ${stream.tail.toString("utf8")}`
+    : Buffer.concat([stream.head, stream.tail]).toString("utf8");

package/dist/process/ExecFileOutput.js

@@ -42,19 +42,34 @@ export const execFileOutputFailure = (cause) => {
     const code = Reflect.get(cause, "code");
     const signal = Reflect.get(cause, "signal");
     const killed = Reflect.get(cause, "killed");
+    const outputTruncated = Reflect.get(cause, "outputTruncated");
+    const stdoutBytes = Reflect.get(cause, "stdoutBytes");
+    const stderrBytes = Reflect.get(cause, "stderrBytes");
+    const collectionFailure = Reflect.get(cause, "collectionFailure");
     if (typeof stdout !== "string" || typeof stderr !== "string")
         return undefined;
     return {
         stdout,
         stderr,
+        ...(typeof stdoutBytes === "number" &&
+            Number.isSafeInteger(stdoutBytes) &&
+            stdoutBytes >= 0
+            ? { stdoutBytes }
+            : {}),
+        ...(typeof stderrBytes === "number" &&
+            Number.isSafeInteger(stderrBytes) &&
+            stderrBytes >= 0
+            ? { stderrBytes }
+            : {}),
         code: typeof code === "string" || typeof code === "number" ? code : null,
         signal: typeof signal === "string" ? signal : null,
         killed: killed === true,
-        outputTruncated: code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER",
+        outputTruncated: outputTruncated === true || code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER",
+        ...(collectionFailure === true ? { collectionFailure: true } : {}),
     };
 };
-/** Run a shell-free command while capturing its complete UTF-8 output. */
-export const execFileOutput = (command, arguments_, options = {}) => new Promise((resolve, reject) => {
+/** Run a shell-free command while capturing its complete output bytes. */
+export const execFileBytes = (command, arguments_, options = {}) => new Promise((resolve, reject) => {
     const { stopSignal, signal, timeout, ...execOptions } = options;
     const invalid = timeout === undefined ? undefined : invalidTimeout(timeout);
     if (invalid !== undefined) {
@@ -79,7 +94,7 @@ export const execFileOutput = (command, arguments_, options = {}) => new Promise
                 ...(timeout === undefined ? {} : { timeout }),
             }
             : { killSignal: stopSignal }),
-        encoding: "utf8",
+        encoding: "buffer",
         maxBuffer: options.maxBuffer ?? Number.POSITIVE_INFINITY,
     }, (error, stdout, stderr) => {
         signal?.removeEventListener("abort", onAbort);
@@ -91,8 +106,10 @@ export const execFileOutput = (command, arguments_, options = {}) => new Promise
                 ? timeoutError(command, timeout, error)
                 : error;
         if (failure !== null) {
-            Reflect.set(failure, "stdout", stdout);
-            Reflect.set(failure, "stderr", stderr);
+            Reflect.set(failure, "stdout", stdout.toString("utf8"));
+            Reflect.set(failure, "stderr", stderr.toString("utf8"));
+            Reflect.set(failure, "stdoutBytes", stdout.byteLength);
+            Reflect.set(failure, "stderrBytes", stderr.byteLength);
             reject(failure);
             return;
         }
@@ -117,3 +134,10 @@ export const execFileOutput = (command, arguments_, options = {}) => new Promise
             stop("timeout");
         }, timeout);
 });
+/** Run a shell-free command while capturing its complete UTF-8 output. */
+export const execFileOutput = (command, arguments_, options = {}) => execFileBytes(command, arguments_, options).then(({ stdout, stderr }) => ({
+    stdout: stdout.toString("utf8"),
+    stderr: stderr.toString("utf8"),
+    stdoutBytes: stdout.byteLength,
+    stderrBytes: stderr.byteLength,
+}));

package/dist/process/JavaScriptWorkerMemoryLimit.js

@@ -0,0 +1,25 @@
+import { javaScriptRuntime } from "../domain/runtimeVersion.js";
+const MIB = 1024 * 1024;
+/**
+ * Commit reserved for Bun itself above a worker's heap budget.
+ *
+ * Measured on Windows x64 (Bun 1.4.2, 32 logical processors) as the peak Job
+ * Object commit of each REA worker on a trivial input: `bun -e 1` commits
+ * 52 MiB, while the source-map codec (278-368 MiB), HAR decoder (300-345 MiB)
+ * and JavaScript analysis worker (321-346 MiB) commit up to 368 MiB before any
+ * real workload because JavaScriptCore commits parsed and compiled module code
+ * and per-thread runtime state. 512 MiB covers that peak with about 40%
+ * margin for hosts with other processor counts or module layouts.
+ */
+export const BUN_WORKER_RUNTIME_RESERVE_BYTES = 512 * MIB;
+/**
+ * Process commit limit for a JavaScript worker launched on `process.execPath`.
+ *
+ * Node.js enforces each worker's V8 heap flags, so it receives no process
+ * limit (null) and its launch is unchanged. Bun ignores those flags; on Windows
+ * the owned Job Object then enforces the worker's heap budget plus Bun's
+ * runtime reserve. Bun elsewhere has no owned enforcement and also gets null.
+ */
+export const javaScriptWorkerMemoryLimitBytes = (heapBudgetMiB, host = process) => host.platform === "win32" && javaScriptRuntime(host.versions).id === "bun"
+    ? heapBudgetMiB * MIB + BUN_WORKER_RUNTIME_RESERVE_BYTES
+    : null;