rea-agents 4.0.0 → 4.1.0

package/dist/ida/IdaWorkspace.js

@@ -0,0 +1,54 @@
+import { createHash, randomUUID } from "node:crypto";
+import { createReadStream, constants } from "node:fs";
+import { copyFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join, normalize } from "node:path";
+import { AnalysisProtocolError } from "../domain/analysisErrorCore.js";
+import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
+/** Read a file digest with bounded memory rather than retaining binary bytes. */
+export const idaFileDigest = async (path) => {
+    const hash = createHash("sha256");
+    for await (const chunk of createReadStream(path))
+        hash.update(chunk);
+    return hash.digest("hex");
+};
+/** Compare host-local paths without confusing Windows paths with POSIX coordinates. */
+export const sameIdaHostPath = (left, right) => process.platform === "win32"
+    ? normalize(left).toLowerCase() === normalize(right).toLowerCase()
+    : normalize(left) === normalize(right);
+/** Private input copy isolates upstream database and sidecar writes from the original. */
+export class IdaWorkspace {
+    runtime;
+    inputPath;
+    sessionId = `rea-${randomUUID()}`;
+    constructor(runtime, inputPath) {
+        this.runtime = runtime;
+        this.inputPath = inputPath;
+    }
+    /** Filesystem root owned exclusively by this headless session. */
+    get directory() {
+        return this.runtime.path;
+    }
+    /** Allocate a protected workspace and copy the admitted input with digest verification. */
+    static async create(target, root = tmpdir()) {
+        const runtime = await PrivateRuntimeRoot.create({
+            parent: normalize(root),
+            prefix: "rea-ida-",
+        });
+        const inputPath = join(runtime.path, basename(target.path));
+        try {
+            await copyFile(target.path, inputPath, constants.COPYFILE_EXCL);
+            if ((await idaFileDigest(inputPath)) !== target.sha256)
+                throw new AnalysisProtocolError("IDA target changed between admission and the private input copy; reopen the target.");
+            return new IdaWorkspace(runtime, inputPath);
+        }
+        catch (cause) {
+            await runtime.close();
+            throw cause;
+        }
+    }
+    /** Delete only this object's privately allocated directory after worker cleanup. */
+    async remove() {
+        await this.runtime.close();
+    }
+}

package/dist/main/shutdown.js

