rea-agents 6.3.0 → 6.5.0

package/dist/domain/analysisView/androidPackageView.js

@@ -0,0 +1,102 @@
+import { analysisViewInputError } from "./analysisViewErrors.js";
+import { z } from "zod";
+import { androidResultSchemas } from "../android/androidAnalysis.js";
+import { err, ok } from "../result.js";
+import { parseAnalysisViewResult } from "./analysisViewParent.js";
+import { completeWithinViewCoverage } from "./analysisViewCoverage.js";
+import { analysisTextPage } from "./analysisViewText.js";
+const packageSchema = androidResultSchemas.inspect_android_package;
+/** All package declarations remain inline; decoded manifest text stays retained. */
+export const androidPackageSummarySchema = packageSchema.extend({
+    manifest: packageSchema.shape.manifest.omit({ text: true }).extend({
+        text_code_units: z.number().int().nonnegative(),
+        text_included: z.literal(false),
+    }),
+});
+/** Exact decoded text; offsets and limits count UTF-16 code units. */
+export const androidViewRequestSchema = z.strictObject({
+    kind: z.literal("android"),
+    facet: z.literal("manifest"),
+    offset: z.number().int().nonnegative().default(0),
+    limit: z.number().int().positive(),
+});
+export const androidManifestViewItemSchema = z.strictObject({
+    text: z.string(),
+    unit: z.literal("utf16-code-units"),
+    source_status: packageSchema.shape.manifest.shape.status,
+    reported_total_bytes: packageSchema.shape.manifest.shape.reported_total_bytes,
+});
+/** Project an authenticated package record without reopening the APK or engine. */
+export const projectAndroidPackageView = (parent, view) => {
+    if (view.kind !== "summary" && view.kind !== "android")
+        return err(analysisViewInputError([
+            {
+                path: ["view"],
+                reason: "invalid_value",
+                message: "Android package Evidence supports summary and manifest views.",
+            },
+        ]));
+    const parsed = parseAnalysisViewResult(packageSchema, parent);
+    if (!parsed.ok)
+        return parsed;
+    // Engine artifact_sha256 identifies the JAR, never the APK. A missing
+    // authenticated APK subject cannot be repaired using the engine identity.
+    if (parent.subject == null)
+        return err(analysisViewInputError([
+            {
+                path: ["source", "subject"],
+                reason: "invalid_value",
+                message: "Android package views require the recorded APK subject identity.",
+            },
+        ]));
+    const report = parsed.value;
+    const shared = {
+        parent_evidence_id: parent.evidenceId,
+        parent_operation: "inspect_android_package",
+        parent_digest: parent.evidenceId.slice(3),
+        artifact: {
+            path: parent.subject.local_path,
+            sha256: parent.subject.digest.sha256,
+        },
+        limitations: [...parent.limitations],
+        unknowns: [
+            "APK signatures were not verified; package declarations do not establish authenticity or runtime behavior.",
+            ...(report.manifest.status === "partial"
+                ? [
+                    "The decoded manifest is partial; exhausting retained text does not establish complete manifest coverage.",
+                ]
+                : []),
+        ],
+    };
+    if (view.kind === "summary") {
+        const { text, ...manifest } = report.manifest;
+        return ok({
+            kind: "summary",
+            view,
+            ...shared,
+            summary: {
+                ...report,
+                manifest: {
+                    ...manifest,
+                    text_code_units: text.length,
+                    text_included: false,
+                },
+            },
+            coverage: completeWithinViewCoverage(1, 1),
+        });
+    }
+    const page = analysisTextPage(report.manifest.text, view.offset, view.limit, "Manifest");
+    if (!page.ok)
+        return page;
+    return ok({
+        kind: "android",
+        view,
+        ...shared,
+        item: {
+            ...page.value.item,
+            source_status: report.manifest.status,
+            reported_total_bytes: report.manifest.reported_total_bytes,
+        },
+        coverage: page.value.coverage,
+    });
+};

package/dist/domain/analysisView/artifactInventoryView.js

