rea-agents 3.0.0 → 3.2.0

package/dist/application/JavaScriptArtifactAnalysis.js

@@ -1,77 +1,50 @@
 import { createHash } from "node:crypto";
 import { analyzeParsedJavaScriptStaticSource } from "../domain/javascriptStaticAnalysis.js";
 import { analyzeParsedJavaScriptSemantics } from "../domain/javascriptSemanticAnalysis.js";
-import { DEFAULT_JAVASCRIPT_SEMANTIC_LIMITS, } from "../domain/javascriptSemanticIr.js";
 import { parseJavaScriptSource } from "../domain/javascriptSourceParser.js";
 import { failedJavaScriptStaticAnalysis } from "../domain/javascriptStaticAnalysisHelpers.js";
 import { analyzeJavaScriptJsonModule } from "./JavaScriptJsonModules.js";
-/** Analyze selected text files under one shared AST, finding, module, and time budget. */
-export const analyzeJavaScriptArtifactFiles = (fileSet, input, now) => {
+/** Analyze every text source from the artifact without a result quota. */
+export const analyzeJavaScriptArtifactFiles = (fileSet) => {
     const state = emptyArtifactAnalysis();
-    const context = {
-        state,
-        input,
-        deadline: now() + input.limits.max_parse_milliseconds,
-        now,
-    };
+    const context = { state };
     for (const file of fileSet.files)
         analyzeArtifactFile(file, context);
-    return finalizeArtifactAnalysis(state, input);
+    return finalizeArtifactAnalysis(state);
 };
-const finalizeArtifactAnalysis = (state, input) => {
-    const omittedHtmlFindings = Math.max(0, state.htmlScripts.length + state.findings - input.limits.max_findings);
-    const findings = Math.min(input.limits.max_findings, state.findings + state.htmlScripts.length);
-    const sourceMapTruncations = state.sourceMaps.filter(({ status }) => status === "truncated").length;
-    const truncatedScopes = state.truncatedScopes +
-        sourceMapTruncations +
-        (omittedHtmlFindings > 0 ? 1 : 0);
+const finalizeArtifactAnalysis = (state) => {
+    const truncatedScopes = state.truncatedScopes;
     return {
         files: state.files,
         packages: state.packages,
         json_modules: state.jsonModules,
-        html_scripts: state.htmlScripts.slice(0, input.limits.max_findings),
+        html_scripts: state.htmlScripts,
         source_maps: state.sourceMaps,
         visited_ast_nodes: state.visitedNodes,
-        findings,
+        findings: state.findings + state.htmlScripts.length,
         modules: state.modules,
         parse_failures: state.parseFailures,
         truncated_scopes: truncatedScopes,
         limitations: [
             "JavaScript and HTML were parsed as inert text; bundle bootstrap code was never executed.",
             "Static paths and relationships may remain unresolved when expressions are dynamic or obfuscated.",
-            ...(input.source_map_read_approved
-                ? []
-                : [
-                    "Source maps were inventoried but their contents were not read without separate approval.",
-                ]),
             ...(truncatedScopes === 0
                 ? []
-                : ["One or more static-analysis scopes reached an approved bound."]),
+                : ["Some static-analysis scopes were truncated."]),
         ],
     };
 };
 const analyzeArtifactFile = (file, context) => {
-    const { state, input } = context;
+    const { state } = context;
     addStructuredObservations(file, state);
     if (file.kind === "html" && file.text.included)
-        state.htmlScripts.push(...parseHtmlScripts(file.path, file.text.value, Math.max(0, input.limits.max_findings - state.findings)));
+        state.htmlScripts.push(...parseHtmlScripts(file.path, file.text.value));
     if (file.kind === "source-map")
         addSourceMap(file, context);
     if (file.kind !== "javascript" || !file.text.included) {
         state.files.push({ file, javascript: null, semantic: null });
         return;
     }
-    const remainingNodes = input.limits.max_ast_nodes - state.visitedNodes;
-    const remainingFindings = input.limits.max_findings - state.findings;
-    const remainingModules = input.limits.max_modules - state.modules;
-    if (remainingNodes <= 0 ||
-        remainingFindings <= 0 ||
-        remainingModules <= 0 ||
-        context.now() > context.deadline) {
-        state.files.push({ file, javascript: null, semantic: null });
-        state.truncatedScopes += 1;
-        return;
-    }
     const parsed = parseJavaScriptSource(file.text.value);
     if (parsed === null) {
         const analysis = failedJavaScriptStaticAnalysis();
@@ -79,50 +52,25 @@ const analyzeArtifactFile = (file, context) => {
         state.parseFailures += 1;
         return;
     }
-    const analysis = analyzeParsedJavaScriptStaticSource(file.text.value, parsed, {
-        maxAstNodes: remainingNodes,
-        maxFindings: remainingFindings,
-        maxModules: remainingModules,
-        deadline: context.deadline,
-        now: context.now,
-    });
+    const analysis = analyzeParsedJavaScriptStaticSource(file.text.value, parsed);
     const staticFindings = findingCount(analysis);
-    const semanticFindingBudget = Math.max(0, input.limits.max_findings - state.findings - staticFindings);
-    const semanticLimits = {
-        ...DEFAULT_JAVASCRIPT_SEMANTIC_LIMITS,
-        maxScopes: remainingNodes,
-        maxBindings: remainingNodes,
-        maxCallables: remainingNodes,
-        maxReferences: remainingNodes,
-        maxModuleLinks: semanticFindingBudget,
-    };
     const semantics = analysis.parse_status === "complete" || analysis.parse_status === "partial"
-        ? analyzeParsedJavaScriptSemantics(parsed, semanticLimits)
+        ? analyzeParsedJavaScriptSemantics(parsed)
         : null;
     state.files.push({
         file,
         javascript: analysis,
-        semantic: semantics === null ? null : { ir: semantics, limits: semanticLimits },
+        semantic: semantics === null ? null : { ir: semantics },
     });
     state.visitedNodes += analysis.visited_ast_nodes;
     state.findings += staticFindings + (semantics?.moduleLinks.length ?? 0);
     state.modules += analysis.bundler_registrations.reduce((count, registration) => count + registration.modules.length, 0);
     if (analysis.parse_status === "failed")
         state.parseFailures += 1;
-    if (analysis.parse_status === "truncated")
-        state.truncatedScopes += 1;
-    if (semantics?.coverage.status === "truncated")
-        state.truncatedScopes += 1;
 };
 const addSourceMap = (file, context) => {
-    const sourceMap = parseSourceMap(file, {
-        deadline: context.deadline,
-        now: context.now,
-        maximumSources: Math.max(0, context.input.limits.max_source_map_sources -
-            context.state.sourceMapSources),
-    });
+    const sourceMap = parseSourceMap(file);
     context.state.sourceMaps.push(sourceMap);
-    context.state.sourceMapSources += sourceMap.sources.length;
 };
 const emptyArtifactAnalysis = () => ({
     files: [],
@@ -135,7 +83,6 @@ const emptyArtifactAnalysis = () => ({
     modules: 0,
     parseFailures: 0,
     truncatedScopes: 0,
-    sourceMapSources: 0,
 });
 const addStructuredObservations = (file, state) => {
     if (file.kind === "package-json")
@@ -163,12 +110,12 @@ const parsePackage = (file) => {
         path: file.path,
         sha256: file.sha256,
         status: "included",
-        name: boundedString(value.name),
-        version: boundedString(value.version),
-        main: boundedString(value.main),
-        renderer: boundedString(value.renderer) ??
-            boundedString(value.browser) ??
-            boundedString(value.module),
+        name: optionalString(value.name),
+        version: optionalString(value.version),
+        main: optionalString(value.main),
+        renderer: optionalString(value.renderer) ??
+            optionalString(value.browser) ??
+            optionalString(value.module),
         limitation: null,
     };
 };
@@ -186,14 +133,14 @@ const unavailablePackage = (file, limitation) => ({
     renderer: null,
     limitation,
 });
-const parseHtmlScripts = (path, text, maximum) => {
+const parseHtmlScripts = (path, text) => {
     const scripts = [];
     const baseHref = htmlBaseHref(text);
     const pattern = /<script\b[^>]*\bsrc\s*=\s*(["'])([^"']+)\1[^>]*>/giu;
     for (const match of text.matchAll(pattern)) {
-        const script = match[2]?.slice(0, 4_096);
-        if (script === undefined || scripts.length >= maximum)
-            break;
+        const script = match[2];
+        if (script === undefined)
+            continue;
         const start = match.index;
         scripts.push({
             html_path: path,
@@ -206,13 +153,11 @@ const parseHtmlScripts = (path, text, maximum) => {
 };
 const htmlBaseHref = (text) => {
     const match = /<base\b[^>]*\bhref\s*=\s*(["'])([^"']+)\1[^>]*>/iu.exec(text);
-    return match?.[2]?.slice(0, 4_096) ?? null;
+    return match?.[2] ?? null;
 };
-const parseSourceMap = (file, context) => {
+const parseSourceMap = (file) => {
     if (!file.text.included)
         return unavailableSourceMap(file);
-    if (context.now() > context.deadline)
-        return truncatedSourceMap(file, null, "Parse deadline reached before source-map decoding.");
     let value;
     try {
         value = JSON.parse(file.text.value);
@@ -220,16 +165,13 @@ const parseSourceMap = (file, context) => {
     catch {
         return invalidSourceMap(file, "Source map is not valid JSON.");
     }
-    if (context.now() > context.deadline)
-        return truncatedSourceMap(file, null, "Parse deadline elapsed during source-map decoding.");
-    const maps = flattenSourceMaps(value, 10_000);
+    const maps = flattenSourceMaps(value);
     if (maps === undefined)
-        return invalidSourceMap(file, "Source map is not a bounded version 3 map.");
-    return collectSourceMapOriginals(file, maps, context);
+        return invalidSourceMap(file, "Source map is not a version 3 map.");
+    return collectSourceMapOriginals(file, maps);
 };
-const collectSourceMapOriginals = (file, maps, context) => {
+const collectSourceMapOriginals = (file, maps) => {
     const sources = [];
-    let total = 0;
     for (const map of maps) {
         const names = map.sources;
         if (!Array.isArray(names))
@@ -239,20 +181,8 @@ const collectSourceMapOriginals = (file, maps, context) => {
             : [];
         const root = typeof map.sourceRoot === "string" ? map.sourceRoot : "";
         for (const [index, raw] of names.entries()) {
-            if (total % 1_024 === 0 && context.now() > context.deadline)
-                return {
-                    path: file.path,
-                    sha256: file.sha256,
-                    status: "truncated",
-                    sources,
-                    omitted_sources: null,
-                    limitation: "Parse deadline elapsed during source-map traversal.",
-                };
             if (typeof raw !== "string")
                 return invalidSourceMap(file, "Source map contains a non-string source name.");
-            total += 1;
-            if (sources.length >= context.maximumSources)
-                continue;
             const content = typeof contents[index] === "string" ? contents[index] : null;
             sources.push({
                 source: resolveSourceName(root, raw),
@@ -261,34 +191,26 @@ const collectSourceMapOriginals = (file, maps, context) => {
             });
         }
     }
-    const omitted = total - sources.length;
     return {
         path: file.path,
         sha256: file.sha256,
-        status: omitted === 0 ? "included" : "truncated",
+        status: "included",
         sources,
-        omitted_sources: omitted,
-        limitation: omitted === 0
-            ? null
-            : "Original-source inventory reached the approved source-map limit.",
+        limitation: null,
     };
 };
 const unavailableSourceMap = (file) => {
     if (file.text.included)
         throw new TypeError("Expected unavailable source-map text");
-    const notApproved = file.text.reason === "not-approved";
     return {
         path: file.path,
         sha256: file.sha256,
-        status: notApproved ? "not-approved" : "invalid",
+        status: "invalid",
         sources: [],
-        omitted_sources: 0,
-        limitation: notApproved
-            ? "Source-map content requires separate approval."
-            : "Source-map text was unavailable within approved limits.",
+        limitation: "Source-map text could not be decoded as UTF-8.",
     };
 };
-const flattenSourceMaps = (root, maximum) => {
+const flattenSourceMaps = (root) => {
     if (!isRecord(root) || root.version !== 3)
         return undefined;
     const maps = [];
@@ -298,8 +220,6 @@ const flattenSourceMaps = (root, maximum) => {
         if (map === undefined || map.version !== 3)
             return undefined;
         if (Array.isArray(map.sections)) {
-            if (pending.length + maps.length + map.sections.length > maximum)
-                return undefined;
             for (const section of map.sections) {
                 if (!isRecord(section) || !isRecord(section.map))
                     return undefined;
@@ -311,20 +231,11 @@ const flattenSourceMaps = (root, maximum) => {
     }
     return maps;
 };
-const truncatedSourceMap = (file, omitted, limitation) => ({
-    path: file.path,
-    sha256: file.sha256,
-    status: "truncated",
-    sources: [],
-    omitted_sources: omitted,
-    limitation,
-});
 const invalidSourceMap = (file, limitation) => ({
     path: file.path,
     sha256: file.sha256,
     status: "invalid",
     sources: [],
-    omitted_sources: 0,
     limitation,
 });
 const findingCount = (analysis) => analysis.references.length +
@@ -347,7 +258,7 @@ const pointForOffset = (text, offset) => {
     const lines = text.slice(0, offset).split("\n");
     return { line: lines.length, column: lines.at(-1)?.length ?? 0 };
 };
-const resolveSourceName = (root, source) => `${root}${root !== "" && !root.endsWith("/") ? "/" : ""}${source}`.slice(0, 4_096);
-const boundedString = (value) => typeof value === "string" && value.length > 0 ? value.slice(0, 4_096) : null;
+const resolveSourceName = (root, source) => `${root}${root !== "" && !root.endsWith("/") ? "/" : ""}${source}`;
+const optionalString = (value) => typeof value === "string" && value.length > 0 ? value : null;
 const sha256 = (value) => createHash("sha256").update(value).digest("hex");
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/application/JavaScriptArtifactFiles.js

@@ -4,16 +4,13 @@ import { AsarArtifactReader } from "../artifacts/AsarArtifactReader.js";
 import { ArtifactPathRegistry, normalizeArtifactPath, } from "../artifacts/ArtifactPaths.js";
 import { ArtifactReaderFailure, } from "../artifacts/ArtifactReader.js";
 import { streamChunkToBuffer } from "../artifacts/StreamBytes.js";
-/** Read only selected textual entries through an already-inventoried reader. */
-export const readJavaScriptArtifactFiles = async (reader, snapshot, input, signal) => {
+/** Read all relevant textual entries through an already-inventoried reader. */
+export const readJavaScriptArtifactFiles = async (reader, snapshot, signal) => {
     const inventory = expectedInventory(snapshot);
     const expected = inventory.files;
-    const selections = selectTextFiles(expected, input);
     const context = {
-        input,
         expected,
         expectedContainers: inventory.containers,
-        selections,
         registry: new ArtifactPathRegistry(),
         files: [],
         containers: [],
@@ -24,62 +21,80 @@ export const readJavaScriptArtifactFiles = async (reader, snapshot, input, signa
     await visitReader(reader, "", snapshot.manifest.root_sha256, context);
     const files = context.files.sort((left, right) => compareCodePoints(left.path, right.path));
     assertExpectedFilesWereVisited(expected, files);
-    const selected = [...selections.values()].filter(({ selected: isSelected }) => isSelected).length;
     return {
         files,
         containers: context.containers.sort((left, right) => compareCodePoints(left.path, right.path)),
-        text_files_selected: selected,
         text_bytes_read: context.textBytes,
-        omitted_text_files: [...selections.values()].filter(({ selected: isSelected }) => !isSelected).length,
-        limit_omitted_text_files: [...selections.values()].filter(({ reason }) => reason === "file-limit" || reason === "byte-limit").length,
-        policy_filtered_text_files: [...selections.values()].filter(({ reason }) => reason === "not-approved").length,
         invalid_utf8_files: context.invalidUtf8,
     };
 };
 const visitReader = async (reader, prefix, containerSha256, context) => {
-    for await (const entry of reader.entries(context.signal)) {
-        abortIfNeeded(context.signal);
-        const path = normalizeArtifactPath(prefix === "" ? entry.path : `${prefix}/${entry.path}`, {
-            maxDepth: context.input.limits.max_depth,
-            maxPathBytes: context.input.limits.max_path_bytes,
-        });
-        const nestedAsar = isFilesystemAsar(entry, path);
-        context.registry.add(path, nestedAsar ? "directory" : entry.kind);
-        if (nestedAsar) {
-            await visitNestedAsar(entry, path, context);
-            continue;
-        }
-        const expected = context.expected.get(path);
-        if (expected === undefined)
-            continue;
-        const selection = context.selections.get(path);
-        const text = await readTextIfSelected(context, {
+    const stack = [
+        {
             reader,
-            entry,
-            expected,
-            selection,
-        });
-        context.files.push({
-            path,
-            container_sha256: containerSha256,
-            sha256: expected.sha256,
-            bytes: expected.bytes,
-            inventory_artifact_id: expected.inventoryArtifactId,
-            kind: expected.kind,
-            unpacked: entry.unpacked,
-            text,
-        });
-    }
-};
-const visitNestedAsar = async (entry, path, context) => {
-    const inventory = expectedContainer(path, context);
-    context.containers.push(inventory);
-    const nested = new AsarArtifactReader(entry.adapterKey);
+            prefix,
+            containerSha256,
+            iterator: reader.entries(context.signal)[Symbol.asyncIterator](),
+            owned: false,
+        },
+    ];
     try {
-        await visitReader(nested, path, inventory.sha256, context);
+        while (stack.length > 0) {
+            const frame = stack.at(-1);
+            if (frame === undefined)
+                break;
+            const next = await frame.iterator.next();
+            if (next.done) {
+                stack.pop();
+                if (frame.owned)
+                    await frame.reader.close();
+                continue;
+            }
+            const entry = next.value;
+            abortIfNeeded(context.signal);
+            const path = normalizeArtifactPath(frame.prefix === "" ? entry.path : `${frame.prefix}/${entry.path}`);
+            const nestedAsar = isFilesystemAsar(entry, path);
+            context.registry.add(path, nestedAsar ? "directory" : entry.kind);
+            if (nestedAsar) {
+                const inventory = expectedContainer(path, context);
+                context.containers.push(inventory);
+                const nested = new AsarArtifactReader(entry.adapterKey);
+                stack.push({
+                    reader: nested,
+                    prefix: path,
+                    containerSha256: inventory.sha256,
+                    iterator: nested.entries(context.signal)[Symbol.asyncIterator](),
+                    owned: true,
+                });
+                continue;
+            }
+            const expected = context.expected.get(path);
+            if (expected === undefined)
+                continue;
+            const text = await readText(context, {
+                reader: frame.reader,
+                entry,
+                expected,
+            });
+            context.files.push({
+                path,
+                container_sha256: frame.containerSha256,
+                sha256: expected.sha256,
+                bytes: expected.bytes,
+                inventory_artifact_id: expected.inventoryArtifactId,
+                kind: expected.kind,
+                unpacked: entry.unpacked,
+                text,
+            });
+        }
     }
     finally {
-        await nested.close();
+        await Promise.allSettled(stack
+            .filter(({ owned }) => owned)
+            .map(async ({ reader, iterator }) => {
+            await iterator.return?.();
+            await reader.close();
+        }));
     }
 };
 const expectedContainer = (path, context) => {
@@ -88,15 +103,10 @@ const expectedContainer = (path, context) => {
         throw new ArtifactReaderFailure("integrity", `Nested ASAR disappeared from inventory: ${path}`);
     return container;
 };
-const readTextIfSelected = async (context, input) => {
+const readText = async (context, input) => {
     if (input.expected.kind === "native-addon")
         return { included: false, reason: "not-applicable" };
-    if (input.selection?.selected !== true)
-        return {
-            included: false,
-            reason: input.selection?.reason ?? "file-limit",
-        };
-    const bytes = await readBounded(await input.reader.open(input.entry, context.signal), context.input.limits.max_text_file_bytes, context.signal);
+    const bytes = await readAll(await input.reader.open(input.entry, context.signal), context.signal);
     const digest = createHash("sha256").update(bytes).digest("hex");
     if (digest !== input.expected.sha256 || bytes.length !== input.expected.bytes)
         throw new ArtifactReaderFailure("integrity", `Artifact entry changed after inventory: ${input.expected.path}`);
@@ -142,47 +152,13 @@ const expectedInventory = (snapshot) => {
     }
     return { files, containers };
 };
-const selectTextFiles = (files, input) => {
-    const selected = new Map();
-    let fileCount = 0;
-    let bytes = 0;
-    const ordered = [...files.values()].sort((left, right) => {
-        const priority = filePriority(left.kind) - filePriority(right.kind);
-        return priority === 0 ? compareCodePoints(left.path, right.path) : priority;
-    });
-    for (const file of ordered) {
-        if (file.kind === "native-addon")
-            continue;
-        if (file.kind === "source-map" && !input.source_map_read_approved) {
-            selected.set(file.path, { selected: false, reason: "not-approved" });
-            continue;
-        }
-        if (fileCount >= input.limits.max_text_files ||
-            file.bytes > input.limits.max_text_file_bytes) {
-            selected.set(file.path, { selected: false, reason: "file-limit" });
-            continue;
-        }
-        if (bytes + file.bytes > input.limits.max_total_text_bytes) {
-            selected.set(file.path, { selected: false, reason: "byte-limit" });
-            continue;
-        }
-        selected.set(file.path, { selected: true, reason: null });
-        fileCount += 1;
-        bytes += file.bytes;
-    }
-    return selected;
-};
-const readBounded = async (stream, maximum, signal) => {
+const readAll = async (stream, signal) => {
     const chunks = [];
     let bytes = 0;
     for await (const raw of stream) {
         abortIfNeeded(signal);
         const chunk = streamChunkToBuffer(raw);
         bytes += chunk.length;
-        if (bytes > maximum) {
-            stream.destroy();
-            throw new ArtifactReaderFailure("limit", "Selected JavaScript artifact text exceeded its byte limit");
-        }
         chunks.push(chunk);
     }
     return Buffer.concat(chunks, bytes);
@@ -209,22 +185,6 @@ const relevantKind = (path) => {
         return "native-addon";
     return undefined;
 };
-const filePriority = (kind) => {
-    switch (kind) {
-        case "package-json":
-            return 0;
-        case "html":
-            return 1;
-        case "javascript":
-            return 2;
-        case "json":
-            return 3;
-        case "source-map":
-            return 4;
-        case "native-addon":
-            return 5;
-    }
-};
 const isFilesystemAsar = (entry, path) => entry.kind === "file" &&
     path.toLowerCase().endsWith(".asar") &&
     isAbsolute(entry.adapterKey);

package/dist/application/JavaScriptArtifactGraphAccumulator.js

@@ -3,7 +3,6 @@ import { createJavaScriptApplicationEdge, createJavaScriptApplicationNode, } fro
 export class JavaScriptArtifactGraphAccumulator {
     #nodes = new Map();
     #edges = new Map();
-    #omittedObservations = 0;
     /** Create or merge one canonical node. */
     addNode(input) {
         const created = createJavaScriptApplicationNode(input);
@@ -18,9 +17,7 @@ export class JavaScriptArtifactGraphAccumulator {
         ]));
         const observations = [...bySemanticId.entries()]
             .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
-            .slice(0, 64)
             .map(([, observation]) => observation);
-        this.#omittedObservations += Math.max(0, bySemanticId.size - 64);
         const merged = createJavaScriptApplicationNode({
             kind: existing.kind,
             identity: existing.identity,
@@ -43,10 +40,6 @@ export class JavaScriptArtifactGraphAccumulator {
     edges() {
         return [...this.#edges.values()];
     }
-    /** Count distinct node observations omitted by the graph contract bound. */
-    omittedObservations() {
-        return this.#omittedObservations;
-    }
 }
 const observationInput = (observation) => {
     const { observation_id: _observationId, identifier_strategy: _strategy, ...input } = observation;