rea-agents 3.1.0 → 3.2.1

package/dist/domain/javascriptSemanticValues.js

@@ -1,19 +1,17 @@
 import * as t from "@babel/types";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { compareCodePoints, propertyName, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
-import { reachSemanticValueLimit, semanticLimitProvenance, semanticOriginsProvenance, semanticProvenance, uniqueSemanticOrigins, } from "./javascriptSemanticProvenance.js";
+import { semanticAmbiguousProvenance, semanticLocalProvenance, semanticOriginsProvenance, semanticUnresolvedProvenance, uniqueSemanticOrigins, } from "./javascriptSemanticProvenance.js";
 import { semanticPrimitiveCandidates as primitiveCandidates, semanticPrimitiveSet as primitiveSet, semanticPrimitiveValue as primitiveValue, } from "./javascriptSemanticPrimitives.js";
 /** Evaluate one binding in the bounded constant-value lattice. */
-export const evaluateSemanticBinding = (binding, state) => evaluateBinding(binding, { state, bindings: new Set(), depth: 0 });
+export const evaluateSemanticBinding = (binding, state) => evaluateBinding(binding, { state, bindings: new Set() });
 /** Evaluate one arbitrary inert expression in the established lexical state. */
-export const evaluateSemanticExpression = (node, state) => evaluateExpression(node, { state, bindings: new Set(), depth: 0 });
+export const evaluateSemanticExpression = (node, state) => evaluateExpression(node, { state, bindings: new Set() });
 /** Follow module provenance through destructuring, members, and aliases. */
-export const evaluateSemanticProvenance = (binding, state) => provenanceForBinding(binding, { state, bindings: new Set(), depth: 0 });
+export const evaluateSemanticProvenance = (binding, state) => provenanceForBinding(binding, { state, bindings: new Set() });
 const evaluateBinding = (binding, context) => {
     if (context.bindings.has(binding.bindingId))
         return { status: "cycle", reason: `Alias cycle at ${binding.name}.` };
-    if (context.depth >= context.state.limits.maxValueDepth)
-        return limitValue(context.state, "maxValueDepth");
     if (binding.initializers.length === 0)
         return {
             status: "unknown",
@@ -31,8 +29,6 @@ const evaluateBinding = (binding, context) => {
     return projectValue(evaluateExpression(initializer.node, nested), initializer.projection);
 };
 const evaluateExpression = (node, context) => {
-    if (context.depth >= context.state.limits.maxValueDepth)
-        return limitValue(context.state, "maxValueDepth");
     const literal = primitiveValue(node);
     if (literal.found)
         return { status: "literal", value: literal.value };
@@ -48,12 +44,12 @@ const evaluateExpression = (node, context) => {
         return mergeValues([
             evaluateExpression(node.consequent, nestedContext(context)),
             evaluateExpression(node.alternate, nestedContext(context)),
-        ], context.state);
+        ]);
     if (t.isLogicalExpression(node))
         return mergeValues([
             evaluateExpression(node.left, nestedContext(context)),
             evaluateExpression(node.right, nestedContext(context)),
-        ], context.state);
+        ]);
     if (t.isObjectExpression(node))
         return evaluateObject(node, context);
     if (t.isArrayExpression(node))
@@ -87,10 +83,8 @@ const evaluateTemplate = (node, context) => {
                 reason: "Template expression is not a bounded primitive.",
             };
         candidates = candidates.flatMap((prefix) => values.map((value) => `${prefix}${String(value)}`));
-        if (candidates.length > context.state.limits.maxUnionValues)
-            return limitValue(context.state, "maxUnionValues");
     }
-    return primitiveSet(candidates, context.state);
+    return primitiveSet(candidates);
 };
 const evaluateObject = (node, context) => {
     const properties = [];
@@ -115,25 +109,25 @@ const evaluateObject = (node, context) => {
                 omittedProperties += 1;
             continue;
         }
-        if (properties.length >= context.state.limits.maxObjectProperties) {
-            reachSemanticValueLimit(context.state, "maxObjectProperties");
-            unknownProperties = true;
-            if (omittedProperties !== null)
-                omittedProperties += 1;
-            continue;
-        }
         properties.push({
             name,
             value: evaluateExpression(property.value, nestedContext(context)),
         });
     }
     properties.sort((left, right) => compareCodePoints(left.name, right.name));