@@ -0,0 +1,140 @@
+import { z } from "zod";
+import { AnalysisInputError } from "../analysisErrorCore.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { err, ok } from "../result.js";
+import { parseArtifactInventoryEvidence, parseArtifactInventoryResult, validateArtifactInventorySubject, } from "../artifactInventoryEvidence.js";
+import { artifactInspectionResultSchema, } from "../artifactInspection.js";
+import { completeWithinViewCoverage, pageViewCoverage, } from "./analysisViewCoverage.js";
+const inputError = (message) => new AnalysisInputError("inspect_analysis_view", undefined, [
+    {
+        path: ["source"],
+        reason: "invalid_value",
+        message,
+    },
+]);
+/** Reuse the owning inventory integrity/completeness parser for both carriers. */
+const parseSource = (parent) => {
+    try {
+        if (parent.operation === "inventory_artifact")
+            return ok({
+                inventory: parseArtifactInventoryResult(parent.normalizedResult, parent.subject ?? null),
+                evidenceIds: [parent.evidenceId],
+                inspection: null,
+            });
+        const inspection = artifactInspectionResultSchema.parse(parent.normalizedResult);
+        for (const step of inspection.substeps) {
+            if (step.evidence_id !== step.evidence.evidence_id ||
+                step.evidence.operation !== step.operation)
+                throw new TypeError("Inspection substep identity differs from its source Evidence");
+        }
+        const parsed = parseArtifactInventoryEvidence(inspection.substeps.map(({ evidence }) => evidence));
+        const manifest = parsed.inventory.manifest;
+        validateArtifactInventorySubject(parent.subject ?? null, manifest);
+        if (inspection.subject.manifest_id !== manifest.manifest_id ||
+            inspection.subject.root_artifact_id !== manifest.root_artifact_id ||
+            inspection.subject.root_sha256 !== manifest.root_sha256 ||
+            inspection.subject.root_format !== manifest.root_format)
+            throw new TypeError("Inspection subject differs from its inventory manifest");
+        return ok({
+            inventory: parsed.inventory,
+            evidenceIds: parsed.evidence.map(({ evidence_id }) => evidence_id),
+            inspection,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof TypeError) && !(cause instanceof z.ZodError))
+            throw cause;
+        return err(inputError(cause.message));
+    }
+};
+/** Project exact source records; exhausted pages cover available records, not runtime behavior. */
+export const projectArtifactInventoryView = (parent, view) => {
+    const operation = parent.operation;
+    if (operation !== "inventory_artifact" && operation !== "inspect_artifact")
+        return err(inputError("Inventory views require inventory_artifact or inspect_artifact Evidence."));
+    if (view.kind !== "summary" && view.kind !== "inventory")
+        return err(inputError("Artifact Evidence supports summary and inventory views."));
+    const parsed = parseSource(parent);
+    if (!parsed.ok)
+        return parsed;
+    const { inventory, evidenceIds, inspection } = parsed.value;
+    const limitations = uniqueSorted([
+        ...parent.limitations,
+        ...inventory.limitations,
+        ...(inspection?.limitations ?? []),
+    ]);
+    const shared = {
+        parent_evidence_id: parent.evidenceId,
+        parent_operation: operation,
+        parent_digest: parent.evidenceId.slice(3),
+        artifact: {
+            path: parent.artifact?.path ?? "",
+            sha256: inventory.manifest.root_sha256,
+        },
+        limitations,
+        unknowns: [
+            "Inventory does not establish application runtime behavior or complete format-specific analysis.",
+            ...(inventory.complete
+                ? []
+                : [
+                    "Parent inventory is partial; counts and exhausted pages cover only available records. Missing matches do not establish absence.",
+                ]),
+        ],
+    };
+    if (view.kind === "summary") {
+        const counts = { file: 0, directory: 0, symlink: 0, slice: 0 };
+        for (const occurrence of inventory.occurrences)
+            counts[occurrence.entry_kind]++;
+        const examined = inventory.nodes.length +
+            inventory.occurrences.length +
+            inventory.edges.length;
+        return ok({
+            kind: "summary",
+            view,
+            summary: {
+                manifest: inventory.manifest,
+                available_counts: {
+                    nodes: inventory.nodes.length,
+                    occurrences: inventory.occurrences.length,
+                    edges: inventory.edges.length,
+                    integrity_contradictions: inventory.integrityContradictions.length,
+                },
+                observed_entry_kind_counts: counts,
+                source_complete: inventory.complete,
+                inventory_evidence_ids: [...evidenceIds],
+                inspection: inspection === null
+                    ? null
+                    : {
+                        coverage: inspection.coverage,
+                        unexplored_branches: inspection.unexplored_branches,
+                    },
+                limitation_count: limitations.length,
+            },
+            coverage: completeWithinViewCoverage(examined, examined),
+            ...shared,
+        });
+    }
+    const paths = view.collection === "occurrences" && view.logical_paths !== undefined
+        ? new Set(view.logical_paths)
+        : undefined;
+    const rows = view.collection === "occurrences" && paths !== undefined
+        ? inventory.occurrences.filter((row) => paths.has(row.logical_path))
+        : view.collection === "occurrences"
+            ? inventory.occurrences
+            : view.collection === "nodes"
+                ? inventory.nodes
+                : view.collection === "edges"
+                    ? inventory.edges
+                    : inventory.integrityContradictions;
+    const items = rows.slice(view.offset, view.offset + view.limit);
+    return ok({
+        kind: "inventory",
+        view,
+        manifest: inventory.manifest,
+        inventory_evidence_ids: [...evidenceIds],
+        source_complete: inventory.complete,
+        items,
+        coverage: pageViewCoverage(view.offset, items.length, rows.length),
+        ...shared,
+    });
+};

