rea-agents 6.3.0 → 6.5.0

package/dist/domain/explicitSensitiveFailure.js

@@ -1,4 +1,4 @@
-import { AnalysisAccessDeniedError, AnalysisArtifactChangedError, AnalysisInputError, AnalysisOutputError, AnalysisCapabilityUnavailableError, AnalysisResourceConstraintError, } from "./analysisErrorCore.js";
+import { AnalysisAccessDeniedError, AnalysisArtifactChangedError, AnalysisInputError, AnalysisOutputError, AnalysisCapabilityUnavailableError, AnalysisResourceConstraintError, AnalysisCancelledError, AnalysisTimeoutError, } from "./analysisErrorCore.js";
 import { redactExplicitText } from "./explicitSensitiveValues.js";
 import { ProviderAdapterError } from "./providerAdapterError.js";
 import { ProviderCleanupError } from "./providerCleanupError.js";
@@ -51,12 +51,45 @@ export const redactExplicitFailure = (error, values) => {
             return diagnostics(value);
         return value;
     };
+    const context = {
+        cause: error,
+        ...(error.diagnostics === undefined
+            ? {}
+            : { diagnostics: diagnostics(error.diagnostics) }),
+        ...(error.capturedOutput === undefined
+            ? {}
+            : {
+                capturedOutput: {
+                    ...error.capturedOutput,
+                    stdout: text(error.capturedOutput.stdout),
+                    stderr: text(error.capturedOutput.stderr),
+                },
+            }),
+        ...(error.cleanup === undefined
+            ? {}
+            : {
+                cleanup: {
+                    reason: text(error.cleanup.reason),
+                    resources: error.cleanup.resources.map(text),
+                },
+            }),
+    };
+    if (error instanceof AnalysisCancelledError)
+        return new AnalysisCancelledError(error.operation, {
+            ...context,
+            partialObservation: error.partialObservation,
+        });
+    if (error instanceof AnalysisTimeoutError)
+        return new AnalysisTimeoutError(error.operation, error.timeoutMs, {
+            ...context,
+            partialObservation: error.partialObservation,
+        });
     if (error instanceof AnalysisAccessDeniedError)
-        return new AnalysisAccessDeniedError(error.operation, text(error.path), error.systemCode, { cause: error });
+        return new AnalysisAccessDeniedError(error.operation, text(error.path), error.systemCode, context);
     if (error instanceof AnalysisArtifactChangedError)
-        return new AnalysisArtifactChangedError(error.operation, text(error.path), text(error.reason), { cause: error });
+        return new AnalysisArtifactChangedError(error.operation, text(error.path), text(error.reason), context);
     if (error instanceof AnalysisInputError)