-    return {
-        status: "object",
-        properties,
-        unknownProperties,
-        omittedProperties,
-    };
+    return unknownProperties
+        ? {
+            status: "object",
+            properties,
+            unknownProperties: true,
+            omittedProperties,
+        }
+        : {
+            status: "object",
+            properties,
+            unknownProperties: false,
+            omittedProperties: 0,
+        };
 };
 const evaluateArray = (node, context) => {
     const items = [];
@@ -151,16 +145,11 @@ const evaluateArray = (node, context) => {
                 omittedItems += 1;
             continue;
         }
-        if (items.length >= context.state.limits.maxObjectProperties) {
-            reachSemanticValueLimit(context.state, "maxObjectProperties");
-            unknownItems = true;
-            if (omittedItems !== null)
-                omittedItems += 1;
-            continue;
-        }
         items.push(evaluateExpression(element, nestedContext(context)));
     }
-    return { status: "array", items, unknownItems, omittedItems };
+    return unknownItems
+        ? { status: "array", items, unknownItems: true, omittedItems }
+        : { status: "array", items, unknownItems: false, omittedItems: 0 };
 };
 const evaluateMember = (node, context) => {
     if (!t.isNode(node.object))
@@ -180,18 +169,18 @@ const evaluateAddition = (node, context) => {
     const values = left.flatMap((leftValue) => right.map((rightValue) => typeof leftValue === "number" && typeof rightValue === "number"
         ? leftValue + rightValue
         : `${String(leftValue)}${String(rightValue)}`));
-    return primitiveSet(values, context.state);
+    return primitiveSet(values);
 };
 const evaluateUnary = (node, context) => {
     const argument = primitiveCandidates(evaluateExpression(node.argument, nestedContext(context)));
     if (argument === null)
         return { status: "unknown", reason: "Non-primitive unary operand." };
     if (node.operator === "!")
-        return primitiveSet(argument.map((value) => !value), context.state);
+        return primitiveSet(argument.map((value) => !value));
     if (node.operator === "+")
-        return primitiveSet(argument.map((value) => Number(value)), context.state);
+        return primitiveSet(argument.map((value) => Number(value)));
     if (node.operator === "-")
-        return primitiveSet(argument.map((value) => -Number(value)), context.state);
+        return primitiveSet(argument.map((value) => -Number(value)));
     return { status: "unknown", reason: `Unsupported unary ${node.operator}.` };
 };
 const projectValue = (value, projection) => {
@@ -230,20 +219,18 @@ const projectValue = (value, projection) => {
 };
 const provenanceForBinding = (binding, context) => {
     if (context.bindings.has(binding.bindingId))
-        return semanticProvenance("cycle", [], `Alias cycle at ${binding.name}.`);
-    if (context.depth >= context.state.limits.maxValueDepth)
-        return semanticLimitProvenance(context.state, "maxValueDepth");
+        return semanticUnresolvedProvenance("cycle", `Alias cycle at ${binding.name}.`);
     if (binding.directOrigins.length > 0)
-        return semanticOriginsProvenance(binding.directOrigins, context.state);
+        return semanticOriginsProvenance(binding.directOrigins);
     if (binding.initializers.length === 0)
-        return semanticProvenance("local", [], null);
+        return semanticLocalProvenance();
     if (binding.initializers.length > 1)
-        return semanticProvenance("ambiguous", [], `Binding ${binding.name} has multiple possible assignments.`);
+        return semanticAmbiguousProvenance([], `Binding ${binding.name} has multiple possible assignments.`);
     const initializer = binding.initializers[0];
     if (initializer === undefined)
-        return semanticProvenance("unknown", [], "Missing binding initializer.");
+        return semanticUnresolvedProvenance("unknown", "Missing binding initializer.");
     if (initializer.projection.includes(null))
-        return semanticProvenance("unknown", [], "Dynamic provenance projection.");
+        return semanticUnresolvedProvenance("unknown", "Dynamic provenance projection.");
     const resolved = provenanceForExpression(initializer.node, nestedContext(context, binding.bindingId));
     if (resolved.status !== "module" || initializer.projection.length === 0)
         return resolved;
@@ -253,31 +240,31 @@ const provenanceForBinding = (binding, context) => {
             ...origin.importedPath,
             ...initializer.projection.map((segment) => String(segment)),
         ],
-    })), context.state);
+    })));
 };
 const provenanceForExpression = (node, context) => {
     const required = requireOrigin(node);
     if (required !== undefined)
-        return semanticOriginsProvenance([required], context.state);
+        return semanticOriginsProvenance([required]);
     if (t.isIdentifier(node)) {
         const binding = resolveSemanticBindingState(context.state, node, node.name);
         return binding === undefined
-            ? semanticProvenance("unknown", [], `Unbound identifier ${node.name}.`)
+            ? semanticUnresolvedProvenance("unknown", `Unbound identifier ${node.name}.`)
             : provenanceForBinding(binding, nestedContext(context));
     }
     if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
         if (!t.isNode(node.object))
-            return semanticProvenance("unknown", [], "Unsupported member base.");
+            return semanticUnresolvedProvenance("unknown", "Unsupported member base.");
         const member = memberKey(node);
         if (typeof member !== "string")
-            return semanticProvenance("unknown", [], "Dynamic provenance member.");
+            return semanticUnresolvedProvenance("unknown", "Dynamic provenance member.");
         const base = provenanceForExpression(node.object, nestedContext(context));
         return base.status !== "module"
             ? base
             : semanticOriginsProvenance(base.origins.map((origin) => ({
                 ...origin,
                 importedPath: [...origin.importedPath, member],
-            })), context.state);
+            })));
     }
     if (t.isConditionalExpression(node) || t.isLogicalExpression(node)) {
         const left = t.isConditionalExpression(node) ? node.consequent : node.left;
@@ -288,10 +275,10 @@ const provenanceForExpression = (node, context) => {
         ];
         const origins = candidates.flatMap((candidate) => candidate.origins);
         return origins.length > 0
-            ? semanticProvenance("ambiguous", uniqueSemanticOrigins(origins), "Multiple module origins.")
-            : semanticProvenance("unknown", [], "Conditional provenance is unresolved.");
+            ? semanticAmbiguousProvenance(uniqueSemanticOrigins(origins), "Multiple module origins.")
+            : semanticUnresolvedProvenance("unknown", "Conditional provenance is unresolved.");
     }
