rea-agents 4.1.0 → 6.0.0

package/dist/application/javascript/JavaScriptSemanticGraphProjection.js

@@ -0,0 +1,144 @@
+import { compareCodePoints } from "../../domain/canonicalOrdering.js";
+import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES } from "../../domain/javascript/javascriptSemanticGraphSchemas.js";
+/** Index one immutable file IR; read retained callable membership at query time. */
+export const createSemanticCallableOwnerLookup = (ir, nodes) => {
+    const entries = ir.callables
+        .map((callable, order) => ({
+        callableId: callable.callableId,
+        range: callable.location,
+        order,
+        priority: positionKey(callable.location),
+    }))
+        .sort((left, right) => pointCompare(left.range.start, right.range.start) ||
+        left.order - right.order);
+    const tree = buildSourceIntervalTree(entries, 0, entries.length);
+    return (location) => {
+        if (location === null || tree === null || nodes.size === 0)
+            return undefined;
+        const pending = [tree];
+        let best;
+        let result;
+        while (pending.length > 0) {
+            const current = pending.pop();
+            if (current === undefined ||
+                pointCompare(current.minimumStart, location.start) > 0 ||
+                pointCompare(current.maximumEnd, location.end) < 0)
+                continue;
+            const candidate = current.entry;
+            if (contains(candidate.range, location)) {
+                const node = nodes.get(candidate.callableId);
+                const rank = best === undefined
+                    ? 1
+                    : compareCodePoints(candidate.priority, best.priority) ||
+                        best.order - candidate.order;
+                if (node !== undefined && rank > 0) {
+                    best = candidate;
+                    result = node;
+                }
+            }
+            if (current.left !== null)
+                pending.push(current.left);
+            if (current.right !== null)
+                pending.push(current.right);
+        }
+        return result;
+    };
+};
+const buildSourceIntervalTree = (entries, start, end) => {
+    if (start >= end)
+        return null;
+    const middle = Math.floor((start + end) / 2);
+    const entry = entries[middle];
+    if (entry === undefined)
+        return null;
+    // This recursion follows a balanced index, not the producer's nesting depth.
+    const left = buildSourceIntervalTree(entries, start, middle);
+    const right = buildSourceIntervalTree(entries, middle + 1, end);
+    let minimumEnd = entry.range.end;
+    let maximumEnd = entry.range.end;
+    for (const child of [left, right]) {
+        if (child !== null && pointCompare(child.minimumEnd, minimumEnd) < 0)
+            minimumEnd = child.minimumEnd;
+        if (child !== null && pointCompare(child.maximumEnd, maximumEnd) > 0)
+            maximumEnd = child.maximumEnd;
+    }
+    return {
+        entry,
+        minimumStart: left?.minimumStart ?? entry.range.start,
+        maximumStart: right?.maximumStart ?? entry.range.start,
+        minimumEnd,
+        maximumEnd,
+        left,
+        right,
+    };
+};
+/** Index an immutable node list; return contained ranges in producer order. */
+export const createSemanticNodeRangeLookup = (nodes) => {
+    const entries = nodes
+        .flatMap((node, order) => {
+        const range = node.identity.source_range;
+        return range === null ? [] : [{ node, range, order }];
+    })
+        .sort((left, right) => pointCompare(left.range.start, right.range.start) ||
+        left.order - right.order);
+    const tree = buildSourceIntervalTree(entries, 0, entries.length);
+    return (range) => {
+        if (tree === null)
+            return [];
+        const pending = [tree];
+        const matches = [];
+        while (pending.length > 0) {
+            const current = pending.pop();
+            if (current === undefined ||
+                pointCompare(current.maximumStart, range.start) < 0 ||
+                pointCompare(current.minimumEnd, range.end) > 0)
+                continue;
+            if (contains(range, current.entry.range))
+                matches.push(current.entry);
+            if (current.left !== null)
+                pending.push(current.left);
+            if (current.right !== null)
+                pending.push(current.right);
+        }
+        return matches
+            .sort((left, right) => left.order - right.order)
+            .map(({ node }) => node);
+    };
+};
+/** Index exact call ranges, preserving the first producer occurrence. */
+export const createSemanticCallSiteLookup = (ir, nodes) => {
+    const identifiers = new Map();
+    for (const call of ir.callSites) {
+        const key = rangeKey(call.location);
+        if (!identifiers.has(key))
+            identifiers.set(key, call.callSiteId);
+    }
+    return (range) => {
+        const identifier = identifiers.get(rangeKey(range));
+        return identifier === undefined ? undefined : nodes.get(identifier);
+    };
+};
+const rangeKey = (range) => `${range.start.line}:${range.start.column}-${range.end.line}:${range.end.column}`;
+/** Report extractor support without treating missing families as absence. */
+export const semanticFamilyStatus = (family, analysis) => {
+    if (![
+        "call-flow",
+        "boundary",
+        "child-process",
+        "closure",
+        "configuration",
+        "data-flow",
+        "event",
+        "object-flow",
+        "promise-ownership",
+        "request",
+        "resource-lifecycle",
+        "timer",
+    ].includes(family))
+        return "unsupported";
+    return analysis.truncated_scopes === 0 ? "partial" : "unknown";
+};
+const contains = (outer, inner) => pointCompare(outer.start, inner.start) <= 0 &&
+    pointCompare(outer.end, inner.end) >= 0;
+const pointCompare = (left, right) => left.line - right.line || left.column - right.column;
+const positionKey = (range) => `${String(range.start.line).padStart(12, "0")}:${String(range.start.column).padStart(12, "0")}`;

