rea-agents 3.1.0 → 3.2.1

package/dist/domain/javascriptSemanticDataEffects.js

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
 import { semanticStaticPropertyName } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
-import { builtinDataEffectMethod as builtinMethod, containsSemanticNode as containsNode, dataEffectArgumentBindingId as argumentBindingId, dataEffectLimitReached as limitReached, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
+import { builtinDataEffectMethod as builtinMethod, containsSemanticNode as containsNode, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
 import { compareCodePoints, propertyName, range, } from "./javascriptStaticAnalysisHelpers.js";
 /** Recover configuration, request, and boundary candidates from inert syntax. */
 export const collectJavaScriptSemanticDataEffects = (program, state, callables) => {
@@ -31,8 +31,6 @@ const collectConfigurations = (program, context) => {
         const details = configurationDetails(node, parent, context);
         if (details === null)
             return;
-        if (limitReached(output.length, context.state.limits.maxConfigurationOperations, "maxConfigurationOperations", context.state))
-            return;
         const operation = {
             configId: `config:${details.kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
             kind: details.kind,
@@ -94,8 +92,6 @@ const collectDefaults = (program, context, configurations) => {
         const sources = configurations.filter(({ node: source }) => containsNode(node.left, source));
         if (sources.length !== 1 || sources[0] === undefined)
             return;
-        if (limitReached(configurations.length + output.length, context.state.limits.maxConfigurationOperations, "maxConfigurationOperations", context.state))
-            return;
         output.push({
             configId: `config:default:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
             kind: "default",
@@ -120,8 +116,6 @@ const collectRequests = (program, context) => {
         const method = requestMethod(node, context.state);
         if (method === null)
             return;
-        if (limitReached(output.length, context.state.limits.maxRequestOperations, "maxRequestOperations", context.state))
-            return;
         const endpoint = requestEndpoint(node);
         output.push({
             node,
@@ -167,8 +161,6 @@ const collectResponseConsumers = (program, context, requests) => {
             : (requestsByBinding.get(binding.bindingId) ?? []);
         if (linked.length === 0)
             return;
-        if (limitReached(requests.length + output.length, context.state.limits.maxRequestOperations, "maxRequestOperations", context.state))
-            return;
         output.push({
             requestId: `response:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
             kind: "response-consumer",
@@ -194,8 +186,6 @@ const collectBoundaries = (program, context) => {
         const details = boundaryDetails(node, context.state);
         if (details === null)
             return;
-        if (limitReached(output.length, context.state.limits.maxBoundaryOperations, "maxBoundaryOperations", context.state))
-            return;
         output.push({
             boundaryId: `boundary:${details.kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
             kind: details.kind,

package/dist/domain/javascriptSemanticFingerprints.js

@@ -25,9 +25,7 @@ export const collectJavaScriptSemanticFingerprints = (input) => {
         return [
             {
                 callableId: callable.callableId,
-                status: parserPartial ||
-                    state.limitsReached.size > 0 ||
-                    callable.returnCoverage.status !== "complete"
+                status: parserPartial || callable.returnCoverage.status !== "complete"
                     ? "partial"
                     : "complete",
                 components: {
@@ -49,8 +47,8 @@ export const collectJavaScriptSemanticFingerprints = (input) => {
                     ],
                 },
                 limitations: [
-                    "The fingerprint is a bounded static candidate and does not prove behavioral equivalence.",
-                    ...(parserPartial || state.limitsReached.size > 0
+                    "The fingerprint is a static candidate and does not prove behavioral equivalence.",
+                    ...(parserPartial
                         ? ["Incomplete semantic recovery makes this fingerprint partial."]
                         : []),
                 ],

package/dist/domain/javascriptSemanticGraphSchemas.js

@@ -1,9 +1,8 @@
 import { z } from "zod";
 import { applicationGraphEvidenceSchema } from "./javascriptApplicationEvidenceSchemas.js";
-import { isJsonWithinLimits } from "./jsonLimits.js";
 import { jsonValueSchema } from "./jsonValue.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const boundedTextSchema = z.string().min(1).max(4_096);
+const boundedTextSchema = z.string().min(1);
 const semanticNodeIdSchema = z.string().regex(/^jsrg_node_[a-f0-9]{64}$/u);
 const semanticRelationIdSchema = z
     .string()
@@ -11,7 +10,7 @@ const semanticRelationIdSchema = z
 const semanticUnknownIdSchema = z
     .string()
     .regex(/^jsrg_unknown_[a-f0-9]{64}$/u);
-/** Semantic entity kinds admitted by JavaScript Semantic Relation Graph v1. */
+/** Semantic entity kinds admitted by JavaScript Semantic Relation Graph. */
 export const JAVASCRIPT_SEMANTIC_NODE_KINDS = [
     "module",
     "function",
@@ -53,7 +52,7 @@ export const JAVASCRIPT_SEMANTIC_RELATION_FAMILIES = [
     "resource-lifecycle",
     "timer",
 ];
-/** Directed semantic relations admitted by graph v1. */
+/** Directed semantic relations admitted by the graph. */
 export const JAVASCRIPT_SEMANTIC_RELATIONS = [
     "acquires",
     "aggregates",
@@ -150,7 +149,6 @@ export const JAVASCRIPT_SEMANTIC_RELATION_FAMILY = {
 const relativePathSchema = z
     .string()
     .min(1)
-    .max(4_096)
     .refine((path) => !path.startsWith("/") &&
     !path.includes("\\") &&
     path.split("/").every((part) => !["", ".", ".."].includes(part)), "Expected a normalized relative POSIX path without traversal");
@@ -170,39 +168,20 @@ const sourceRangeSchema = z
             message: "Source range end must not precede its start",
         });
 });
-const semanticPropertiesSchema = z
-    .record(z.string().min(1).max(128), jsonValueSchema)
-    .superRefine((properties, context) => {
-    if (Object.keys(properties).length > 64)
-        context.addIssue({
-            code: "custom",
-            message: "Semantic properties exceed 64 keys",
-        });
-    if (!isJsonWithinLimits(properties, {
-        maxDepth: 6,
-        maxNodes: 512,
-        maxStringLength: 4_096,
-    }))
-        context.addIssue({
-            code: "custom",
-            message: "Semantic properties exceed structural limits",
-        });
-});
+const semanticPropertiesSchema = z.record(z.string().min(1), jsonValueSchema);
 const semanticNodeIdentitySchema = z.strictObject({
     artifact_sha256: digestSchema,
     module_path: relativePathSchema,
     source_range: sourceRangeSchema.nullable(),
-    role_key: z.string().min(1).max(1_024),
+    role_key: z.string().min(1),
 });
 /** One semantic entity before its canonical identifier is derived. */
 export const javaScriptSemanticNodeInputSchema = z.strictObject({
     kind: z.enum(JAVASCRIPT_SEMANTIC_NODE_KINDS),
     identity: semanticNodeIdentitySchema,
     function_node_id: semanticNodeIdSchema.nullable(),
-    application_node_ids: z
-        .array(z.string().regex(/^jag_node_[a-f0-9]{64}$/u))
-        .max(64),
-    label: z.string().min(1).max(1_024).nullable(),
+    application_node_ids: z.array(z.string().regex(/^jag_node_[a-f0-9]{64}$/u)),
+    label: z.string().min(1).nullable(),
     properties: semanticPropertiesSchema,
     evidence: applicationGraphEvidenceSchema,
 });
@@ -246,10 +225,10 @@ export const JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS = [
 export const javaScriptSemanticUnknownInputSchema = z.strictObject({
     node_id: semanticNodeIdSchema.nullable(),
     family: z.enum(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES),
-    relation_kinds: z.array(z.enum(JAVASCRIPT_SEMANTIC_RELATIONS)).min(1).max(45),
+    relation_kinds: z.array(z.enum(JAVASCRIPT_SEMANTIC_RELATIONS)).min(1),
     reason: z.enum(JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS),
     detail: boundedTextSchema,
-    candidate_node_ids: z.array(semanticNodeIdSchema).max(1_000),
+    candidate_node_ids: z.array(semanticNodeIdSchema),
     evidence: applicationGraphEvidenceSchema,
 });
 /** One canonical unresolved semantic frontier. */
@@ -257,13 +236,12 @@ export const javaScriptSemanticUnknownSchema = javaScriptSemanticUnknownInputSch
     unknown_id: semanticUnknownIdSchema,
 });
 const fingerprintComponentsSchema = z.strictObject({
-    parameter_arity: z.number().int().min(0).max(10_000),
+    parameter_arity: z.number().int().min(0),
     normalized_ast_sha256: digestSchema,
     control_flow_sha256: digestSchema,
     relation_shape_sha256: digestSchema,
     literal_set_sha256: digestSchema,
-    effects: z
-        .array(z.enum([
+    effects: z.array(z.enum([
         "async",
         "child-process",
         "event",
@@ -271,16 +249,15 @@ const fingerprintComponentsSchema = z.strictObject({
         "promise",
         "resource",
         "timer",
-    ]))
-        .max(7),
+    ])),
 });
 /** One bounded rename-resistant function fingerprint. */
 export const javaScriptSemanticFingerprintInputSchema = z.strictObject({
     function_node_id: semanticNodeIdSchema,
-    algorithm: z.literal("rea.javascript-semantic-function/v1"),
+    algorithm: z.literal("rea.javascript-semantic-function"),
     status: z.enum(["complete", "partial", "unavailable"]),
     components: fingerprintComponentsSchema,
-    limitations: z.array(boundedTextSchema).max(100),
+    limitations: z.array(boundedTextSchema),
     evidence: applicationGraphEvidenceSchema,
 });
 /** One canonical function fingerprint record. */
@@ -293,37 +270,34 @@ const familyCoverageSchema = z.strictObject({
     status: z.enum(["complete", "partial", "unknown", "unsupported"]),
     retained_relations: z.number().int().min(0),
     omitted_relations: z.number().int().min(0).nullable(),
-    unknown_ids: z.array(semanticUnknownIdSchema).max(100_000),
+    unknown_ids: z.array(semanticUnknownIdSchema),
 });
 const graphCoverageSchema = z.strictObject({
     status: z.enum(["complete", "partial", "unknown", "unavailable"]),
     truncated: z.boolean(),
     omitted_nodes: z.number().int().min(0).nullable(),
     omitted_relations: z.number().int().min(0).nullable(),
-    limits: z
-        .array(z.strictObject({
-        name: z.string().min(1).max(128),
+    limits: z.array(z.strictObject({
+        name: z.string().min(1),
         value: z.number().int().min(0),
         unit: z.enum(["items", "bytes", "milliseconds", "depth", "other"]),
-    }))
-        .max(32),
+    })),
     families: z.array(familyCoverageSchema).length(12),
 });
 /** Graph content before its top-level commitment is derived. */
 export const javaScriptSemanticGraphInputSchema = z.strictObject({
     schema: z.literal("JavaScriptSemanticRelationGraph"),
-    schema_version: z.literal(1),
     root_artifact_sha256: digestSchema,
     application_graph_id: z.string().regex(/^jag_[a-f0-9]{64}$/u),
-    root_node_ids: z.array(semanticNodeIdSchema).min(1).max(10_000),
-    nodes: z.array(javaScriptSemanticNodeSchema).min(1).max(100_000),
-    relations: z.array(javaScriptSemanticRelationSchema).max(200_000),
-    fingerprints: z.array(javaScriptSemanticFingerprintSchema).max(20_000),
-    unknowns: z.array(javaScriptSemanticUnknownSchema).max(100_000),
+    root_node_ids: z.array(semanticNodeIdSchema).min(1),
+    nodes: z.array(javaScriptSemanticNodeSchema).min(1),
+    relations: z.array(javaScriptSemanticRelationSchema),
+    fingerprints: z.array(javaScriptSemanticFingerprintSchema),
+    unknowns: z.array(javaScriptSemanticUnknownSchema),
     coverage: graphCoverageSchema,
-    limitations: z.array(boundedTextSchema).max(1_000),
+    limitations: z.array(boundedTextSchema),
 });
-/** Stored JavaScript Semantic Relation Graph v1. */
+/** Stored JavaScript Semantic Relation Graph. */
 export const javaScriptSemanticGraphRecordSchema = javaScriptSemanticGraphInputSchema.extend({
     graph_id: z.string().regex(/^jsrg_[a-f0-9]{64}$/u),
 });

package/dist/domain/javascriptSemanticGraphSerialization.js

@@ -1,5 +1,4 @@
 import canonicalize from "canonicalize";
-import { z } from "zod";
 import { javaScriptSemanticGraphSchema, } from "./javascriptSemanticGraph.js";
 const canonicalJson = (value) => {
     const encoded = canonicalize(value);
@@ -7,17 +6,7 @@ const canonicalJson = (value) => {
         throw new TypeError("JavaScript semantic graph could not canonicalize data");
     return encoded;
 };
-/** Parse a stored semantic graph and reject unsupported versions or stale IDs. */
-export const parseJavaScriptSemanticGraph = (input) => {
-    const envelope = z
-        .object({ schema: z.string(), schema_version: z.number() })
-        .passthrough()
-        .safeParse(input);
-    if (envelope.success &&
-        envelope.data.schema === "JavaScriptSemanticRelationGraph" &&
-        envelope.data.schema_version !== 1)
-        throw new TypeError(`Unsupported JavaScript Semantic Relation Graph schema version: ${String(envelope.data.schema_version)}`);
-    return javaScriptSemanticGraphSchema.parse(input);
-};
+/** Parse a stored semantic graph and reject stale IDs. */
+export const parseJavaScriptSemanticGraph = (input) => javaScriptSemanticGraphSchema.parse(input);
 /** Serialize a verified semantic graph as canonical JSON. */
 export const serializeJavaScriptSemanticGraph = (input) => canonicalJson(parseJavaScriptSemanticGraph(input));

package/dist/domain/javascriptSemanticIr.js

@@ -1,30 +1,3 @@
-/** Conservative defaults for one source file. */
-export const DEFAULT_JAVASCRIPT_SEMANTIC_LIMITS = {
-    maxScopes: 4_096,
-    maxBindings: 20_000,
-    maxCallables: 20_000,
-    maxReferences: 100_000,
-    maxModuleLinks: 20_000,
-    maxReturnSites: 20_000,
-    maxCallSites: 20_000,
-    maxCallArguments: 100_000,
-    maxArgumentFlows: 100_000,
-    maxCallReturnFlows: 100_000,
-    maxClosureCaptures: 100_000,
-    maxPromiseOperations: 100_000,
-    maxEventOperations: 100_000,
-    maxTimerOperations: 100_000,
-    maxChildProcessOperations: 100_000,
-    maxConfigurationOperations: 100_000,
-    maxRequestOperations: 100_000,
-    maxBoundaryOperations: 100_000,
-    maxResourceOperations: 100_000,
-    maxObjectOperations: 100_000,
-    maxFrontiers: 20_000,
-    maxValueDepth: 16,
-    maxUnionValues: 32,
-    maxObjectProperties: 256,
-};
 /** Find the innermost resolved reference at one source coordinate. */
 export const semanticReferenceAt = (ir, line, column) => ir.references.find(({ location }) => location.start.line === line && location.start.column === column);
 /** Read one binding by its deterministic semantic identifier. */
@@ -32,7 +5,6 @@ export const semanticBinding = (ir, bindingId) => ir.bindings.find(({ bindingId:
 /** Fail-closed result when Babel cannot produce an inert syntax tree. */
 export const failedJavaScriptSemanticIr = () => ({
     schema: "JavaScriptSemanticIR",
-    schemaVersion: 4,
     scopes: [],
     bindings: [],
     callables: [],
@@ -55,7 +27,7 @@ export const failedJavaScriptSemanticIr = () => ({
     objectOperations: [],
     functionFingerprints: [],
     frontiers: [],
-    coverage: { status: "failed", omittedCount: null, limitsReached: [] },
+    coverage: { status: "failed", omittedCount: null },
     limitations: [
         "JavaScript parsing failed; no semantic absence claim is available.",
         "No JavaScript was executed.",

package/dist/domain/javascriptSemanticObjects.js

@@ -1,5 +1,5 @@
 import * as t from "@babel/types";
-import { reachSemanticLimit, semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { propertyName, range } from "./javascriptStaticAnalysisHelpers.js";
@@ -80,10 +80,6 @@ const collectDestructuring = (node, ownerCallableId, state, output) => {
     }
 };
 const addObjectOperation = (input, state, output) => {
-    if (output.length >= state.limits.maxObjectOperations) {
-        reachSemanticLimit(state, "maxObjectOperations");
-        return;
-    }
     output.push({
         objectOperationId: `object:${input.kind}:${String(input.node.start ?? -1)}:${String(input.node.end ?? -1)}`,
         kind: input.kind,

package/dist/domain/javascriptSemanticPrimitives.js

@@ -1,18 +1,11 @@
 import * as t from "@babel/types";
-import { reachSemanticValueLimit, semanticPrimitiveKey, } from "./javascriptSemanticProvenance.js";
+import { semanticPrimitiveKey } from "./javascriptSemanticProvenance.js";
 import { compareCodePoints } from "./javascriptStaticAnalysisHelpers.js";
 /** Normalize one bounded collection of possible primitive values. */
-export const semanticPrimitiveSet = (values, state) => {
+export const semanticPrimitiveSet = (values) => {
     const unique = [
         ...new Map(values.map((value) => [semanticPrimitiveKey(value), value])).values(),
     ].sort((left, right) => compareCodePoints(semanticPrimitiveKey(left), semanticPrimitiveKey(right)));
-    if (unique.length > state.limits.maxUnionValues) {
-        reachSemanticValueLimit(state, "maxUnionValues");
-        return {
-            status: "limit-reached",
-            reason: "maxUnionValues reached.",
-        };
-    }
     const only = unique[0];
     return unique.length === 1 && only !== undefined
         ? { status: "literal", value: only }

package/dist/domain/javascriptSemanticProjection.js

@@ -9,10 +9,6 @@ export const collectSemanticCallable = (input) => {
     const kind = callableKind(node);
     if (kind === undefined)
         return;
-    if (state.callables.length >= state.limits.maxCallables) {
-        reachSemanticLimit(state, "maxCallables");
-        return;
-    }
     const callableId = semanticCallableIdForNode(node) ?? "callable:unknown:-1:-1";
     state.callables.push({
         callableId,
@@ -28,7 +24,6 @@ export const collectSemanticCallable = (input) => {
             status: "partial",
             retainedCount: 0,
             omittedCount: null,
-            limitsReached: [],
         },
     });
     state.callableNodesById.set(callableId, node);
@@ -78,10 +73,6 @@ export const collectSemanticReferences = (program, state) => {
             if (seen.has(key))
                 return;
             seen.add(key);
-            if (output.length >= state.limits.maxReferences) {
-                reachSemanticLimit(state, "maxReferences");
-                return;
-            }
             const binding = resolveSemanticBindingState(state, node, node.name);
             const blocked = binding === undefined &&
                 semanticResolutionBlocked(state, node, node.name);
@@ -146,11 +137,6 @@ export const semanticModuleOrigin = (node, projection) => {
 export const semanticStaticPropertyName = (property, computed) => computed && !t.isStringLiteral(property) && !t.isNumericLiteral(property)
     ? ""
     : propertyName(property);
-/** Record one exact limit hit without inventing the total omitted population. */
-export const reachSemanticLimit = (state, limit) => {
-    state.limitsReached.add(limit);
-    state.omittedCount += 1;
-};
 const callableKind = (node) => {
     if (t.isClassMethod(node) ||
         t.isClassPrivateMethod(node) ||
@@ -281,10 +267,6 @@ const collectCommonJsExport = (node, state) => {
     });
 };
 const addModuleLink = (state, link) => {
-    if (state.moduleLinks.length >= state.limits.maxModuleLinks) {
-        reachSemanticLimit(state, "maxModuleLinks");
-        return;
-    }
     state.moduleLinks.push({ ...link, callableId: link.callableId ?? null });
 };
 /** Deterministic callable identity shared by collection and return recovery. */

package/dist/domain/javascriptSemanticPromises.js

@@ -1,5 +1,5 @@
 import * as t from "@babel/types";
-import { reachSemanticLimit, semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { compareCodePoints, range, sourceRangesEqual, } from "./javascriptStaticAnalysisHelpers.js";
@@ -36,16 +36,13 @@ const collectCandidates = (program, state, callables) => {
                 callableStack.push(callableId);
             const details = promiseCandidateDetails(node, state);
             if (details !== null) {
-                if (output.length >= state.limits.maxPromiseOperations)
-                    reachSemanticLimit(state, "maxPromiseOperations");
-                else
-                    output.push({
-                        node,
-                        ...details,
-                        promiseId: semanticPromiseId(details.kind, node),
-                        ownerCallableId: callableStack.at(-1) ?? null,
-                        ancestors: [...ancestors],
-                    });
+                output.push({
+                    node,
+                    ...details,
+                    promiseId: semanticPromiseId(details.kind, node),
+                    ownerCallableId: callableStack.at(-1) ?? null,
+                    ancestors: [...ancestors],
+                });
             }
             ancestors.push(node);
         },
@@ -224,9 +221,7 @@ const aggregateSources = (candidate, candidateByNode, state) => {
     return combinePromiseResolutions(resolutions);
 };
 const resolvePromiseExpression = (rawNode, context) => {
-    const { current, candidateByNode, state, seenBindings, depth } = context;
-    if (depth >= state.limits.maxValueDepth)
-        return unresolvedPromise();
+    const { current, candidateByNode, state, seenBindings } = context;
     const node = unwrapExpression(rawNode);
     const direct = candidateByNode.get(node);
     if (direct !== undefined && direct.promiseId !== current.promiseId)
@@ -247,7 +242,6 @@ const resolvePromiseExpression = (rawNode, context) => {
     return resolvePromiseExpression(initializer.node, {
         ...context,
         seenBindings: nestedSeen,
-        depth: depth + 1,
     });
 };
 const promiseResolutionContext = (current, candidateByNode, state) => ({
@@ -255,7 +249,6 @@ const promiseResolutionContext = (current, candidateByNode, state) => ({
     candidateByNode,
     state,
     seenBindings: new Set(),
-    depth: 0,
 });
 const unwrapExpression = (node) => {
     if (t.isParenthesizedExpression(node) ||

package/dist/domain/javascriptSemanticProvenance.js

@@ -1,29 +1,26 @@
 import { compareCodePoints } from "./javascriptStaticAnalysisHelpers.js";
-/** Construct one immutable semantic provenance value. */
-export const semanticProvenance = (status, origins, reason) => ({ status, origins, reason });
-/** Normalize bounded exact module origins into one provenance classification. */
-export const semanticOriginsProvenance = (origins, state) => {
+/** Construct exact local provenance without inventing module origins. */
+export const semanticLocalProvenance = () => ({
+    status: "local",
+    origins: [],
+    reason: null,
+});
+/** Construct an unresolved provenance outcome with an actionable reason. */
+export const semanticUnresolvedProvenance = (status, reason) => ({ status, origins: [], reason });
+/** Construct ambiguous provenance while retaining every origin. */
+export const semanticAmbiguousProvenance = (origins, reason) => ({ status: "ambiguous", origins, reason });
+/** Normalize exact module origins into one provenance classification. */
+export const semanticOriginsProvenance = (origins) => {
     const unique = uniqueSemanticOrigins(origins);
-    if (unique.length > state.limits.maxUnionValues)
-        return semanticLimitProvenance(state, "maxUnionValues");
-    return unique.length === 1
-        ? semanticProvenance("module", unique, null)
-        : semanticProvenance("ambiguous", unique, "Multiple module origins.");
+    const origin = unique[0];
+    return unique.length === 1 && origin !== undefined
+        ? { status: "module", origins: [origin], reason: null }
+        : semanticAmbiguousProvenance(unique, "Multiple module origins.");
 };
 /** Deduplicate and canonically order module origins. */
 export const uniqueSemanticOrigins = (origins) => [
     ...new Map(origins.map((origin) => [semanticOriginKey(origin), origin])).values(),
 ].sort((left, right) => compareCodePoints(semanticOriginKey(left), semanticOriginKey(right)));
-/** Mark and return an explicit provenance-limit value. */
-export const semanticLimitProvenance = (state, limit) => {
-    reachSemanticValueLimit(state, limit);
-    return semanticProvenance("limit-reached", [], `${limit} reached.`);
-};
-/** Record one value-lattice limit against the shared semantic analysis state. */
-export const reachSemanticValueLimit = (state, limit) => {
-    state.limitsReached.add(limit);
-    state.omittedCount += 1;
-};
 const semanticOriginKey = (origin) => `${origin.specifier}\0${origin.importedPath.join("\0")}`;
 /** Canonically distinguish primitive values across type boundaries. */
 export const semanticPrimitiveKey = (value) => `${value === null ? "null" : typeof value}:${JSON.stringify(value)}`;