-        return new AnalysisInputError(error.operation, { cause: error }, error.issues.map((issue) => ({
+        return new AnalysisInputError(error.operation, context, error.issues.map((issue) => ({
             ...issue,
             // Unknown-argument paths contain literal field names, including names
             // beginning with '/'; they are not producer JSON-pointer coordinates.
@@ -69,40 +102,25 @@ export const redactExplicitFailure = (error, values) => {
                 : { expected: visit(issue.expected) }),
         })));
     if (error instanceof AnalysisOutputError)
-        return new AnalysisOutputError(error.operation, text(error.reason), {
-            cause: error,
-        });
+        return new AnalysisOutputError(error.operation, text(error.reason), context);
     if (error instanceof AnalysisCapabilityUnavailableError)
         return new AnalysisCapabilityUnavailableError(error.providerId, error.operation, text(error.reason), {
-            cause: error,
+            ...context,
             ...(error.userMessage === undefined
                 ? {}
                 : { userMessage: text(error.userMessage) }),
+            ...(error.retryable ? { retryable: true } : {}),
         });
     if (error instanceof AnalysisResourceConstraintError)
         return new AnalysisResourceConstraintError(error.operation, error.resource, text(error.reason), error.reportedLimits === null ? null : diagnostics(error.reportedLimits), {
-            cause: error,
+            ...context,
             ...(error.remediationAction === undefined
                 ? {}
                 : { remediationAction: text(error.remediationAction) }),
-            ...(error.capturedOutput === undefined
-                ? {}
-                : {
-                    capturedOutput: {
-                        stdout: text(error.capturedOutput.stdout),
-                        stderr: text(error.capturedOutput.stderr),
-                        truncated: error.capturedOutput.truncated,
-                    },
-                }),
         });
     if (error instanceof ProviderCleanupError)
         return new ProviderCleanupError(error.providerId, error.cleanupResources.map(text), diagnostics(error.diagnostics ?? {}), { operation: error.operation, cause: error });
     if (error instanceof ProviderAdapterError)
-        return new ProviderAdapterError(error.providerId, error.operation, {
-            cause: error,
-            ...(error.diagnostics === undefined
-                ? {}
-                : { diagnostics: diagnostics(error.diagnostics) }),
-        });
+        return new ProviderAdapterError(error.providerId, error.operation, context);
     return error;
 };

package/dist/domain/firmware/firmwareAnalysis.js

@@ -75,6 +75,32 @@ const chunk = z.strictObject({
     handler: z.string().nullable(),
     encrypted: z.boolean().nullable(),
     root_file_range: range.nullable(),
+    /** The producer reported extraction problems for this chunk. */
+    extraction_failed: z.boolean(),
+});
+/** One unextracted region or failing task/stage, with a supported continuation
+ * using already configured capabilities when one exists. */
+export const extractionGap = z.strictObject({
+    kind: z.enum([
+        "missing-extractor-dependency",
+        "unknown-chunk-handler",
+        "encrypted-chunk",
+        "depth-limited",
+        "extractor-failure",
+        "unpublished-entry",
+    ]),
+    /** Logical task path from the producer report; `$output/…` for unpublished entries. */
+    input_path: z.string(),
+    relative_path: z.string().nullable(),
+    handler: z.string().nullable(),
+    /** Reported chunk or multi-file stage identity; it does not imply a byte range. */
+    provider_id: z.string().nullable(),
+    range: range.nullable(),
+    root_file_range: range.nullable(),
+    /** Extractor executables named by the producer; empty when it named none. */
+    dependencies: z.array(z.string()),
+    /** Lookup key in the result's extraction_continuations table. */
+    continuation_id: z.string(),
 });
 /** Portable results retain reported boundaries, unknowns and extraction lineage. */
 export const firmwareResultSchemas = {
@@ -123,6 +149,9 @@ export const firmwareResultSchemas = {
         })),
         depth_limited_paths: z.array(z.string()),
         diagnostics: z.array(jsonValueSchema),
+        extraction_gaps: z.array(extractionGap),
+        /** Each distinct recovery instruction is serialized once, shared by gap ID. */
+        extraction_continuations: z.array(z.strictObject({ id: z.string(), instruction: z.string() })),
         published_bytes: bytes,
     }),
 };