package/dist/application/{JavaScriptSemanticGraphResourceProjection.js → javascript/JavaScriptSemanticGraphResourceProjection.js}

@@ -1,5 +1,5 @@
-import { createJavaScriptSemanticGraphUnknown } from "../domain/javascriptSemanticGraph.js";
-import { addSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, constructSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
+import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
 import { semanticCallSiteAt, } from "./JavaScriptSemanticGraphFlowProjection.js";
 /** Project built-in resource acquisition and exact local release handles. */
@@ -21,7 +21,7 @@ export const projectSemanticResources = (context) => {
         else
             projectRelease(context, operation, resourceNodes);
 };
-const addResourceNode = (context, operation) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+const addResourceNode = (context, operation) => retainSemanticGraphNode(context.state, context.file, {
     kind: "resource",
     roleKey: operation.resourceId,
     location: operation.location,
@@ -31,7 +31,7 @@ const addResourceNode = (context, operation) => addSemanticGraphNode(context.sta
         : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
             null),
     properties: { method: operation.method },
-}, context.state));
+});
 const projectRelease = (context, operation, resourceNodes) => {
     const callSite = semanticCallSiteAt(context, operation.location);
     const resources = operation.linkedResourceIds.flatMap((identifier) => {

package/dist/application/{JavaScriptSemanticGraphValueProjection.js → javascript/JavaScriptSemanticGraphValueProjection.js}

@@ -1,4 +1,4 @@
-import { addSemanticGraphNode, addSemanticGraphRelation, constructSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
+import { retainSemanticGraphNode, addSemanticGraphRelation, } from "./JavaScriptSemanticGraphConstruction.js";
 /** Project bounded literal values and object slots for exact query seeds. */
 export const projectSemanticValues = (context) => {
     for (const binding of context.ir.bindings) {
@@ -55,16 +55,16 @@ const projectValue = (input) => {
             });
         }
 };
-const addLiteralNode = (context, binding, value, role) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+const addLiteralNode = (context, binding, value, role) => retainSemanticGraphNode(context.state, context.file, {
     kind: "literal",
     roleKey: `literal:${binding.bindingId}:${role}:${JSON.stringify(value)}`,
     location: binding.definitions[0]?.location ?? null,
     label: JSON.stringify(value),
     functionNodeId: context.bindingNodes.get(binding.bindingId)?.function_node_id ?? null,
     properties: { value },
-}, context.state));
+});
 /** Create one canonical property slot for a binding/property identity. */
-export const semanticPropertySlot = (context, objectBindingId, name) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+export const semanticPropertySlot = (context, objectBindingId, name) => retainSemanticGraphNode(context.state, context.file, {
     kind: "property-slot",
     roleKey: `property:${objectBindingId}:${name}`,
     location: null,
@@ -74,4 +74,4 @@ export const semanticPropertySlot = (context, objectBindingId, name) => addSeman
         name,
         object_binding_id: objectBindingId,
     },
-}, context.state));
+});