@@ -13,7 +13,8 @@ export const createShutdown = (input) => {
         return shutdownPromise;
     };
     const requestShutdown = () => {
-        shutdown().catch(() => {
+        shutdown().catch((cause) => {
+            serverLogger.debug({ failure_cause: describeShutdownFailure(cause) }, "MCP shutdown rejected");
             dependencies.setExitCode(1);
             serverLogger.error(MCP_SHUTDOWN_FAILED);
             dependencies.writeStderr(`${MCP_SHUTDOWN_FAILED}\n`);
@@ -22,3 +23,22 @@ export const createShutdown = (input) => {
     unregisterShutdown = dependencies.registerShutdown(requestShutdown);
     return { shutdown, request: requestShutdown };
 };
+const describeShutdownFailure = (cause) => {
+    if (cause instanceof Error) {
+        const code = "code" in cause ? cause.code : undefined;
+        return {
+            name: cause.name,
+            message: cause.message,
+            ...(typeof code === "string" ||
+                (typeof code === "number" && Number.isFinite(code))
+                ? { code }
+                : {}),
+        };
+    }
+    if (cause === null ||
+        typeof cause === "string" ||
+        typeof cause === "boolean" ||
+        (typeof cause === "number" && Number.isFinite(cause)))
+        return { type: cause === null ? "null" : typeof cause, value: cause };
+    return { type: typeof cause };
+};

package/dist/main/startup.js

@@ -1,4 +1,4 @@
-import { projectAnalysisError } from "../domain/errors.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 export const openInitialTarget = async (session, config, serverLogger, writeStderr) => {
     if (config.hopperTargetPath === undefined)
         return { ok: true };

package/dist/main/transport.js

@@ -6,8 +6,10 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
     try {
         optionalProviders = await serverContext.loadOptionalProviders();
     }
-    catch {
-        serverLogger.warn("Optional MCP providers could not load; affected tools remain unavailable");
+    catch (cause) {
+        serverLogger.warn({
+            error: cause instanceof Error ? cause.message : String(cause),
+        }, "Optional MCP providers could not load; affected tools remain unavailable");
     }
     let handle;
     try {
@@ -21,9 +23,11 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
             },
         });
     }
-    catch {
+    catch (cause) {
         await session.close();
-        serverLogger.error(MCP_CONNECTION_START_FAILED);
+        serverLogger.error({
+            error: cause instanceof Error ? cause.message : String(cause),
+        }, MCP_CONNECTION_START_FAILED);
         dependencies.writeStderr(`${MCP_CONNECTION_START_FAILED}\n`);
         return { ok: false };
     }

package/dist/main.js

@@ -5,7 +5,7 @@ import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { parseConfig } from "./config.js";
 import { createBinarySession } from "./application/runtime.js";
 import { createLogger } from "./logger.js";
-import { projectAnalysisError } from "./domain/errors.js";
+import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 import { SERVER_START_FAILED } from "./main/messages.js";
 import { createRuntimeState } from "./main/state.js";
 import { openInitialTarget } from "./main/startup.js";
@@ -98,7 +98,10 @@ export const runEntrypoint = async (start = () => run(), writeStderr = (text) =>
     try {
         setExitCode(await start());
     }
-    catch {
+    catch (cause) {
+        // Intentionally redact the startup cause from caller-visible output;
+        // unexpected failures must not leak internal details.
+        void cause;
         writeStderr(`${SERVER_START_FAILED}\n`);
         setExitCode(1);
     }

package/dist/native/AppleDispatchMetadata.js

@@ -2,7 +2,8 @@ import { createHash } from "node:crypto";
 import { open } from "node:fs/promises";
 import { constants } from "node:fs";
 import { objcSwiftMetadataSchema, nativeDispatchMetadataResultSchema, } from "../domain/objcSwiftMetadata.js";
-import { AnalysisCancelledError, EvidenceIntegrityError, } from "../domain/errors.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
 import { decodeSwiftClassVtables } from "./AppleSwiftVtables.js";
 import { createObjcProtocolReader } from "./AppleObjcProtocols.js";
 const hex = (value) => `0x${value.toString(16)}`;
@@ -125,8 +126,9 @@ export const decodeAppleDispatchMetadata = (bytes, maxRecords, provenance, archi
                 try {
                     fileOffset = offset(target);
                 }
-                catch {
-                    /* serialized target remains unresolved */
+                catch (cause) {
+                    // best-effort cleanup: serialized target remains unresolved.
+                    void cause;
                 }
                 if (admit())
                     result.relative_pointers.push({
@@ -154,8 +156,9 @@ export const decodeAppleDispatchMetadata = (bytes, maxRecords, provenance, archi
                     throw new RangeError("Method implementation is not in an executable segment");
                 implementationLocation = location(implementation);
             }
-            catch {
-                /* external/chained pointers remain unresolved */
+            catch (cause) {
+                // best-effort cleanup: external/chained pointers remain unresolved.
+                void cause;
             }
             result.objc_dispatch_implementations.push({
                 class_name: className,
@@ -213,7 +216,9 @@ export const decodeAppleDispatchMetadata = (bytes, maxRecords, provenance, archi
             try {
                 superclassName = string(pointer((pointer(superclass + 32n) & ~7n) + 24n));
             }
-            catch {
+            catch (cause) {
+                // Superclass resolution failure is recorded; the cause adds no identity.
+                void cause;
                 failures.push(`Superclass pointer ${hex(superclass)} of ${name} requires unsupported binding/fixup resolution`);
             }
         }
@@ -235,7 +240,9 @@ export const decodeAppleDispatchMetadata = (bytes, maxRecords, provenance, archi
                 try {
                     value = u32(encodedOffset);
                 }
-                catch {
+                catch (cause) {
+                    // Unresolved offsets are recorded; the cause adds no identity.
+                    void cause;
                     failures.push(`Unresolved ivar offset pointer ${hex(encodedOffset)}`);
                 }
                 result.objc_ivars.push({
@@ -538,10 +545,10 @@ export const inspectAppleDispatchMetadata = async (target, maxRecords, signal) =
 };
 const selectMachoSlice = (bytes, architecture) => {
     const magic = bytes.readUInt32BE(0);
-    const littleEndian = magic === 0xbebafeca || magic === 0xbfbafeca;
-    if (magic !== 0xcafebabe && magic !== 0xcafebabf && !littleEndian)
+    const header = fatHeaderFormat(magic);
+    if (header === null)
         return { slice: 0, sliceEnd: bytes.length };
-    const fat64 = magic === 0xcafebabf || magic === 0xbfbafeca;
+    const { littleEndian, fat64 } = header;
     const stride = fat64 ? 32 : 20;
     const readUInt32 = littleEndian
         ? (offset) => bytes.readUInt32LE(offset)
@@ -580,3 +587,17 @@ const selectMachoSlice = (bytes, architecture) => {
         throw invalid("Requested FAT architecture is absent");
     return selected;
 };
+const fatHeaderFormat = (magic) => {
+    switch (magic) {
+        case 0xcafebabe:
+            return { littleEndian: false, fat64: false };
+        case 0xcafebabf:
+            return { littleEndian: false, fat64: true };
+        case 0xbebafeca:
+            return { littleEndian: true, fat64: false };
+        case 0xbfbafeca:
+            return { littleEndian: true, fat64: true };
+        default:
+            return null;
+    }
+};

package/dist/native/NativeMacOSProvider.js

@@ -6,7 +6,9 @@ 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, ProviderAdapterError, AnalysisError, } from "../domain/errors.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { demangleSwiftSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, } from "../domain/nativeInspection.js";
 import { err, ok } from "../domain/result.js";
@@ -209,28 +211,45 @@ class NativeMacOSClient {
         const display = await this.#run("inspect_signature", "codesign", ["-d", "--verbose=4", this.target.path], { signal, acceptNonZero: true });
         if (!display.ok)
             return display;
-        const unsigned = /not signed at all|code object is not signed/iu.test(`${display.value.stdout}\n${display.value.stderr}`);
-        if (!unsigned && display.value.exitCode !== 0)
-            return err(translateCommandFailure("inspect_signature", new NativeCommandFailure("codesign", "nonzero-exit", display.value.exitCode)));
-        const requirements = await this.#run("inspect_signature", "codesign", ["-d", "-r-", this.target.path], { signal, acceptNonZero: unsigned });
+        const displayOutput = commandOutput(display.value);
+        const unsigned = isUnsignedCodeSignObservation(display.value);
+        const displayFailure = codeSignCaptureFailure(display.value);
+        if (displayFailure !== null)
+            return err(displayFailure);
+        const requirements = await this.#run("inspect_signature", "codesign", ["-d", "-r-", this.target.path], { signal, acceptNonZero: true });
         if (!requirements.ok)
             return requirements;
-        const entitlements = await this.#run("inspect_signature", "codesign", ["-d", "--entitlements", ":-", this.target.path], { signal, acceptNonZero: unsigned });
+        const requirementsFailure = codeSignCaptureFailure(requirements.value);
+        if (requirementsFailure !== null)
+            return err(requirementsFailure);
+        const entitlements = await this.#run("inspect_signature", "codesign", ["-d", "--entitlements", ":-", this.target.path], { signal, acceptNonZero: true });
         if (!entitlements.ok)
             return entitlements;
-        const parsed = parseCodeSignature(`${display.value.stdout}\n${display.value.stderr}`, unsigned);
-        const requirementText = /designated\s*=>\s*(.+)$/mu.exec(`${requirements.value.stdout}\n${requirements.value.stderr}`)?.[1] ?? null;
-        const entitlementValue = parseEntitlements(`${entitlements.value.stdout}\n${entitlements.value.stderr}`);
-        const provenance = [
-            display.value,
-            requirements.value,
-            entitlements.value,
-        ].map((capture) => invocation(capture, this.target.path));
+        const entitlementsFailure = codeSignCaptureFailure(entitlements.value);
+        if (entitlementsFailure !== null)
+            return err(entitlementsFailure);
+        const parsed = parseCodeSignature(displayOutput, unsigned);
+        const requirementText = /designated\s*=>\s*(.+)$/mu.exec(commandOutput(requirements.value))?.[1] ?? null;
+        const entitlementValue = parseEntitlements(commandOutput(entitlements.value));
+        const captures = [display.value, requirements.value, entitlements.value];
+        const limitations = [...parsed.limitations];
+        const mixedSigning = !unsigned &&
+            (isNonzeroUnsignedObservation(requirements.value) ||
+                isNonzeroUnsignedObservation(entitlements.value));
+        if (mixedSigning) {
+            const slices = await this.#inspectMixedSignatureSlices(displayOutput, requirements.value.exitCode !== 0, entitlements.value.exitCode !== 0, signal);
+            if (!slices.ok)
+                return slices;
+            captures.push(...slices.value.captures);
+            limitations.push(...slices.value.limitations);
+        }
+        const provenance = captures.map((capture) => invocation(capture, this.target.path));
         const result = inspectSignatureSchema.parse({
             ...parsed,
             designated_requirement: requirementText,
             entitlements: entitlementValue,
             provenance,
+            limitations,
         });
         return ok({
             result: jsonValueSchema.parse(result),
@@ -239,6 +258,35 @@ class NativeMacOSClient {
             locations: [],
         });
     }
+    async #inspectMixedSignatureSlices(displayOutput, requirementsUnavailable, entitlementsUnavailable, signal) {
+        const captures = [];
+        const unsigned = [];
+        const unclassified = [];
+        for (const architecture of codeSignArchitectures(displayOutput, this.target)) {
+            const slice = await this.#run("inspect_signature", "codesign", ["-d", "-a", architecture, "--verbose=4", this.target.path], { signal, acceptNonZero: true });
+            if (!slice.ok)
+                return slice;
+            captures.push(slice.value);
+            if (slice.value.exitCode === 0)
+                continue;
+            if (isNonzeroUnsignedObservation(slice.value))
+                unsigned.push(architecture);
+            else
+                unclassified.push(architecture);
+        }
+        const limitations = [
+            unsigned.length > 0
+                ? `Unsigned Mach-O slices: ${unsigned.join(", ")}.`
+                : "One or more Mach-O slices are unsigned, but their architectures could not be classified.",
+        ];
+        if (unclassified.length > 0)
+            limitations.push(`Signature state could not be classified for Mach-O slices: ${unclassified.join(", ")}.`);
+        if (requirementsUnavailable)
+            limitations.push("The aggregate designated requirement is unavailable because Mach-O slices have mixed signing states.");
+        if (entitlementsUnavailable)
+            limitations.push("The aggregate entitlements are unavailable because Mach-O slices have mixed signing states.");
+        return ok({ captures, limitations });
+    }
     async #inspectPlist(parameters, signal) {
         const requested = parameters.path;
         if (requested !== undefined && typeof requested !== "string")
@@ -253,6 +301,8 @@ class NativeMacOSClient {
         if (!capture.ok)
             return capture;
         const parsed = parsePlistJson(capture.value.stdout);
+        if (!parsed.ok)
+            return parsed;
         const provenance = [classified.value, capture.value].map((item) => invocation(item, plist.value, "$PLIST"));
         const result = inspectPlistSchema.parse({
             format: /binary property list/iu.test(classified.value.stdout)
@@ -260,7 +310,7 @@ class NativeMacOSClient {
                 : /XML|text/iu.test(classified.value.stdout)
                     ? "xml"
                     : "unknown",
-            ...parsed,
+            ...parsed.value,
             source_path: plist.value,
             provenance,
             limitations: [],
@@ -302,6 +352,28 @@ const translateCommandFailure = (operation, failure) => {
         return new AnalysisCancelledError(operation);
     return new ProviderAdapterError(IDENTITY.id, operation, { cause: failure });
 };
+const translateCodeSignExitFailure = (capture) => translateCommandFailure("inspect_signature", new NativeCommandFailure("codesign", "nonzero-exit", capture.exitCode));
+const commandOutput = (capture) => `${capture.stdout}\n${capture.stderr}`;
+const isUnsignedCodeSignObservation = (capture) => /not signed at all|code object is not signed/iu.test(commandOutput(capture));
+const isNonzeroUnsignedObservation = (capture) => capture.exitCode !== null &&
+    capture.exitCode !== 0 &&
+    isUnsignedCodeSignObservation(capture);
+const codeSignCaptureFailure = (capture) => capture.exitCode === 0 || isNonzeroUnsignedObservation(capture)
+    ? null
+    : translateCodeSignExitFailure(capture);
+const codeSignArchitectures = (displayOutput, target) => {
+    const universal = /^Format=Mach-O universal \(([^)\r\n]+)\)$/mu.exec(displayOutput)?.[1];
+    if (universal !== undefined) {
+        const architectures = universal
+            .split(/\s+/u)
+            .filter((architecture) => /^(?:i386|x86_64|armv7|arm64|arm64e)$/u.test(architecture));
+        if (architectures.length > 0)
+            return [...new Set(architectures)];
+    }
+    if (target.kind !== "executable" || target.format !== "mach-o")
+        return [];
+    return target.availableArchitectures.map((architecture) => architecture === "x86" ? "i386" : architecture);
+};
 const invocation = (capture, artifactPath, alias = "$ARTIFACT") => ({
     tool: capture.tool,
     command: [

package/dist/native/NativeMachoInspection.js

@@ -4,9 +4,11 @@ import { err, ok } from "../domain/result.js";
 import { parseDyldSymbols } from "./parsers/dyldInfo.js";
 import { parseLipoArchitectures } from "./parsers/lipo.js";
 import { parseOtoolLoadCommands } from "./parsers/otool.js";
-const REQUIRED_COMMANDS = [
+const DISCOVERY_COMMANDS = [
     ["file", ["-b"]],
     ["lipo", ["-detailed_info"]],
+];
+const REQUIRED_SLICE_COMMANDS = [
     ["otool", ["-h", "-l"]],
     ["nm", ["-gjU"]],
     ["dyld_info", ["-imports"]],
@@ -18,10 +20,20 @@ const VTOOL_UNAVAILABLE_LIMITATION = "vtool is unavailable; build metadata is no
 /** 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) {
+    for (const [tool, prefix] of DISCOVERY_COMMANDS) {
+        const captured = await context.run(tool, [...prefix, context.target.path], context.signal);
+        if (!captured.ok)
+            return err(captured.error);
+        captures.push(captured.value);
+    }
+    const lipo = captures.find(({ tool }) => tool === "lipo");
+    if (lipo === undefined)
+        throw new TypeError("Missing lipo capture");
+    const selectedArchitecture = selectArchitecture(context.target, parseLipoArchitectures(lipo.stdout).map(({ name }) => name));
+    for (const [tool, prefix] of REQUIRED_SLICE_COMMANDS) {
         const captured = await context.run(tool, [
             ...prefix,
-            ...selectedArchitectureArguments(tool, context.target),
+            ...selectedArchitectureArguments(tool, selectedArchitecture),
             context.target.path,
         ], context.signal);
         if (!captured.ok)
@@ -32,7 +44,7 @@ export const inspectNativeMacho = async (context) => {
     const [tool, prefix] = OPTIONAL_VTOOL_COMMAND;
     const optional = await context.run(tool, [
         ...prefix,
-        ...selectedArchitectureArguments(tool, context.target),
+        ...selectedArchitectureArguments(tool, selectedArchitecture),
         context.target.path,
     ], context.signal);
     if (optional.ok)
@@ -170,14 +182,32 @@ export const architectureLocations = (architectures) => {
     }
     return locations;
 };
-const selectedArchitectureArguments = (tool, target) => {
-    if (target.kind !== "executable" ||
-        target.availableArchitectures.length < 2 ||
-        tool === "file" ||
-        tool === "lipo")
+const selectedArchitectureArguments = (tool, architecture) => {
+    if (architecture === null)
         return [];
-    const architecture = target.architecture === "x86" ? "i386" : target.architecture;
+    const baseArchitecture = architecture.split(".")[0] ?? architecture;
+    // dyld_info distinguishes arm64e ABI variants; the other Apple tools use
+    // the base CPU-family spelling for the same slice.
+    const toolArchitecture = tool === "dyld_info" ? architecture : baseArchitecture;
     return tool === "dwarfdump"
-        ? [`--arch=${architecture}`]
-        : ["-arch", architecture];
+        ? [`--arch=${toolArchitecture}`]
+        : ["-arch", toolArchitecture];
+};
+const selectArchitecture = (target, available) => {
+    if (target.kind !== "executable" || target.availableArchitectures.length < 2)
+        return null;
+    const normalized = target.architecture === "x86" ? "i386" : target.architecture;
+    if (available.includes(normalized))
+        return normalized;
+    // BinaryTarget intentionally normalizes ARM64 CPU subtypes. Recover the
+    // concrete arm64e slice name from lipo before invoking slice-aware tools.
+    if (normalized === "arm64") {
+        const arm64e = available.find((architecture) => architecture === "arm64e");
+        if (arm64e !== undefined)
+            return arm64e;
+        const variant = available.find((architecture) => /^arm64e\.[A-Za-z0-9_]+$/u.test(architecture));
+        if (variant !== undefined)
+            return variant;
+    }
+    return normalized;
 };

package/dist/native/NativeUiHelperRuntime.js

@@ -3,6 +3,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { execFileOutput } from "../process/ExecFileOutput.js";
+import { safeParseJson } from "../domain/safeJson.js";
 /** Lazily compile one owned helper per observation/scenario and remove its compiler cache. */
 export const createNativeUiHelperRuntime = () => {
     let root;
@@ -30,7 +31,12 @@ export const createNativeUiHelperRuntime = () => {
             maxBuffer: 16 * 1024 * 1024,
             ...(signal === undefined ? {} : { signal }),
         });
-        return JSON.parse(output.stdout);
+        const parsed = safeParseJson(output.stdout);
+        if (!parsed.ok)
+            throw new Error(`Native helper returned invalid JSON: ${parsed.error}`, {
+                cause: parsed.cause,
+            });
+        return parsed.value;
     };
     return {
         invoke,

package/dist/native/NativeUiObservation.js

@@ -1,7 +1,9 @@
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import { nativeUiObservationInputSchema, nativeUiScenarioInputSchema, nativeUiSnapshotSchema, nativeUiResultSchema, } from "../domain/nativeUiObservation.js";
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, ProviderAdapterError, } from "../domain/errors.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../domain/analysisErrorCore.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import {} from "../domain/analysisErrorBase.js";
 import { err, ok } from "../domain/result.js";
 import { createNativeUiHelperRuntime } from "./NativeUiHelperRuntime.js";
 const helper = fileURLToPath(new URL("../../bridge/native/ReaNativeUI.swift", import.meta.url));
@@ -122,7 +124,9 @@ const observeWithHelper = async (target, operation, parameters, options) => {
                         abort();
                 });
             }
-            catch {
+            catch (cause) {
+                // Cancellation is recorded as a cancelled outcome.
+                void cause;
                 results.push({
                     index,
                     kind: step.kind,

package/dist/native/parsers/demangle.js

@@ -6,7 +6,7 @@ const resultSchema = z.object({
 });
 /** Preserve input ordering while parsing `swift-demangle --compact` lines. */
 export const parseDemangledSymbols = (inputs, output) => {
-    const lines = output.trimEnd().split(/\r?\n/u);
+    const lines = output.replace(/\r?\n$/u, "").split(/\r?\n/u);
     if (lines.length !== inputs.length)
         throw new TypeError("swift-demangle output count does not match input");
     return inputs.map((input, index) => {

package/dist/native/parsers/dyldInfo.js

@@ -4,7 +4,7 @@ export const parseDyldSymbols = (output, mode, imageBase = null) => {
     return output.split(/\r?\n/u).flatMap((rawLine) => {
         const line = rawLine.trim();
         if (mode === "imports") {
-            const imported = /^(?:0x[\da-f]+\s+)?(\S+)(?:\s+\[([^\]]+)\])?\s+\(from (.+)\)$/iu.exec(line);
+            const imported = /^(?:0x[\da-f]+\s+)?(.+?)(?:\s+\[([^\]]+)\])?\s+\(from (.+)\)$/iu.exec(line);
             if (imported?.[1] !== undefined)
                 return [
                     {
@@ -17,7 +17,7 @@ export const parseDyldSymbols = (output, mode, imageBase = null) => {
                 ];
             return [];
         }
-        const reexport = /^\[re-export\]\s+(\S+)(?:\s+\(from (.+)\))?$/u.exec(line);
+        const reexport = /^\[re-export\]\s+(.+?)(?:\s+\(from (.+)\))?$/u.exec(line);
         if (reexport?.[1] !== undefined)
             return [
                 {
@@ -28,7 +28,7 @@ export const parseDyldSymbols = (output, mode, imageBase = null) => {
                     source: reexport[2] ?? null,
                 },
             ];
-        const exported = /^(0x[\da-f]+)\s+(\S+)(?:\s+\[([^\]]+)\])?$/iu.exec(line);
+        const exported = /^(0x[\da-f]+)\s+(.+?)(?:\s+\[([^\]]+)\])?$/iu.exec(line);
         if (exported?.[1] === undefined || exported[2] === undefined)
             return [];
         const absolute = /\babsolute\b/u.test(exported[3] ?? "");

package/dist/native/parsers/otool.js

@@ -137,7 +137,10 @@ const parseFields = (block) => {
         if (match?.[1] === undefined || match[2] === undefined)
             continue;
         const value = match[2].trim();
-        fields[match[1]] = numeric(value) ?? value;
+        fields[match[1]] =
+            match[1] === "segname" || match[1] === "sectname"
+                ? value
+                : (numeric(value) ?? value);
     }
     return fields;
 };

package/dist/native/parsers/plist.js

@@ -1,9 +1,17 @@
 import { z } from "zod";
+import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
+import { err, ok } from "../../domain/result.js";
+import { safeParseJson } from "../../domain/safeJson.js";
 const plistObject = z.record(z.string(), z.unknown());
 /** Parse plutil JSON output and project stable bundle metadata. */
 export const parsePlistJson = (output) => {
     // plutil output can carry a UTF-8 BOM, which JSON.parse rejects outright.
-    const value = JSON.parse(output.replace(/^\uFEFF/u, ""));
+    const parsed = safeParseJson(output.replace(/^\uFEFF/u, ""));
+    if (!parsed.ok)
+        return err(new AnalysisOutputError("inspect_plist", parsed.error, {
+            cause: parsed.cause,
+        }));
+    const value = parsed.value;
     const object = plistObject.safeParse(value);
     const field = (name) => {
         if (!object.success)
@@ -11,7 +19,7 @@ export const parsePlistJson = (output) => {
         const candidate = object.data[name];
         return typeof candidate === "string" ? candidate : null;
     };
-    return {
+    return ok({
         value,
         bundle: {
             identifier: field("CFBundleIdentifier"),
@@ -20,5 +28,5 @@ export const parsePlistJson = (output) => {
             version: field("CFBundleVersion"),
             short_version: field("CFBundleShortVersionString"),
         },
-    };
+    });
 };

package/dist/process/PrivateRuntimeRoot.js

@@ -1,6 +1,7 @@
 import { chmod, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { WindowsPrivateRuntime } from "../windows/WindowsPrivateRuntime.js";
 import { windowsNativeCapabilities, } from "./WindowsAuthority.js";
 /** Report whether this process can establish a private runtime root. */
 export const privateRuntimeRootCapability = (platform = process.platform) => platform === "win32"
@@ -15,7 +16,7 @@ export class PrivateRuntimeRootUnavailableError extends Error {
     }
 }
 /**
- * Owns one POSIX mode-0700 temporary runtime root and removes it idempotently.
+ * Owns a private temporary runtime root and removes it idempotently.
  *
  * Protocol adapters decide what belongs inside the directory; this primitive
  * establishes a private filesystem boundary on POSIX and deterministic cleanup.
@@ -23,9 +24,11 @@ export class PrivateRuntimeRootUnavailableError extends Error {
  */
 export class PrivateRuntimeRoot {
     path;
+    windowsRuntime;
     #closePromise;
-    constructor(path) {
+    constructor(path, windowsRuntime) {
         this.path = path;
+        this.windowsRuntime = windowsRuntime;
     }
     /** Allocate a new private runtime root without performing protocol work. */
     static async create(options = {}) {
@@ -33,6 +36,10 @@ export class PrivateRuntimeRoot {
         const capability = privateRuntimeRootCapability(platform);
         if (!capability.available)
             throw new PrivateRuntimeRootUnavailableError(capability.reason);
+        if (platform === "win32") {
+            const runtime = WindowsPrivateRuntime.create(options.parent ?? tmpdir(), options.prefix ?? "rea-provider-");
+            return new PrivateRuntimeRoot(runtime.observation.path, runtime);
+        }
         const path = await mkdtemp(join(options.parent ?? tmpdir(), options.prefix ?? "rea-provider-"));
         try {
             await chmod(path, 0o700);
@@ -45,7 +52,10 @@ export class PrivateRuntimeRoot {
     }
     /** Remove the runtime root; concurrent and repeated callers share cleanup. */
     close() {
-        this.#closePromise ??= rm(this.path, { recursive: true, force: true });
+        this.#closePromise ??=
+            this.windowsRuntime === undefined
+                ? rm(this.path, { recursive: true, force: true })
+                : Promise.resolve().then(() => this.windowsRuntime?.close());
         return this.#closePromise;
     }
 }