-    return semanticProvenance("local", [], null);
+    return semanticLocalProvenance();
 };
 const requireOrigin = (node) => {
     if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
@@ -309,11 +296,11 @@ const requireOrigin = (node) => {
     const specifier = stringValue(node.arguments[0]);
     return specifier === undefined ? undefined : { specifier, importedPath: [] };
 };
-const mergeValues = (values, state) => {
+const mergeValues = (values) => {
     const primitives = values.flatMap((value) => primitiveCandidates(value) ?? []);
     return primitives.length === values.length ||
         values.every((value) => value.status === "union" || value.status === "literal")
-        ? primitiveSet(primitives, state)
+        ? primitiveSet(primitives)
         : { status: "ambiguous", reason: "Branches have incompatible values." };
 };
 const memberKey = (node) => {
@@ -323,13 +310,8 @@ const memberKey = (node) => {
         return node.property.value;
     return undefined;
 };
-const limitValue = (state, limit) => {
-    reachSemanticValueLimit(state, limit);
-    return { status: "limit-reached", reason: `${limit} reached.` };
-};
 const nestedContext = (context, bindingId) => ({
     state: context.state,
-    depth: context.depth + 1,
     bindings: bindingId === undefined
         ? context.bindings
         : new Set([...context.bindings, bindingId]),

package/dist/domain/javascriptStaticAnalysis.js

@@ -6,37 +6,28 @@ import { inspectBundlerRegistration, inspectEsbuildWrapper, } from "./javascript
 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) => {
+/** Parse one JavaScript artifact and recover static structure only. */
+export const analyzeJavaScriptStaticSource = (source) => {
     const file = parseJavaScriptSource(source);
     return file === null
         ? failedJavaScriptStaticAnalysis()
-        : analyzeParsedJavaScriptStaticSource(source, file, limits);
+        : analyzeParsedJavaScriptStaticSource(source, file);
 };
 /** Recover static structure from an already parsed JavaScript artifact. */
-export const analyzeParsedJavaScriptStaticSource = (source, file, limits) => {
+export const analyzeParsedJavaScriptStaticSource = (source, file) => {
     const accumulator = createJavaScriptAnalysisAccumulator();
-    traverseStaticSource(source, file, accumulator, limits);
-    addSourceMapDirectives(source, accumulator, limits.maxFindings);
-    return finalizeStaticAnalysis(source, file, accumulator, limits);
+    traverseStaticSource(source, file, accumulator);
+    addSourceMapDirectives(source, accumulator);
+    return finalizeStaticAnalysis(source, file, accumulator);
 };
-const traverseStaticSource = (source, file, accumulator, limits) => {
-    if (limits.now() > limits.deadline)
-        accumulator.truncated = true;
-    if (!accumulator.truncated)
-        t.traverseFast(file, (node) => {
-            accumulator.visitedNodes += 1;
-            if (accumulator.visitedNodes > limits.maxAstNodes ||
-                (accumulator.visitedNodes % 1_024 === 0 &&
-                    limits.now() > limits.deadline)) {
-                accumulator.truncated = true;
-                return t.traverseFast.stop;
-            }
-            inspectNode(source, node, accumulator, limits);
-            return undefined;
-        });
+const traverseStaticSource = (source, file, accumulator) => {
+    t.traverseFast(file, (node) => {
+        accumulator.visitedNodes += 1;
+        inspectNode(source, node, accumulator);
+        return undefined;
+    });
 };
-const finalizeStaticAnalysis = (source, file, accumulator, limits) => {
+const finalizeStaticAnalysis = (source, file, accumulator) => {
     const parserErrors = file.errors.length;
     const limitations = [
         ...(parserErrors === 0
@@ -44,15 +35,6 @@ const finalizeStaticAnalysis = (source, file, accumulator, limits) => {
             : [
                 "The parser recovered from syntax errors; affected facts are partial.",
             ]),
-        ...(accumulator.truncated
-            ? ["AST analysis stopped at the configured node or time bound."]
-            : []),
-        ...(accumulator.droppedFindings === 0
-            ? []
-            : ["Static findings were truncated at the configured finding bound."]),
-        ...(accumulator.structuralTruncation
-            ? ["Bundler metadata reached a per-record structural bound."]
-            : []),
         ...(accumulator.unknownFindings === 0
             ? []
             : [
@@ -61,14 +43,11 @@ const finalizeStaticAnalysis = (source, file, accumulator, limits) => {
         "JavaScript syntax was parsed as data and was never evaluated.",
     ];
     return {
-        parse_status: accumulator.truncated || accumulator.droppedFindings > 0
-            ? "truncated"
-            : parserErrors > 0 || accumulator.unknownFindings > 0
-                ? "partial"
-                : "complete",
+        parse_status: parserErrors > 0 || accumulator.unknownFindings > 0
+            ? "partial"
+            : "complete",
         parse_error_count: parserErrors,
-        visited_ast_nodes: Math.min(accumulator.visitedNodes, limits.maxAstNodes),
-        dropped_findings: accumulator.droppedFindings,
+        visited_ast_nodes: accumulator.visitedNodes,
         references: finalizeLocatedFindings(accumulator.references, accumulator.modules),
         endpoints: finalizeLocatedFindings(accumulator.endpoints, accumulator.modules),
         storage: finalizeLocatedFindings(accumulator.storage, accumulator.modules),
@@ -87,16 +66,15 @@ const finalizeStaticAnalysis = (source, file, accumulator, limits) => {
         limitations,
     };
 };
-const inspectNode = (source, node, accumulator, limits) => {
+const inspectNode = (source, node, accumulator) => {
     const findings = {
         source,
         accumulator,
-        maximum: limits.maxFindings,
     };
     inspectElectronStaticNode(node, findings);
     if (t.isCallExpression(node)) {
-        inspectBundlerRegistration(source, node, accumulator, limits);
-        inspectEsbuildWrapper(source, node, accumulator, limits);
+        inspectBundlerRegistration(source, node, accumulator);
+        inspectEsbuildWrapper(source, node, accumulator);
         inspectCall(source, node, findings);
     }
     else if (t.isNewExpression(node))

package/dist/domain/javascriptStaticAnalysisBundler.js

@@ -1,68 +1,49 @@
 import * as t from "@babel/types";
 import { collectJavaScriptExports, fingerprintJavaScriptAst, } from "./javascriptAstFingerprint.js";
-import { addBoundedFinding } from "./javascriptStaticAnalysisFindings.js";
+import { addFindingOnce } from "./javascriptStaticAnalysisFindings.js";
 import { argumentValue, calleeName, chunkRuntime, compareCodePoints, factoryRequireName, moduleFactory, modulePropertyName, range, registrationKey, sha256Text, sourceSlice, staticArrayValues, } from "./javascriptStaticAnalysisHelpers.js";
 /** Inspect a bundler registration call and recover its module table. */
-export const inspectBundlerRegistration = (source, call, accumulator, limits) => {
+export const inspectBundlerRegistration = (source, call, accumulator) => {
     const runtime = chunkRuntime(call);
     const entry = call.arguments[0];
     if (runtime === undefined || !t.isArrayExpression(entry))
         return;
     const chunkIds = entry.elements[0];
     const table = entry.elements[1];
-    const runtimeValue = runtimeMetadata(entry.elements[2], limits.maxFindings);
+    const runtimeValue = runtimeMetadata(entry.elements[2]);
     if (!t.isArrayExpression(chunkIds) || !t.isObjectExpression(table))
         return;
-    const recovered = recoverBundlerModules(source, table, accumulator, limits);
-    const chunkKeys = staticArrayValues(chunkIds, Math.min(256, limits.maxFindings));
-    if (chunkKeys.omitted > 0) {
-        accumulator.droppedFindings += chunkKeys.omitted;
-        accumulator.structuralTruncation = true;
-    }
+    const recovered = recoverBundlerModules(source, table, accumulator);
+    const chunkKeys = staticArrayValues(chunkIds);
     accumulator.unknownFindings += chunkKeys.unknown;
-    if (runtimeValue.omittedEntryModuleKeys > 0 ||
-        runtimeValue.omittedAsyncChunkKeys > 0 ||
-        recovered.omittedAsyncChunkKeys > 0) {
-        accumulator.droppedFindings +=
-            runtimeValue.omittedEntryModuleKeys +
-                runtimeValue.omittedAsyncChunkKeys +
-                recovered.omittedAsyncChunkKeys;
-        accumulator.structuralTruncation = true;
-    }
     accumulator.unknownFindings +=
         runtimeValue.unknownEntryModuleKeys +
             runtimeValue.unknownAsyncChunkKeys +
             recovered.unknownAsyncChunkKeys;
-    const asyncChunkKeys = boundedUniqueValues([...runtimeValue.asyncChunkKeys, ...recovered.asyncChunkKeys], Math.min(256, limits.maxFindings));
-    if (asyncChunkKeys.omitted > 0) {
-        accumulator.droppedFindings += asyncChunkKeys.omitted;
-        accumulator.structuralTruncation = true;
-    }
+    const asyncChunkKeys = uniqueValues([
+        ...runtimeValue.asyncChunkKeys,
+        ...recovered.asyncChunkKeys,
+    ]);
     const registration = {
         bundler: runtime.toLowerCase().includes("rspack")
             ? "rspack"
             : "webpack",
         runtime,
         chunk_keys: chunkKeys.values,
-        omitted_chunk_keys: chunkKeys.omitted,
         unknown_chunk_keys: chunkKeys.unknown,
         runtime_require_name: runtimeValue.requireName,
         runtime_module_cache_status: bundlerModuleCacheStatus(source),
         entry_module_keys: runtimeValue.entryModuleKeys,
-        omitted_entry_module_keys: runtimeValue.omittedEntryModuleKeys,
         unknown_entry_module_keys: runtimeValue.unknownEntryModuleKeys,
         async_chunk_keys: asyncChunkKeys.values,
-        omitted_async_chunk_keys: runtimeValue.omittedAsyncChunkKeys +
-            recovered.omittedAsyncChunkKeys +
-            asyncChunkKeys.omitted,
         unknown_async_chunk_keys: runtimeValue.unknownAsyncChunkKeys + recovered.unknownAsyncChunkKeys,
         modules: recovered.modules.sort((left, right) => compareCodePoints(left.module_key, right.module_key)),
         location: range(call),
     };
-    addBoundedFinding(accumulator, `registration\0${registrationKey(registration)}`, limits.maxFindings, () => accumulator.registrations.push(registration));
+    addFindingOnce(accumulator, `registration\0${registrationKey(registration)}`, () => accumulator.registrations.push(registration));
 };
 /** Inspect esbuild helper wrappers and recover their literal module tables. */
-export const inspectEsbuildWrapper = (source, call, accumulator, limits) => {
+export const inspectEsbuildWrapper = (source, call, accumulator) => {
     const name = calleeName(call.callee);
     const wrapperKind = name === "__commonJS" || name.endsWith(".__commonJS")
         ? "commonjs"
@@ -72,74 +53,55 @@ export const inspectEsbuildWrapper = (source, call, accumulator, limits) => {
     const table = call.arguments[0];
     if (wrapperKind === null || !t.isObjectExpression(table))
         return;
-    const recovered = recoverBundlerModules(source, table, accumulator, limits);
+    const recovered = recoverBundlerModules(source, table, accumulator);
     if (recovered.modules.length === 0)
         return;
-    if (recovered.omittedAsyncChunkKeys > 0) {
-        accumulator.droppedFindings += recovered.omittedAsyncChunkKeys;
-        accumulator.structuralTruncation = true;
-    }
     accumulator.unknownFindings += recovered.unknownAsyncChunkKeys;
     const registration = {
         bundler: "esbuild",
         runtime: `esbuild-${wrapperKind}`,
         chunk_keys: [`${wrapperKind}@${String(call.start ?? 0)}`],
-        omitted_chunk_keys: 0,
         unknown_chunk_keys: 0,
         runtime_require_name: null,
         runtime_module_cache_status: "not-observed",
         entry_module_keys: [],
-        omitted_entry_module_keys: 0,
         unknown_entry_module_keys: 0,
         async_chunk_keys: recovered.asyncChunkKeys,
-        omitted_async_chunk_keys: recovered.omittedAsyncChunkKeys,
         unknown_async_chunk_keys: recovered.unknownAsyncChunkKeys,
         modules: recovered.modules.sort((left, right) => compareCodePoints(left.module_key, right.module_key)),
         location: range(call),
     };
-    addBoundedFinding(accumulator, `registration\0${registrationKey(registration)}`, limits.maxFindings, () => accumulator.registrations.push(registration));
+    addFindingOnce(accumulator, `registration\0${registrationKey(registration)}`, () => accumulator.registrations.push(registration));
 };
-const recoverBundlerModules = (source, table, accumulator, limits) => {
+const recoverBundlerModules = (source, table, accumulator) => {
     const modules = [];
     const asyncChunkKeys = [];
-    let omittedAsyncChunkKeys = 0;
     let unknownAsyncChunkKeys = 0;
     for (const property of table.properties) {
-        const recovered = recoverBundlerModule(source, property, accumulator, limits);
+        const recovered = recoverBundlerModule(source, property, accumulator);
         if (recovered === null)
             continue;
         modules.push(recovered.module);
         asyncChunkKeys.push(...recovered.asyncChunkKeys);
-        omittedAsyncChunkKeys += recovered.omittedAsyncChunkKeys;
         unknownAsyncChunkKeys += recovered.unknownAsyncChunkKeys;
     }
     return {
         modules,
         asyncChunkKeys,
-        omittedAsyncChunkKeys,
         unknownAsyncChunkKeys,
     };
 };
-const recoverBundlerModule = (source, property, accumulator, limits) => {
+const recoverBundlerModule = (source, property, accumulator) => {
     const factory = moduleFactory(property);
     if (factory === undefined)
         return null;
-    if (accumulator.moduleCount >= limits.maxModules) {
-        accumulator.droppedFindings += 1;
-        return null;
-    }
-    accumulator.moduleCount += 1;
     const key = modulePropertyName(property);
     if (key.startsWith("[computed@") || key.startsWith("[unknown@"))
         accumulator.unknownFindings += 1;
-    const fingerprint = fingerprintJavaScriptAst(factory, Math.min(limits.maxAstNodes, 100_000));
-    const exportsValue = collectJavaScriptExports(factory, 256);
+    const fingerprint = fingerprintJavaScriptAst(factory);
+    const exportsValue = collectJavaScriptExports(factory);
     const requireName = factoryRequireName(factory);
-    const asyncChunks = collectBundlerAsyncChunkKeys(factory, requireName, limits.maxFindings);
-    if (fingerprint.truncated || exportsValue.truncated) {
-        accumulator.droppedFindings += 1;
-        accumulator.structuralTruncation = true;
-    }
+    const asyncChunks = collectBundlerAsyncChunkKeys(factory, requireName);
     if (typeof factory.start === "number" && typeof factory.end === "number")
         accumulator.modules.push({
             start: factory.start,
@@ -152,66 +114,49 @@ const recoverBundlerModule = (source, property, accumulator, limits) => {
             module_key: key,
             factory_require_name: requireName,
             source_sha256: sha256Text(sourceSlice(source, factory)),
-            structural_fingerprint_sha256: fingerprint.truncated
-                ? null
-                : fingerprint.sha256,
-            structural_fingerprint_algorithm: fingerprint.truncated
-                ? null
-                : "babel-ast-v1",
-            structural_fingerprint_status: fingerprint.truncated
-                ? "truncated"
-                : "complete",
+            structural_fingerprint_sha256: fingerprint,
+            structural_fingerprint_algorithm: "babel-ast-v1",
             exports: exportsValue.values,
-            exports_truncated: exportsValue.truncated,
             location: range(factory),
         },
         asyncChunkKeys: asyncChunks.values,
-        omittedAsyncChunkKeys: asyncChunks.omitted,
         unknownAsyncChunkKeys: asyncChunks.unknown,
     };
 };
-const runtimeMetadata = (node, maximum) => {
+const runtimeMetadata = (node) => {
     if (!isBundlerFunction(node))
         return {
             requireName: null,
             entryModuleKeys: [],
-            omittedEntryModuleKeys: 0,
             unknownEntryModuleKeys: node === null || node === undefined ? 0 : 1,
             asyncChunkKeys: [],
-            omittedAsyncChunkKeys: 0,
             unknownAsyncChunkKeys: 0,
         };
     const parameter = node.params[0];
-    const requireName = t.isIdentifier(parameter)
-        ? parameter.name.slice(0, 4_096)
-        : null;
+    const requireName = t.isIdentifier(parameter) ? parameter.name : null;
     if (requireName === null)
         return {
             requireName,
             entryModuleKeys: [],
-            omittedEntryModuleKeys: 0,
             unknownEntryModuleKeys: 1,
             asyncChunkKeys: [],
-            omittedAsyncChunkKeys: 0,
             unknownAsyncChunkKeys: 0,
         };
-    const entries = collectBundlerEntryModuleKeys(node, requireName, maximum);
-    const asyncChunks = collectBundlerAsyncChunkKeys(node, requireName, maximum);
+    const entries = collectBundlerEntryModuleKeys(node, requireName);
+    const asyncChunks = collectBundlerAsyncChunkKeys(node, requireName);
     return {
         requireName,
         entryModuleKeys: entries.values,
-        omittedEntryModuleKeys: entries.omitted,
         unknownEntryModuleKeys: entries.unknown,
         asyncChunkKeys: asyncChunks.values,
-        omittedAsyncChunkKeys: asyncChunks.omitted,
         unknownAsyncChunkKeys: asyncChunks.unknown,
     };
 };
-const collectBundlerEntryModuleKeys = (factory, requireName, maximum) => collectBundlerCallArgumentValues(factory, requireName, maximum);
-const collectBundlerAsyncChunkKeys = (factory, requireName, maximum) => requireName === null
-    ? { values: [], omitted: 0, unknown: 0 }
-    : collectBundlerCallArgumentValues(factory, `${requireName}.e`, maximum);
-const collectBundlerCallArgumentValues = (factory, callee, maximum) => {
+const collectBundlerEntryModuleKeys = (factory, requireName) => collectBundlerCallArgumentValues(factory, requireName);
+const collectBundlerAsyncChunkKeys = (factory, requireName) => requireName === null
+    ? { values: [], unknown: 0 }
+    : collectBundlerCallArgumentValues(factory, `${requireName}.e`);
+const collectBundlerCallArgumentValues = (factory, callee) => {
     const values = [];
     let unknown = 0;
     t.traverseFast(factory, (node) => {
@@ -226,19 +171,15 @@ const collectBundlerCallArgumentValues = (factory, callee, maximum) => {
             values.push(value);
         return undefined;
     });
-    return boundedUniqueValues(values, Math.min(256, maximum), unknown);
+    return uniqueValues(values, unknown);
 };
 const isBundlerFunction = (node) => t.isFunctionExpression(node) ||
     t.isArrowFunctionExpression(node) ||
     t.isObjectMethod(node);
-const boundedUniqueValues = (values, maximum, unknown = 0) => {
-    const bounded = [
-        ...new Set(values.map((value) => value.slice(0, 4_096))),
-    ].sort(compareCodePoints);
-    const retained = bounded.slice(0, Math.max(0, maximum));
+const uniqueValues = (values, unknown = 0) => {
+    const unique = [...new Set(values)].sort(compareCodePoints);
     return {
-        values: retained,
-        omitted: Math.max(0, bounded.length - retained.length),
+        values: unique,
         unknown,
     };
 };