package/dist/application/{JavaScriptSemanticTraceService.js → javascript/JavaScriptSemanticTraceService.js}

@@ -1,10 +1,10 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { queryJavaScriptSemanticGraph } from "../domain/javascriptSemanticQuery.js";
-import { javaScriptSemanticTraceResultSchema, traceJavaScriptSemanticsInputSchema, } from "../domain/javascriptSemanticTraceSchemas.js";
-import { err, ok } from "../domain/result.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { queryJavaScriptSemanticGraph } from "../../domain/javascript/javascriptSemanticQuery.js";
+import { javaScriptSemanticTraceResultSchema, traceJavaScriptSemanticsInputSchema, } from "../../domain/javascript/javascriptSemanticTraceSchemas.js";
+import { err, ok } from "../../domain/result.js";
 import { parseApplicationGraphEvidence } from "./JavaScriptApplicationEvidenceGraph.js";
 import { createJavaScriptSemanticTraceEvidence } from "./JavaScriptApplicationWorkflowEvidence.js";
 const OPERATION = "trace_javascript_semantics";

package/dist/application/{ManagedApplicationGraphService.js → managed/ManagedApplicationGraphService.js}

@@ -1,11 +1,11 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
-import { createEvidence } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { managedApplicationGraphResultSchema, projectManagedApplicationGraph, projectManagedApplicationGraphInputSchema, } from "../domain/managedApplicationGraph.js";
-import { err, ok } from "../domain/result.js";
-import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { managedApplicationGraphResultSchema, projectManagedApplicationGraph, projectManagedApplicationGraphInputSchema, } from "../../domain/managed/managedApplicationGraph.js";
+import { err, ok } from "../../domain/result.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
 const OPERATION = "project_managed_application_graph";
 /** Project authenticated managed Evidence into a provider-neutral graph. */
 export const projectManagedApplicationGraphEvidence = (rawInput) => {

package/dist/application/{ManagedMemberComparisonService.js → managed/ManagedMemberComparisonService.js}

@@ -1,16 +1,16 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { z } from "zod";
-import { compareManagedMembers, managedMemberComparisonResultSchema, parseManagedMemberEvidence, } from "../domain/managedMemberComparison.js";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
-import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
-import {} from "../domain/analysisErrorBase.js";
-import { createEvidence } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { parseBinaryTarget } from "./BinaryTargetResolver.js";
-import { err, ok } from "../domain/result.js";
-import { inspectManagedMembersBytes } from "../dotnet/ManagedMemberInspector.js";
-import { MANAGED_STATIC_PROVIDER, MANAGED_WORKFLOW_PROVIDER, } from "./InvestigationProviders.js";
+import { compareManagedMembers, managedMemberComparisonResultSchema, parseManagedMemberEvidence, } from "../../domain/managed/managedMemberComparison.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { parseBinaryTarget } from "../BinaryTargetResolver.js";
+import { err, ok } from "../../domain/result.js";
+import { inspectManagedMembersBytes } from "../../dotnet/ManagedMemberInspector.js";
+import { MANAGED_STATIC_PROVIDER, MANAGED_WORKFLOW_PROVIDER, } from "../InvestigationProviders.js";
 /** Compare managed members from input parsed by a trusted adapter. */
 export const compareManagedMembersEvidenceValidated = (input) => {
     const operation = "compare_managed_members";

package/dist/application/{ManagedNativeVerificationService.js → managed/ManagedNativeVerificationService.js}

@@ -1,11 +1,11 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
-import { createEvidence } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { managedNativeVerificationInputSchema, verifyManagedNativeBoundaries, } from "../domain/managedNativeVerification.js";
-import { err, ok } from "../domain/result.js";
-import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { managedNativeVerificationInputSchema, verifyManagedNativeBoundaries, } from "../../domain/managed/managedNativeVerification.js";
+import { err, ok } from "../../domain/result.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
 const OPERATION = "verify_managed_native_boundaries";
 /** Verify managed/native boundary declarations against native Evidence. */
 export const verifyManagedNativeBoundariesEvidence = (rawInput) => {

package/dist/application/{ManagedReconstructionService.js → managed/ManagedReconstructionService.js}

@@ -1,11 +1,11 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
-import { createEvidence } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { importManagedReconstruction, managedReconstructionImportInputSchema, } from "../domain/managedReconstruction.js";
-import { err, ok } from "../domain/result.js";
-import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { importManagedReconstruction, managedReconstructionImportInputSchema, } from "../../domain/managed/managedReconstruction.js";
+import { err, ok } from "../../domain/result.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
 const OPERATION = "import_managed_reconstruction";
 /** Authenticate and import managed decompiler reconstruction as Evidence. */
 export const importManagedReconstructionEvidence = (rawInput) => {

package/dist/application/{NativeApiInspection.js → native/NativeApiInspection.js}

@@ -1,4 +1,4 @@
-import { nativeApiInspectionResultSchema, } from "../domain/nativeApiBoundary.js";
+import { nativeApiInspectionResultSchema, } from "../../domain/native/nativeApiBoundary.js";
 const unavailableBoundary = () => ({
     available: false,
     reason: "The selected provider did not expose a structured native API boundary model.",

package/dist/application/{NativeCallRoutes.js → native/NativeCallRoutes.js}

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { parseRelatedAddresses, referenceKindSchema, } from "../domain/hopperValues.js";
-import { err, ok } from "../domain/result.js";
-import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
+import { parseRelatedAddresses, referenceKindSchema, } from "../../domain/hopperValues.js";
+import { err, ok } from "../../domain/result.js";
+import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
 const referencesSchema = z.object({
     reference_kinds_available: z.boolean().optional(),
     references: z.array(z.object({

package/dist/application/{NativeDispatchMetadataInspection.js → native/NativeDispatchMetadataInspection.js}

@@ -1,8 +1,8 @@
 import { z } from "zod";
-import { nativeDispatchMetadataResultSchema, inspectNativeDispatchMetadata, } from "../domain/objcSwiftMetadata.js";
-import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { err, ok } from "../domain/result.js";
+import { nativeDispatchMetadataResultSchema, inspectNativeDispatchMetadata, } from "../../domain/native/objcSwiftMetadata.js";
+import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { err, ok } from "../../domain/result.js";
 /** Prefer validated binary metadata, otherwise preserve the bound provider's symbol-only coverage. */
 export const inspectNativeDispatch = async (analysis, maxRecords, signal) => {
     const binaryMetadata = await analysis.execute("inspect_native_dispatch_metadata", { max_records: maxRecords }, signal === undefined ? {} : { signal });

package/dist/application/{NativeUiActionTrace.js → native/NativeUiActionTrace.js}

@@ -1,13 +1,13 @@
 import { z } from "zod";
-import { interfaceBuilderAnalysisSchema } from "../domain/interfaceBuilderGraph.js";
-import { nativeInvestigationGraphSchema, nativeInvestigationTraceSchema, traceNativeInvestigationGraph, joinInterfaceBuilderDispatch, } from "../domain/nativeInvestigationGraph.js";
-import { nativeDispatchMetadataResultSchema } from "../domain/objcSwiftMetadata.js";
+import { interfaceBuilderAnalysisSchema } from "../../domain/apple/interfaceBuilderGraph.js";
+import { nativeInvestigationGraphSchema, nativeInvestigationTraceSchema, traceNativeInvestigationGraph, joinInterfaceBuilderDispatch, } from "../../domain/native/nativeInvestigationGraph.js";
+import { nativeDispatchMetadataResultSchema } from "../../domain/native/objcSwiftMetadata.js";
 import { inspectNativeDispatch } from "./NativeDispatchMetadataInspection.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { readNativeCallRoutes } from "./NativeCallRoutes.js";
-import { err, ok } from "../domain/result.js";
-import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { err, ok } from "../../domain/result.js";
+import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
+import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
 /** Build a UI-to-code trace from the active app and selected native provider. */
 export const traceNativeUiAction = async (analysis, input, signal) => {
     const [uiExecution, metadataExecution] = await Promise.all([

package/dist/application/{NativeValueTrace.js → native/NativeValueTrace.js}

@@ -1,9 +1,9 @@
-import { functionDossierSchema } from "../domain/hopperValues.js";
-import { nativeCallTargetsSchema } from "../domain/nativeInstruction.js";
-import { nativeValueTraceInputSchema, nativeValueTraceSchema, } from "../domain/nativeValueTrace.js";
-import { createEvidence } from "../domain/evidence.js";
-import { AnalysisCancelledError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
-import { err, ok } from "../domain/result.js";
+import { functionDossierSchema } from "../../domain/hopperValues.js";
+import { nativeCallTargetsSchema } from "../../domain/native/nativeInstruction.js";
+import { nativeValueTraceInputSchema, nativeValueTraceSchema, } from "../../domain/native/nativeValueTrace.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { AnalysisCancelledError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { err, ok } from "../../domain/result.js";
 /** Compose bounded high-p-code def-use graphs across exactly referenced call destinations. */
 export const traceNativeValues = async (analysis, parameters, signal) => {
     const input = nativeValueTraceInputSchema.parse(parameters);

package/dist/application/{ProcessCli.js → process/ProcessCli.js}

@@ -1,14 +1,14 @@
 import { readFile } from "node:fs/promises";
-import { AnalysisError } from "../domain/analysisErrorBase.js";
-import { AnalysisInputError } from "../domain/analysisErrorCore.js";
-import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
-import { createEvidence, parseEvidence } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { projectInputIssues } from "../domain/inputIssueProjection.js";
-import { processTraceSpecificationSchema } from "../domain/processTraceComparison.js";
-import { processScenarioSchema } from "../domain/processScenario.js";
-import { compareProcessCaptures, parseProcessCapture, } from "../domain/processCapture.js";
-import { captureProcessScenario } from "./ProcessHarness.js";
+import { AnalysisError } from "../../domain/analysisErrorBase.js";
+import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
+import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
+import { createEvidence, parseEvidence } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { projectInputIssues } from "../../domain/inputIssueProjection.js";
+import { processTraceSpecificationSchema } from "../../domain/process/processTraceComparison.js";
+import { processScenarioSchema } from "../../domain/process/processScenario.js";
+import { compareProcessCaptures, parseProcessCapture, } from "../../domain/process/processCapture.js";
+import { captureProcessScenario } from "../../process/capture/ProcessHarness.js";
 import { PROCESS_PROVIDER, createProcessCaptureEvidence, } from "./ProcessEvidence.js";
 /** Identify the process workflow's typed diagnostic result for CLI exit status. */
 export const isProcessCliFailure = (value) => typeof value === "object" &&
@@ -114,7 +114,11 @@ const readJson = async (path) => {
         throw new ProcessCliFailure("invalid_input", "Process input file could not be read. Check that the path exists and is readable.");
     }
     try {
-        const parsed = JSON.parse(bytes.toString("utf8"));
+        const text = new TextDecoder("utf-8", {
+            fatal: true,
+            ignoreBOM: true,
+        }).decode(bytes);
+        const parsed = JSON.parse(text);
         return parsed;
     }
     catch (cause) {

package/dist/application/{ProcessEvidence.js → process/ProcessEvidence.js}

@@ -1,7 +1,7 @@
-import { createEvidence } from "../domain/evidence.js";
-import { PROCESS_PROVIDER } from "../domain/processEvidenceProvider.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-export { PROCESS_PROVIDER } from "../domain/processEvidenceProvider.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { PROCESS_PROVIDER } from "../../domain/process/processEvidenceProvider.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+export { PROCESS_PROVIDER } from "../../domain/process/processEvidenceProvider.js";
 /** Project one process scenario into secret-free Evidence parameters. */
 const processEvidenceParameters = (scenario) => ({
     executable_name: scenario.executable.split("/").at(-1) ?? scenario.executable,

package/dist/{application/ArtifactInventory/hash.js → artifacts/ArtifactHash.js}

@@ -1,12 +1,14 @@
 import { createHash } from "node:crypto";
-import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
-import { streamChunkToBuffer } from "../../artifacts/StreamBytes.js";
+import { ArtifactReaderFailure } from "./ArtifactReader.js";
+import { streamChunkToBuffer } from "./StreamBytes.js";
 /** Bounded classification evidence; this is not an executable format size limit. */
 export const ARTIFACT_CLASSIFICATION_PREFIX_BYTES = 8_192;
+/** Preserve the inventory cancellation reason at a stream boundary. */
 export const abortIfNeeded = (signal) => {
     if (signal?.aborted === true)
         throw new ArtifactReaderFailure("cancelled", "Artifact inventory cancelled");
 };
+/** Hash every stream byte and retain its bounded classification prefix. */
 export const hashReadable = async (stream, signal) => {
     const hash = createHash("sha256");
     const prefixes = [];

package/dist/artifacts/ArtifactPaths.js

@@ -7,13 +7,13 @@ export const normalizeArtifactPath = (input) => {
         input.includes("\\") ||
         input.startsWith("/") ||
         DRIVE_OR_UNC.test(input))
-        throw new ArtifactReaderFailure("path", "Artifact path is absolute or unsafe");
+        throw new ArtifactReaderFailure("path", `Artifact path is absolute or unsafe: ${JSON.stringify(input)}`);
     const normalized = input.normalize("NFC").replace(/\/+$/u, "");
     const parts = normalized.split("/");
     if (normalized.length === 0 ||
         parts.some((part) => part === "" || part === "." || part === "..") ||
         posix.normalize(normalized) !== normalized)
-        throw new ArtifactReaderFailure("path", "Artifact path is not normalized");
+        throw new ArtifactReaderFailure("path", `Artifact path is not normalized: ${JSON.stringify(input)}`);
     return normalized;
 };
 /** Reject exact, Unicode-normalized, case-folded, and prefix collisions. */
@@ -28,7 +28,7 @@ export class ArtifactPathRegistry {
             const foldedPart = part.toLocaleLowerCase("en-US");
             let child = node.children.get(foldedPart);
             if (child !== undefined && child.spelling !== part)
-                throw new ArtifactReaderFailure("path", `Artifact path collision: ${path}`);
+                throw new ArtifactReaderFailure("path", `Artifact path collision: ${path} differs only in case from ${[...parts.slice(0, index), child.spelling].join("/")}`);
             if (child === undefined) {
                 child = { spelling: part, kind: undefined, children: new Map() };
                 node.children.set(foldedPart, child);

package/dist/artifacts/ArtifactProvider.js

@@ -1,56 +1,27 @@
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
-import { inspectBundleKeyedArchive } from "./KeyedArchiveReader.js";
+import { inspectBundleKeyedArchive } from "./apple/KeyedArchiveReader.js";
+import { traceDylibResolution } from "./apple/DylibResolutionReader.js";
 import { basename, dirname } from "node:path";
-import { inventoryArtifact } from "../application/ArtifactInventory.js";
-import { extractArtifact } from "../application/ArtifactExtraction.js";
-import { analyzeInterfaceBuilderBundle } from "../application/InterfaceBuilderAnalysis.js";
-import { analyzeAppleAssetCatalogs } from "../application/AppleAssetCatalogAnalysis.js";
+import { inventoryArtifact } from "./inventory/ArtifactInventory.js";
+import { extractArtifact } from "./extraction/ArtifactExtraction.js";
+import { analyzeInterfaceBuilderBundle } from "./apple/InterfaceBuilderAnalysis.js";
+import { analyzeAppleAssetCatalogs } from "./apple/AppleAssetCatalogAnalysis.js";
 import { ARTIFACT_ANALYSIS_OPERATIONS, artifactInventoryInputSchema, artifactExtractionExecutionSchema, } from "../contracts/artifactToolContracts.js";
 import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
 import { ArtifactOperationError } from "../domain/artifactOperationError.js";
 import {} from "../domain/analysisErrorBase.js";
-import { interfaceBuilderLimitsSchema } from "../domain/interfaceBuilderGraph.js";
+import { interfaceBuilderLimitsSchema } from "../domain/apple/interfaceBuilderGraph.js";
 import { err, ok } from "../domain/result.js";
 import { ArtifactReaderFailure } from "./ArtifactReader.js";
-import { ARTIFACT_GRAPH_PROVIDER } from "../application/InvestigationProviders.js";
+import { ARTIFACT_PROVIDER_IDENTITY as IDENTITY, artifactCapabilities, } from "./ArtifactProviderMetadata.js";
 import { createEvidence } from "../domain/evidence.js";
 import { createArtifactInspection } from "../domain/artifactInspection.js";
-import { resolveArtifactIntegrityPolicy } from "../application/ArtifactInventory/policy.js";
-const IDENTITY = Object.freeze(ARTIFACT_GRAPH_PROVIDER);
+import { resolveArtifactIntegrityPolicy } from "./inventory/policy.js";
 /** Read-only inventory and exclusively owned extraction provider. */
 export class ArtifactProvider {
     #capabilities;
     constructor(platform = process.platform) {
-        this.#capabilities = Object.freeze(ARTIFACT_ANALYSIS_OPERATIONS.map((operation) => {
-            const common = {
-                provider: IDENTITY,
-                operation,
-                effects: Object.freeze({
-                    mutatesArtifact: false,
-                    launchesProcess: operation !== "decode_interface_builder" &&
-                        operation !== "inspect_keyed_archive",
-                    mayShowUi: false,
-                    mayAccessNetwork: false,
-                    mayWriteFilesystem: operation === "extract_artifact" ||
-                        operation === "inspect_artifact" ||
-                        operation === "inventory_artifact",
-                    changesPermissions: false,
-                    requiresRoot: false,
-                }),
-                limitations: Object.freeze([
-                    "DMG child inventory automatically uses a read-only native macOS mount; PKG remains root-hash-only.",
-                    "ASAR files discovered in filesystem-backed inventories are expanded without bulk extraction; other nested containers remain recorded only.",
-                ]),
-            };
-            return Object.freeze(operation === "inspect_asset_catalog" && platform !== "darwin"
-                ? {
-                    ...common,
-                    available: false,
-                    availabilityCode: "unsupported_host",
-                    reason: "Apple asset catalogs require macOS assetutil.",
-                }
-                : { ...common, available: true, reason: null });
-        }));
+        this.#capabilities = artifactCapabilities(platform);
     }
     identity() {
         return IDENTITY;
@@ -128,6 +99,8 @@ class ArtifactClient {
             if (operation === "inspect_asset_catalog") {
                 return await this.inspectAssetCatalog(parameters, options);
             }
+            if (operation === "trace_dylib_resolution")
+                return await this.traceDylibResolution(parameters, options);
             if (operation === "extract_artifact") {
                 const parsed = artifactExtractionExecutionSchema.parse(parameters);
                 const result = await extractArtifact({
@@ -184,6 +157,30 @@ class ArtifactClient {
             })),
         }));
     }
+    async traceDylibResolution(parameters, options) {
+        if (this.target.kind !== "executable" || this.target.format !== "mach-o")
+            throw new ArtifactReaderFailure("unavailable", "trace_dylib_resolution requires an active Mach-O or .app bundle target");
+        // Only a target opened from an app bundle directory carries its Info.plist;
+        // a regular file whose name ends in .app is a standalone image.
+        const bundle = this.target.bundleInfoPlist === undefined
+            ? undefined
+            : this.target.sourcePath;
+        const result = await traceDylibResolution({
+            rootPath: bundle ?? dirname(this.target.path),
+            targetPath: this.target.path,
+            targetSha256: this.target.sha256,
+            enumerateRoots: bundle !== undefined,
+            parameters,
+            ...(options?.signal === undefined ? {} : { signal: options.signal }),
+        });
+        return ok(createAnalysisExecution(result, IDENTITY, {
+            limitations: result.limitations,
+            locations: result.images.map(({ path }) => ({
+                kind: "artifact-path",
+                path,
+            })),
+        }));
+    }
     async inspectArtifact(parameters, options) {
         const parsed = artifactInventoryInputSchema.parse(parameters);
         const inventoryParameters = {
@@ -235,7 +232,7 @@ class ArtifactClient {
 const isArtifactOperation = (operation) => ARTIFACT_ANALYSIS_OPERATIONS.includes(operation);
 const translateFailure = (operation, cause) => {
     if (cause instanceof ArtifactReaderFailure)
-        return new ArtifactOperationError(operation, cause.reason, cause.details);
+        return new ArtifactOperationError(operation, cause.reason, cause.details, cause.message);
     return new ArtifactOperationError(operation, "io");
 };
 const subjectFor = (path, manifest) => ({