rea-agents 4.1.0 → 6.0.0

package/dist/application/investigation/InvestigationRecords.js

@@ -0,0 +1,69 @@
+import { createEvidence } from "../../domain/evidence.js";
+import { EvidenceLedger } from "./EvidenceLedger.js";
+import { UNKNOWN_REGISTRY_PROVIDER, unknownEvidenceLinks, unknownMutationEvidence, } from "./UnknownEvidence.js";
+/** One investigation's validated record owner, independent of binary execution. */
+export class InvestigationRecords {
+    #evidence = new EvidenceLedger();
+    /** Record immutable Evidence idempotently; reject conflicting content. */
+    recordEvidence(evidence) {
+        return this.#evidence.record(evidence);
+    }
+    /** Check one semantic Evidence ID without exposing stored values. */
+    hasEvidence(evidenceId) {
+        return this.#evidence.has(evidenceId);
+    }
+    /** Return a detached Evidence value for one semantic ID. */
+    evidenceById(evidenceId) {
+        return this.#evidence.get(evidenceId);
+    }
+    /** Export a detached deterministic bundle of Evidence and Unknown revisions. */
+    exportEvidenceBundle() {
+        return this.#evidence.export();
+    }
+    /** Atomically merge a bundle and report changes for the owner's post-commit observers. */
+    mergeEvidenceBundle(bundle) {
+        return this.#evidence.import(bundle);
+    }
+    /** Clear records when the owning runtime applies its existing lifecycle policy. */
+    clear() {
+        this.#evidence.clear();
+    }
+    /** Record an Unknown with an explicitly supplied Evidence subject, if any. */
+    recordUnknown(input, target) {
+        const recorded = this.#evidence.recordUnknown(input, unknownMutationEvidence(target, input));
+        return recorded;
+    }
+    /** Commit derived Evidence and its Unknown atomically without an implicit subject. */
+    recordEvidenceWithUnknown(evidence, input) {
+        const recorded = this.#evidence.recordWithUnknown(evidence, input, unknownMutationEvidence(undefined, input));
+        return recorded;
+    }
+    /** Update an optimistic revision with an explicitly supplied Evidence subject. */
+    updateUnknown(input, target) {
+        const evidence = createEvidence(target, UNKNOWN_REGISTRY_PROVIDER, {
+            predicateType: "rea.residual-unknown-mutation",
+            operation: "update_unknown",
+            parameters: {
+                unknown_id: input.unknown_id,
+                expected_revision: input.expected_revision,
+            },
+            result: { action: "update", status: input.status },
+            confidence: "derived",
+            authority: "analyst-inference",
+            evidenceLinks: unknownEvidenceLinks(input),
+            limitations: [
+                "Registry mutation evidence records analyst intent, not proof of the answer.",
+            ],
+        });
+        const updated = this.#evidence.updateUnknown(input, evidence);
+        return updated;
+    }
+    /** Return detached current Unknown revisions matching the selected filters. */
+    listUnknowns(filters = {}) {
+        return this.#evidence.listUnknowns(filters);
+    }
+    /** Verify registry consistency without asserting the answer is true. */
+    verifyUnknownResolution(unknownId) {
+        return this.#evidence.verifyUnknownResolution(unknownId);
+    }
+}

package/dist/application/{UnknownEvidence.js → investigation/UnknownEvidence.js}