package/dist/domain/analysisView/binaryLayoutView.js

@@ -1,7 +1,6 @@
 import { AnalysisInputError, } from "../analysisErrorCore.js";
-import { uniqueSorted } from "../canonicalOrdering.js";
 import { err, ok } from "../result.js";
-import { completeWithinViewCoverage as completeCoverage, pageViewCoverage as pageCoverage, } from "./analysisViewCoverage.js";
+import { boundedViewMessages, completeWithinViewCoverage as completeCoverage, pageViewCoverage as pageCoverage, } from "./analysisViewCoverage.js";
 const OPERATION = "inspect_analysis_view";
 const inputError = (issues) => new AnalysisInputError(OPERATION, undefined, issues);
 const layoutUnknowns = (layout) => {
@@ -76,8 +75,8 @@ const parentFields = (parent, layout) => ({
         path: layout.artifact.path,
         sha256: layout.artifact.sha256,
     },
-    limitations: uniqueSorted([...parent.limitations, ...layout.limitations]),
-    unknowns: uniqueSorted([...layoutUnknowns(layout)]),
+    limitations: boundedViewMessages([...parent.limitations, ...layout.limitations], parent.evidenceId, "limitations"),
+    unknowns: boundedViewMessages(layoutUnknowns(layout), parent.evidenceId, "unknowns"),
 });
 const layoutSummary = (layout) => ({
     bytes: layout.artifact.bytes,
@@ -96,6 +95,14 @@ const layoutSummary = (layout) => ({
 /** Project one layout view without re-running the decoder. */
 export const projectBinaryLayoutView = (parent, layout, view) => {
     const shared = parentFields(parent, layout);
+    if (view.kind === "native")
+        return err(layoutIncompatible("Native views require analyze_function Evidence."));
+    if (view.kind === "inventory")
+        return err(layoutIncompatible("Inventory views require artifact Evidence."));
+    if (view.kind === "wasm")
+        return err(layoutIncompatible("WASM views require inspect_wasm_artifact Evidence."));
+    if (view.kind === "evm")
+        return err(layoutIncompatible("EVM views require inspect_evm_interface Evidence."));
     if (view.kind === "summary")
         return ok({
             kind: "summary",
@@ -136,6 +143,8 @@ export const projectBinaryLayoutView = (parent, layout, view) => {
             ...shared,
         });
     }
+    if (view.kind !== "page")
+        return err(layoutIncompatible("Layout views require summary, facet, item or page selections."));
     if (view.collection === "modules")
         return err(layoutIncompatible("modules collection applies to analyze_javascript_application Evidence."));
     const rows = view.collection === "sections" ? layout.sections : layout.symbols;

package/dist/domain/analysisView/dartAotView.js

@@ -0,0 +1,93 @@
+import { analysisViewInputError } from "./analysisViewErrors.js";
+import { z } from "zod";
+import { flutterResultSchemas } from "../flutter/flutterBuildAnalysis.js";
+import { err, ok } from "../result.js";
+import { parseAnalysisViewResult } from "./analysisViewParent.js";
+import { completeWithinViewCoverage, pageViewCoverage, } from "./analysisViewCoverage.js";
+const aotSchema = flutterResultSchemas.inspect_dart_aot;
+/** Snapshot identity and original coverage, without unrelated string inventories. */
+export const dartAotSummarySchema = aotSchema.extend({
+    string_pool: aotSchema.shape.string_pool
+        .omit({ package_uris: true, dart_uris: true, class_like_tokens: true })
+        .extend({
+        returned_counts: z.strictObject({
+            package_uris: z.number().int().nonnegative(),
+            dart_uris: z.number().int().nonnegative(),
+            class_like_tokens: z.number().int().nonnegative(),
+        }),
+    }),
+});
+/** Pages of the producer-returned strings, preserving original order and scope. */
+export const dartAotViewRequestSchema = z.strictObject({
+    kind: z.literal("dart-aot"),
+    collection: z.enum(["package_uris", "dart_uris", "class_like_tokens"]),
+    offset: z.number().int().nonnegative().default(0),
+    limit: z.number().int().positive().default(64),
+});
+export const dartAotViewContextSchema = z.strictObject({
+    abi: aotSchema.shape.abi,
+    libapp: aotSchema.shape.libapp,
+    source_coverage: aotSchema.shape.coverage,
+    string_pool: dartAotSummarySchema.shape.string_pool,
+});
+/** Reuse authenticated AOT Evidence without opening the APK or rescanning its ELF. */
+export const projectDartAotView = (parent, view) => {
+    if (view.kind !== "summary" && view.kind !== "dart-aot")
+        return err(analysisViewInputError([
+            {
+                path: ["view"],
+                reason: "invalid_value",
+                message: "Dart AOT Evidence supports summary and string-pool pages.",
+            },
+        ]));
+    const parsed = parseAnalysisViewResult(aotSchema, parent);
+    if (!parsed.ok)
+        return parsed;
+    const report = parsed.value;
+    const { package_uris, dart_uris, class_like_tokens, ...pool } = report.string_pool;
+    const string_pool = {
+        ...pool,
+        returned_counts: {
+            package_uris: package_uris.length,
+            dart_uris: dart_uris.length,
+            class_like_tokens: class_like_tokens.length,
+        },
+    };
+    const shared = {
+        parent_evidence_id: parent.evidenceId,
+        parent_operation: "inspect_dart_aot",
+        parent_digest: parent.evidenceId.slice(3),
+        artifact: { path: report.target.path, sha256: report.target.sha256 },
+        limitations: [...parent.limitations],
+        unknowns: [
+            "String-pool entries are byte-pattern observations, not recovered typed classes or functions.",
+            "Counts ending in _at_least remain lower bounds; exhausting returned strings does not establish a complete snapshot inventory.",
+            ...(parent.subject == null
+                ? [
+                    "The parent has no recorded subject; its normalized target identity cannot be cross-checked against a subject digest.",
+                ]
+                : []),
+        ],
+    };
+    if (view.kind === "summary")
+        return ok({
+            kind: "summary",
+            view,
+            ...shared,
+            summary: { ...report, string_pool },
+            coverage: completeWithinViewCoverage(1, 1),
+        });
+    const collection = report.string_pool[view.collection];
+    const items = collection.slice(view.offset, view.offset + view.limit);
+    return ok({
+        kind: "dart-aot",
+        view,
+        ...shared,
+        items,
+        abi: report.abi,
+        libapp: report.libapp,
+        source_coverage: report.coverage,
+        string_pool,
+        coverage: pageViewCoverage(view.offset, items.length, collection.length),
+    });
+};

package/dist/domain/analysisView/evmInterfaceView.js

@@ -0,0 +1,105 @@
+import { analysisViewInputError } from "./analysisViewErrors.js";
+import { z } from "zod";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { evmInterfaceSchema } from "../evm/evmInterface.js";
+import { err, ok } from "../result.js";
+import { parseAnalysisViewResult } from "./analysisViewParent.js";
+import { completeWithinViewCoverage, pageViewCoverage, } from "./analysisViewCoverage.js";
+import { analysisTextPage } from "./analysisViewText.js";
+/** Retained inferred candidates or exact text; offsets for text count UTF-16 code units. */
+export const evmViewRequestSchema = z.strictObject({
+    kind: z.literal("evm"),
+    facet: z.enum(["functions", "bytecode_hex", "stdout", "stderr"]),
+    offset: z.number().int().nonnegative().default(0),
+    limit: z.number().int().positive().default(64),
+});
+export const evmViewItemSchema = z.union([
+    evmInterfaceSchema.shape.functions,
+    z.strictObject({ text: z.string(), unit: z.literal("utf16-code-units") }),
+]);
+/** Complete inferred interface facts without the unrequested hex or duplicated stdout. */
+export const evmSummarySchema = z.strictObject({
+    artifact: evmInterfaceSchema.shape.artifact,
+    bytecode: evmInterfaceSchema.shape.bytecode.omit({ hex: true }),
+    evidence_kind: evmInterfaceSchema.shape.evidence_kind,
+    functions: evmInterfaceSchema.shape.functions,
+    discovery_completeness: evmInterfaceSchema.shape.discovery_completeness,
+    runtime_execution: evmInterfaceSchema.shape.runtime_execution,
+    diagnostics: evmInterfaceSchema.shape.diagnostics
+        .omit({ stdout: true })
+        .extend({
+        stdout_code_units: z.number().int().nonnegative(),
+    }),
+    limitations: evmInterfaceSchema.shape.limitations,
+});
+/** Select already authenticated producer facts; no interpreter or provider is invoked. */
+export const projectEvmInterfaceView = (parent, view) => {
+    if (view.kind !== "summary" && view.kind !== "evm")
+        return err(analysisViewInputError([
+            {
+                path: ["view"],
+                reason: "invalid_value",
+                message: "EVM Evidence supports summary and evm views.",
+            },
+        ]));
+    const parsed = parseAnalysisViewResult(evmInterfaceSchema, parent);
+    if (!parsed.ok)
+        return parsed;
+    const report = parsed.value;
+    if (parent.subject == null ||
+        parent.subject.format !== "file" ||
+        parent.subject.local_path !== report.artifact.path ||
+        parent.subject.digest.sha256 !== report.artifact.sha256)
+        return err(analysisViewInputError([
+            {
+                path: ["source", "subject"],
+                reason: "invalid_value",
+                message: "EVM parent subject must identify the report's exact carrier path and SHA-256.",
+            },
+        ]));
+    const shared = {
+        parent_evidence_id: parent.evidenceId,
+        parent_operation: "inspect_evm_interface",
+        parent_digest: parent.evidenceId.slice(3),
+        artifact: { path: report.artifact.path, sha256: report.artifact.sha256 },
+        limitations: uniqueSorted([...parent.limitations, ...report.limitations]),
+        unknowns: [
+            "Candidates remain inferred; discovery completeness, bytecode kind, hardfork and deployment authenticity are unknown. Runtime execution was not performed.",
+        ],
+    };
+    if (view.kind === "summary") {
+        const { hex: _hex, ...bytecode } = report.bytecode;
+        const { stdout, ...diagnostics } = report.diagnostics;
+        return ok({
+            kind: "summary",
+            view,
+            ...shared,
+            summary: {
+                artifact: report.artifact,
+                bytecode,
+                evidence_kind: report.evidence_kind,
+                functions: report.functions,
+                discovery_completeness: report.discovery_completeness,
+                runtime_execution: report.runtime_execution,
+                diagnostics: { ...diagnostics, stdout_code_units: stdout.length },
+                limitations: report.limitations,
+            },
+            coverage: completeWithinViewCoverage(report.functions.length, report.functions.length),
+        });
+    }
+    if (view.facet === "functions") {
+        const item = report.functions.slice(view.offset, view.offset + view.limit);
+        return ok({
+            kind: "evm",
+            view,
+            item,
+            ...shared,
+            coverage: pageViewCoverage(view.offset, item.length, report.functions.length),
+        });
+    }
+    const text = view.facet === "bytecode_hex"
+        ? report.bytecode.hex
+        : report.diagnostics[view.facet];
+    const page = analysisTextPage(text, view.offset, view.limit, view.facet);
+    return page.ok ? ok({ kind: "evm", view, ...page.value, ...shared }) : page;
+};

package/dist/domain/analysisView/interfaceBuilderView.js

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import { analysisViewInputError } from "./analysisViewErrors.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { interfaceBuilderAnalysisSchema, interfaceBuilderDocumentSchema, } from "../apple/interfaceBuilderGraph.js";
+import { nativeInvestigationCoverageSchema, nativeInvestigationEdgeSchema, nativeInvestigationNodeSchema, } from "../native/nativeInvestigationGraph.js";
+import { err, ok } from "../result.js";
+import { parseAnalysisViewResult } from "./analysisViewParent.js";
+import { completeWithinViewCoverage, pageViewCoverage, } from "./analysisViewCoverage.js";
+const page = {
+    kind: z.literal("interface-builder"),
+    offset: z.number().int().nonnegative().default(0),
+    limit: z.number().int().positive().default(64),
+};
+/** Original decoded rows; graph rows can be narrowed to one decoded document. */
+export const interfaceBuilderViewRequestSchema = z.discriminatedUnion("collection", [
+    z.strictObject({
+        ...page,
+        collection: z.enum(["nodes", "edges"]),
+        document: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("Exact documents[].relative_path; selects rows whose evidence names that archive."),
+    }),
+    z.strictObject({
+        ...page,
+        collection: z.enum(["documents", "coverage"]),
+    }),
+]);
+export const interfaceBuilderViewItemsSchema = z.union([
+    z.array(interfaceBuilderDocumentSchema),
+    z.array(nativeInvestigationNodeSchema),
+    z.array(nativeInvestigationEdgeSchema),
+    z.array(nativeInvestigationCoverageSchema),
+]);
+/** The decoder's own truncation, independent of page exhaustion. */
+export const interfaceBuilderViewContextSchema = z.strictObject({
+    source_truncated: z.boolean(),
+});
+const countsSchema = z.record(z.string(), z.number().int().positive());
+/** Every decoded document with graph counts; rows and evidence stay retained. */
+export const interfaceBuilderSummarySchema = z.strictObject({
+    target_sha256: interfaceBuilderAnalysisSchema.shape.target_sha256,
+    provider: interfaceBuilderAnalysisSchema.shape.graph.shape.provider,
+    documents: interfaceBuilderAnalysisSchema.shape.documents,
+    available_counts: z.strictObject({
+        nodes: z.number().int().nonnegative(),
+        edges: z.number().int().nonnegative(),
+        coverage: z.number().int().nonnegative(),
+    }),
+    node_kinds: countsSchema,
+    edge_relations: countsSchema,
+    coverage_statuses: countsSchema,
+    truncated: z.boolean(),
+    limitation_count: z.number().int().nonnegative(),
+});
+const tally = (values) => {
+    const counts = new Map();
+    for (const value of values)
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    return Object.fromEntries([...counts].sort(([left], [right]) => (left < right ? -1 : 1)));
+};
+/** Admit a well-formed report bound to its recorded target, if one exists. */
+const parseInterfaceBuilderReport = (parent) => {
+    const parsed = parseAnalysisViewResult(interfaceBuilderAnalysisSchema, parent);
+    if (!parsed.ok)
+        return parsed;
+    const report = parsed.value;
+    if (report.graph.target_sha256 !== report.target_sha256 ||
+        (parent.subject != null &&
+            parent.subject.digest.sha256 !== report.target_sha256))
+        return err(analysisViewInputError([
+            {
+                path: ["source", "subject"],
+                reason: "invalid_value",
+                message: "Interface Builder parent Evidence subject and graph must identify the report's target SHA-256.",
+            },
+        ]));
+    return ok(report);
+};
+/** Every decoded document with graph tallies; rows stay in the retained parent. */
+const summarizeInterfaceBuilder = (report, limitationCount) => {
+    const { graph } = report;
+    const total = report.documents.length +
+        graph.nodes.length +
+        graph.edges.length +
+        graph.coverage.length;
+    return {
+        summary: {
+            target_sha256: report.target_sha256,
+            provider: graph.provider,
+            documents: report.documents,
+            available_counts: {
+                nodes: graph.nodes.length,
+                edges: graph.edges.length,
+                coverage: graph.coverage.length,
+            },
+            node_kinds: tally(graph.nodes.map((node) => node.kind)),
+            edge_relations: tally(graph.edges.map((edge) => edge.relation)),
+            coverage_statuses: tally(graph.coverage.map((row) => row.status)),
+            truncated: graph.truncated,
+            limitation_count: limitationCount,
+        },
+        coverage: completeWithinViewCoverage(total, total),
+    };
+};
+/** Project retained decode_interface_builder Evidence without reopening archives. */
+export const projectInterfaceBuilderView = (parent, view) => {
+    if (view.kind !== "summary" && view.kind !== "interface-builder")
+        return err(analysisViewInputError([
+            {
+                path: ["view"],
+                reason: "invalid_value",
+                message: "Interface Builder decoding supports summary and interface-builder views.",
+            },
+        ]));
+    const parsed = parseInterfaceBuilderReport(parent);
+    if (!parsed.ok)
+        return parsed;
+    const report = parsed.value;
+    const { graph } = report;
+    const limitations = uniqueSorted([
+        ...parent.limitations,
+        ...report.limitations,
+    ]);
+    const shared = {
+        parent_evidence_id: parent.evidenceId,
+        parent_operation: "decode_interface_builder",
+        parent_digest: parent.evidenceId.slice(3),
+        artifact: {
+            path: parent.subject?.local_path ?? "",
+            sha256: report.target_sha256,
+        },
+        limitations,
+        unknowns: [
+            "Rows describe recognized archive objects and connections only; unrecognized classes, fields and runtime-created UI remain unknown.",
+            ...(graph.truncated
+                ? [
+                    "The decoded graph is incomplete (see coverage and limitations for the cause); page exhaustion does not establish absence of undecoded objects or connections.",
+                ]
+                : []),
+        ],
+    };
+    if (view.kind === "summary")
+        return ok({
+            kind: "summary",
+            view,
+            ...shared,
+            ...summarizeInterfaceBuilder(report, limitations.length),
+        });
+    const document = view.collection === "nodes" || view.collection === "edges"
+        ? view.document
+        : undefined;
+    if (document !== undefined &&
+        !report.documents.some((row) => row.relative_path === document))
+        return err(analysisViewInputError([
+            {
+                path: ["view", "document"],
+                reason: "invalid_value",
+                message: "Select an exact documents[].relative_path from this decoded report.",
+            },
+        ]));
+    const inDocument = (candidates) => document === undefined
+        ? candidates
+        : candidates.filter((row) => row.evidence.some((evidence) => evidence.artifact_path === document));
+    const rows = view.collection === "documents"
+        ? report.documents
+        : view.collection === "coverage"
+            ? graph.coverage
+            : view.collection === "nodes"
+                ? inDocument(graph.nodes)
+                : inDocument(graph.edges);
+    const items = rows.slice(view.offset, view.offset + view.limit);
+    return ok({
+        kind: "interface-builder",
+        view,
+        items,
+        ...shared,
+        source_truncated: graph.truncated,
+        coverage: pageViewCoverage(view.offset, items.length, rows.length),
+    });
+};