package/dist/domain/flutter/flutterBuildAnalysis.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+import { localPathStringSchema } from "../localPath.js";
+import { digestSchema } from "../digests.js";
+/**
+ * Caller intent for Flutter build identification. This family is pure
+ * parsing: it reads an APK's `lib/<abi>/libapp.so` and `libflutter.so`
+ * directly and runs no engine, tool, or device.
+ */
+export const flutterInputSchemas = {
+    identify_flutter_build: z.strictObject({
+        path: localPathStringSchema.describe("Local APK file to inspect"),
+    }),
+    inspect_dart_aot: z.strictObject({
+        path: localPathStringSchema.describe("Local APK file carrying a Flutter AOT payload"),
+        abi: z
+            .string()
+            .min(2)
+            .max(16)
+            .regex(/^[a-z0-9_\x2d]+$/u, "ABI name as it appears under lib/, e.g. arm64-v8a")
+            .optional()
+            .describe("ABI to inspect; defaults to arm64-v8a, x86_64, x86, armeabi-v7a, then remaining ABIs alphabetically"),
+    }),
+};
+/** Retained delivery is selected independently of the provider's ABI request. */
+export const dartAotInspectionInputSchema = flutterInputSchemas.inspect_dart_aot.extend({
+    detail: z.enum(["complete", "summary"]).optional(),
+});
+/** Validate operation and input together so their types remain correlated. */
+export const flutterRequestSchema = z.discriminatedUnion("operation", [
+    z.strictObject({
+        operation: z.literal("identify_flutter_build"),
+        input: flutterInputSchemas.identify_flutter_build,
+    }),
+    z.strictObject({
+        operation: z.literal("inspect_dart_aot"),
+        input: flutterInputSchemas.inspect_dart_aot,
+    }),
+]);
+/** One hardware ABI's Flutter payload inside the APK. */
+export const flutterResultSchemas = {
+    identify_flutter_build: z.strictObject({
+        target: z.strictObject({
+            path: localPathStringSchema,
+            bytes: z.number().int().nonnegative(),
+            sha256: digestSchema,
+        }),
+        flutter_detected: z.boolean(),
+        abis: z.array(z.strictObject({
+            abi: z.string().min(1),
+            libapp: z.strictObject({
+                present: z.boolean(),
+                bytes: z.number().int().nonnegative().nullable(),
+                sha256: digestSchema.nullable(),
+                /** Supported ELF header with table extents inside the library; table contents are not validated. */
+                elf_header_valid: z.boolean().nullable(),
+                /** Number of Dart snapshot sections found (vm + isolate). */
+                snapshot_hash_sources: z.number().int().nonnegative(),
+                /** Distinct hashes found; more than one means the sections disagree. */
+                snapshot_hash_candidates: z.array(z.string().regex(/^[0-9a-f]{32}$/u)),
+                /** The single hash when every snapshot section agrees. */
+                snapshot_hash: z
+                    .string()
+                    .regex(/^[0-9a-f]{32}$/u)
+                    .nullable(),
+            }),
+            libflutter: z.strictObject({
+                present: z.boolean(),
+                bytes: z.number().int().nonnegative().nullable(),
+                sha256: digestSchema.nullable(),
+                build_id: z
+                    .string()
+                    .regex(/^[0-9a-f]{8,128}$/u)
+                    .nullable()
+                    .describe("The single GNU build ID when ELF note coverage is complete and unambiguous"),
+                build_id_candidates: z
+                    .array(z.string().regex(/^[0-9a-f]{8,128}$/u))
+                    .max(64)
+                    .describe("Distinct GNU build IDs observed in ELF-owned note ranges; conflicting IDs remain explicit"),
+                dart_version: z
+                    .string()
+                    .nullable()
+                    .describe("Labeled 'Dart VM version' string, when a build carries one"),
+                toolchain_lines: z.array(z.string().min(1)),
+                /** Dart labels omitted by grammar or single-version projection bounds. */
+                dart_version_capped: z.boolean(),
+                /** Toolchain labels omitted by grammar or projection bounds. */
+                toolchain_capped: z.boolean(),
+            }),
+        })),
+        coverage: z.enum(["complete", "partial"]),
+    }),
+    inspect_dart_aot: z.strictObject({
+        target: z.strictObject({
+            path: localPathStringSchema,
+            bytes: z.number().int().nonnegative(),
+            sha256: digestSchema,
+        }),
+        abi: z.string().min(1),
+        libapp: z.strictObject({
+            coverage: z
+                .enum(["complete", "partial"])
+                .describe("Coverage of ELF symbols, independent data headers, AOT kind, extents and agreeing hashes"),
+            bytes: z.number().int().nonnegative(),
+            sha256: digestSchema,
+            snapshot_hash: z
+                .string()
+                .regex(/^[0-9a-f]{32}$/u)
+                .nullable(),
+            /** Distinct hashes found; more than one means the sections disagree. */
+            snapshot_hash_candidates: z.array(z.string().regex(/^[0-9a-f]{32}$/u)),
+            /** Distinct exported data headers with a valid hash at the header's fixed offset. */
+            snapshot_hash_sources: z.number().int().nonnegative(),
+            /** Snapshot symbols read from the dynamic symbol table. */
+            sections: z.array(z.strictObject({
+                name: z.string().min(1),
+                offset: z.number().int().nonnegative(),
+                size: z.number().int().nonnegative(),
+                magic_valid: z.boolean(),
+                kind: z.number().int().nonnegative().nullable(),
+                /** Raw declared snapshot length, excluding the four magic bytes. */
+                header_length: z.number().int().nonnegative().nullable(),
+            })),
+        }),
+        string_pool: z.strictObject({
+            coverage: z
+                .enum(["complete", "partial"])
+                .describe("Coverage of the bounded printable-run projection; independent of snapshot header validity"),
+            /** Distinct package: source URIs, sorted, bounded. */
+            package_uris: z.array(z.string().min(1)),
+            package_uri_count_at_least: z.number().int().nonnegative(),
+            /** Distinct dart: SDK URIs, sorted, bounded. */
+            dart_uris: z.array(z.string().min(1)),
+            dart_uri_count_at_least: z.number().int().nonnegative(),
+            /** Identifier-like tokens, bounded; includes incidental matches. */
+            class_like_tokens: z.array(z.string().min(1)),
+            class_like_token_count_at_least: z.number().int().nonnegative(),
+            printable_run_count: z.number().int().nonnegative(),
+        }),
+        coverage: z.enum(["complete", "partial"]),
+    }),
+};

