rea-agents 3.1.0 → 3.2.0

package/dist/mcpDoctor.js

@@ -2,19 +2,18 @@ import { Client } from "@modelcontextprotocol/client";
 import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
 import { Formatter } from "incur";
 import { resolve } from "node:path";
-import { CATALOG_IDENTITY, MCP_RESOURCE_CATALOG, MCP_RESOURCE_TEMPLATE_CATALOG, } from "./catalogIdentity.js";
+import { CATALOG_IDENTITY } from "./catalogIdentity.js";
 import { PROMPT_CONTRACTS } from "./contracts/promptContracts.js";
 import { TOOL_CONTRACTS } from "./contracts/toolContracts.js";
 import { PRODUCT_IDENTITY } from "./identity.js";
 import { MCP_STARTUP_POLICY } from "./mcpStartupPolicy.js";
-const STDERR_LIMIT_BYTES = 64 * 1_024;
 const OUTPUT_FORMATS = ["toon", "json", "yaml", "md", "jsonl"];
-/** Diagnose the actual production stdio adapter with one bounded SDK session. */
+/** Diagnose the actual production stdio adapter with one startup-bounded SDK session. */
 export const runProductionMcpDoctor = async (options) => {
     const deadline = Date.now() + (options.deadlineMs ?? MCP_STARTUP_POLICY.doctorDeadlineMs);
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(new Error("Production MCP doctor deadline expired")), Math.max(1, deadline - Date.now()));
-    const stderr = boundedStderr();
+    const stderr = captureStderr();
     const transport = new TrackedStdioClientTransport({
         command: options.command,
         args: [...options.args],
@@ -56,21 +55,16 @@ export const runProductionMcpDoctor = async (options) => {
 };
 const inspectProductionMcpSession = async (client, deadline, signal) => {
     const request = requestOptions(deadline, signal);
-    const [tools, prompts, resources, templates, identity, requestFlow] = await Promise.all([
+    const [tools, prompts, requestFlow] = await Promise.all([
         client.listTools(undefined, request),
         client.listPrompts(undefined, request),
-        client.listResources(undefined, request),
-        client.listResourceTemplates(undefined, request),
-        client.readResource({ uri: "rea://server/identity" }, request),
-        client.callTool({ name: "binary_session", arguments: { detail: "full" } }, request),
+        client.callTool({ name: "binary_session", arguments: {} }, request),
     ]);
     const inventory = {
         tools: compareInventory(TOOL_CONTRACTS.map(({ name }) => name), tools.tools.map(({ name }) => name)),
         prompts: compareInventory(PROMPT_CONTRACTS.map(({ name }) => name), prompts.prompts.map(({ name }) => name)),
-        resources: compareInventory(MCP_RESOURCE_CATALOG.map(({ name }) => name), resources.resources.map(({ name }) => name)),
-        resource_templates: compareInventory(MCP_RESOURCE_TEMPLATE_CATALOG.map(({ name }) => name), templates.resourceTemplates.map(({ name }) => name)),
     };
-    const observedIdentity = parseIdentityResource(identity.contents);
+    const observedIdentity = parseIdentityToolResult(requestFlow.structuredContent);
     const serverVersion = client.getServerVersion();
     const protocolVersion = client.getNegotiatedProtocolVersion();
     const checks = [
@@ -161,29 +155,23 @@ const inventoryCheck = (name, comparison) => ({
         comparison.duplicates.length === 0,
     detail: `expected=${String(comparison.expected)} observed=${String(comparison.observed)} missing=${comparison.missing.join(",") || "none"} unexpected=${comparison.unexpected.join(",") || "none"} duplicates=${comparison.duplicates.join(",") || "none"}`,
 });
-const parseIdentityResource = (contents) => {
-    const first = contents.find((candidate) => isRecord(candidate) && typeof candidate.text === "string");
-    if (!isRecord(first) || typeof first.text !== "string")
+const parseIdentityToolResult = (input) => {
+    if (!isRecord(input) || !isRecord(input.result))
         return { packageVersion: null, catalogDigest: null };
-    try {
-        const identity = JSON.parse(first.text);
-        if (!isRecord(identity))
-            return { packageVersion: null, catalogDigest: null };
-        const packageIdentity = identity.package;
-        const catalog = identity.catalog;
-        const digests = isRecord(catalog) ? catalog.digests : undefined;
-        return {
-            packageVersion: isRecord(packageIdentity) && typeof packageIdentity.version === "string"
-                ? packageIdentity.version
-                : null,
-            catalogDigest: isRecord(digests) && typeof digests.combined_sha256 === "string"
-                ? digests.combined_sha256
-                : null,
-        };
-    }
-    catch {
+    const identity = input.result.server_identity;
+    if (!isRecord(identity))
         return { packageVersion: null, catalogDigest: null };
-    }
+    const packageIdentity = identity.package;
+    const catalog = identity.catalog;
+    const digests = isRecord(catalog) ? catalog.digests : undefined;
+    return {
+        packageVersion: isRecord(packageIdentity) && typeof packageIdentity.version === "string"
+            ? packageIdentity.version
+            : null,
+        catalogDigest: isRecord(digests) && typeof digests.combined_sha256 === "string"
+            ? digests.combined_sha256
+            : null,
+    };
 };
 const parseOutputArguments = (arguments_) => {
     let format = "toon";
@@ -234,28 +222,20 @@ const targetFreeEnvironment = (environment) => {
         delete result[name];
     return result;
 };
-const boundedStderr = () => {
-    let text = "";
+const captureStderr = () => {
+    const chunks = [];
     let bytes = 0;
-    let truncated = false;
     return {
         append(chunk) {
             const buffer = Buffer.isBuffer(chunk)
                 ? chunk
                 : Buffer.from(String(chunk), "utf8");
             bytes += buffer.byteLength;
-            const retained = Buffer.byteLength(text, "utf8");
-            if (retained < STDERR_LIMIT_BYTES)
-                text += buffer
-                    .subarray(0, STDERR_LIMIT_BYTES - retained)
-                    .toString("utf8");
-            if (bytes > STDERR_LIMIT_BYTES)
-                truncated = true;
+            chunks.push(Buffer.from(buffer));
         },
         value: () => ({
-            stderr: text,
+            stderr: Buffer.concat(chunks, bytes).toString("utf8"),
             stderr_bytes: bytes,
-            stderr_truncated: truncated,
         }),
     };
 };

package/dist/native/CommandRunner.js

@@ -14,17 +14,17 @@ export class NativeCommandFailure extends Error {
         this.exitCode = exitCode;
     }
 }
-/** Run allowlisted Xcode tools directly with bounded output and no shell. */
+/** Run allowlisted Xcode tools directly without a shell. */
 export class XcrunCommandRunner {
     resolveTool;
     #resolved = new Map();
-    constructor(resolveTool = (tool) => resolveXcrunTool(tool)) {
+    constructor(resolveTool = (tool, signal) => resolveXcrunTool(tool, signal)) {
         this.resolveTool = resolveTool;
     }
     run(tool, arguments_, options) {
         if (!ALLOWED_TOOLS.has(tool))
             return Promise.resolve(err(new NativeCommandFailure(tool, "unavailable")));
-        return this.#resolve(tool).then(async (resolved) => {
+        return this.#resolve(tool, options.signal).then(async (resolved) => {
             if (!resolved.ok)
                 return resolved;
             const captured = await captureProcess(resolved.value.path, arguments_, tool, options);
@@ -41,15 +41,13 @@ export class XcrunCommandRunner {
                 : captured;
         });
     }
-    async #resolve(tool) {
+    async #resolve(tool, signal) {
         const existing = this.#resolved.get(tool);
         if (existing !== undefined)
-            return existing;
-        const pending = this.resolveTool(tool);
-        this.#resolved.set(tool, pending);
-        const resolved = await pending;
-        if (!resolved.ok && this.#resolved.get(tool) === pending)
-            this.#resolved.delete(tool);
+            return ok(existing);
+        const resolved = await this.resolveTool(tool, signal);
+        if (resolved.ok)
+            this.#resolved.set(tool, resolved.value);
         return resolved;
     }
 }
@@ -66,9 +64,14 @@ const ALLOWED_TOOLS = new Set([
     "swift-demangle",
     "vtool",
 ]);
-const resolveXcrunTool = async (tool) => {
-    const found = await captureProcess("/usr/bin/xcrun", ["--find", tool], "xcrun", { timeoutMs: 5_000, maxOutputBytes: 64 * 1024 });
-    if (!found.ok || found.value.exitCode !== 0)
+const resolveXcrunTool = async (tool, signal) => {
+    const found = await captureProcess("/usr/bin/xcrun", ["--find", tool], "xcrun", signal === undefined ? {} : { signal });
+    if (!found.ok) {
+        if (found.error.reason === "cancelled")
+            return err(new NativeCommandFailure(tool, "cancelled"));
+        return err(new NativeCommandFailure(tool, "unavailable"));
+    }
+    if (found.value.exitCode !== 0)
         return err(new NativeCommandFailure(tool, "unavailable"));
     const candidate = found.value.stdout.trim();
     if (!candidate.startsWith("/"))
@@ -107,7 +110,6 @@ const captureProcess = (executable, arguments_, tool, options) => new Promise((r
         if (settled)
             return;
         settled = true;
-        clearTimeout(timeout);
         options.signal?.removeEventListener("abort", onAbort);
         resolve(result);
     };
@@ -117,20 +119,13 @@ const captureProcess = (executable, arguments_, tool, options) => new Promise((r
     };
     const onAbort = () => stop("cancelled");
     options.signal?.addEventListener("abort", onAbort, { once: true });
-    const timeout = setTimeout(() => stop("timeout"), options.timeoutMs);
     child.stdout.on("data", (chunk) => {
         stdoutBytes += chunk.length;
-        if (stdoutBytes + stderrBytes > options.maxOutputBytes)
-            stop("output-limit");
-        else
-            stdout.push(chunk);
+        stdout.push(chunk);
     });
     child.stderr.on("data", (chunk) => {
         stderrBytes += chunk.length;
-        if (stdoutBytes + stderrBytes > options.maxOutputBytes)
-            stop("output-limit");
-        else
-            stderr.push(chunk);
+        stderr.push(chunk);
     });
     child.once("error", (cause) => finish(err(new NativeCommandFailure(tool, "io", null, { cause }))));
     child.once("close", (code, signal) => {
@@ -147,8 +142,6 @@ const captureProcess = (executable, arguments_, tool, options) => new Promise((r
             stderr: Buffer.concat(stderr).toString("utf8"),
             stdoutBytes,
             stderrBytes,
-            stdoutTruncated: false,
-            stderrTruncated: false,
             exitCode: code,
             signal,
         }));

package/dist/native/NativeMacOSProvider.js

@@ -1,10 +1,10 @@
-import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
-import { realpath, stat } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { stat } from "node:fs/promises";
 import { parse as parseXmlPlist } from "plist";
 import { z } from "zod";
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
 import { NATIVE_TOOL_CONTRACTS, } from "../contracts/nativeToolContracts.js";
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, AnalysisTimeoutError, ProviderAdapterError, } from "../domain/errors.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, ProviderAdapterError, } from "../domain/errors.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { demangleSwiftSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, } from "../domain/nativeInspection.js";
 import { err, ok } from "../domain/result.js";
@@ -21,8 +21,6 @@ export const NATIVE_MACOS_PROVIDER_IDENTITY = Object.freeze({
     version: null,
 });
 const IDENTITY = NATIVE_MACOS_PROVIDER_IDENTITY;
-const TIMEOUT_MS = 30_000;
-const OUTPUT_LIMIT = 4 * 1024 * 1024;
 /** Read-only semantic provider composed from Xcode command-line utilities. */
 export class NativeMacOSProvider {
     runner;
@@ -41,11 +39,7 @@ export class NativeMacOSProvider {
             return Object.freeze({
                 provider: IDENTITY,
                 operation: contract.name,
-                inputContractVersion: 1,
-                outputContractVersion: 1,
                 ...availability,
-                pagination: "none",
-                exhaustive: contract.name !== "inspect_macho",
                 effects: Object.freeze({
                     mutatesArtifact: false,
                     launchesProcess: true,
@@ -55,11 +49,6 @@ export class NativeMacOSProvider {
                     changesPermissions: false,
                     requiresRoot: false,
                 }),
-                limits: Object.freeze({
-                    maxResults: contract.name === "demangle_swift" ? 500 : null,
-                    maxPayloadBytes: OUTPUT_LIMIT,
-                    timeoutMs: TIMEOUT_MS,
-                }),
                 limitations: Object.freeze([
                     "Availability and textual formats depend on the installed macOS/Xcode toolchain.",
                 ]),
@@ -199,9 +188,9 @@ class NativeMacOSClient {
         });
     }
     async #inspectPlist(parameters, signal) {
-        const requested = parameters.relative_path;
-        if (typeof requested !== "string")
-            return err(new AnalysisOutputError("inspect_plist", "relative_path was not a string"));
+        const requested = parameters.path;
+        if (requested !== undefined && typeof requested !== "string")
+            return err(new AnalysisOutputError("inspect_plist", "path was not a string"));
         const plist = await resolvePlistPath(this.target, requested);
         if (!plist.ok)
             return plist;
@@ -220,7 +209,7 @@ class NativeMacOSClient {
                     ? "xml"
                     : "unknown",
             ...parsed,
-            source_path: requested,
+            source_path: plist.value,
             provenance,
             limitations: [],
         });
@@ -228,7 +217,7 @@ class NativeMacOSClient {
             result: jsonValueSchema.parse(result),
             provenance,
             limitations: [],
-            locations: [{ kind: "artifact-path", path: requested }],
+            locations: [{ kind: "artifact-path", path: plist.value }],
         });
     }
     async #inspectMacho(signal) {
@@ -246,8 +235,6 @@ class NativeMacOSClient {
     async #run(operation, tool, arguments_, options = {}) {
         const captured = await this.runner.run(tool, arguments_, {
             ...(options.signal === undefined ? {} : { signal: options.signal }),
-            timeoutMs: TIMEOUT_MS,
-            maxOutputBytes: OUTPUT_LIMIT,
             acceptNonZero: options.acceptNonZero ?? false,
         });
         if (captured.ok)
@@ -261,8 +248,6 @@ const translateCommandFailure = (operation, failure) => {
         return new AnalysisCapabilityUnavailableError(IDENTITY.id, operation, `${failure.tool} is unavailable through xcrun.`);
     if (failure.reason === "cancelled")
         return new AnalysisCancelledError(operation);
-    if (failure.reason === "timeout")
-        return new AnalysisTimeoutError(operation, TIMEOUT_MS);
     return new ProviderAdapterError(IDENTITY.id, operation, { cause: failure });
 };
 const invocation = (capture, artifactPath, alias = "$ARTIFACT") => ({
@@ -277,8 +262,6 @@ const invocation = (capture, artifactPath, alias = "$ARTIFACT") => ({
     exit: { code: capture.exitCode, signal: capture.signal },
     stdout_bytes: capture.stdoutBytes,
     stderr_bytes: capture.stderrBytes,
-    stdout_truncated: capture.stdoutTruncated,
-    stderr_truncated: capture.stderrTruncated,
 });
 const parseEntitlements = (output) => {
     const start = output.indexOf("<?xml");
@@ -290,23 +273,15 @@ const parseEntitlements = (output) => {
 const resolvePlistPath = async (target, requested) => {
     try {
         const source = target.sourcePath ?? target.path;
+        if (requested !== undefined && isAbsolute(requested))
+            return ok(resolve(requested));
         const sourceMetadata = await stat(source);
         const root = sourceMetadata.isDirectory() ? source : dirname(target.path);
-        const candidate = resolve(root, requested);
-        if (!within(root, candidate))
-            return err(new ProviderAdapterError(IDENTITY.id, "inspect_plist"));
-        const canonicalRoot = await realpath(root);
-        const canonical = await realpath(candidate);
-        if (!within(canonicalRoot, canonical))
-            return err(new ProviderAdapterError(IDENTITY.id, "inspect_plist"));
-        return ok(canonical);
+        return ok(requested === undefined
+            ? resolve(root, "Contents/Info.plist")
+            : resolve(root, requested));
     }
     catch (cause) {
         return err(new ProviderAdapterError(IDENTITY.id, "inspect_plist", { cause }));
     }
 };
-const within = (root, candidate) => {
-    const child = relative(root, candidate);
-    return (child === "" ||
-        (!child.startsWith(`..${sep}`) && child !== ".." && !isAbsolute(child)));
-};

package/dist/native/NativeMachoInspection.js

@@ -15,7 +15,7 @@ const REQUIRED_COMMANDS = [
 ];
 const OPTIONAL_VTOOL_COMMAND = ["vtool", ["-show-build"]];
 const VTOOL_UNAVAILABLE_LIMITATION = "vtool is unavailable; build metadata is normalized from otool only.";
-/** Inspect one Mach-O with bounded native commands and normalized output. */
+/** Inspect one Mach-O with the required native commands and normalized output. */
 export const inspectNativeMacho = async (context) => {
     const captures = [];
     for (const [tool, prefix] of REQUIRED_COMMANDS) {

package/dist/process/BoundedFileBytes.js

@@ -0,0 +1,17 @@
+/** Read through EOF, returning undefined on overflow; consume at most maxBytes + 1 bytes without closing the handle. */
+export const readBoundedFileBytes = async (handle, maxBytes) => {
+    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));
+    let total = 0;
+    for (;;) {
+        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)));
+    }
+};

package/dist/process/ExecFileOutput.js

@@ -0,0 +1,11 @@
+import { execFile, } from "node:child_process";
+/** Run a shell-free command while capturing its complete UTF-8 output. */
+export const execFileOutput = (command, arguments_, options = {}) => new Promise((resolve, reject) => {
+    execFile(command, [...arguments_], { ...options, encoding: "utf8", maxBuffer: Number.POSITIVE_INFINITY }, (error, stdout, stderr) => {
+        if (error !== null) {
+            reject(error);
+            return;
+        }
+        resolve({ stdout, stderr });
+    });
+});

package/dist/process/PendingOperations.js

@@ -1,9 +1,8 @@
 /**
  * Correlates event-driven provider replies with bounded waits.
  *
- * The registry owns every request timer and abort listener. Settling, timing
- * out, cancelling, or failing an operation removes both before resolution, so
- * late protocol replies can be ignored without retaining request resources.
+ * The registry owns optional request timers and cancellation listeners.
+ * Settling, timing out, cancelling, or failing removes these before resolution.
  */
 export class PendingOperations {
     #pending = new Map();
@@ -15,7 +14,7 @@ export class PendingOperations {
     has(key) {
         return this.#pending.has(key);
     }
-    /** Register one unique operation key and start its bounded wait. */
+    /** Register one unique operation key and await its reply or cancellation. */
     wait(key, options) {
         if (this.#pending.has(key))
             throw new Error("Pending operation key is already registered");
@@ -25,7 +24,9 @@ export class PendingOperations {
             const onAbort = options.signal === undefined
                 ? undefined
                 : () => this.#finish(key, options.cancelledValue());
-            const timer = setTimeout(() => this.#finish(key, options.timeoutValue()), options.timeoutMs);
+            const timer = options.timeoutMs === undefined
+                ? undefined
+                : setTimeout(() => this.#finish(key, options.timeoutValue()), options.timeoutMs);
             this.#pending.set(key, {
                 resolve,
                 timer,
@@ -50,7 +51,8 @@ export class PendingOperations {
         if (pending === undefined)
             return false;
         this.#pending.delete(key);
-        clearTimeout(pending.timer);
+        if (pending.timer !== undefined)
+            clearTimeout(pending.timer);
         if (pending.signal !== undefined && pending.onAbort !== undefined)
             pending.signal.removeEventListener("abort", pending.onAbort);
         pending.resolve(value);

package/dist/process/ProcessOwnership.js

@@ -4,6 +4,7 @@ import { promisify } from "node:util";
 import { observeOwnedProcessGroupWithHost, observeOwnedProcessLineageWithHost, } from "./ProcessOwnershipObservation.js";
 import { launcherIdentityFailure } from "./ProcessOwnershipIdentity.js";
 import { descendantsOf, liveProcesses } from "./ProcessOwnershipProcessTree.js";
+import { execFileOutput } from "./ExecFileOutput.js";
 const execFileAsync = promisify(execFile);
 /**
  * Terminate one Windows process tree through the platform utility.
@@ -51,7 +52,7 @@ const systemHost = {
     async listProcesses() {
         if (process.platform === "win32")
             return [];
-        const { stdout } = await execFileAsync("ps", [
+        const { stdout } = await execFileOutput("ps", [
             "-axo",
             "pid=,ppid=,pgid=,stat=,command=",
         ]);
@@ -71,7 +72,7 @@ const systemHost = {
         if (process.platform === "linux") {
             return parseProcessEnvironment(await readFile(`/proc/${pid}/environ`, "utf8"));
         }
-        const { stdout } = await execFileAsync("ps", ["eww", "-p", String(pid)]);
+        const { stdout } = await execFileOutput("ps", ["eww", "-p", String(pid)]);
         const environment = {};
         for (const match of stdout.matchAll(/(?:^|\s)([A-Za-z_][A-Za-z0-9_]*)=([^\s]*)/gu)) {
             const name = match[1];

package/dist/process/ProcessOwnershipObservation.js

@@ -63,7 +63,6 @@ export const observeOwnedProcessLineageWithHost = async (ownership, host) => {
         status: "verified",
         observedAt: new Date().toISOString(),
         lineage: {
-            schemaVersion: 1,
             runId: ownership.runId,
             launcherPid: launcher.pid,
             launcherParentPid: launcher.parentPid,

package/dist/process/ProviderProcess.js

@@ -1,5 +1,4 @@
 import { spawn } from "node:child_process";
-const DEFAULT_OUTPUT_BYTES = 64 * 1024;
 const DEFAULT_TERMINATION_GRACE_MS = 250;
 const DEFAULT_KILL_GRACE_MS = 1_000;
 /**
@@ -47,8 +46,8 @@ export const spawnOwnedProviderProcess = async (options) => {
 export class ProviderProcessSupervisor {
     launch;
     #options;
-    #stdout;
-    #stderr;
+    #stdout = new ProcessOutputCapture();
+    #stderr = new ProcessOutputCapture();
     #exit = deferred();
     #onStdout = (chunk) => {
         this.#capture("stdout", this.#stdout, chunk);
@@ -71,11 +70,6 @@ export class ProviderProcessSupervisor {
     constructor(launch, options = {}) {
         this.launch = launch;
         this.#options = options;
-        const limit = options.maxOutputBytesPerStream ?? DEFAULT_OUTPUT_BYTES;
-        if (!Number.isSafeInteger(limit) || limit <= 0)
-            throw new RangeError("Provider output limit must be a positive integer");
-        this.#stdout = new BoundedByteCapture(limit);
-        this.#stderr = new BoundedByteCapture(limit);
         this.#attach(launch.process.stdout, "stdout");
         this.#attach(launch.process.stderr, "stderr");
         launch.process.once("exit", this.#onExit);
@@ -84,7 +78,7 @@ export class ProviderProcessSupervisor {
         if (launch.process.exitCode !== null || launch.process.signalCode !== null)
             this.#recordExit(launch.process.exitCode, launch.process.signalCode);
     }
-    /** Latest bounded output and exit observation. */
+    /** Latest complete output and exit observation. */
     snapshot() {
         return {
             stdout: this.#stdout.snapshot(),
@@ -203,7 +197,6 @@ export class ProviderProcessSupervisor {
             stream,
             bytes: bytes.byteLength,
             totalBytes: capture.bytes,
-            truncated: capture.truncated,
         });
     }
     #recordExit(code, signal) {
@@ -219,35 +212,21 @@ export class ProviderProcessSupervisor {
         });
     }
 }
-class BoundedByteCapture {
-    limit;
+class ProcessOutputCapture {
     #chunks = [];
     #bytes = 0;
-    #retainedBytes = 0;
-    constructor(limit) {
-        this.limit = limit;
-    }
     get bytes() {
         return this.#bytes;
     }
-    get truncated() {
-        return this.#bytes > this.#retainedBytes;
-    }
     append(chunk) {
         this.#bytes += chunk.byteLength;
-        const remaining = this.limit - this.#retainedBytes;
-        if (remaining <= 0)
-            return;
-        const retained = Buffer.from(chunk.subarray(0, remaining));
-        this.#chunks.push(retained);
-        this.#retainedBytes += retained.byteLength;
+        this.#chunks.push(Buffer.from(chunk));
     }
     snapshot() {
+        const text = Buffer.concat(this.#chunks, this.#bytes).toString("utf8");
         return {
-            text: Buffer.concat(this.#chunks, this.#retainedBytes).toString("utf8"),
+            text,
             bytes: this.#bytes,
-            retainedBytes: this.#retainedBytes,
-            truncated: this.truncated,
         };
     }
 }

package/dist/reference/ReferenceSourceReader.js

@@ -1,61 +1,45 @@
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 import { err, ok } from "../domain/result.js";
 import { traverseDirectory } from "./ReferenceSourceReaderEntries.js";
-import { compareNames } from "./ReferenceSourceReaderPaths.js";
 import {} from "./ReferenceSourceReaderTypes.js";
 import { isAborted, noFollowOpenSupported, prepareRoot, } from "./ReferenceSourceReaderValidate.js";
-const DEFAULT_LIMITS = {
-    maxBytes: 16 * 1024 * 1024,
-    maxEntries: 10_000,
-    maxDepth: 32,
-    maxPathBytes: 4_096,
-};
 const PATH_RACE_LIMITATION = "Path identity is revalidated around operations; Node lacks portable descriptor-relative openat traversal, so a syscall-boundary pathname race remains.";
-/** Read a bounded source tree without intentionally following symbolic links. */
-export const readReferenceSource = async (root, limits = DEFAULT_LIMITS, options = {}) => {
+/** Read a source tree without intentionally following symbolic links. */
+export const readReferenceSource = async (root, options = {}) => {
     if (!noFollowOpenSupported())
         return err({
             tag: "reference-source-reader",
             code: "unsupported",
             message: "Safe no-follow file opens are unavailable",
         });
-    const prepared = await prepareRoot(root, limits, options.signal);
+    const prepared = await prepareRoot(root, options.signal);
     if (!prepared.ok)
         return prepared;
     const { canonicalRoot, rootIdentity } = prepared.value;
     const state = {
         root: canonicalRoot,
         rootIdentity,
-        limits,
         ...(options.signal === undefined ? {} : { signal: options.signal }),
         ...(options.shouldExclude === undefined
             ? {}
             : { shouldExclude: options.shouldExclude }),
         entries: [],
-        pending: [{ path: canonicalRoot, depth: 0 }],
+        pending: [{ path: canonicalRoot }],
         bytesRead: 0,
-        filesSeen: 0,
-        truncated: false,
-        stopReason: undefined,
     };
     const traversal = await traverse(state);
     if (!traversal.ok)
         return traversal;
-    state.entries.sort((left, right) => compareNames(left.path, right.path));
+    state.entries.sort((left, right) => compareUnicodeCodePoints(left.path, right.path));
     return ok({
         root: canonicalRoot,
         entries: state.entries,
         bytesRead: state.bytesRead,
-        truncated: state.truncated,
-        limitations: [
-            PATH_RACE_LIMITATION,
-            ...(state.stopReason === "entry-limit"
-                ? ["Traversal stopped because the entry limit was reached."]
-                : []),
-        ],
+        limitations: [PATH_RACE_LIMITATION],
     });
 };
 const traverse = async (state) => {
-    while (state.pending.length > 0 && state.stopReason === undefined) {
+    while (state.pending.length > 0) {
         if (isAborted(state.signal))
             return err({
                 tag: "reference-source-reader",