rea-agents 2.5.0 → 3.1.0

package/dist/domain/javascriptRuntimeReconciliationMatching.js

@@ -20,14 +20,16 @@ const reconcileEntity = (entity, index, layers) => {
         const content = index.byCategoryDigest.get(categoryDigestKey(entity.staticKind, entity.sourceSha256)) ?? [];
         const locatedKeys = new Set(locations.map(({ candidate }) => candidateKey(candidate)));
         const combined = content.filter((candidate) => locatedKeys.has(candidateKey(candidate)));
-        if (combined.length === 1)
-            return matched(entity, combined[0], {
+        const combinedCandidate = combined.at(0);
+        if (combined.length === 1 && combinedCandidate !== undefined)
+            return matched(entity, combinedCandidate, {
                 basis: "content-and-location",
                 confidence: "high",
                 reason: "content-and-location-match",
             });
-        if (content.length === 1) {
-            const candidate = content[0];
+        const contentCandidate = content.at(0);
+        if (content.length === 1 && contentCandidate !== undefined) {
+            const candidate = contentCandidate;
             const digestBasis = candidate.digests.find(({ sha256 }) => sha256 === entity.sourceSha256)?.basis;
             return matched(entity, candidate, {
                 basis: digestBasis ?? "content-sha256",
@@ -59,8 +61,9 @@ const reconcileEntity = (entity, index, layers) => {
             candidates: [],
         });
     }
-    if (locations.length === 1) {
-        const located = locations[0];
+    const location = locations.at(0);
+    if (locations.length === 1 && location !== undefined) {
+        const located = location;
         return matched(entity, located.candidate, {
             basis: located.mapping.basis,
             confidence: "medium",
@@ -174,50 +177,55 @@ const createItem = (entity, input) => {
         ...semantic,
     };
 };
-const reconciliationEvidence = (entity, layer, basis, confidence) => ({
-    authority: "cross-layer-reconciliation",
-    state: "inferred",
-    confidence: confidence === "medium" ? "medium" : "high",
-    artifact: entity.sourceSha256 === null
-        ? {
-            available: false,
-            reason: "not-observed",
-            detail: "Runtime source bytes were not captured for this mapping.",
-        }
-        : {
-            available: true,
-            artifact_id: `art_${entity.sourceSha256}`,
-            sha256: entity.sourceSha256,
-        },
-    location: entity.node.observations[0].evidence.location,
-    extractor: {
-        name: "rea-javascript-runtime-reconciliation",
-        version: "1",
-        operation: "reconcile_javascript_runtime",
-        executable_sha256: null,
-    },
-    coverage: layer.graph.coverage.status === "complete" &&
-        entity.capture.scriptsCompleteWithinScope
-        ? { status: "complete", truncated: false, omitted_count: 0, limits: [] }
-        : {
-            status: "partial",
-            truncated: false,
-            omitted_count: null,
-            limits: [],
+const reconciliationEvidence = (entity, layer, basis, confidence) => {
+    const observation = entity.node.observations.at(0);
+    if (observation === undefined)
+        throw new TypeError("Runtime reconciliation entity has no observation");
+    return {
+        authority: "cross-layer-reconciliation",
+        state: "inferred",
+        confidence: confidence === "medium" ? "medium" : "high",
+        artifact: entity.sourceSha256 === null
+            ? {
+                available: false,
+                reason: "not-observed",
+                detail: "Runtime source bytes were not captured for this mapping.",
+            }
+            : {
+                available: true,
+                artifact_id: `art_${entity.sourceSha256}`,
+                sha256: entity.sourceSha256,
+            },
+        location: observation.evidence.location,
+        extractor: {
+            name: "rea-javascript-runtime-reconciliation",
+            version: "1",
+            operation: "reconcile_javascript_runtime",
+            executable_sha256: null,
         },
-    limitations: [
-        basis === "content-sha256" ||
-            basis === "module-source-sha256" ||
-            basis === "content-and-location"
-            ? "Equal content digests establish byte identity, not execution causality."
-            : "Location correspondence is inferred from an artifact root or caller-declared mapping.",
-        "Passive script parsing or target presence does not prove feature execution.",
-    ],
-    evidence_ids: [
-        layer.evidence.evidence_id,
-        entity.capture.evidence.evidence_id,
-    ].sort(),
-});
+        coverage: layer.graph.coverage.status === "complete" &&
+            entity.capture.scriptsCompleteWithinScope
+            ? { status: "complete", truncated: false, omitted_count: 0, limits: [] }
+            : {
+                status: "partial",
+                truncated: false,
+                omitted_count: null,
+                limits: [],
+            },
+        limitations: [
+            basis === "content-sha256" ||
+                basis === "module-source-sha256" ||
+                basis === "content-and-location"
+                ? "Equal content digests establish byte identity, not execution causality."
+                : "Location correspondence is inferred from an artifact root or caller-declared mapping.",
+            "Passive script parsing or target presence does not prove feature execution.",
+        ],
+        evidence_ids: [
+            layer.evidence.evidence_id,
+            entity.capture.evidence.evidence_id,
+        ].sort(),
+    };
+};
 const strongestLocationBasis = (values) => {
     const bases = new Set(values.map(({ mapping }) => mapping.basis));
     if (bases.has("artifact-path"))

package/dist/domain/javascriptRuntimeReconciliationParsing.js

@@ -9,6 +9,7 @@ import { javascriptRuntimeObservationSchema, javascriptRuntimeKindSchema, } from
 import { parseEvidence } from "./evidence.js";
 import { javascriptApplicationAnalysisResultSchema, } from "./javascriptApplicationAnalysis.js";
 import { compareCodePoints, } from "./javascriptApplicationGraph.js";
+import { parseActiveElectronCapture } from "./javascriptRuntimeReconciliationActive.js";
 /** Parse and semantically bind every static analysis Evidence layer. */
 export const parseStaticLayers = (layers) => layers
     .map((layer) => parseStaticLayer(layer))
@@ -133,7 +134,10 @@ const parseRuntimeCapture = (input) => {
             scriptsCompleteWithinScope: false,
         };
     }
-    throw new TypeError("Runtime reconciliation requires inspect_web_page, inspect_electron_page, or observe_javascript_runtime Evidence");
+    if (evidence.operation === "capture_electron_scenario") {
+        return parseActiveElectronCapture(evidence);
+    }
+    throw new TypeError("Runtime reconciliation requires inspect_web_page, inspect_electron_page, observe_javascript_runtime, or capture_electron_scenario Evidence");
 };
 const assertV8RuntimeParameters = (evidence, result) => {
     const parameters = z

package/dist/domain/javascriptRuntimeReconciliationResult.js

@@ -78,27 +78,34 @@ const sourceMapAuthority = (input) => ({
     limitation: "Source-map declarations and approved original-source reads retain separate static authority and are not used as primary runtime byte matches.",
 });
 const reconciliationCoverage = (input, completion) => ({
-    status: completion.outputTruncated || completion.inputTruncated
+    status: completion.outputTruncated || completion.inputStatus === "truncated"
         ? "truncated"
-        : completion.inputPartial
+        : completion.inputStatus === "partial"
             ? "partial"
             : "complete-within-inputs",
-    truncated: completion.outputTruncated || completion.inputTruncated,
+    truncated: completion.outputTruncated || completion.inputStatus === "truncated",
     omitted_runtime_entities: input.runtime.omittedEntities,
     omitted_reconciliation_items: input.matching.omittedItems,
     omitted_static_load_states: input.loadStates.omittedStates,
     omitted_graph_items: input.omittedGraphItems,
 });
-const completionFlags = (input) => ({
-    outputTruncated: input.runtime.omittedEntities > 0 ||
-        input.matching.omittedItems > 0 ||
-        input.loadStates.omittedStates > 0 ||
-        input.omittedGraphItems > 0,
-    inputTruncated: input.layers.some(({ graph }) => graph.coverage.truncated) ||
-        input.captures.some(({ inspection }) => inspection.completeness.conditions.includes("truncated")),
-    inputPartial: input.layers.some(({ graph }) => graph.coverage.status !== "complete") ||
-        input.captures.some(({ inspection }) => inspection.completeness.status !== "complete_within_window"),
-});
+const completionFlags = (input) => {
+    const inputTruncated = input.layers.some(({ graph }) => graph.coverage.truncated) ||
+        input.captures.some(({ inspection }) => inspection.completeness.conditions.includes("truncated"));
+    const inputPartial = input.layers.some(({ graph }) => graph.coverage.status !== "complete") ||
+        input.captures.some(({ inspection }) => inspection.completeness.status !== "complete_within_window");
+    return {
+        outputTruncated: input.runtime.omittedEntities > 0 ||
+            input.matching.omittedItems > 0 ||
+            input.loadStates.omittedStates > 0 ||
+            input.omittedGraphItems > 0,
+        inputStatus: inputTruncated
+            ? "truncated"
+            : inputPartial
+                ? "partial"
+                : "complete",
+    };
+};
 const reconciliationLimitations = (completion) => uniqueSorted([
     "Only caller-supplied, semantically verified Evidence records were reconciled.",
     "Digest equality establishes byte identity but not code reachability, module initialization, or feature execution.",
@@ -106,7 +113,7 @@ const reconciliationLimitations = (completion) => uniqueSorted([
     "Not-observed means absent from the bounded captures in scope, never globally unloaded.",
     "Caller-declared file and URL mappings are inference inputs and do not expand CDP origin or filesystem-root authority.",
     "Source-map authority remains separate from passive runtime authority.",
-    ...(completion.inputPartial
+    ...(completion.inputStatus !== "complete"
         ? ["One or more static graphs or passive captures were incomplete."]
         : []),
     ...(completion.outputTruncated

package/dist/domain/javascriptRuntimeReconciliationSchemas.js

@@ -133,7 +133,7 @@ const layerSummarySchema = z.strictObject({
 const captureSummarySchema = z.strictObject({
     evidence_id: evidenceIdSchema,
     capture_sha256: digestSchema,
-    kind: z.enum(["browser", "electron", "v8-inspector"]),
+    kind: z.enum(["browser", "electron", "v8-inspector", "electron-active"]),
     target_node_id: nodeIdSchema,
     target_key: boundedTextSchema,
     target_location: boundedTextSchema,

package/dist/domain/javascriptSemanticAnalysis.js

@@ -1,4 +1,3 @@
-import { parse } from "@babel/parser";
 import * as t from "@babel/types";
 import { DEFAULT_JAVASCRIPT_SEMANTIC_LIMITS, failedJavaScriptSemanticIr, } from "./javascriptSemanticIr.js";
 import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, reachSemanticLimit, semanticModuleOrigin, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
@@ -7,20 +6,17 @@ import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { collectSemanticReturns, resolveSemanticModuleCallables, } from "./javascriptSemanticReturns.js";
 import { collectJavaScriptDerivedSemantics } from "./javascriptSemanticDerivedAnalysis.js";
 import { compareCodePoints, propertyName, range, } from "./javascriptStaticAnalysisHelpers.js";
+import { parseJavaScriptSource, } from "./javascriptSourceParser.js";
 /** Recover bounded lexical bindings, aliases, constants, and module links. */
 export const analyzeJavaScriptSemantics = (source, inputLimits = {}) => {
+    const file = parseJavaScriptSource(source);
+    return file === null
+        ? failedJavaScriptSemanticIr()
+        : analyzeParsedJavaScriptSemantics(file, inputLimits);
+};
+/** Recover semantics from an already parsed JavaScript artifact. */
+export const analyzeParsedJavaScriptSemantics = (file, inputLimits = {}) => {
     const limits = { ...DEFAULT_JAVASCRIPT_SEMANTIC_LIMITS, ...inputLimits };
-    let file;
-    try {
-        file = parse(source, {
-            sourceType: "unambiguous",
-            errorRecovery: true,
-            plugins: ["jsx", "typescript"],
-        });
-    }
-    catch {
-        return failedJavaScriptSemanticIr();
-    }
     const state = createState(file.program, limits);
     collectDefinitions(file.program, state);
     const references = collectSemanticReferences(file.program, state);

package/dist/domain/javascriptSourceParser.js

@@ -0,0 +1,15 @@
+import { parse } from "@babel/parser";
+/** Parse JavaScript or TypeScript once without retaining unused comment nodes. */
+export const parseJavaScriptSource = (source) => {
+    try {
+        return parse(source, {
+            sourceType: "unambiguous",
+            errorRecovery: true,
+            attachComment: false,
+            plugins: ["jsx", "typescript"],
+        });
+    }
+    catch {
+        return null;
+    }
+};

package/dist/domain/javascriptStaticAnalysis.js

@@ -1,4 +1,3 @@
-import { parse } from "@babel/parser";
 import * as t from "@babel/types";
 import { inspectElectronStaticNode } from "./electronStaticAnalysis.js";
 import { detectVendors, failedJavaScriptStaticAnalysis, registrationKey, sortedUnique, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
@@ -6,19 +5,16 @@ import { addReference, addSourceMapDirectives, inspectCall, inspectRouteProperty
 import { inspectBundlerRegistration, inspectEsbuildWrapper, } from "./javascriptStaticAnalysisBundler.js";
 import { finalizeLocatedFindings } from "./javascriptStaticAnalysisFindings.js";
 import { createJavaScriptAnalysisAccumulator, } from "./javascriptStaticAnalysisState.js";
+import { parseJavaScriptSource, } from "./javascriptSourceParser.js";
 /** Parse one bounded JavaScript artifact and recover static structure only. */
 export const analyzeJavaScriptStaticSource = (source, limits) => {
-    let file;
-    try {
-        file = parse(source, {
-            sourceType: "unambiguous",
-            errorRecovery: true,
-            plugins: ["jsx", "typescript"],
-        });
-    }
-    catch {
-        return failedJavaScriptStaticAnalysis();
-    }
+    const file = parseJavaScriptSource(source);
+    return file === null
+        ? failedJavaScriptStaticAnalysis()
+        : analyzeParsedJavaScriptStaticSource(source, file, limits);
+};
+/** Recover static structure from an already parsed JavaScript artifact. */
+export const analyzeParsedJavaScriptStaticSource = (source, file, limits) => {
     const accumulator = createJavaScriptAnalysisAccumulator();
     traverseStaticSource(source, file, accumulator, limits);
     addSourceMapDirectives(source, accumulator, limits.maxFindings);

package/dist/domain/knownPageCoverage.js

@@ -11,11 +11,19 @@ export const assessKnownPageCoverage = (page, includedCount = page.items.length)
         page.returned === page.total &&
         sourceOmittedCount === 0;
     const omittedCount = Math.max(0, page.total - retainedCount);
-    return {
-        complete: sourceComplete && omittedCount === 0,
-        sourceComplete,
-        includedCount: retainedCount,
-        omittedCount,
-        sourceOmittedCount,
-    };
+    return sourceComplete && omittedCount === 0
+        ? {
+            complete: true,
+            sourceComplete: true,
+            includedCount: retainedCount,
+            omittedCount: 0,
+            sourceOmittedCount: 0,
+        }
+        : {
+            complete: false,
+            sourceComplete,
+            includedCount: retainedCount,
+            omittedCount,
+            sourceOmittedCount,
+        };
 };

package/dist/domain/mobileApplicationInvestigation.js

@@ -0,0 +1,159 @@
+import { z } from "zod";
+/** Supported mobile artifact formats. */
+export const mobileArtifactFormatSchema = z.enum([
+    "apk",
+    "aab",
+    "ipa",
+    "dex",
+    "native_lib",
+]);
+/** Mobile platform. */
+export const mobilePlatformSchema = z.enum([
+    "android",
+    "ios",
+    "cross_platform",
+]);
+/** Android manifest entry. */
+export const androidManifestSchema = z.strictObject({
+    package_name: z.string().min(1),
+    version_name: z.string().nullable(),
+    version_code: z.number().int().nullable(),
+    min_sdk: z.number().int().nullable(),
+    target_sdk: z.number().int().nullable(),
+    permissions: z.array(z.string()).default([]),
+    activities: z.array(z.string()).default([]),
+    services: z.array(z.string()).default([]),
+    receivers: z.array(z.string()).default([]),
+    providers: z.array(z.string()).default([]),
+});
+/** iOS app manifest (Info.plist). */
+export const iosManifestSchema = z.strictObject({
+    bundle_identifier: z.string().min(1),
+    bundle_version: z.string().nullable(),
+    short_version: z.string().nullable(),
+    minimum_os_version: z.string().nullable(),
+    supported_platforms: z.array(z.string()).default([]),
+    ui_required_device_capabilities: z.array(z.string()).default([]),
+    app_permissions: z.array(z.string()).default([]),
+});
+/** Signing information. */
+export const signingInfoSchema = z.strictObject({
+    is_signed: z.boolean().default(false),
+    signer_identity: z.string().nullable(),
+    certificate_fingerprint: z.string().nullable(),
+    signature_scheme: z.string().nullable(),
+    is_debuggable: z.boolean().default(false),
+});
+/** Native library entry. */
+export const nativeLibrarySchema = z.strictObject({
+    path: z.string().min(1),
+    architecture: z.string().nullable(),
+    size: z.number().int().nonnegative(),
+    digest: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .nullable(),
+});
+/** Resource entry within a mobile artifact. */
+export const mobileResourceSchema = z.strictObject({
+    path: z.string().min(1),
+    type: z.enum([
+        "layout",
+        "drawable",
+        "string",
+        "asset",
+        "raw",
+        "native_lib",
+        "manifest",
+        "entitlements",
+        "provisioning",
+        "other",
+    ]),
+    size: z.number().int().nonnegative(),
+});
+/** Static analysis result for a mobile artifact. */
+export const mobileArtifactManifestSchema = z.strictObject({
+    format: mobileArtifactFormatSchema,
+    platform: mobilePlatformSchema,
+    app_name: z.string().nullable(),
+    android_manifest: androidManifestSchema.nullable(),
+    ios_manifest: iosManifestSchema.nullable(),
+    signing: signingInfoSchema,
+    resources: z.array(mobileResourceSchema).default([]),
+    native_libraries: z.array(nativeLibrarySchema).default([]),
+    total_size: z.number().int().nonnegative(),
+    architectures: z.array(z.string()).default([]),
+});
+/** Detect mobile artifact format from file extension. */
+export function detectMobileFormat(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".apk"))
+        return "apk";
+    if (lower.endsWith(".aab"))
+        return "aab";
+    if (lower.endsWith(".ipa"))
+        return "ipa";
+    if (lower.endsWith(".dex"))
+        return "dex";
+    if (lower.endsWith(".so") || lower.endsWith(".dylib") || lower.endsWith(".a"))
+        return "native_lib";
+    return null;
+}
+/** Detect platform from format. */
+export function detectPlatform(format) {
+    switch (format) {
+        case "apk":
+        case "aab":
+        case "dex":
+            return "android";
+        case "ipa":
+            return "ios";
+        case "native_lib":
+            return "cross_platform";
+    }
+}
+/** Classify a resource by its path. */
+export function classifyMobileResource(path) {
+    const lower = path.toLowerCase();
+    if (lower.includes("androidmanifest.xml"))
+        return "manifest";
+    if (lower.includes(".entitlements"))
+        return "entitlements";
+    if (lower.includes("provisioning") || lower.includes(".mobileprovision"))
+        return "provisioning";
+    if (lower.includes("/layout/"))
+        return "layout";
+    if (lower.includes("/drawable/") || lower.includes("/mipmap/"))
+        return "drawable";
+    if (lower.includes("/values/"))
+        return "string";
+    if (lower.includes("assets/") || lower.includes("raw/"))
+        return "asset";
+    if (lower.endsWith(".so") || lower.endsWith(".dylib"))
+        return "native_lib";
+    if (lower.endsWith(".xml"))
+        return "layout";
+    return "other";
+}
+/** Get all native libraries for a specific architecture. */
+export function nativeLibsByArchitecture(manifest, arch) {
+    return manifest.native_libraries.filter((l) => l.architecture === arch);
+}
+/** Check if an Android artifact has internet permission. */
+export function hasInternetPermission(manifest) {
+    if (!manifest.android_manifest)
+        return false;
+    return manifest.android_manifest.permissions.some((p) => p.includes("INTERNET") || p.includes("android.permission.INTERNET"));
+}
+/** Get all unique architectures across native libraries. */
+export function getAllArchitectures(manifest) {
+    const archs = new Set();
+    for (const lib of manifest.native_libraries) {
+        if (lib.architecture)
+            archs.add(lib.architecture);
+    }
+    for (const arch of manifest.architectures) {
+        archs.add(arch);
+    }
+    return [...archs];
+}

package/dist/domain/nativeApiBoundary.js

@@ -0,0 +1,138 @@
+import { z } from "zod";
+const inferenceConfidenceSchema = z.enum(["low", "medium", "high"]);
+const inferenceEvidenceSchema = z
+    .object({
+    kind: z.enum([
+        "signature-source",
+        "decompiler-type",
+        "type-lock",
+        "calling-convention",
+        "jump-table",
+    ]),
+    source: z.string().min(1),
+    detail: z.string().min(1),
+})
+    .strict();
+const inferredBoundaryTypeFacts = {
+    ordinal: z.number().int().min(0).nullable(),
+    name: z.string().min(1).nullable(),
+    data_type: z.string().min(1),
+    size_bytes: z.number().int().min(0).nullable(),
+    storage: z.string().min(1).nullable(),
+    confidence: inferenceConfidenceSchema,
+    evidence: z.array(inferenceEvidenceSchema).min(1),
+    decompiler_artifacts: z.array(z.enum([
+        "recovered-signature",
+        "register-or-stack-storage",
+        "compiler-generated-variable",
+    ])),
+};
+const inferredReturnTypeSchema = z.strictObject({
+    ...inferredBoundaryTypeFacts,
+    role: z.literal("return"),
+    ordinal: z.null(),
+    name: z.null(),
+});
+const inferredParameterTypeSchema = z.strictObject({
+    ...inferredBoundaryTypeFacts,
+    role: z.literal("parameter"),
+    ordinal: z.number().int().min(0),
+});
+const jumpTableDataSourceSchema = z
+    .object({
+    address: z.string().min(1),
+    provenance: z.enum([
+        "ghidra-decompiler-load-table",
+        "ghidra-dispatch-block-data-reference",
+    ]),
+    entry_size_bytes: z.number().int().min(1).nullable(),
+    entry_count: z.number().int().min(0).nullable(),
+    confidence: inferenceConfidenceSchema,
+    evidence: z.array(inferenceEvidenceSchema).min(1),
+})
+    .strict();
+const jumpTableMappingSchema = z
+    .object({
+    case_value: z.number().int().nullable(),
+    target_address: z.string().min(1),
+    data_addresses: z.array(z.string().min(1)),
+    confidence: inferenceConfidenceSchema,
+    evidence: z.array(inferenceEvidenceSchema).min(1),
+})
+    .strict();
+const inferredJumpTableSchema = z
+    .object({
+    dispatch_address: z.string().min(1),
+    data_sources: z.array(jumpTableDataSourceSchema),
+    data_sources_truncated: z.boolean(),
+    mappings: z.array(jumpTableMappingSchema),
+    mappings_truncated: z.boolean(),
+    limitations: z.array(z.string()),
+})
+    .strict();
+const availableNativeApiBoundarySchema = z
+    .object({
+    available: z.literal(true),
+    provenance: z.string().min(1),
+    signature_source: z.string().min(1),
+    calling_convention: z.string().min(1),
+    return_type: inferredReturnTypeSchema,
+    parameters: z.array(inferredParameterTypeSchema),
+    parameters_truncated: z.boolean(),
+    jump_tables: z.array(inferredJumpTableSchema),
+    jump_tables_truncated: z.boolean(),
+    pseudocode: z
+        .object({
+        classification: z.literal("decompiler-generated-non-source"),
+        compilable: z.literal(false),
+    })
+        .strict(),
+    decompiler_artifacts: z.array(z.enum([
+        "recovered-signature",
+        "register-and-stack-variables",
+        "compiler-generated-control-flow",
+        "pointer-arithmetic",
+        "pseudocode",
+    ])),
+    limitations: z.array(z.string()),
+})
+    .strict();
+const unavailableNativeApiBoundarySchema = z
+    .object({
+    available: z.literal(false),
+    reason: z.string().min(1),
+    residual_unknowns: z.array(z.string().min(1)).min(1),
+})
+    .strict();
+/** Provider-neutral native API boundary observations attached to a function dossier. */
+export const nativeApiBoundarySchema = z.discriminatedUnion("available", [
+    unavailableNativeApiBoundarySchema,
+    availableNativeApiBoundarySchema,
+]);
+const nativeApiInspectionSubstepSchema = z
+    .object({
+    operation: z.enum([
+        "analyze_function",
+        "project_native_api_boundary",
+        "preserve_residual_unknowns",
+    ]),
+    status: z.enum(["completed", "unsupported"]),
+    observations: z.array(z.string().min(1)),
+})
+    .strict();
+/** Agent-facing projection of structured native API reconstruction substeps. */
+export const nativeApiInspectionResultSchema = z
+    .object({
+    schema_version: z.literal(1),
+    procedure: z
+        .object({
+        address: z.string().min(1),
+        name: z.string().min(1),
+    })
+        .strict(),
+    boundary: nativeApiBoundarySchema,
+    substeps: z.array(nativeApiInspectionSubstepSchema).min(3).max(3),
+    unsupported_branches: z.array(z.string().min(1)),
+    residual_unknowns: z.array(z.string().min(1)),
+})
+    .strict();