package/dist/domain/functionCallCoverage.js

@@ -0,0 +1,60 @@
+import { relationshipCoverageLimitations, } from "./relationshipCoverage.js";
+import { uniqueSorted } from "./canonicalOrdering.js";
+const callerCoveragePrefix = "Callers: ";
+const calleeCoveragePrefix = "Callees: ";
+/** Combine caller and callee read outcomes without losing either explanation. */
+export const combineFunctionRelationshipCoverage = (callers, callees) => {
+    const reads = [
+        { direction: "callers", coverage: callers },
+        { direction: "callees", coverage: callees },
+    ];
+    const diagnostics = uniqueSorted(reads.flatMap(({ coverage }) => coverage?.diagnostics ?? []));
+    const details = diagnostics.length > 0 ? { diagnostics } : {};
+    const callersLimited = callers?.status !== "complete";
+    const calleesLimited = callees?.status !== "complete";
+    const limited_directions = callersLimited
+        ? calleesLimited
+            ? ["callers", "callees"]
+            : ["callers"]
+        : ["callees"];
+    const reasons = reads.flatMap(({ direction, coverage }) => {
+        const label = direction === "callers" ? callerCoveragePrefix : calleeCoveragePrefix;
+        return relationshipCoverageLimitations(coverage).map((reason) => `${label}${reason}`);
+    });
+    if (reads.some(({ coverage }) => coverage === undefined || coverage.status === "unknown"))
+        return {
+            status: "unknown",
+            reason: uniqueSorted(reasons).join(" "),
+            limited_directions,
+            ...details,
+        };
+    if (reasons.length > 0)
+        return {
+            status: "partial",
+            limitations: uniqueSorted(reasons),
+            limited_directions,
+            ...details,
+        };
+    return { status: "complete", ...details };
+};
+/**
+ * Forward searches depend on callee coverage. Preserve the historical
+ * unknown-reason encoding when reading observations without explicit directions.
+ */
+export const isCallerOnlyIncompleteCoverage = (coverage) => {
+    if (coverage.status === "complete")
+        return false;
+    if (coverage.limited_directions !== undefined)
+        return !coverage.limited_directions.some((direction) => direction === "callees");
+    return (coverage.status === "unknown" &&
+        coverage.reason.startsWith(callerCoveragePrefix) &&
+        !coverage.reason.includes(calleeCoveragePrefix));
+};
+/** Explain why two resolved call sets cannot establish call-set equality. */
+export const functionCallCoverageLimitations = (coverage, dossier) => {
+    return uniqueSorted([
+        ...relationshipCoverageLimitations(coverage),
+        ...(coverage?.status === "complete" ? [] : (coverage?.diagnostics ?? [])),
+        ...(dossier.unresolved_calls ?? []).map(({ address, reason }) => `Unresolved call at ${address}: ${reason}`),
+    ]);
+};