@@ -1,4 +1,4 @@
-import { createEvidence } from "../domain/evidence.js";
+import { createEvidence } from "../../domain/evidence.js";
 /** Provider identity for analyst-authored residual-unknown mutations. */
 export const UNKNOWN_REGISTRY_PROVIDER = {
     id: "rea-unknown-registry",

package/dist/application/{ElectronActiveEvidence.js → javascript/ElectronActiveEvidence.js}

@@ -1,6 +1,6 @@
-import { canonicalDigest } from "../domain/comparisonSemantics.js";
-import { createEvidence } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
+import { canonicalDigest } from "../../domain/comparisonSemantics.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
 /** Create Evidence without retaining arbitrary runtime argument values. */
 export const createElectronActiveEvidence = (input, result, provider) => createEvidence(undefined, provider, {
     predicateType: "rea.electron-active-scenario",

package/dist/application/javascript/ElectronActiveObservationPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/{ElectronActiveObservationService.js → javascript/ElectronActiveObservationService.js}

@@ -1,8 +1,8 @@
 import { dirname } from "node:path";
 import { realpath } from "node:fs/promises";
-import { AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
-import { err } from "../domain/result.js";
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../../domain/analysisErrorCore.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { err } from "../../domain/result.js";
 import { createElectronActiveEvidence } from "./ElectronActiveEvidence.js";
 const OPERATION = "capture_electron_scenario";
 const PROVIDER_ID = "rea-playwright-electron-active";

package/dist/application/{ElectronBoundaryAnalysis.js → javascript/ElectronBoundaryAnalysis.js}

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../domain/canonicalOrdering.js";
+import { compareCodePoints } from "../../domain/canonicalOrdering.js";
 import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
 /** Flatten all per-file IPC facts into deterministic application records. */
 export const collectElectronIpcRecords = (analysis) => analysis.files

package/dist/application/{ElectronBoundaryGraphContext.js → javascript/ElectronBoundaryGraphContext.js}

@@ -1,4 +1,4 @@
-import { sha256Text } from "../domain/javascriptStaticAnalysisHelpers.js";
+import { sha256Text } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
 import { astObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 /** Resolve the file or recovered bundle module that owns one finding. */
 export const electronFindingSourceNode = (context, file, moduleKey) => moduleKey === null

package/dist/application/{ElectronEvidence.js → javascript/ElectronEvidence.js}

@@ -1,5 +1,5 @@
-import { createEvidence, } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
+import { createEvidence, } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
 /** Create Evidence for one Electron observation. */
 export const createElectronEvidence = (operation, input, result, provider) => createEvidence(undefined, provider, {
     predicateType: operation === "list_electron_targets"

package/dist/application/javascript/ElectronObservationPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/{ElectronObservationService.js → javascript/ElectronObservationService.js}

@@ -1,6 +1,6 @@
-import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
-import { err, ok } from "../domain/result.js";
+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. */
 export const listElectronTargets = async (provider, input, options = {}) => {

package/dist/application/{JavaScriptApplicationEvidence.js → javascript/JavaScriptApplicationEvidence.js}

@@ -1,6 +1,5 @@
-import { createEvidence, } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { JAVASCRIPT_APPLICATION_PROVIDER } from "./InvestigationProviders.js";
+import { createEvidence, } from "../../domain/evidence.js";
+import { JAVASCRIPT_APPLICATION_PROVIDER } from "../InvestigationProviders.js";
 /** Create Evidence for one deterministic local JavaScript application graph. */
 export const createJavaScriptApplicationEvidence = (input, result) => createEvidence({
     path: result.input_path,
@@ -10,7 +9,7 @@ export const createJavaScriptApplicationEvidence = (input, result) => createEvid
     predicateType: "rea.javascript-application-analysis",
     operation: "analyze_javascript_application",
     parameters: parameters(input),
-    result: jsonValueSchema.parse(result),
+    result,
     rawResult: null,
     confidence: "derived",
     authority: "shipped-artifact",

package/dist/application/{JavaScriptApplicationEvidenceGraph.js → javascript/JavaScriptApplicationEvidenceGraph.js}

@@ -1,8 +1,8 @@
-import { JAVASCRIPT_APPLICATION_PROVIDER, JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER, MANAGED_WORKFLOW_PROVIDER, } from "./InvestigationProviders.js";
-import { parseEvidence } from "../domain/evidence.js";
-import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../domain/javascriptApplicationAnalysis.js";
-import { javascriptRuntimeReconciliationResultSchema } from "../domain/javascriptRuntimeReconciliationSchemas.js";
-import { managedApplicationGraphResultSchema } from "../domain/managedApplicationGraph.js";
+import { JAVASCRIPT_APPLICATION_PROVIDER, JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER, MANAGED_WORKFLOW_PROVIDER, } from "../InvestigationProviders.js";
+import { parseEvidence } from "../../domain/evidence.js";
+import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../../domain/javascript/javascriptApplicationAnalysis.js";
+import { javascriptRuntimeReconciliationResultSchema } from "../../domain/javascript/javascriptRuntimeReconciliationSchemas.js";
+import { managedApplicationGraphResultSchema } from "../../domain/managed/managedApplicationGraph.js";
 /** Parse and authenticate one REA-produced JavaScript Application Graph Evidence. */
 export const parseApplicationGraphEvidence = (input) => {
     const evidence = parseEvidence(input);

package/dist/application/{JavaScriptApplicationService.js → javascript/JavaScriptApplicationService.js}

@@ -1,15 +1,15 @@
 import { z } from "zod";
-import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
-import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../domain/javascriptApplicationAnalysis.js";
-import { AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
-import { ArtifactOperationError } from "../domain/artifactOperationError.js";
-import {} from "../domain/analysisErrorBase.js";
-import { projectInputIssues } from "../domain/inputIssueProjection.js";
-import { err, ok } from "../domain/result.js";
-import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
+import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../../domain/javascript/javascriptApplicationAnalysis.js";
+import { AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { ArtifactOperationError } from "../../domain/artifactOperationError.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { projectInputIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
 import { createJavaScriptApplicationEvidence } from "./JavaScriptApplicationEvidence.js";
 import { reconstructJavaScriptArtifact } from "./JavaScriptArtifactReconstruction.js";
-import { JAVASCRIPT_APPLICATION_PROVIDER } from "./InvestigationProviders.js";
+import { JAVASCRIPT_APPLICATION_PROVIDER } from "../InvestigationProviders.js";
 const OPERATION = "analyze_javascript_application";
 /** Statically analyze one local JavaScript/Electron application. */
 export const analyzeJavaScriptApplication = async (rawInput, options = {}) => {
@@ -30,13 +30,26 @@ export const analyzeJavaScriptApplicationValidated = async (input, options = {})
         const reconstructed = await reconstructJavaScriptArtifact({
             input_path: input.input_path,
             format: input.format,
-        }, options.signal);
+        }, options.signal, options.progress);
         const { electron_summary: summary, ...application } = reconstructed;
+        await options.progress?.report({
+            phase: "validate_javascript_application_result",
+            completed: 0,
+            total: 1,
+            message: "Validating the application analysis result",
+        });
         const result = javascriptApplicationAnalysisResultSchema.parse({
             ...application,
             summary,
             limitations: reconstructed.graph.limitations,
         });
+        await options.progress?.report({
+            phase: "create_javascript_application_evidence",
+            completed: 0,
+            total: 1,
+            message: "Creating and hashing application analysis Evidence",
+        });
+        const evidence = createJavaScriptApplicationEvidence(input, result);
         await options.progress?.report({
             phase: "analyze_javascript_application",
             completed: 1,
@@ -44,11 +57,11 @@ export const analyzeJavaScriptApplicationValidated = async (input, options = {})
             message: "Application graph and Electron boundaries reconstructed",
             terminal: true,
         });
-        return ok(createJavaScriptApplicationEvidence(input, result));
+        return ok(evidence);
     }
     catch (cause) {
         if (cause instanceof ArtifactReaderFailure)
-            return err(new ArtifactOperationError(OPERATION, cause.reason, cause.details));
+            return err(new ArtifactOperationError(OPERATION, cause.reason, cause.details, cause.message));
         if (cause instanceof z.ZodError)
             return err(new AnalysisOutputError(OPERATION, describeResultSchemaFailure(cause), {
                 cause,

package/dist/application/{JavaScriptApplicationWorkflowEvidence.js → javascript/JavaScriptApplicationWorkflowEvidence.js}

@@ -1,6 +1,6 @@
-import { createEvidence, } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+import { createEvidence, } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
 /** Create derived Evidence for one bounded application-graph feature trace. */
 export const createApplicationFeatureTraceEvidence = (parameters, result) => createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
     predicateType: "rea.application-feature-trace",

package/dist/application/{JavaScriptApplicationWorkflowService.js → javascript/JavaScriptApplicationWorkflowService.js}

@@ -1,16 +1,16 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
-import { projectInputIssues } from "../domain/inputIssueProjection.js";
-import { compareJavaScriptApplicationVersions } from "../domain/javascriptApplicationVersionComparison.js";
-import { compareApplicationVersionsInputSchema } from "../domain/javascriptApplicationVersionComparisonSchemas.js";
-import { compareJavaScriptExportShapes } from "../domain/javascriptExportShapeComparison.js";
-import { compareJavaScriptExportShapesInputSchema } from "../domain/javascriptExportShapeComparisonSchemas.js";
-import { traceApplicationFeature } from "../domain/javascriptFeatureTrace.js";
-import { traceApplicationFeatureInputSchema } from "../domain/javascriptFeatureTraceSchemas.js";
-import { err, ok } from "../domain/result.js";
-import { compareSourceToBundle } from "../domain/sourceToBundleComparison.js";
-import { compareSourceToBundleInputSchema } from "../domain/sourceToBundleComparisonSchemas.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { projectInputIssues } from "../../domain/inputIssueProjection.js";
+import { compareJavaScriptApplicationVersions } from "../../domain/javascript/javascriptApplicationVersionComparison.js";
+import { compareApplicationVersionsInputSchema } from "../../domain/javascript/javascriptApplicationVersionComparisonSchemas.js";
+import { compareJavaScriptExportShapes } from "../../domain/javascript/javascriptExportShapeComparison.js";
+import { compareJavaScriptExportShapesInputSchema } from "../../domain/javascript/javascriptExportShapeComparisonSchemas.js";
+import { traceApplicationFeature } from "../../domain/javascript/javascriptFeatureTrace.js";
+import { traceApplicationFeatureInputSchema } from "../../domain/javascript/javascriptFeatureTraceSchemas.js";
+import { err, ok } from "../../domain/result.js";
+import { compareSourceToBundle } from "../../domain/javascript/sourceToBundleComparison.js";
+import { compareSourceToBundleInputSchema } from "../../domain/javascript/sourceToBundleComparisonSchemas.js";
 import { parseApplicationGraphEvidence, parseNativeApplicationEvidence, } from "./JavaScriptApplicationEvidenceGraph.js";
 import { createApplicationFeatureTraceEvidence, createApplicationVersionComparisonEvidence, createJavaScriptExportShapeComparisonEvidence, createSourceToBundleComparisonEvidence, } from "./JavaScriptApplicationWorkflowEvidence.js";
 /** Authenticate Evidence and derive one bounded cross-layer feature trace. */

package/dist/application/{JavaScriptArtifactAnalysis.js → javascript/JavaScriptArtifactAnalysis.js}

@@ -1,14 +1,45 @@
 import { createHash } from "node:crypto";
-import { analyzeParsedJavaScriptStaticSource } from "../domain/javascriptStaticAnalysis.js";
-import { analyzeParsedJavaScriptSemantics } from "../domain/javascriptSemanticAnalysis.js";
-import { parseJavaScriptSource } from "../domain/javascriptSourceParser.js";
-import { hasValidSourceMapContents } from "../domain/sourceMapContents.js";
-import { failedJavaScriptStaticAnalysis } from "../domain/javascriptStaticAnalysisHelpers.js";
+import { setImmediate } from "node:timers/promises";
+import { analyzeParsedJavaScriptStaticSource } from "../../domain/javascript/javascriptStaticAnalysis.js";
+import { analyzeParsedJavaScriptSemantics } from "../../domain/javascript/javascriptSemanticAnalysis.js";
+import { parseJavaScriptSource } from "../../domain/javascript/javascriptSourceParser.js";
+import { hasValidSourceMapContents } from "../../domain/sourceMapContents.js";
+import { flattenSourceMapLeaves } from "../../domain/sourceMapEnvelope.js";
+import { failedJavaScriptStaticAnalysis } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
 import { analyzeJavaScriptJsonModule } from "./JavaScriptJsonModules.js";
+import { htmlArtifactReferences } from "../../domain/javascript/htmlArtifactReferences.js";
 /** Analyze every text source from the artifact without a result quota. */
-export const analyzeJavaScriptArtifactFiles = (fileSet) => {
+export const analyzeJavaScriptArtifactFiles = (fileSet) => analyzeArtifactFiles(fileSet, (_file, ir) => ir);
+/** Project each file's full IR immediately, retaining only later module facts. */
+export const analyzeAndProjectJavaScriptArtifactFiles = async (fileSet, projectSemantics, beforeFile) => {
     const state = emptyArtifactAnalysis();
-    const context = { state };
+    const projectFileSemantics = (file, ir) => {
+        projectSemantics(file, ir);
+        const programScopes = ir.scopes.filter(({ kind }) => kind === "program");
+        const programScopeId = programScopes[0]?.scopeId;
+        const localNames = new Set(ir.moduleLinks.map(({ localName }) => localName));
+        const callableIds = new Set(ir.moduleLinks.map(({ callableId }) => callableId));
+        return {
+            scopes: programScopes,
+            bindings: ir.bindings.filter(({ name, scopeId }) => scopeId === programScopeId && localNames.has(name)),
+            callables: ir.callables.filter(({ callableId }) => callableIds.has(callableId)),
+            moduleLinks: ir.moduleLinks,
+            coverage: ir.coverage,
+            limitations: ir.limitations,
+        };
+    };
+    const context = { state, projectSemantics: projectFileSemantics };
+    for (const [index, file] of fileSet.files.entries()) {
+        // Let progress, cancellation and garbage collection run between files.
+        await setImmediate();
+        await beforeFile?.(file, index, fileSet.files.length);
+        analyzeArtifactFile(file, context);
+    }
+    return finalizeArtifactAnalysis(state);
+};
+const analyzeArtifactFiles = (fileSet, projectSemantics) => {
+    const state = emptyArtifactAnalysis();
+    const context = { state, projectSemantics };
     for (const file of fileSet.files)
         analyzeArtifactFile(file, context);
     return finalizeArtifactAnalysis(state);
@@ -61,7 +92,9 @@ const analyzeArtifactFile = (file, context) => {
     state.files.push({
         file,
         javascript: analysis,
-        semantic: semantics === null ? null : { ir: semantics },
+        semantic: semantics === null
+            ? null
+            : { ir: context.projectSemantics(file, semantics) },
     });
     state.visitedNodes += analysis.visited_ast_nodes;
     state.findings += staticFindings + (semantics?.moduleLinks.length ?? 0);
@@ -136,26 +169,13 @@ const unavailablePackage = (file, limitation) => ({
     limitation,
 });
 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];
-        if (script === undefined)
-            continue;
-        const start = match.index;
-        scripts.push({
-            html_path: path,
-            script_path: script,
-            base_href: baseHref,
-            location: rangeForOffsets(text, start, start + match[0].length),
-        });
-    }
-    return scripts;
-};
-const htmlBaseHref = (text) => {
-    const match = /<base\b[^>]*\bhref\s*=\s*(["'])([^"']+)\1[^>]*>/iu.exec(text);
-    return match?.[2] ?? null;
+    const { scripts, baseHref } = htmlArtifactReferences(text);
+    return scripts.map(({ scriptPath, startOffset, endOffset }) => ({
+        html_path: path,
+        script_path: scriptPath,
+        base_href: baseHref,
+        location: rangeForOffsets(text, startOffset, endOffset),
+    }));
 };
 const parseSourceMap = (file) => {
     if (!file.text.included)
@@ -215,25 +235,8 @@ const unavailableSourceMap = (file) => {
     };
 };
 const flattenSourceMaps = (root) => {
-    if (!isRecord(root) || root.version !== 3)
-        return undefined;
-    const maps = [];
-    const pending = [root];
-    while (pending.length > 0) {
-        const map = pending.pop();
-        if (map === undefined || map.version !== 3)
-            return undefined;
-        if (Array.isArray(map.sections)) {
-            for (const section of map.sections) {
-                if (!isRecord(section) || !isRecord(section.map))
-                    return undefined;
-                pending.push(section.map);
-            }
-        }
-        else
-            maps.push(map);
-    }
-    return maps;
+    const leaves = flattenSourceMapLeaves(root);
+    return leaves === undefined ? undefined : [...leaves];
 };
 const invalidSourceMap = (file, limitation) => ({
     path: file.path,

package/dist/application/javascript/JavaScriptArtifactAnalysisTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/application/{JavaScriptArtifactGraphAccumulator.js → javascript/JavaScriptArtifactGraphAccumulator.js}

@@ -1,11 +1,11 @@
-import { createJavaScriptApplicationEdge, createJavaScriptApplicationNode, } from "../domain/javascriptApplicationGraph.js";
+import { createJavaScriptApplicationEdge, createJavaScriptApplicationNode, } from "../../domain/javascript/javascriptApplicationGraph.js";
 /** Deduplicate graph entities while retaining distinct evidence observations. */
 export class JavaScriptArtifactGraphAccumulator {
     #nodes = new Map();
     #edges = new Map();
     /** Create or merge one canonical node. */
     addNode(input) {
-        const created = createJavaScriptApplicationNode(input);
+        const created = createJavaScriptApplicationNode(displayableNode(input));
         const existing = this.#nodes.get(created.node_id);
         if (existing === undefined) {
             this.#nodes.set(created.node_id, created);
@@ -45,3 +45,17 @@ const observationInput = (observation) => {
     const { observation_id: _observationId, identifier_strategy: _strategy, ...input } = observation;
     return input;
 };
+/**
+ * Static findings can carry legal empty strings, such as `fetch("")`,
+ * `require("")`, or a source map's `sources: [""]`. Labels must be nonempty,
+ * so an empty value has no label rather than synthetic text that a real value
+ * could share; literal feature seeds match labels. Identities and observation
+ * properties keep the exact value.
+ */
+const displayableNode = (input) => ({
+    ...input,
+    observations: input.observations.map((observation) => ({
+        ...observation,
+        label: observation.label === "" ? null : observation.label,
+    })),
+});

package/dist/application/{JavaScriptArtifactGraphBuilder.js → javascript/JavaScriptArtifactGraphBuilder.js}

@@ -1,9 +1,9 @@
-import { createJavaScriptApplicationGraph, } from "../domain/javascriptApplicationGraph.js";
+import { createJavaScriptApplicationGraph, } from "../../domain/javascript/javascriptApplicationGraph.js";
 import { JavaScriptArtifactGraphAccumulator } from "./JavaScriptArtifactGraphAccumulator.js";
 import { addJavaScriptHtmlRoles, addJavaScriptSourceMapOriginals, } from "./JavaScriptArtifactGraphDocuments.js";
 import { addJavaScriptStaticFindings } from "./JavaScriptArtifactGraphFindings.js";
 import { addJavaScriptModuleRelationships, addJavaScriptSourceModules, } from "./JavaScriptModuleRelationships.js";
-import { completeApplicationCoverage, partialApplicationCoverage, } from "../domain/javascriptApplicationEvidenceSchemas.js";
+import { completeApplicationCoverage, partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { addJavaScriptArtifactContainers, addJavaScriptArtifactFiles, addJavaScriptBundlerNodes, addJavaScriptPackageNodes, createJavaScriptArtifactRootNode, } from "./JavaScriptArtifactGraphStructure.js";
 import { addElectronBoundaries } from "./ElectronBoundaryGraph.js";
 import { classifyElectronIpcPairings, collectElectronIpcRecords, } from "./ElectronBoundaryAnalysis.js";

package/dist/application/{JavaScriptArtifactGraphContext.js → javascript/JavaScriptArtifactGraphContext.js}

@@ -1,4 +1,4 @@
-import { completeApplicationCoverage, partialApplicationCoverage, } from "../domain/javascriptApplicationEvidenceSchemas.js";
+import { completeApplicationCoverage, partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { JavaScriptArtifactGraphAccumulator } from "./JavaScriptArtifactGraphAccumulator.js";
 import { artifactObservationEvidence, astObservationEvidence, staticInferenceEvidence, unavailableAstEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { resolveArtifactPathByContext, } from "./JavaScriptArtifactPathResolution.js";

package/dist/application/{JavaScriptArtifactGraphDocuments.js → javascript/JavaScriptArtifactGraphDocuments.js}

@@ -1,6 +1,6 @@
 import { addArtifactContainsEdge, addStaticInferenceEdge, createElectronRoleNode, linkElectronRoleToAsset, } from "./JavaScriptArtifactGraphContext.js";
-import { artifactObservationEvidence } from "./JavaScriptArtifactGraphEvidence.js";
-import { completeApplicationCoverage } from "../domain/javascriptApplicationEvidenceSchemas.js";
+import { artifactObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
+import { completeApplicationCoverage } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
 /** Project HTML renderer entrypoints and their local script assets. */
 export const addJavaScriptHtmlRoles = (context) => {
@@ -46,8 +46,32 @@ export const addJavaScriptHtmlRoles = (context) => {
                 htmlBaseHref: script.base_href,
             });
             const resolvedPath = resolution.resolved_path;
-            if (resolvedPath === null)
+            if (resolvedPath === null) {
+                context.accumulator.addNode({
+                    kind: role.kind,
+                    identity: role.identity,
+                    observations: [
+                        {
+                            label: script.script_path,
+                            properties: {
+                                mechanism: "html-script-reference",
+                                script_path: script.script_path,
+                                base_href: script.base_href,
+                                ...resolution,
+                            },
+                            evidence: staticInferenceEvidence({
+                                sha256: html.sha256,
+                                path: html.path,
+                                range: script.location,
+                                operation: "resolve-html-script-reference",
+                                coverage: completeApplicationCoverage(),
+                                limitations: resolution.limitations,
+                            }),
+                        },
+                    ],
+                });
                 continue;
+            }
             const resolved = context.fileNodes.get(resolvedPath);
             if (resolved === undefined)
                 continue;

package/dist/application/{JavaScriptArtifactGraphFindings.js → javascript/JavaScriptArtifactGraphFindings.js}

@@ -190,7 +190,12 @@ const addDiscoveredRole = (context, input) => {
     });
 };
 const addSourceMapEdge = (context, input) => {
-    const resolvedPath = resolveArtifactPath(input.value.declared_url, input.file.path, context.filesByPath);
+    const resolvedPath = resolveArtifactPathByContext({
+        declaredPath: input.value.declared_url,
+        sourcePath: input.file.path,
+        context: "url-reference",
+        files: context.filesByPath,
+    }).resolved_path;
     const resolvedFile = resolvedPath === null ? undefined : context.filesByPath.get(resolvedPath);
     const resolvedNode = resolvedPath === null ? undefined : context.fileNodes.get(resolvedPath);
     const target = resolvedFile?.kind === "source-map" && resolvedNode !== undefined
@@ -247,12 +252,20 @@ const resolveReference = (context, sourcePath, reference) => {
             ? null
             : { path: `${sourcePath}#module:${specifier}`, file, node: module };
     }
-    const path = resolveArtifactPath(specifier, sourcePath, context.filesByPath, reference.kind === "require"
-        ? "require"
-        : reference.kind === "static-import" ||
-            reference.kind === "dynamic-import"
-            ? "import"
-            : undefined);
+    // Worker scripts are URLs relative to the script, not module specifiers.
+    const path = reference.kind === "worker" || reference.kind === "service-worker"
+        ? resolveArtifactPathByContext({
+            declaredPath: specifier,
+            sourcePath,
+            context: "url-reference",
+            files: context.filesByPath,
+        }).resolved_path
+        : resolveArtifactPath(specifier, sourcePath, context.filesByPath, reference.kind === "require"
+            ? "require"
+            : reference.kind === "static-import" ||
+                reference.kind === "dynamic-import"
+                ? "import"
+                : undefined);
     if (path === null)
         return null;
     const file = context.filesByPath.get(path);

package/dist/application/{JavaScriptArtifactGraphStructure.js → javascript/JavaScriptArtifactGraphStructure.js}

@@ -1,4 +1,4 @@
-import { completeApplicationCoverage } from "../domain/javascriptApplicationEvidenceSchemas.js";
+import { completeApplicationCoverage } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { addArtifactContainsEdge, addUnavailableStaticParseScope, artifactFileNodeKind, artifactLocalIdentity, createElectronRoleNode, linkElectronRoleToAsset, } from "./JavaScriptArtifactGraphContext.js";
 import { artifactObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";