rea-agents 6.4.0 → 6.5.0

package/dist/application/investigation/UnknownEvidence.js

@@ -1,33 +1,37 @@
 import { createEvidence } from "../../domain/evidence.js";
 /** Provider identity for analyst-authored residual-unknown mutations. */
-export const UNKNOWN_REGISTRY_PROVIDER = {
+const UNKNOWN_REGISTRY_PROVIDER = {
     id: "rea-unknown-registry",
     name: "REA residual unknown registry",
     version: "1",
 };
 /** Create immutable evidence for one approved residual-unknown mutation. */
-export const unknownMutationEvidence = (target, input) => createEvidence(target, UNKNOWN_REGISTRY_PROVIDER, {
+export const unknownMutationEvidence = (target, mutation) => createEvidence(target, UNKNOWN_REGISTRY_PROVIDER, {
     predicateType: "rea.residual-unknown-mutation",
-    operation: "record_unknown",
-    parameters: { domain: input.domain, severity: input.severity },
-    result: {
-        action: "record",
-        question: input.question,
-        required_authority: input.required_authority,
-        required_confidence: input.required_confidence,
-    },
+    operation: mutation.operation,
+    parameters: { ...mutation.input },
+    result: mutation.operation === "record_unknown"
+        ? {
+            action: "record",
+            question: mutation.input.question,
+            required_authority: mutation.input.required_authority,
+            required_confidence: mutation.input.required_confidence,
+        }
+        : { action: "update", status: mutation.input.status },
     confidence: "derived",
     authority: "analyst-inference",
-    evidenceLinks: unknownEvidenceLinks(input),
+    evidenceLinks: unknownEvidenceLinks(mutation.input),
     limitations: [
         "Registry mutation evidence records analyst intent, not proof of the answer.",
     ],
 });
 /** Deduplicate evidence links carried by an unknown mutation. */
-export const unknownEvidenceLinks = (input) => [
-    ...input.supporting_evidence_ids,
-    ...input.contradicting_evidence_ids,
-    ...("resolution" in input && input.resolution !== null
-        ? input.resolution.evidence_ids
-        : []),
-].filter((id, index, values) => values.indexOf(id) === index);
+const unknownEvidenceLinks = (input) => [
+    ...new Set([
+        ...input.supporting_evidence_ids,
+        ...input.contradicting_evidence_ids,
+        ...("resolution" in input && input.resolution !== null
+            ? input.resolution.evidence_ids
+            : []),
+    ]),
+];

package/dist/application/javascript/ElectronActiveObservationService.js

@@ -1,39 +1,69 @@
 import { dirname } from "node:path";
-import { realpath } from "node:fs/promises";
+import { constants } from "node:fs";
+import { access, realpath, stat } from "node:fs/promises";
 import { AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../../domain/analysisErrorCore.js";
-import {} from "../../domain/analysisErrorBase.js";
-import { err } from "../../domain/result.js";
+import { err, ok } from "../../domain/result.js";
 import { createElectronActiveEvidence } from "./ElectronActiveEvidence.js";
 const OPERATION = "capture_electron_scenario";
 const PROVIDER_ID = "rea-playwright-electron-active";
-const canonicalizeInput = async (input) => {
+const resolveInputPath = async (field, selected) => {
     try {
-        const [executablePath, applicationPath] = await Promise.all([
-            realpath(input.executable_path),
-            realpath(input.application_path),
-        ]);
-        const applicationRoot = input.application_root === undefined
-            ? dirname(applicationPath)
-            : await realpath(input.application_root);
-        return {
-            ok: true,
-            value: {
-                ...input,
-                executable_path: executablePath,
-                application_path: applicationPath,
-                application_root: applicationRoot,
+        return ok(await realpath(selected));
+    }
+    catch (cause) {
+        return err({
+            issue: {
+                path: [field],
+                reason: "invalid_value",
+                message: `Cannot resolve ${field} ${selected}: ${cause instanceof Error ? cause.message : String(cause)}`,
             },
-        };
+            cause,
+        });
+    }
+};
+/** Resolve the executable and require a launchable regular file before any spawn. */
+const resolveExecutablePath = async (selected) => {
+    const resolved = await resolveInputPath("executable_path", selected);
+    if (!resolved.ok)
+        return resolved;
+    try {
+        if (!(await stat(resolved.value)).isFile())
+            throw new Error("not a regular file");
+        if (process.platform !== "win32")
+            await access(resolved.value, constants.X_OK);
+        return resolved;
     }
     catch (cause) {
-        return err(new AnalysisInputError(OPERATION, { cause }, [
-            {
-                path: ["application_path"],
-                reason: "invalid_format",
-                message: "Electron executable, application, and root must resolve to existing paths",
+        return err({
+            issue: {
+                path: ["executable_path"],
+                reason: "invalid_value",
+                message: `executable_path ${selected} is not an executable file: ${cause instanceof Error ? cause.message : String(cause)}`,
             },
-        ]));
+            cause,
+        });
+    }
+};
+const canonicalizeInput = async (input) => {
+    const [executable, application, root] = await Promise.all([
+        resolveExecutablePath(input.executable_path),
+        resolveInputPath("application_path", input.application_path),
+        input.application_root === undefined
+            ? Promise.resolve(ok(undefined))
+            : resolveInputPath("application_root", input.application_root),
+    ]);
+    if (!executable.ok || !application.ok || !root.ok) {
+        const failures = [executable, application, root].flatMap((result) => result.ok ? [] : [result.error]);
+        return err(new AnalysisInputError(OPERATION, {
+            cause: new AggregateError(failures.map(({ cause }) => cause), "Electron paths could not be resolved"),
+        }, failures.map(({ issue }) => issue)));
     }
+    return ok({
+        ...input,
+        executable_path: executable.value,
+        application_path: application.value,
+        application_root: root.value ?? dirname(application.value),
+    });
 };
 /** Canonicalize request paths and execute one provider-owned Electron run. */
 export const captureElectronScenario = async (provider, input, options = {}) => {

package/dist/application/javascript/ElectronBoundaryAnalysis.js

@@ -1,5 +1,5 @@
 import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
-import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
+import { resolveArtifactPathByContext, } from "./JavaScriptArtifactPathResolution.js";
 /** Flatten all per-file IPC facts into deterministic application records. */
 export const collectElectronIpcRecords = (analysis) => analysis.files
     .flatMap(({ file, javascript }) => (javascript?.electron.ipc ?? []).map((finding) => ({
@@ -35,7 +35,7 @@ export const unambiguousElectronIpcPairings = (records) => classifyElectronIpcPa
         : [];
 });
 /** Summarize static Electron findings without treating gaps as absence. */
-export const summarizeElectronBoundaries = (analysis) => {
+export const summarizeElectronBoundaries = (analysis, directoryPaths) => {
     const files = new Map(analysis.files.map(({ file }) => [file.path, file]));
     const javascript = analysis.files.flatMap(({ javascript: value }) => value === null ? [] : [value]);
     const windows = javascript.flatMap(({ electron }) => electron.browser_windows);
@@ -77,6 +77,8 @@ export const summarizeElectronBoundaries = (analysis) => {
                 specifier: finding.module_path,
                 context: finding.module_resolution_context,
                 files,
+                directoryPaths,
+                runtimePathKind: "node-entrypoint",
             })).length,
         native_addon_bindings: nativeBindings.length,
         resolved_native_addon_bindings: nativeBindings.filter(({ file, finding }) => resolvesToFile({
@@ -84,6 +86,7 @@ export const summarizeElectronBoundaries = (analysis) => {
             specifier: finding.specifier,
             context: "module-specifier",
             files,
+            directoryPaths,
             kind: "native-addon",
             moduleKind: finding.module_kind,
         })).length,
@@ -105,9 +108,20 @@ const resolvesToFile = (input) => {
         sourcePath: input.file.path,
         context: input.context,
         files: input.files,
+        ...(input.directoryPaths === undefined
+            ? {}
+            : { directoryPaths: input.directoryPaths }),
+        ...(input.runtimePathKind === undefined
+            ? {}
+            : { runtimePathKind: input.runtimePathKind }),
         ...(input.moduleKind === undefined ? {} : { moduleKind: input.moduleKind }),
     }).resolved_path;
     return (resolved !== null &&
         (input.kind === undefined || input.files.get(resolved)?.kind === input.kind));
 };
-const ipcRecordKey = (path, finding) => `${path}\0${String(finding.location.start.line)}:${String(finding.location.start.column)}\0${finding.side}\0${finding.operation}`;
+const ipcRecordKey = (path, finding) => {
+    const identity = `${path}\0${String(finding.location.start.line)}:${String(finding.location.start.column)}\0${finding.side}\0${finding.operation}\0${finding.channel ?? finding.channel_expression}\0${JSON.stringify(finding.handler_location)}`;
+    return finding.invocation_location === undefined
+        ? identity
+        : `${identity}\0${String(finding.invocation_location.start.line)}:${String(finding.invocation_location.start.column)}`;
+};

package/dist/application/javascript/ElectronBoundaryGraph.js

@@ -1,9 +1,11 @@
 import { addElectronIpcBoundaries } from "./ElectronBoundaryGraphIpc.js";
 import { addElectronNativeBoundaries } from "./ElectronBoundaryGraphNative.js";
 import { addElectronWindowBoundaries } from "./ElectronBoundaryGraphWindows.js";
+import { addElectronCallPaths } from "./ElectronBoundaryGraphCallPaths.js";
 /** Add every static Electron process and security-boundary fact to the JAG. */
 export const addElectronBoundaries = (context) => {
     addElectronWindowBoundaries(context);
     addElectronIpcBoundaries(context);
     addElectronNativeBoundaries(context);
+    addElectronCallPaths(context);
 };

package/dist/application/javascript/ElectronBoundaryGraphCallPaths.js

@@ -0,0 +1,144 @@
+import { sha256Text } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
+import { collectElectronIpcRecords, unambiguousElectronIpcPairings, } from "./ElectronBoundaryAnalysis.js";
+import { addElectronInferenceEdge, electronFindingSourceNode, electronRangeKey, } from "./ElectronBoundaryGraphContext.js";
+import { artifactLocalIdentity, javascriptAnalysisCoverage, } from "./JavaScriptArtifactGraphContext.js";
+import { staticInferenceEvidence } from "./JavaScriptArtifactGraphEvidence.js";
+/** Retain context-specific wrapper paths, then join only unique IPC records. */
+export const addElectronCallPaths = (context) => {
+    const projected = [];
+    for (const { file, javascript } of context.analysis.files) {
+        if (javascript === null)
+            continue;
+        const coverage = javascriptAnalysisCoverage(javascript);
+        for (const path of javascript.electron.call_paths ?? []) {
+            const pathId = sha256Text(JSON.stringify(path));
+            const nodes = path.steps.map((step, index) => context.accumulator.addNode({
+                kind: "javascript-expression",
+                identity: artifactLocalIdentity(file.sha256, "electron-call-path-step", `${pathId}:${String(index)}`),
+                observations: [
+                    {
+                        label: step.label,
+                        properties: {
+                            path_id: pathId,
+                            entry: path.entry,
+                            ...(path.entry_path === undefined
+                                ? {}
+                                : { entry_path: [...path.entry_path] }),
+                            entry_kind: path.entry_kind,
+                            channel: path.channel,
+                            terminal: path.terminal,
+                            step_kind: step.kind,
+                            step_index: index,
+                            module_key: step.module_key,
+                            module_runtime: step.module_runtime,
+                            conditions: path.conditions,
+                            resolution: "candidate",
+                        },
+                        evidence: staticInferenceEvidence({
+                            sha256: file.sha256,
+                            path: file.path,
+                            range: step.location,
+                            operation: "substitute-electron-wrapper",
+                            coverage,
+                            limitations: [
+                                "Lexical wrapper substitution is a static candidate; guards, runtime overrides and execution remain unverified.",
+                            ],
+                        }),
+                    },
+                ],
+            }));
+            const first = nodes[0], entry = path.steps[0];
+            const owner = entry
+                ? electronFindingSourceNode(context, file, entry.module_key, entry.module_runtime ?? undefined)
+                : undefined;
+            if (first && entry && owner)
+                addElectronInferenceEdge(context, {
+                    source: owner,
+                    target: first,
+                    file,
+                    range: entry.location,
+                    coverage,
+                    relation: "contains",
+                    operation: "locate-electron-wrapper-path",
+                    properties: {
+                        path_id: pathId,
+                        entry: path.entry,
+                        ...(path.entry_path === undefined
+                            ? {}
+                            : { entry_path: [...path.entry_path] }),
+                        resolution: "candidate",
+                    },
+                });
+            for (let i = 1; i < nodes.length; i += 1) {
+                const source = nodes[i - 1], target = nodes[i], previous = path.steps[i - 1], step = path.steps[i];
+                if (!source || !target || !previous || !step)
+                    continue;
+                addElectronInferenceEdge(context, {
+                    source,
+                    target,
+                    file,
+                    range: step.location,
+                    coverage,
+                    relation: ["exposure", "factory", "ipc"].includes(previous.kind)
+                        ? "maps_to"
+                        : "calls",
+                    operation: "trace-electron-wrapper-path",
+                    properties: {
+                        path_id: pathId,
+                        entry: path.entry,
+                        ...(path.entry_path === undefined
+                            ? {}
+                            : { entry_path: [...path.entry_path] }),
+                        channel: path.channel,
+                        resolution: "candidate",
+                        conditions: path.conditions,
+                    },
+                });
+            }
+            projected.push({ file, path, coverage, nodes });
+        }
+    }
+    for (const { transmission, handler } of unambiguousElectronIpcPairings(collectElectronIpcRecords(context.analysis))) {
+        const sources = projected.filter((p) => p.path.entry_kind === "bridge-member" && matches(p, transmission));
+        const targets = projected.filter((p) => p.path.entry_kind === "ipc-handler" && matches(p, handler));
+        for (const from of sources)
+            for (const to of targets) {
+                const source = from.nodes.at(-1), target = to.nodes[0];
+                if (!source || !target)
+                    continue;
+                addElectronInferenceEdge(context, {
+                    source,
+                    target,
+                    file: from.file,
+                    range: transmission.finding.location,
+                    coverage: from.coverage,
+                    relation: transmission.finding.mode === "invoke" ? "invokes" : "sends",
+                    operation: "join-electron-wrapper-paths",
+                    properties: {
+                        channel: transmission.finding.channel,
+                        pairing_basis: "unique-exact-literal-channel",
+                        resolution: "candidate",
+                        handler_path: to.file.path,
+                        bridge_conditions: from.path.conditions,
+                        handler_conditions: to.path.conditions,
+                    },
+                    limitations: [
+                        "The unique static channel match does not establish runtime registration, sender acceptance, or dispatch.",
+                    ],
+                });
+            }
+    }
+};
+const matches = (projected, record) => {
+    const { path } = projected;
+    const { finding } = record;
+    const invocation = finding.invocation_location;
+    const sourceStepKind = finding.mode === "send" || finding.mode === "invoke" ? "terminal" : "ipc";
+    return (projected.file.path === record.file.path &&
+        path.channel === finding.channel &&
+        path.steps.some((step) => step.kind === sourceStepKind &&
+            electronRangeKey(step.location) === electronRangeKey(finding.location)) &&
+        (invocation === undefined ||
+            path.steps.some((step) => (step.kind === "call" || step.kind === "exposure") &&
+                electronRangeKey(step.location) === electronRangeKey(invocation))));
+};

package/dist/application/javascript/ElectronBoundaryGraphIpc.js

@@ -1,5 +1,5 @@
 import { artifactLocalIdentity, javascriptAnalysisCoverage, } from "./JavaScriptArtifactGraphContext.js";
-import { astObservationEvidence } from "./JavaScriptArtifactGraphEvidence.js";
+import { astObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { collectElectronIpcRecords, unambiguousElectronIpcPairings, } from "./ElectronBoundaryAnalysis.js";
 import { addElectronAstEdge, addElectronInferenceEdge, electronFindingSourceNode, electronObservationIdentity, electronRangeContains, electronRangeKey, } from "./ElectronBoundaryGraphContext.js";
 /** Project IPC syntax, handler locations, validations, and exact pairings. */
@@ -62,7 +62,9 @@ const addChannelNode = (context, record, coverage) => {
         : `literal:${finding.channel}`;
     return context.accumulator.addNode({
         kind: "ipc-channel",
-        identity: electronObservationIdentity(context, "electron-ipc-channel", identityKey),
+        identity: finding.resolution_basis === "wrapper-substitution"
+            ? artifactLocalIdentity(file.sha256, "electron-inferred-ipc-channel", identityKey)
+            : electronObservationIdentity(context, "electron-ipc-channel", identityKey),
         observations: [
             {
                 label: finding.channel ?? finding.channel_expression,
@@ -73,18 +75,27 @@ const addChannelNode = (context, record, coverage) => {
                     channel: finding.channel,
                     channel_expression: finding.channel_expression,
                     resolution: finding.channel === null ? "dynamic" : "literal",
+                    ...(finding.invocation_location === undefined
+                        ? {}
+                        : { invocation_location: finding.invocation_location }),
                 },
-                evidence: astObservationEvidence({
+                evidence: (finding.resolution_basis === "wrapper-substitution"
+                    ? staticInferenceEvidence
+                    : astObservationEvidence)({
                     sha256: file.sha256,
                     path: file.path,
                     range: finding.location,
                     operation: "observe-ipc-channel-expression",
                     coverage,
-                    limitations: finding.channel === null
+                    limitations: finding.resolution_basis === "wrapper-substitution"
                         ? [
-                            "The channel expression is dynamic; its runtime value and pairings remain unknown.",
+                            "The channel is inferred through lexical wrapper substitution; runtime registration and dispatch remain unverified.",
                         ]
-                        : [],
+                        : finding.channel === null
+                            ? [
+                                "The channel expression is dynamic; its runtime value and pairings remain unknown.",
+                            ]
+                            : [],
                 }),
             },
         ],
@@ -108,8 +119,13 @@ const addHandlerNode = (input) => {
                     channel_expression: finding.channel_expression,
                     handler_kind: finding.handler_kind,
                     handler_location: finding.handler_location,
+                    ...(finding.invocation_location === undefined
+                        ? {}
+                        : { invocation_location: finding.invocation_location }),
                 },
-                evidence: astObservationEvidence({
+                evidence: (finding.resolution_basis === "wrapper-substitution"
+                    ? staticInferenceEvidence
+                    : astObservationEvidence)({
                     sha256: file.sha256,
                     path: file.path,
                     range: handlerRange,
@@ -141,6 +157,9 @@ const addHandlerNode = (input) => {
             channel: finding.channel,
             channel_expression: finding.channel_expression,
             resolution: finding.channel === null ? "dynamic" : "literal",
+            ...(finding.invocation_location === undefined
+                ? {}
+                : { invocation_location: finding.invocation_location }),
         },
     });
     return handler;

package/dist/application/javascript/ElectronBoundaryGraphNative.js

@@ -19,7 +19,7 @@ const addNativeBinding = (input) => {
     const source = electronFindingSourceNode(context, file, value.module_key, value.module_runtime);
     if (source === undefined)
         return;
-    const resolved = resolveArtifactPath(value.specifier, file.path, context.filesByPath, value.module_kind);
+    const resolved = resolveArtifactPath(value.specifier, file.path, context.filesByPath, value.module_kind, context.directoryPaths);
     const addon = resolved === null ? undefined : context.fileNodes.get(resolved);
     const binding = context.accumulator.addNode({
         kind: "native-export",

package/dist/application/javascript/ElectronBoundaryGraphWindows.js

@@ -1,7 +1,7 @@
 import { artifactLocalIdentity, createElectronRoleNode, javascriptAnalysisCoverage, linkElectronRoleToAsset, } from "./JavaScriptArtifactGraphContext.js";
-import { astObservationEvidence } from "./JavaScriptArtifactGraphEvidence.js";
+import { astObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { addElectronAstEdge, addElectronInferenceEdge, electronFindingSourceNode, electronRangeKey, } from "./ElectronBoundaryGraphContext.js";
-import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
+import { artifactPathResolutionProperties, resolveArtifactPathByContext, } from "./JavaScriptArtifactPathResolution.js";
 /** Project BrowserWindow, contextBridge, preload, and utility-process facts. */
 export const addElectronWindowBoundaries = (context) => {
     for (const analyzed of context.analysis.files) {
@@ -77,6 +77,9 @@ const addWindowPreload = (input, window) => {
         sourcePath: input.file.path,
         context: resolutionContext,
         files: input.context.filesByPath,
+        directoryPaths: input.context.directoryPaths,
+        unanalyzedFiles: input.context.unanalyzedFiles,
+        runtimePathKind: "exact-file",
     });
     const role = createElectronRoleNode(input.context, {
         kind: "electron-preload",
@@ -100,6 +103,7 @@ const addWindowPreload = (input, window) => {
             resolved_path: resolution.resolved_path,
             resolution_status: resolution.resolution_status,
             limitations: resolution.limitations,
+            ...artifactPathResolutionProperties(resolution),
         },
     });
     linkElectronRoleToAsset(input.context, {
@@ -126,8 +130,11 @@ const addContextBridge = (input) => {
                     api_status: value.api_status,
                     members: value.members,
                     unknown_members: value.unknown_members,
+                    resolution_basis: value.resolution_basis ?? "direct-syntax",
                 },
-                evidence: astObservationEvidence({
+                evidence: (value.resolution_basis === "wrapper-substitution"
+                    ? staticInferenceEvidence
+                    : astObservationEvidence)({
                     sha256: file.sha256,
                     path: file.path,
                     range: value.location,
@@ -154,6 +161,22 @@ const addContextBridge = (input) => {
 };
 const addUtilityProcess = (input) => {
     const { context, file, value, coverage } = input;
+    const resolution = value.module_path === null
+        ? undefined
+        : resolveArtifactPathByContext({
+            declaredPath: value.module_path,
+            sourcePath: file.path,
+            context: value.module_resolution_context,
+            files: context.filesByPath,
+            directoryPaths: context.directoryPaths,
+            unanalyzedFiles: context.unanalyzedFiles,
+            runtimePathKind: "node-entrypoint",
+        });
+    const resolutionProperties = {
+        resolved_path: resolution?.resolved_path ?? null,
+        resolution_status: resolution?.resolution_status ?? null,
+        ...artifactPathResolutionProperties(resolution),
+    };
     const utility = context.accumulator.addNode({
         kind: "electron-utility",
         identity: artifactLocalIdentity(file.sha256, "electron-utility-process", `${value.module_path ?? value.module_expression}:${electronRangeKey(value.location)}`),
@@ -174,6 +197,22 @@ const addUtilityProcess = (input) => {
                     coverage,
                 }),
             },
+            ...(resolution === undefined
+                ? []
+                : [
+                    {
+                        label: "utility process entrypoint resolution",
+                        properties: resolutionProperties,
+                        evidence: staticInferenceEvidence({
+                            sha256: file.sha256,
+                            path: file.path,
+                            range: value.location,
+                            operation: "resolve-utility-process-entrypoint",
+                            coverage,
+                            limitations: resolution.limitations,
+                        }),
+                    },
+                ]),
         ],
     });
     addElectronInferenceEdge(context, {
@@ -184,19 +223,17 @@ const addUtilityProcess = (input) => {
         coverage,
         relation: "loads",
         operation: "map-utility-process-launch",
+        limitations: resolution?.limitations ?? [],
         properties: {
             declared_path: value.module_path,
             expression: value.module_expression,
+            ...resolutionProperties,
         },
     });
     if (value.module_path === null)
         return;
-    const resolution = resolveArtifactPathByContext({
-        declaredPath: value.module_path,
-        sourcePath: file.path,
-        context: value.module_resolution_context,
-        files: context.filesByPath,
-    });
+    if (resolution === undefined)
+        return;
     const resolved = resolution.resolved_path;
     const target = resolved === null
         ? undefined
@@ -216,6 +253,7 @@ const addUtilityProcess = (input) => {
             resolution_context: resolution.resolution_context,
             resolved_path: resolved,
             resolution_status: resolution.resolution_status,
+            ...artifactPathResolutionProperties(resolution),
         },
     });
 };

package/dist/application/javascript/ElectronObservationService.js

@@ -1,5 +1,4 @@
 import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
-import {} from "../../domain/analysisErrorBase.js";
 import { err, ok } from "../../domain/result.js";
 import { createElectronEvidence } from "./ElectronEvidence.js";
 /** List local file pages exposed by the explicitly selected endpoint. */

package/dist/application/javascript/JavaScriptApplicationEvidence.js

@@ -37,4 +37,19 @@ const applicationObservation = (input, result) => ({
 const parameters = (input) => ({
     format: input.format,
     integrity_policy: input.integrity_policy,
+    ...(input.max_semantic_nodes === undefined
+        ? {}
+        : { max_semantic_nodes: input.max_semantic_nodes }),
+    ...(input.max_semantic_nodes_per_file === undefined
+        ? {}
+        : { max_semantic_nodes_per_file: input.max_semantic_nodes_per_file }),
+    ...(input.source_paths === undefined
+        ? {}
+        : { source_paths: input.source_paths }),
+    ...(input.max_heap_mb === undefined
+        ? {}
+        : { max_heap_mb: input.max_heap_mb }),
+    ...(input.analysis_timeout_ms === undefined
+        ? {}
+        : { analysis_timeout_ms: input.analysis_timeout_ms }),
 });