package/dist/domain/functionComparisonDimensions.js

@@ -1,6 +1,6 @@
 import { canonicalJson } from "./comparisonSemantics.js";
 import { diffLines } from "diff";
-import { commentProjection, identityProjection, isAutoName, normalizeCfg, referenceKindProjection, referenceProjection, sorted, stringAndNameProjection, } from "./functionComparisonNormalization.js";
+import { commentProjection, identityProjection, isAutoName, normalizeCfg, referenceKindProjection, referenceProjection, sorted, stringAndNameProjection, swiftLiteralSitesConflict, } from "./functionComparisonNormalization.js";
 import { dimensionResult, unresolvedDimension, } from "./functionComparisonResults.js";
 export const compareDimensions = (left, right, context) => {
     return [
@@ -12,14 +12,66 @@ export const compareDimensions = (left, right, context) => {
         compareReferences(left, right, context),
         compareStringsAndNames(left, right, context),
         compareCfg(left, right, context),
-    ];
+    ].map((result) => {
+        const limitations = [
+            ...facetLimitations(left, result.dimension).map((reason) => `Left: ${reason}`),
+            ...facetLimitations(right, result.dimension).map((reason) => `Right: ${reason}`),
+        ];
+        return limitations.length === 0
+            ? result
+            : unresolvedDimension({
+                dimension: result.dimension,
+                links: context.links,
+                leftCount: null,
+                rightCount: null,
+                limitations: [...result.limitations, ...limitations],
+            });
+    });
+};
+/** An empty undeclared facet is not evidence of observed absence. */
+const facetLimitations = (snapshot, dimension) => {
+    const { dossier } = snapshot;
+    const fields = {
+        identity: [],
+        pseudocode: [["pseudocode", dossier.pseudocode.length]],
+        assembly: [["assembly", dossier.assembly.length]],
+        comments: [["comments", dossier.comments.length]],
+        calls: [
+            ["callers", dossier.callers.length],
+            ["callees", dossier.callees.length],
+        ],
+        references: [
+            [
+                "references",
+                dossier.incoming_references.length + dossier.outgoing_references.length,
+            ],
+        ],
+        strings_names: [
+            [
+                "strings_names",
+                dossier.referenced_strings.length + dossier.referenced_names.length,
+            ],
+        ],
+        cfg: [["cfg", dossier.basic_blocks.length]],
+    };
+    return fields[dimension].flatMap(([field, count]) => {
+        const availability = dossier.facet_availability?.[field];
+        if (availability?.available === false)
+            return [`${field}: ${availability.reason}`];
+        return availability === undefined && count === 0
+            ? [`${field}: Provider did not declare coverage for this empty facet.`]
+            : [];
+    });
 };
 const compareText = (dimension, left, right, context) => {
-    const limitations = dimension === "assembly"
-        ? [
-            "Assembly is opaque provider text; relocation normalization is unavailable.",
-        ]
-        : [];
+    const limitations = [
+        "Exact provider text is compared without address or generated-name normalization; layout-only differences do not establish a behavior change.",
+        ...(dimension === "assembly"
+            ? [
+                "Assembly is opaque provider text; relocation normalization is unavailable.",
+            ]
+            : []),
+    ];
     if (context.providersDiffer)
         return unresolvedDimension({
             dimension,
@@ -42,6 +94,7 @@ const compareText = (dimension, left, right, context) => {
             leftCount: [...left].length,
             rightCount: [...right].length,
             limitations: [
+                ...limitations,
                 "Bounded line diff exceeded its time or edit-distance limit.",
             ],
         });
@@ -78,8 +131,11 @@ const compareComments = (left, right, context) => {
     return compareValues("comments", leftValues, rightValues, context);
 };
 const compareStringsAndNames = (left, right, context) => {
-    const leftValues = stringAndNameProjection(left);
-    const rightValues = stringAndNameProjection(right);
+    const complete = swiftLiteralCoverage(left) === swiftLiteralCoverage(right) &&
+        swiftLiteralCoverage(left) !== "partial";
+    // Facts both dossiers record decide a change before Swift literal coverage can.
+    const leftValues = stringAndNameProjection(left, complete);
+    const rightValues = stringAndNameProjection(right, complete);
     if (leftValues === null || rightValues === null)
         return unresolvedDimension({
             dimension: "strings_names",
@@ -90,8 +146,31 @@ const compareStringsAndNames = (left, right, context) => {
                 "Reference source locations could not be normalized to function offsets.",
             ],
         });
-    return compareValues("strings_names", leftValues, rightValues, context);
+    const compared = compareValues("strings_names", leftValues, rightValues, context);
+    if (complete || compared.status === "changed")
+        return compared;
+    // A retained literal differs only when the opposite dossier establishes its absence.
+    if (swiftLiteralSitesConflict(left, right)) {
+        const leftAll = stringAndNameProjection(left);
+        const rightAll = stringAndNameProjection(right);
+        if (leftAll !== null && rightAll !== null)
+            return compareValues("strings_names", leftAll, rightAll, context);
+    }
+    return unresolvedDimension({
+        dimension: "strings_names",
+        links: context.links,
+        leftCount: null,
+        rightCount: null,
+        limitations: [
+            "Swift String literal coverage differs or is partial; referenced strings and names match, and complete coverage does not establish a differing literal.",
+        ],
+    });
 };
+const swiftLiteralCoverage = (snapshot) => (snapshot.dossier.swift_string_literal_omissions ?? []).length > 0
+    ? "partial"
+    : snapshot.dossier.swift_string_literals === undefined
+        ? "absent"
+        : "complete";
 const compareReferences = (left, right, context) => {
     const leftProjection = referenceProjection(left);
     const rightProjection = referenceProjection(right);
@@ -143,6 +222,18 @@ const compareIdentity = (left, right, context) => {
 const compareCalls = (left, right, context) => {
     const leftValues = callProjection(left);
     const rightValues = callProjection(right);
+    const coverageLimitations = [
+        ...left.callCoverageLimitations.map((reason) => `Left: ${reason}`),
+        ...right.callCoverageLimitations.map((reason) => `Right: ${reason}`),
+    ];
+    if (coverageLimitations.length > 0)
+        return unresolvedDimension({
+            dimension: "calls",
+            links: context.links,
+            leftCount: leftValues.length,
+            rightCount: rightValues.length,
+            limitations: coverageLimitations,
+        });
     if ([...leftValues, ...rightValues].some(({ name }) => isAutoName(name)))
         return unresolvedDimension({
             dimension: "calls",

package/dist/domain/functionComparisonNormalization.js

@@ -8,21 +8,21 @@ export const identityProjection = (snapshot) => ({
         .sort(),
 });
 export const functionMatch = (left, right) => {
-    if (!isAutoName(left.dossier.procedure.name) &&
-        left.dossier.procedure.name === right.dossier.procedure.name)
+    const leftName = left.dossier.procedure.name;
+    const rightName = right.dossier.procedure.name;
+    const stableNames = !isAutoName(leftName) && !isAutoName(rightName);
+    if (stableNames && leftName === rightName)
         return {
             status: "matched",
             method: "symbol",
-            left_name: left.dossier.procedure.name,
-            right_name: right.dossier.procedure.name,
+            left_name: leftName,
+            right_name: rightName,
         };
     return {
-        status: left.dossier.procedure.name === right.dossier.procedure.name
-            ? "ambiguous"
-            : "mismatched",
+        status: stableNames ? "mismatched" : "ambiguous",
         method: "explicit",
-        left_name: left.dossier.procedure.name,
-        right_name: right.dossier.procedure.name,
+        left_name: leftName,
+        right_name: rightName,
     };
 };
 export const normalizeCfg = (blocks) => {
@@ -114,7 +114,7 @@ export const commentProjection = (snapshot) => {
     }));
     return values.some(({ offset }) => offset === null) ? null : sorted(values);
 };
-export const stringAndNameProjection = (snapshot) => {
+export const stringAndNameProjection = (snapshot, includeSwiftLiterals = true) => {
     const values = [
         ...snapshot.dossier.referenced_strings.map(({ source_address: sourceAddress, value }) => ({
             kind: "string",
@@ -126,11 +126,67 @@ export const stringAndNameProjection = (snapshot) => {
             source_offset: relativeAddress(sourceAddress, snapshot.dossier.procedure.address),
             value,
         })),
+        ...(includeSwiftLiterals
+            ? (snapshot.dossier.swift_string_literals ?? [])
+            : []).map(({ source_address: sourceAddress, value, representation, registers, }) => ({
+            kind: "swift_string",
+            source_offset: relativeAddress(sourceAddress, snapshot.dossier.procedure.address),
+            value,
+            representation,
+            registers,
+        })),
     ];
     return values.some(({ source_offset: offset }) => offset === null)
         ? null
         : sorted(values);
 };
+/**
+ * A retained literal proves presence, not that every path through its site was examined.
+ * A differing retained fact proves a change only when the opposite dossier is complete
+ * and therefore establishes its absence.
+ */
+export const swiftLiteralSitesConflict = (left, right) => {
+    const leftSites = swiftLiteralSites(left);
+    const rightSites = swiftLiteralSites(right);
+    for (const site of new Set([
+        ...leftSites.values.keys(),
+        ...rightSites.values.keys(),
+    ])) {
+        const leftValues = leftSites.values.get(site) ?? (leftSites.complete ? [] : undefined);
+        const rightValues = rightSites.values.get(site) ?? (rightSites.complete ? [] : undefined);
+        if (leftValues === undefined || rightValues === undefined)
+            continue;
+        const leftFacts = new Set(leftValues);
+        const rightFacts = new Set(rightValues);
+        if ((rightSites.complete &&
+            leftValues.some((value) => !rightFacts.has(value))) ||
+            (leftSites.complete && rightValues.some((value) => !leftFacts.has(value))))
+            return true;
+    }
+    return false;
+};
+const swiftLiteralSites = (snapshot) => {
+    const base = snapshot.dossier.procedure.address;
+    const omissions = snapshot.dossier.swift_string_literal_omissions ?? [];
+    const site = (sourceAddress, registers) => {
+        const offset = relativeAddress(sourceAddress, base);
+        return offset === null ? null : canonicalJson([offset, registers]);
+    };
+    // Keep the same literal facts the full strings_names projection compares.
+    const values = new Map();
+    for (const literal of snapshot.dossier.swift_string_literals ?? []) {
+        const key = site(literal.source_address, literal.registers);
+        if (key === null)
+            continue;
+        values.set(key, [
+            ...(values.get(key) ?? []),
+            canonicalJson([literal.value, literal.representation]),
+        ].sort(compareUnicodeCodePoints));
+    }
+    const complete = snapshot.dossier.swift_string_literals !== undefined &&
+        omissions.length === 0;
+    return { values, complete };
+};
 export const sorted = (values) => values
     .map((value) => ({
     value,

package/dist/domain/functionComparisonResults.js

@@ -37,14 +37,15 @@ export const unresolvedDimension = (input) => ({
     limitations: [...input.limitations],
 });
 export const overallStatus = (dimensions, match) => {
-    if (match === "ambiguous" ||
-        dimensions.some(({ status }) => status === "unknown"))
-        return "unknown";
     if (match === "mismatched")
         return "changed";
-    return dimensions.some(({ status }) => status === "changed")
-        ? "changed"
-        : "unchanged";
+    if (match === "ambiguous")
+        return "unknown";
+    if (dimensions.some(({ status }) => status === "changed"))
+        return "changed";
+    if (dimensions.some(({ status }) => status === "unknown"))
+        return "unknown";
+    return "unchanged";
 };
 export const summarize = (dimensions) => ({
     unchanged: dimensions.filter(({ status }) => status === "unchanged").length,