rea-agents 3.1.0 → 3.2.1

package/dist/domain/sourceToBundleComparisonSchemas.js

@@ -5,7 +5,7 @@ import { historicalSourceGraphSchema } from "./referenceSourceGraph.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const nodeIdSchema = z.string().regex(/^jag_node_[a-f0-9]{64}$/u);
-const boundedTextSchema = z.string().min(1).max(4_096);
+const textSchema = z.string().min(1);
 export const SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS = [
     ["exact-source-digest", 100],
     ["source-map-original-path", 70],
@@ -22,47 +22,29 @@ const sourceToBundleSignalKindSchema = z.enum([
     "basename-match",
     "language-extension",
 ]);
-const sourceToBundleLimitsSchema = z.strictObject({
-    max_source_files: z.number().int().min(1).max(100_000).default(10_000),
-    max_application_nodes: z.number().int().min(1).max(100_000).default(20_000),
-    max_candidate_nodes: z.number().int().min(1).max(1_000).default(100),
-    max_candidate_evaluations: z
-        .number()
-        .int()
-        .min(1)
-        .max(10_000_000)
-        .default(1_000_000),
-});
-/** Historical source inventory, authenticated application Evidence, and bounds. */
+/** Historical source inventory and authenticated application Evidence. */
 export const compareSourceToBundleInputSchema = z.strictObject({
     reference: historicalSourceGraphSchema,
     application: evidenceSchema,
-    limits: sourceToBundleLimitsSchema.default({
-        max_source_files: 10_000,
-        max_application_nodes: 20_000,
-        max_candidate_nodes: 100,
-        max_candidate_evaluations: 1_000_000,
-    }),
-    unknown_registry_approved: z.literal(true).optional(),
 });
 const sourceToBundleSignalSchema = z.strictObject({
     kind: sourceToBundleSignalKindSchema,
     weight: z.number().int().min(1).max(100),
-    source_value: boundedTextSchema,
-    current_values: z.array(boundedTextSchema).min(1).max(64),
+    source_value: textSchema,
+    current_values: z.array(textSchema).min(1),
 });
 const sourceToBundleCandidateSchema = z.strictObject({
     current_node_id: nodeIdSchema,
     current_node_kind: z.enum(JAVASCRIPT_APPLICATION_NODE_KINDS),
-    score: z.number().int().min(1).max(300),
+    score: z.number().int().min(1),
     confidence: z.enum(["exact", "high", "medium", "low"]),
-    signals: z.array(sourceToBundleSignalSchema).min(1).max(6),
+    signals: z.array(sourceToBundleSignalSchema).min(1),
 });
 const sourceToBundleItemSchema = z.strictObject({
     mapping_id: z.string().regex(/^stbc_item_[a-f0-9]{64}$/u),
-    source_path: boundedTextSchema,
+    source_path: textSchema,
     source_sha256: digestSchema.nullable(),
-    source_language: z.string().min(1).max(100).nullable(),
+    source_language: textSchema.nullable(),
     status: z.enum([
         "unchanged",
         "modified",
@@ -73,14 +55,12 @@ const sourceToBundleItemSchema = z.strictObject({
         "unknown",
     ]),
     confidence: z.enum(["exact", "high", "medium", "unknown"]),
-    current_node_ids: z.array(nodeIdSchema).max(1_000),
-    candidates: z.array(sourceToBundleCandidateSchema).max(1_000),
-    omitted_candidates: z.number().int().min(0),
-    limitations: z.array(boundedTextSchema).max(100),
+    current_node_ids: z.array(nodeIdSchema),
+    candidates: z.array(sourceToBundleCandidateSchema),
+    limitations: z.array(textSchema),
 });
 /** Deterministic, evidence-bearing historical-source to shipped-bundle comparison. */
 export const sourceToBundleComparisonResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     comparison_id: z.string().regex(/^stbc_[a-f0-9]{64}$/u),
     reference: z.strictObject({
         root_sha256: digestSchema,
@@ -92,7 +72,7 @@ export const sourceToBundleComparisonResultSchema = z.strictObject({
         root_artifact_sha256: digestSchema,
     }),
     scoring: z.strictObject({
-        algorithm: z.literal("rea-source-to-bundle-signals/v1"),
+        algorithm: z.literal("rea-source-to-bundle-signals"),
         minimum_candidate_score: z.literal(20),
         weights: z.array(z.strictObject({
             signal: sourceToBundleSignalKindSchema,
@@ -108,10 +88,10 @@ export const sourceToBundleComparisonResultSchema = z.strictObject({
         duplicated: z.number().int().min(0),
         unknown: z.number().int().min(0),
     }),
-    items: z.array(sourceToBundleItemSchema).max(100_000),
-    unmapped_current_node_ids: z.array(nodeIdSchema).max(100_000),
+    items: z.array(sourceToBundleItemSchema),
+    unmapped_current_node_ids: z.array(nodeIdSchema),
     coverage: z.strictObject({
-        status: z.enum(["complete-within-inputs", "partial", "truncated"]),
+        status: z.enum(["complete-within-inputs", "partial"]),
         reference_inventory_state: z.enum(["complete", "partial", "unknown"]),
         application_graph_status: z.enum([
             "complete",
@@ -120,14 +100,9 @@ export const sourceToBundleComparisonResultSchema = z.strictObject({
             "unavailable",
         ]),
         retained_source_files: z.number().int().min(0),
-        omitted_source_files: z.number().int().min(0),
         retained_application_nodes: z.number().int().min(0),
-        omitted_application_nodes: z.number().int().min(0),
         candidate_evaluations: z.number().int().min(0),
-        omitted_candidate_evaluations: z.number().int().min(0),
-        omitted_candidate_references: z.number().int().min(0),
-        omitted_unmapped_current_nodes: z.number().int().min(0),
     }),
-    evidence_links: z.array(evidenceIdSchema).min(1).max(1),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    evidence_links: z.array(evidenceIdSchema).length(1),
+    limitations: z.array(textSchema),
 });

package/dist/domain/sourceToBundleSignals.js

@@ -13,7 +13,6 @@ const PATH_PROPERTIES = [
     "resolved_path",
     "declared_path",
 ];
-const MAX_PATH_SUFFIXES = 128;
 const signalWeight = (kind) => {
     const entry = SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS.find(([signal]) => signal === kind);
     if (entry === undefined)
@@ -28,20 +27,17 @@ export const sourceBearingNodes = (nodes) => nodes
 export const historicalSourceFiles = (graph) => graph.entries
     .filter((entry) => entry.kind === "file" && entry.classifications.includes("source"))
     .sort((left, right) => compareText(left.path, right.path));
-/** Build bounded-key indices without assigning fuzzy matches. */
+/** Build deterministic candidate indices without assigning fuzzy matches. */
 export const buildSourceToBundleCandidateIndex = (nodes) => {
     const projections = nodes.map(projectCurrentNode);
     const byDigest = new Map();
     const byPathSuffix = new Map();
     const byBasename = new Map();
-    let pathIndexTruncated = false;
     for (const projection of projections) {
         for (const digest of projection.digests)
             addIndexValue(byDigest, digest, projection.node.node_id);
         for (const path of projection.paths) {
-            const suffixes = pathSuffixes(path.value);
-            pathIndexTruncated ||= suffixes.truncated;
-            for (const suffix of suffixes.values)
+            for (const suffix of pathSuffixes(path.value))
                 addIndexValue(byPathSuffix, suffix, projection.node.node_id);
             addIndexValue(byBasename, posix.basename(path.value), projection.node.node_id);
         }
@@ -51,7 +47,6 @@ export const buildSourceToBundleCandidateIndex = (nodes) => {
         byDigest,
         byPathSuffix,
         byBasename,
-        pathIndexTruncated,
     };
 };
 /** Candidate identifiers ordered by strongest available signal, then ID. */
@@ -153,7 +148,7 @@ const signal = (kind, sourceValue, currentValues) => ({
     kind,
     weight: signalWeight(kind),
     source_value: sourceValue,
-    current_values: [...new Set(currentValues)].sort(compareText).slice(0, 64),
+    current_values: [...new Set(currentValues)].sort(compareText),
 });
 const candidateConfidence = (signals) => {
     const kinds = new Set(signals.map(({ kind }) => kind));
@@ -191,13 +186,7 @@ const uniquePaths = (paths) => [
 ].sort((left, right) => compareText(`${left.kind}\0${left.value}`, `${right.kind}\0${right.value}`));
 const pathSuffixes = (path) => {
     const parts = path.split("/");
-    const start = Math.max(0, parts.length - MAX_PATH_SUFFIXES);
-    return {
-        values: parts
-            .slice(start)
-            .map((_, index) => parts.slice(start + index).join("/")),
-        truncated: start > 0,
-    };
+    return parts.map((_, index) => parts.slice(index).join("/"));
 };
 const addIndexValue = (index, key, nodeId) => {
     const values = index.get(key) ?? new Set();

package/dist/domain/staticRuntimeCorrelation.js

@@ -39,7 +39,7 @@ const observedPatternSchema = z.enum([
 const artifactSelectorSchema = z
     .object({
     kind: z.literal("artifact"),
-    logical_path: z.string().min(1).max(4_096),
+    logical_path: z.string().min(1),
 })
     .strict();
 const functionSelectorSchema = z
@@ -66,21 +66,18 @@ const mappingSchema = z
     side_alignment: z.enum(["left_to_left", "left_to_right"]),
     hypothesis: z
         .object({
-        statement: z.string().trim().min(1).max(500),
+        statement: z.string().trim().min(1),
         expected_pattern: expectedPatternSchema,
     })
         .strict(),
 })
     .strict();
-/** Strict bounded input for explicit static/runtime hypothesis correlation. */
+/** Strict input for explicit static/runtime hypothesis correlation. */
 export const staticRuntimeCorrelationInputSchema = z
     .object({
-    static_comparisons: z.array(evidenceSchema).min(1).max(100),
-    runtime_comparisons: z.array(evidenceSchema).min(1).max(100),
-    mappings: z.array(mappingSchema).min(1).max(500),
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(100).default(100),
-    unknown_registry_approved: z.literal(true).optional(),
+    static_comparisons: z.array(evidenceSchema).min(1),
+    runtime_comparisons: z.array(evidenceSchema).min(1),
+    mappings: z.array(mappingSchema).min(1),
 })
     .strict();
 const correlationItemSchema = z.object({
@@ -102,15 +99,15 @@ const correlationItemSchema = z.object({
     }),
     side_alignment: z.enum(["left_to_left", "left_to_right"]),
     hypothesis: z.object({
-        statement: z.string().min(1).max(500),
+        statement: z.string().min(1),
         expected_pattern: expectedPatternSchema,
     }),
     observed_pattern: observedPatternSchema,
     classification: z.enum(["hypothesis", "contradiction", "unresolved_branch"]),
-    evidence_links: z.array(evidenceIdSchema).min(2).max(20_100),
+    evidence_links: z.array(evidenceIdSchema).min(2),
     limitations: z.array(z.string()),
 });
-/** Deterministic, paginated static/runtime correlation payload. */
+/** Deterministic static/runtime correlation payload. */
 export const staticRuntimeCorrelationResultSchema = z.object({
     status: z.enum(["correlated", "contradicted", "unknown", "truncated"]),
     summary: z.object({
@@ -119,28 +116,24 @@ export const staticRuntimeCorrelationResultSchema = z.object({
         unresolved: z.number().int().min(0),
     }),
     correlations: z.object({
-        items: z.array(correlationItemSchema).max(100),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1).max(100),
-        total: z.number().int().min(0),
-        next_offset: z.number().int().min(0).nullable(),
+        items: z.array(correlationItemSchema),
     }),
-    evidence_links: z.array(evidenceIdSchema).min(2).max(20_100),
+    evidence_links: z.array(evidenceIdSchema).min(2),
     limitations: z.array(z.string()),
 });
 const EXPECTED = {
     compare_artifacts: [
-        "rea.artifact-comparison/v1",
+        "rea.artifact-comparison",
         "rea-artifact-comparison",
         "REA artifact comparison",
     ],
     compare_functions: [
-        "rea.function-comparison/v1",
+        "rea.function-comparison",
         "rea-function-comparison",
         "REA function comparison",
     ],
     compare_process_captures: [
-        ["rea.process-comparison/v3", "rea.process-comparison/v4"],
+        "rea.process-comparison",
         "rea-process",
         "REA deterministic process harness",
     ],
@@ -160,10 +153,7 @@ export const correlateStaticAndRuntime = (input) => {
     if (new Set(correlations.map(({ correlation_id: id }) => id)).size !==
         correlations.length)
         throw new TypeError("Static/runtime correlation rejects duplicate mappings");
-    const page = correlations.slice(parsed.offset, parsed.offset + parsed.limit);
     const links = uniqueSorted(correlations.flatMap(({ evidence_links: evidenceLinks }) => evidenceLinks));
-    if (links.length > 20_100)
-        throw new TypeError("Static/runtime Evidence closure exceeds limit");
     const unresolved = correlations.filter(({ classification }) => classification === "unresolved_branch");
     const contradictions = correlations.filter(({ classification }) => classification === "contradiction");
     return staticRuntimeCorrelationResultSchema.parse({
@@ -180,13 +170,7 @@ export const correlateStaticAndRuntime = (input) => {
             unresolved: unresolved.length,
         },
         correlations: {
-            items: page,
-            offset: parsed.offset,
-            limit: parsed.limit,
-            total: correlations.length,
-            next_offset: parsed.offset + page.length < correlations.length
-                ? parsed.offset + page.length
-                : null,
+            items: correlations,
         },
         evidence_links: links,
         limitations: [
@@ -253,11 +237,7 @@ const selectStatic = (evidence, selector) => {
     if (evidence.operation !== "compare_artifacts")
         throw new TypeError("Artifact selector requires artifact comparison Evidence");
     const result = artifactComparisonResultSchema.parse(evidence.normalized_result);
-    if (result.changes.offset !== 0 ||
-        result.changes.next_offset !== null ||
-        result.changes.items.length !== result.changes.total)
-        throw new TypeError("Static/runtime correlation requires complete artifact comparison pagination");
-    const matches = result.changes.items.filter(({ logical_path: path }) => path === selector.logical_path);
+    const matches = result.changes.filter(({ logical_path: path }) => path === selector.logical_path);
     const match = matches.at(0);
     if (matches.length !== 1 || match === undefined)
         throw new TypeError("Artifact selector must resolve exactly one reported delta");
@@ -279,8 +259,7 @@ const parseStatic = (input) => {
     assertComparisonIdentity(evidence);
     if (evidence.operation === "compare_artifacts") {
         const result = artifactComparisonResultSchema.parse(evidence.normalized_result);
-        assertCompleteArtifactResult(result);
-        assertNestedLinks(evidence, result.changes.items.flatMap(({ evidence_links: links }) => links));
+        assertNestedLinks(evidence, result.changes.flatMap(({ evidence_links: links }) => links));
     }
     else {
         const result = functionComparisonResultSchema.parse(evidence.normalized_result);
@@ -334,21 +313,30 @@ const comparisonParameterLinks = (evidence) => {
     }
     const parameters = z
         .object({
-        left_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-        right_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+        left_evidence_id: evidenceIdSchema.optional(),
+        right_evidence_id: evidenceIdSchema.optional(),
+        left_evidence_ids: z.array(evidenceIdSchema).min(1).optional(),
+        right_evidence_ids: z.array(evidenceIdSchema).min(1).optional(),
     })
         .passthrough()
         .parse(evidence.parameters);
-    return [...parameters.left_evidence_ids, ...parameters.right_evidence_ids];
+    const left = parameters.left_evidence_id === undefined
+        ? (parameters.left_evidence_ids ?? [])
+        : [parameters.left_evidence_id];
+    const right = parameters.right_evidence_id === undefined
+        ? (parameters.right_evidence_ids ?? [])
+        : [parameters.right_evidence_id];
+    if (left.length === 0 || right.length === 0)
+        throw new TypeError("Comparison Evidence omitted its source parameters");
+    return [...left, ...right];
 };
-const sameSet = (left, right) => left.length === right.length &&
-    new Set(left).size === left.length &&
-    left.every((item) => right.includes(item));
-const assertCompleteArtifactResult = (result) => {
-    if (result.changes.offset !== 0 ||
-        result.changes.next_offset !== null ||
-        result.changes.items.length !== result.changes.total)
-        throw new TypeError("Static/runtime correlation requires complete artifact comparison pagination");
+const sameSet = (left, right) => {
+    if (left.length !== right.length)
+        return false;
+    const rightSet = new Set(right);
+    return (rightSet.size === right.length &&
+        new Set(left).size === left.length &&
+        left.every((item) => rightSet.has(item)));
 };
 const observedPattern = (staticStatus, runtimeStatus) => {
     if (staticStatus === "truncated" || runtimeStatus === "truncated")

package/dist/domain/symbolAnalysis.js

@@ -1,16 +1,3 @@
-const MAX_SCANNED_SYMBOLS = 5_000;
-const MAX_RETURNED_SYMBOLS = 100;
-/** Select Swift class symbols using the legacy `_TtC` convention. */
-export const discoverSwiftClasses = (procedures, pattern) => {
-    const classes = procedures
-        .slice(0, MAX_SCANNED_SYMBOLS)
-        .filter(({ name }) => name.includes("_TtC"))
-        .filter(({ name }) => pattern.length === 0 || name.includes(pattern));
-    return {
-        count: classes.length,
-        classes: classes.slice(0, MAX_RETURNED_SYMBOLS).map(toJsonEntry),
-    };
-};
 /** Select and deduplicate Objective-C class labels. */
 export const discoverObjcClasses = (names, pattern) => {
     const classes = uniqueByName(names
@@ -18,7 +5,7 @@ export const discoverObjcClasses = (names, pattern) => {
         .filter(({ name }) => pattern.length === 0 || name.includes(pattern)));
     return {
         count: classes.length,
-        classes: classes.slice(0, MAX_RETURNED_SYMBOLS).map(toJsonEntry),
+        classes: classes.map(toJsonEntry),
     };
 };
 /** Select and deduplicate Objective-C and Swift protocol labels. */
@@ -26,7 +13,7 @@ export const discoverObjcProtocols = (names) => {
     const protocols = uniqueByName(names.filter(({ name }) => name.includes("OBJC_PROTOCOL") || name.includes("_TtP")));
     return {
         count: protocols.length,
-        protocols: protocols.slice(0, MAX_RETURNED_SYMBOLS).map(toJsonEntry),
+        protocols: protocols.map(toJsonEntry),
     };
 };
 const SWIFT_CATEGORIES = [
@@ -37,19 +24,23 @@ const SWIFT_CATEGORIES = [
     ["extensions", "_TtE"],
 ];
 /** Categorize deduplicated Swift mangled symbols. */
-export const categorizeSwiftTypes = (procedures) => {
+export const categorizeSwiftTypes = (procedures, filter = {}) => {
     const groups = Object.fromEntries([...SWIFT_CATEGORIES.map(([category]) => category), "other"].map((category) => [category, []]));
     const seen = new Set();
-    for (const entry of procedures.slice(0, MAX_SCANNED_SYMBOLS)) {
+    for (const entry of procedures) {
         if (!entry.name.includes("_Tt") || seen.has(entry.name))
             continue;
-        seen.add(entry.name);
         const category = SWIFT_CATEGORIES.find(([, prefix]) => entry.name.startsWith(prefix))?.[0] ?? "other";
+        if (filter.category !== undefined && filter.category !== category)
+            continue;
+        if (filter.pattern !== undefined && !entry.name.includes(filter.pattern))
+            continue;
+        seen.add(entry.name);
         groups[category]?.push(entry);
     }
     const categories = Object.fromEntries(Object.entries(groups).map(([category, items]) => [
         category,
-        { count: items.length, items: items.slice(0, 50).map(toJsonEntry) },
+        { count: items.length, items: items.map(toJsonEntry) },
     ]));
     return { total: seen.size, categories };
 };

package/dist/domain/unicodeCodePointOrder.js

@@ -0,0 +1,12 @@
+/** Compare strings lexicographically by Unicode code point, independent of locale. */
+export const compareUnicodeCodePoints = (left, right) => {
+    const leftPoints = [...left].map((value) => value.codePointAt(0) ?? 0);
+    const rightPoints = [...right].map((value) => value.codePointAt(0) ?? 0);
+    const length = Math.min(leftPoints.length, rightPoints.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = (leftPoints[index] ?? 0) - (rightPoints[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return leftPoints.length - rightPoints.length;
+};

package/dist/domain/webBundleAnalysis.js

@@ -1,56 +1,9 @@
 import { z } from "zod";
 import { inspectWebPageWithSourceInputSchema } from "./browserObservation.js";
 import { webTextArtifactSchema } from "./webContentArtifact.js";
-const webBundleLimitsSchema = z.object({
-    max_findings: z.number().int().min(1).max(10_000).default(1_000),
-    max_ast_nodes: z.number().int().min(1).max(2_000_000).default(250_000),
-    max_source_maps: z.number().int().min(1).max(1_000).default(100),
-    max_source_map_bytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(16 * 1_024 * 1_024)
-        .default(4 * 1_024 * 1_024),
-    max_total_source_map_bytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(64 * 1_024 * 1_024)
-        .default(16 * 1_024 * 1_024),
-    max_source_map_mappings: z.number().int().min(1).max(100_000).default(10_000),
-    max_original_sources: z.number().int().min(1).max(20_000).default(2_000),
-});
-/** Capture-and-analyze input with separate source and source-map approvals. */
-const analyzeWebBundleFactsSchema = inspectWebPageWithSourceInputSchema.safeExtend({
-    analysis_limits: webBundleLimitsSchema.default({
-        max_findings: 1_000,
-        max_ast_nodes: 250_000,
-        max_source_maps: 100,
-        max_source_map_bytes: 4 * 1_024 * 1_024,
-        max_total_source_map_bytes: 16 * 1_024 * 1_024,
-        max_source_map_mappings: 10_000,
-        max_original_sources: 2_000,
-    }),
-});
-export const analyzeWebBundleInputSchema = z
-    .union([
-    analyzeWebBundleFactsSchema.safeExtend({
-        fetch_source_maps: z.literal(false).default(false),
-        source_map_fetch_approved: z.literal(false).default(false),
-    }),
-    analyzeWebBundleFactsSchema.safeExtend({
-        fetch_source_maps: z.literal(true),
-        source_map_fetch_approved: z.literal(true),
-    }),
-])
-    .superRefine((input, context) => {
-    if (input.analysis_limits.max_source_map_bytes >
-        input.analysis_limits.max_total_source_map_bytes)
-        context.addIssue({
-            code: "custom",
-            path: ["analysis_limits", "max_source_map_bytes"],
-            message: "Per-map source-map byte limit cannot exceed the aggregate limit",
-        });
+/** Capture-and-analyze input with optional source-map fetching. */
+export const analyzeWebBundleInputSchema = inspectWebPageWithSourceInputSchema.safeExtend({
+    fetch_source_maps: z.boolean().default(false),
 });
 const sourceLocationSchema = z.object({
     script_key: z.string(),
@@ -69,72 +22,91 @@ const findingSchema = z.object({
     mechanism: z.string(),
     location: sourceLocationSchema,
 });
-const sourceMapSchema = z.object({
-    script_key: z.string(),
-    declared_url: z.string(),
-    status: z.enum([
-        "included",
-        "fetch_failed",
-        "invalid",
-        "policy_filtered",
-        "truncated",
-    ]),
+const originalSourceSchema = z.object({
+    source: z.string(),
     artifact: webTextArtifactSchema.nullable(),
-    original_sources: z.array(z.object({
-        source: z.string(),
-        artifact: webTextArtifactSchema.nullable(),
-    })),
-    original_module_edges: z.array(z.object({
-        from_source: z.string(),
-        kind: z.enum(["static_import", "dynamic_import", "require"]),
-        specifier: z.string(),
-        resolved_source: z.string().nullable(),
-    })),
-    mappings: z.array(z.object({
-        generated_line: z.number().int().min(1),
-        generated_column: z.number().int().min(0),
-        source: z.string(),
-        original_line: z.number().int().min(1),
-        original_column: z.number().int().min(0),
-        name: z.string().nullable(),
-    })),
-    limitation: z.string().nullable(),
 });
+const originalModuleEdgeSchema = z.object({
+    from_source: z.string(),
+    kind: z.enum(["static_import", "dynamic_import", "require"]),
+    specifier: z.string(),
+    resolved_source: z.string().nullable(),
+});
+const sourceMapMappingSchema = z.object({
+    generated_line: z.number().int().min(1),
+    generated_column: z.number().int().min(0),
+    source: z.string(),
+    original_line: z.number().int().min(1),
+    original_column: z.number().int().min(0),
+    name: z.string().nullable(),
+});
+const sourceMapContextShape = {
+    script_key: z.string(),
+    declared_url: z.string(),
+};
+const parsedSourceMapShape = {
+    artifact: webTextArtifactSchema,
+    original_sources: z.array(originalSourceSchema),
+    original_module_edges: z.array(originalModuleEdgeSchema),
+    mappings: z.array(sourceMapMappingSchema),
+};
+const sourceMapSchema = z.union([
+    z.object({
+        ...sourceMapContextShape,
+        ...parsedSourceMapShape,
+        status: z.literal("included"),
+        limitation: z.null(),
+    }),
+    z.object({
+        ...sourceMapContextShape,
+        ...parsedSourceMapShape,
+        status: z.enum(["fetch_failed", "invalid", "policy_filtered"]),
+        artifact: z.null(),
+        original_sources: z.tuple([]),
+        original_module_edges: z.tuple([]),
+        mappings: z.tuple([]),
+        limitation: z.string(),
+    }),
+]);
 const webTextArtifactSummarySchema = z.object({
-    uri: z.string().regex(/^rea:\/\/web-content\/sha256\/[a-f0-9]{64}$/u),
     sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     bytes: z.number().int().min(0),
-    media_type: z.string().min(1).max(256),
+    media_type: z.string().min(1),
     charset: z.literal("utf-8"),
     text_available: z.literal(true),
 });
-const sourceMapsSchema = z
+export const webSourceMapsSchema = z
     .object({
-    status: z.enum([
-        "not_requested",
-        "included",
-        "partial",
-        "unavailable",
-        "truncated",
-    ]),
+    status: z.enum(["not_requested", "included", "partial", "unavailable"]),
     requested: z.number().int().min(0),
     processed: z.number().int().min(0),
-    dropped: z.number().int().min(0),
-    dropped_script_keys: z.array(z.string()),
     items: z.array(sourceMapSchema),
 })
     .superRefine((sourceMaps, context) => {
-    if (sourceMaps.requested !== sourceMaps.processed + sourceMaps.dropped ||
-        sourceMaps.processed !== sourceMaps.items.length ||
-        sourceMaps.dropped !== sourceMaps.dropped_script_keys.length)
+    if (sourceMaps.requested !== sourceMaps.processed ||
+        sourceMaps.processed !== sourceMaps.items.length)
         context.addIssue({
             code: "custom",
             message: "Source-map coverage counts are inconsistent",
         });
+    const statuses = sourceMaps.items.map(({ status }) => status);
+    const included = statuses.filter((status) => status === "included").length;
+    const allowedStatuses = sourceMaps.items.length === 0
+        ? ["not_requested", "unavailable"]
+        : included === sourceMaps.items.length
+            ? ["included"]
+            : included > 0
+                ? ["partial"]
+                : ["unavailable"];
+    if (!allowedStatuses.includes(sourceMaps.status))
+        context.addIssue({
+            code: "custom",
+            message: "Source-map status contradicts retained coverage",
+            path: ["status"],
+        });
 });
-/** Provider-neutral result of bounded JavaScript bundle reverse engineering. */
+/** Provider-neutral result of JavaScript bundle reverse engineering. */
 export const webBundleAnalysisSchema = z.object({
-    schema_version: z.literal(1),
     capture: z.object({
         target_url: z.string(),
         scripts_observed: z.number().int().min(0),
@@ -171,7 +143,7 @@ export const webBundleAnalysisSchema = z.object({
             trust: z.literal("page-declared-untrusted"),
             location: sourceLocationSchema,
         })),
-        source_maps: sourceMapsSchema,
+        source_maps: webSourceMapsSchema,
     }),
     inferences: z.array(z.object({
         kind: z.enum(["vendor_fingerprint", "route_framework", "bundle_runtime"]),
@@ -185,11 +157,10 @@ export const webBundleAnalysisSchema = z.object({
         affected_script_keys: z.array(z.string()),
     })),
     completeness: z.object({
-        status: z.enum(["complete_within_limits", "truncated", "partial"]),
+        status: z.enum(["complete", "partial"]),
         parsed_scripts: z.number().int().min(0),
         parse_failures: z.number().int().min(0),
         visited_ast_nodes: z.number().int().min(0),
-        dropped_findings: z.number().int().min(0),
     }),
     limitations: z.array(z.string()),
 });