rea-agents 3.1.0 → 3.2.0

package/dist/domain/javascriptApplicationAnalysis.js

@@ -2,104 +2,15 @@ import { isAbsolute } from "node:path";
 import { z } from "zod";
 import { javascriptApplicationGraphSchema } from "./javascriptApplicationGraph.js";
 import { javaScriptSemanticGraphSchema } from "./javascriptSemanticGraph.js";
-const MAX_GRAPH_NODES = 100_000;
-const MAX_GRAPH_EDGES = 200_000;
-const countSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+const countSchema = z.number().int().min(0);
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-/** Default hard bounds for one local JavaScript application analysis. */
-export const JAVASCRIPT_APPLICATION_ANALYSIS_DEFAULT_LIMITS = {
-    max_entries: 8_000,
-    max_total_artifact_bytes: 512 * 1_024 * 1_024,
-    max_artifact_entry_bytes: 128 * 1_024 * 1_024,
-    max_compression_ratio: 1_000,
-    max_depth: 64,
-    max_path_bytes: 4_096,
-    max_text_files: 5_000,
-    max_total_text_bytes: 128 * 1_024 * 1_024,
-    max_text_file_bytes: 8 * 1_024 * 1_024,
-    max_ast_nodes: 2_000_000,
-    max_findings: 8_000,
-    max_modules: 20_000,
-    max_source_map_sources: 5_000,
-    max_parse_milliseconds: 30_000,
-};
-/** Combined artifact, text, AST, and graph projection bounds. */
-export const javascriptApplicationAnalysisLimitsSchema = z
-    .strictObject({
-    max_entries: z.number().int().min(1).max(1_000_000).default(8_000),
-    max_total_artifact_bytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(Number.MAX_SAFE_INTEGER)
-        .default(512 * 1_024 * 1_024),
-    max_artifact_entry_bytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(Number.MAX_SAFE_INTEGER)
-        .default(128 * 1_024 * 1_024),
-    max_compression_ratio: z.number().min(1).max(100_000).default(1_000),
-    max_depth: z.number().int().min(1).max(100).default(64),
-    max_path_bytes: z.number().int().min(1).max(65_535).default(4_096),
-    max_text_files: z.number().int().min(1).max(100_000).default(5_000),
-    max_total_text_bytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(512 * 1_024 * 1_024)
-        .default(128 * 1_024 * 1_024),
-    max_text_file_bytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(64 * 1_024 * 1_024)
-        .default(8 * 1_024 * 1_024),
-    max_ast_nodes: z.number().int().min(1).max(20_000_000).default(2_000_000),
-    max_findings: z.number().int().min(1).max(200_000).default(8_000),
-    max_modules: z.number().int().min(1).max(100_000).default(20_000),
-    max_source_map_sources: z.number().int().min(1).max(100_000).default(5_000),
-    max_parse_milliseconds: z
-        .number()
-        .int()
-        .min(1)
-        .max(300_000)
-        .default(30_000),
-})
-    .superRefine((limits, context) => {
-    const projectedNodes = 7 * limits.max_entries +
-        2 * limits.max_findings +
-        limits.max_modules +
-        limits.max_source_map_sources +
-        1;
-    if (projectedNodes > MAX_GRAPH_NODES)
-        context.addIssue({
-            code: "custom",
-            path: ["max_entries"],
-            message: "Combined application-analysis limits can exceed the 100000-node graph contract",
-        });
-    const projectedEdges = 9 * limits.max_entries +
-        6 * limits.max_findings +
-        limits.max_modules +
-        limits.max_source_map_sources;
-    if (projectedEdges > MAX_GRAPH_EDGES)
-        context.addIssue({
-            code: "custom",
-            path: ["max_entries"],
-            message: "Combined application-analysis limits can exceed the 200000-edge graph contract",
-        });
-});
-/** Public target-free request for bounded static JavaScript application analysis. */
+/** Public target-free request for static JavaScript application analysis. */
 export const analyzeJavaScriptApplicationInputSchema = z.strictObject({
     input_path: z
         .string()
         .min(1)
-        .max(16_384)
         .refine(isAbsolute, "JavaScript application input path must be absolute"),
     format: z.enum(["auto", "asar", "directory"]).default("auto"),
-    approved: z.literal(true),
-    source_map_read_approved: z.boolean().default(false),
-    limits: javascriptApplicationAnalysisLimitsSchema.default(JAVASCRIPT_APPLICATION_ANALYSIS_DEFAULT_LIMITS),
 });
 /** Compact counts for the high-level Electron architecture/security surface. */
 const electronBoundarySummarySchema = z.strictObject({
@@ -128,11 +39,7 @@ const electronBoundarySummarySchema = z.strictObject({
 const reconstructionStatisticsSchema = z.strictObject({
     relevant_files: countSchema,
     nested_asar_containers: countSchema,
-    text_files_selected: countSchema,
     text_bytes_read: countSchema,
-    omitted_text_files: countSchema,
-    limit_omitted_text_files: countSchema,
-    policy_filtered_text_files: countSchema,
     invalid_utf8_files: countSchema,
     parsed_javascript_files: countSchema,
     visited_ast_nodes: countSchema,
@@ -141,10 +48,10 @@ const reconstructionStatisticsSchema = z.strictObject({
     parse_failures: countSchema,
     truncated_scopes: countSchema,
 });
-/** Legacy structural JavaScript application analysis result. */
-export const javaScriptApplicationAnalysisResultV1Schema = z.strictObject({
-    schema_version: z.literal(1),
-    input_path: z.string().min(1).max(16_384),
+/** JavaScript application analysis with an authenticated semantic companion. */
+export const javascriptApplicationAnalysisResultSchema = z
+    .strictObject({
+    input_path: z.string().min(1),
     format: z.enum(["asar", "directory"]),
     root_artifact_sha256: digestSchema,
     inventory_manifest_id: z.string().regex(/^agm_[a-f0-9]{64}$/u),
@@ -152,12 +59,7 @@ export const javaScriptApplicationAnalysisResultV1Schema = z.strictObject({
     graph: javascriptApplicationGraphSchema,
     summary: electronBoundarySummarySchema,
     statistics: reconstructionStatisticsSchema,
-    limitations: z.array(z.string().min(1).max(4_096)).max(1_000),
-});
-/** JavaScript application analysis with an authenticated semantic companion. */
-export const javaScriptApplicationAnalysisResultV2Schema = javaScriptApplicationAnalysisResultV1Schema
-    .extend({
-    schema_version: z.literal(2),
+    limitations: z.array(z.string().min(1)),
     semantic_graph: javaScriptSemanticGraphSchema,
 })
     .superRefine((result, context) => {
@@ -167,8 +69,7 @@ export const javaScriptApplicationAnalysisResultV2Schema = javaScriptApplication
             path: ["semantic_graph", "application_graph_id"],
             message: "Semantic graph must commit the containing application graph",
         });
-    if (result.semantic_graph.root_artifact_sha256 !==
-        result.root_artifact_sha256)
+    if (result.semantic_graph.root_artifact_sha256 !== result.root_artifact_sha256)
         context.addIssue({
             code: "custom",
             path: ["semantic_graph", "root_artifact_sha256"],
@@ -190,8 +91,3 @@ export const javaScriptApplicationAnalysisResultV2Schema = javaScriptApplication
                     message: "Semantic node references an absent application node",
                 });
 });
-/** Strict versioned high-level result returned inside Evidence v2. */
-export const javascriptApplicationAnalysisResultSchema = z.discriminatedUnion("schema_version", [
-    javaScriptApplicationAnalysisResultV1Schema,
-    javaScriptApplicationAnalysisResultV2Schema,
-]);

package/dist/domain/javascriptApplicationChangeGraph.js

@@ -13,50 +13,34 @@ export const buildJavaScriptApplicationChangeGraph = (input) => {
             ...(left === null ? [] : [left]),
         ]),
     ]);
-    const retainedIds = orderedNodeIds.slice(0, input.limits.max_graph_nodes);
-    const retained = new Set(retainedIds);
-    const merged = mergeNodes(retainedIds.flatMap((nodeId) => allNodes.get(nodeId) ?? []));
+    const retained = new Set(orderedNodeIds);
+    const mergedNodes = mergeNodes(orderedNodeIds.flatMap((nodeId) => allNodes.get(nodeId) ?? []));
     const sourceEdges = uniqueEdges([
         ...input.left.edges,
         ...input.right.edges,
     ]).filter(({ source_node_id: source, target_node_id: target }) => retained.has(source) && retained.has(target));
     const comparisonEdges = input.items.flatMap((item) => changedFromEdge(item, input, retained));
     const candidateEdges = uniqueEdges([...sourceEdges, ...comparisonEdges]);
-    const edges = candidateEdges.slice(0, input.limits.max_graph_edges);
-    const omittedNodes = Math.max(0, orderedNodeIds.length - retainedIds.length);
-    const omittedEdges = Math.max(0, candidateEdges.length - edges.length);
-    const graphOmissions = omittedNodes + omittedEdges + merged.omittedObservations;
-    const rootNodeIds = preferredRoots
-        .filter((nodeId) => retained.has(nodeId))
-        .slice(0, 1_000);
-    const fallbackRoot = merged.nodes[0]?.node_id;
+    const rootNodeIds = preferredRoots.filter((nodeId) => retained.has(nodeId));
+    const fallbackRoot = mergedNodes[0]?.node_id;
     const graph = createJavaScriptApplicationGraph({
         schema: "JavaScriptApplicationGraph",
-        schema_version: 1,
         root_node_ids: rootNodeIds.length > 0
             ? rootNodeIds
             : fallbackRoot === undefined
                 ? []
                 : [fallbackRoot],
-        nodes: merged.nodes,
-        edges,
-        coverage: changeGraphCoverage(input, graphOmissions),
+        nodes: mergedNodes,
+        edges: candidateEdges,
+        coverage: changeGraphCoverage(input),
         limitations: uniqueSorted([
             ...input.left.limitations.map((value) => `Left: ${value}`),
             ...input.right.limitations.map((value) => `Right: ${value}`),
             "changed_from edges are cross-version inferences and never promote structural or semantic matches to exact identity.",
             "The change graph contains compared entities and their retained relationships; it is not an executable application.",
-            ...(graphOmissions === 0
-                ? []
-                : ["The change graph omitted content at explicit caller bounds."]),
         ]),
     });
-    return {
-        graph,
-        omittedNodes,
-        omittedEdges,
-        omittedObservations: merged.omittedObservations,
-    };
+    return { graph };
 };
 const nodeCandidates = (input) => {
     const required = new Set([
@@ -106,8 +90,7 @@ const comparisonEvidence = (item, input) => {
     const left = input.left.nodes.find(({ node_id: id }) => id === item.left_node_id);
     const source = right?.observations[0]?.evidence ?? left?.observations[0]?.evidence;
     const complete = input.left.coverage.status === "complete" &&
-        input.right.coverage.status === "complete" &&
-        input.omittedComparisonItems === 0;
+        input.right.coverage.status === "complete";
     return {
         authority: "cross-version-comparison",
         state: "inferred",
@@ -132,19 +115,9 @@ const comparisonEvidence = (item, input) => {
             ? { status: "complete", truncated: false, omitted_count: 0, limits: [] }
             : {
                 status: "partial",
-                truncated: input.omittedComparisonItems > 0,
-                omitted_count: input.omittedComparisonItems > 0
-                    ? input.omittedComparisonItems
-                    : (source?.coverage.omitted_count ?? null),
-                limits: input.omittedComparisonItems > 0
-                    ? [
-                        {
-                            name: "max-comparison-items",
-                            value: input.limits.max_comparison_items,
-                            unit: "items",
-                        },
-                    ]
-                    : [],
+                truncated: input.left.coverage.truncated || input.right.coverage.truncated,
+                omitted_count: combineOmittedCounts(input.left.coverage.omitted_count, input.right.coverage.omitted_count),
+                limits: sourceCoverageLimits(input),
             },
         limitations: [
             "Cross-version pairing is inferred from the stated match basis; changed_from does not prove runtime reachability.",
@@ -153,31 +126,7 @@ const comparisonEvidence = (item, input) => {
         evidence_ids: [input.leftEvidenceId, input.rightEvidenceId],
     };
 };
-const changeGraphCoverage = (input, graphOmissions) => {
-    const outputOmissions = graphOmissions + input.omittedComparisonItems;
-    if (outputOmissions > 0)
-        return {
-            status: "partial",
-            truncated: true,
-            omitted_count: outputOmissions,
-            limits: [
-                {
-                    name: "max-comparison-items",
-                    value: input.limits.max_comparison_items,
-                    unit: "items",
-                },
-                {
-                    name: "max-graph-nodes",
-                    value: input.limits.max_graph_nodes,
-                    unit: "items",
-                },
-                {
-                    name: "max-graph-edges",
-                    value: input.limits.max_graph_edges,
-                    unit: "items",
-                },
-            ],
-        };
+const changeGraphCoverage = (input) => {
     if (input.left.coverage.status === "complete" &&
         input.right.coverage.status === "complete")
         return {
@@ -186,24 +135,21 @@ const changeGraphCoverage = (input, graphOmissions) => {
             omitted_count: 0,
             limits: [],
         };
-    const counts = [
-        input.left.coverage.omitted_count,
-        input.right.coverage.omitted_count,
-    ];
     return {
         status: "partial",
-        truncated: false,
-        omitted_count: counts.every((value) => value !== null)
-            ? counts.reduce((total, value) => total + (value ?? 0), 0)
-            : null,
-        limits: [],
+        truncated: input.left.coverage.truncated || input.right.coverage.truncated,
+        omitted_count: combineOmittedCounts(input.left.coverage.omitted_count, input.right.coverage.omitted_count),
+        limits: sourceCoverageLimits(input),
     };
 };
+const sourceCoverageLimits = (input) => [
+    ...new Map([...input.left.coverage.limits, ...input.right.coverage.limits].map((limit) => [`${limit.name}\0${limit.value}\0${limit.unit}`, limit])).values(),
+].sort((left, right) => compareCodePoints(left.name, right.name));
+const combineOmittedCounts = (left, right) => left === null || right === null ? null : left + right;
 const mergeNodes = (nodes) => {
     const groups = new Map();
     for (const node of nodes)
         groups.set(node.node_id, [...(groups.get(node.node_id) ?? []), node]);
-    let omittedObservations = 0;
     const merged = [...groups.values()].map((group) => {
         const first = group[0];
         if (first === undefined)
@@ -213,19 +159,13 @@ const mergeNodes = (nodes) => {
                 .flatMap(({ observations: values }) => values)
                 .map((observation) => [observation.observation_id, observation])).values(),
         ].sort((left, right) => compareCodePoints(left.observation_id, right.observation_id));
-        omittedObservations += Math.max(0, observations.length - 64);
         return createJavaScriptApplicationNode({
             kind: first.kind,
             identity: first.identity,
-            observations: observations
-                .slice(0, 64)
-                .map(({ observation_id: _id, identifier_strategy: _strategy, ...value }) => value),
+            observations: observations.map(({ observation_id: _id, identifier_strategy: _strategy, ...value }) => value),
         });
     });
-    return {
-        nodes: merged.sort((left, right) => compareCodePoints(left.node_id, right.node_id)),
-        omittedObservations,
-    };
+    return merged.sort((left, right) => compareCodePoints(left.node_id, right.node_id));
 };
 const uniqueEdges = (edges) => [...new Map(edges.map((edge) => [edge.edge_id, edge])).values()].sort((left, right) => compareCodePoints(left.edge_id, right.edge_id));
 const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);

package/dist/domain/javascriptApplicationEvidenceSchemas.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const boundedTextSchema = z.string().min(1).max(4_096);
-const boundedKeySchema = z.string().min(1).max(512);
+const boundedTextSchema = z.string().min(1);
+const boundedKeySchema = z.string().min(1);
 const unsafePathSegments = new Set(["", ".", ".."]);
 const isSafeRelativePath = (path) => {
     if (path.startsWith("/") || path.includes("\\"))
@@ -11,7 +11,6 @@ const isSafeRelativePath = (path) => {
 const relativePathSchema = z
     .string()
     .min(1)
-    .max(4_096)
     .refine(isSafeRelativePath, "Expected a normalized relative POSIX path without traversal");
 /** Authority that produced one node observation or relationship. */
 const applicationEvidenceAuthoritySchema = z.enum([
@@ -47,7 +46,6 @@ const applicationConfidenceSchema = z.enum([
 const applicationUnavailableReasonSchema = z.enum([
     "not-applicable",
     "not-observed",
-    "not-approved",
     "truncated",
     "provider-unavailable",
     "unresolved",
@@ -124,7 +122,7 @@ const applicationLocationSchema = z.discriminatedUnion("kind", [
     fileOffsetRangeSchema,
     z.strictObject({
         kind: z.literal("url"),
-        url: z.string().min(1).max(16_384),
+        url: z.string().min(1),
     }),
     z.strictObject({
         kind: z.literal("runtime"),
@@ -154,13 +152,13 @@ const applicationLocationReferenceSchema = z.discriminatedUnion("available", [
 ]);
 /** Versioned extractor coordinates attached to every graph fact. */
 const applicationExtractorSchema = z.strictObject({
-    name: z.string().min(1).max(128),
-    version: z.string().min(1).max(128),
-    operation: z.string().min(1).max(256),
+    name: z.string().min(1),
+    version: z.string().min(1),
+    operation: z.string().min(1),
     executable_sha256: digestSchema.nullable(),
 });
 const applicationLimitSchema = z.strictObject({
-    name: z.string().min(1).max(128),
+    name: z.string().min(1),
     value: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
     unit: z.enum([
         "items",
@@ -173,39 +171,54 @@ const applicationLimitSchema = z.strictObject({
     ]),
 });
 /** Bounded collection coverage without treating omission as absence. */
-export const applicationCoverageSchema = z
-    .strictObject({
-    status: z.enum(["complete", "partial", "unknown", "unavailable"]),
-    truncated: z.boolean(),
-    omitted_count: z
-        .number()
-        .int()
-        .min(0)
-        .max(Number.MAX_SAFE_INTEGER)
-        .nullable(),
-    limits: z.array(applicationLimitSchema).max(32),
-})
-    .superRefine((coverage, context) => {
-    if (coverage.status === "complete" &&
-        (coverage.truncated || coverage.omitted_count !== 0))
-        context.addIssue({
-            code: "custom",
-            message: "Complete coverage cannot be truncated or omit items",
-        });
-    if (coverage.truncated &&
-        (coverage.status !== "partial" ||
-            coverage.limits.length === 0 ||
-            coverage.omitted_count === 0))
-        context.addIssue({
-            code: "custom",
-            message: "Truncated coverage must be partial, name a limit, and not claim zero omissions",
-        });
-    if (["unknown", "unavailable"].includes(coverage.status) &&
-        (coverage.truncated || coverage.omitted_count !== null))
-        context.addIssue({
-            code: "custom",
-            message: "Unknown or unavailable coverage cannot invent truncation counts",
-        });
+const coverageLimitsSchema = z.array(applicationLimitSchema);
+const omittedCountSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+export const applicationCoverageSchema = z.union([
+    z.strictObject({
+        status: z.literal("complete"),
+        truncated: z.literal(false),
+        omitted_count: z.literal(0),
+        limits: coverageLimitsSchema,
+    }),
+    z.strictObject({
+        status: z.literal("partial"),
+        truncated: z.literal(false),
+        omitted_count: omittedCountSchema.nullable(),
+        limits: coverageLimitsSchema,
+    }),
+    z.strictObject({
+        status: z.literal("partial"),
+        truncated: z.literal(true),
+        omitted_count: z.union([omittedCountSchema.positive(), z.null()]),
+        limits: z.array(applicationLimitSchema).min(1),
+    }),
+    z.strictObject({
+        status: z.enum(["unknown", "unavailable"]),
+        truncated: z.literal(false),
+        omitted_count: z.null(),
+        limits: coverageLimitsSchema,
+    }),
+]);
+/** Construct complete bounded coverage under the stated configured limits. */
+export const completeApplicationCoverage = (limits = []) => applicationCoverageSchema.parse({
+    status: "complete",
+    truncated: false,
+    omitted_count: 0,
+    limits,
+});
+/** Construct partial non-truncated coverage without inventing omissions. */
+export const partialApplicationCoverage = (limits, omittedCount) => applicationCoverageSchema.parse({
+    status: "partial",
+    truncated: false,
+    omitted_count: omittedCount,
+    limits,
+});
+/** Construct limit-truncated coverage with a named bound. */
+export const truncatedApplicationCoverage = (limits, omittedCount) => applicationCoverageSchema.parse({
+    status: "partial",
+    truncated: true,
+    omitted_count: omittedCount,
+    limits,
 });
 const applicationGraphEvidenceBaseSchema = z.strictObject({
     authority: applicationEvidenceAuthoritySchema,
@@ -215,8 +228,8 @@ const applicationGraphEvidenceBaseSchema = z.strictObject({
     location: applicationLocationReferenceSchema,
     extractor: applicationExtractorSchema,
     coverage: applicationCoverageSchema,
-    limitations: z.array(boundedTextSchema).max(100),
-    evidence_ids: z.array(z.string().regex(/^ev_[a-f0-9]{64}$/u)).max(100),
+    limitations: z.array(boundedTextSchema),
+    evidence_ids: z.array(z.string().regex(/^ev_[a-f0-9]{64}$/u)),
 });
 const checkAuthorityState = (evidence, context) => {
     if (evidence.authority === "static-relationship-inference" &&
@@ -343,7 +356,7 @@ export const applicationNodeIdentitySchema = z.discriminatedUnion("strategy", [
     z.strictObject({
         strategy: z.literal("structural-fingerprint"),
         stability: z.literal("cross-version-inference"),
-        algorithm: z.string().min(1).max(128),
+        algorithm: z.string().min(1),
         fingerprint_sha256: digestSchema,
         basis: z
             .array(z.enum([
@@ -354,8 +367,7 @@ export const applicationNodeIdentitySchema = z.discriminatedUnion("strategy", [
             "literals",
             "api-usage",
         ]))
-            .min(1)
-            .max(6),
+            .min(1),
     }),
     z.strictObject({
         strategy: z.literal("artifact-local-key"),

package/dist/domain/javascriptApplicationGraph.js

@@ -205,7 +205,7 @@ const checkGraphInvariants = (graph, context) => {
             path: ["graph_id"],
         });
 };
-/** Strict versioned JavaScript Application Graph with verified commitments. */
+/** Strict JavaScript Application Graph with verified commitments. */
 export const javascriptApplicationGraphSchema = javascriptApplicationGraphRecordSchema.superRefine(checkGraphInvariants);
 /** Build one normalized application entity and derive all semantic IDs. */
 export const createJavaScriptApplicationNode = (input) => {
@@ -264,18 +264,8 @@ export const createJavaScriptApplicationGraph = (input) => {
         graph_id: `jag_${digestCanonical(semantic)}`,
     });
 };
-/** Parse a stored graph, rejecting unsupported versions and stale IDs. */
-export const parseJavaScriptApplicationGraph = (input) => {
-    const envelope = z
-        .object({ schema: z.string(), schema_version: z.number() })
-        .passthrough()
-        .safeParse(input);
-    if (envelope.success &&
-        envelope.data.schema === "JavaScriptApplicationGraph" &&
-        envelope.data.schema_version !== 1)
-        throw new TypeError(`Unsupported JavaScript Application Graph schema version: ${String(envelope.data.schema_version)}`);
-    return javascriptApplicationGraphSchema.parse(input);
-};
+/** Parse a stored graph and reject stale IDs. */
+export const parseJavaScriptApplicationGraph = (input) => javascriptApplicationGraphSchema.parse(input);
 /** Compute the byte-stable SHA-256 commitment of a verified graph. */
 export const computeJavaScriptApplicationGraphSha256 = (input) => digestCanonical(parseJavaScriptApplicationGraph(input));
 /** Serialize a verified graph as RFC 8785 canonical JSON. */

package/dist/domain/javascriptApplicationGraphSchemas.js

@@ -1,9 +1,8 @@
 import { z } from "zod";
 import { applicationCoverageSchema, applicationGraphEvidenceSchema, applicationNodeIdentitySchema, } from "./javascriptApplicationEvidenceSchemas.js";
-import { isJsonWithinLimits } from "./jsonLimits.js";
 import { jsonValueSchema } from "./jsonValue.js";
-const boundedTextSchema = z.string().min(1).max(4_096);
-/** Node kinds admitted by JavaScript Application Graph v1. */
+const boundedTextSchema = z.string().min(1);
+/** Node kinds admitted by JavaScript Application Graph. */
 export const JAVASCRIPT_APPLICATION_NODE_KINDS = [
     "package",
     "installer",
@@ -42,7 +41,7 @@ export const JAVASCRIPT_APPLICATION_NODE_KINDS = [
 ];
 /** Provider-neutral application entity categories. */
 const applicationNodeKindSchema = z.enum(JAVASCRIPT_APPLICATION_NODE_KINDS);
-/** Directed relations admitted by JavaScript Application Graph v1. */
+/** Directed relations admitted by JavaScript Application Graph. */
 export const JAVASCRIPT_APPLICATION_RELATIONS = [
     "contains",
     "loads",
@@ -59,27 +58,10 @@ export const JAVASCRIPT_APPLICATION_RELATIONS = [
 ];
 /** Provider-neutral relation categories. */
 const applicationRelationSchema = z.enum(JAVASCRIPT_APPLICATION_RELATIONS);
-const applicationPropertiesSchema = z
-    .record(z.string().min(1).max(128), jsonValueSchema)
-    .superRefine((properties, context) => {
-    if (Object.keys(properties).length > 64)
-        context.addIssue({
-            code: "custom",
-            message: "Application graph properties exceed 64 keys",
-        });
-    if (!isJsonWithinLimits(properties, {
-        maxDepth: 6,
-        maxNodes: 512,
-        maxStringLength: 4_096,
-    }))
-        context.addIssue({
-            code: "custom",
-            message: "Application graph properties exceed structural limits",
-        });
-});
+const applicationPropertiesSchema = z.record(z.string().min(1), jsonValueSchema);
 /** One node observation before its semantic identifier is derived. */
 const applicationNodeObservationInputSchema = z.strictObject({
-    label: z.string().min(1).max(1_024).nullable(),
+    label: z.string().min(1).nullable(),
     properties: applicationPropertiesSchema,
     evidence: applicationGraphEvidenceSchema,
 });
@@ -95,14 +77,14 @@ export const applicationNodeObservationSchema = applicationNodeObservationInputS
 export const applicationNodeInputSchema = z.strictObject({
     kind: applicationNodeKindSchema,
     identity: applicationNodeIdentitySchema,
-    observations: z.array(applicationNodeObservationInputSchema).min(1).max(64),
+    observations: z.array(applicationNodeObservationInputSchema).min(1),
 });
 /** One stable application entity with one or more bounded observations. */
 export const applicationNodeSchema = z.strictObject({
     node_id: z.string().regex(/^jag_node_[a-f0-9]{64}$/u),
     kind: applicationNodeKindSchema,
     identity: applicationNodeIdentitySchema,
-    observations: z.array(applicationNodeObservationSchema).min(1).max(64),
+    observations: z.array(applicationNodeObservationSchema).min(1),
 });
 /** One directed relationship before its semantic identifier is derived. */
 export const applicationEdgeInputSchema = z.strictObject({
@@ -123,17 +105,13 @@ export const applicationEdgeSchema = applicationEdgeInputSchema.extend({
 /** Graph content before its top-level semantic identifier is derived. */
 export const javascriptApplicationGraphInputSchema = z.strictObject({
     schema: z.literal("JavaScriptApplicationGraph"),
-    schema_version: z.literal(1),
-    root_node_ids: z
-        .array(z.string().regex(/^jag_node_[a-f0-9]{64}$/u))
-        .min(1)
-        .max(1_000),
-    nodes: z.array(applicationNodeSchema).min(1).max(100_000),
-    edges: z.array(applicationEdgeSchema).max(200_000),
+    root_node_ids: z.array(z.string().regex(/^jag_node_[a-f0-9]{64}$/u)).min(1),
+    nodes: z.array(applicationNodeSchema).min(1),
+    edges: z.array(applicationEdgeSchema),
     coverage: applicationCoverageSchema,
-    limitations: z.array(boundedTextSchema).max(1_000),
+    limitations: z.array(boundedTextSchema),
 });
-/** Strict stored shape for JavaScript Application Graph v1. */
+/** Strict stored shape for a JavaScript Application Graph. */
 export const javascriptApplicationGraphRecordSchema = javascriptApplicationGraphInputSchema.extend({
     graph_id: z.string().regex(/^jag_[a-f0-9]{64}$/u),
 });