rea-agents 4.1.0 → 6.0.0

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

@@ -1,5 +1,6 @@
 import { builtinModules } from "node:module";
 import { posix } from "node:path";
+import { admitsCanonicalPathSyntax, hasScheme, looksExternal, stripQueryAndFragment, } from "../../domain/artifactPathSyntax.js";
 const EXTENSIONS = [
     ".js",
     ".cjs",
@@ -13,16 +14,24 @@ const EXTENSIONS = [
 const NODE_BUILTINS = new Set(builtinModules.map((name) => name.replace(/^node:/u, "")));
 /** Resolve one declaration under its exact syntax/metadata context. */
 export const resolveArtifactPathByContext = (input) => resolvePackagePath(input, new Set());
-const resolvePackagePath = (input, packageChain, mode = "full") => {
+const resolvePackagePath = (input, packageChain, mode = "full", exportsTargetUrl = false) => {
     const rejected = rejectDeclaration(input);
     if (rejected !== null)
         return rejected;
-    const candidate = contextualCandidate(input);
+    const candidate = contextualCandidate(input, exportsTargetUrl);
     if (typeof candidate !== "string")
         return candidate;
     const confined = confineCandidate(input, candidate);
     if (typeof confined !== "string")
         return confined;
+    if (input.context === "html-reference")
+        return outcome(input, resolveFileCandidates(input, [confined]) ?? {
+            resolvedPath: null,
+            status: "not-found",
+            limitations: [
+                `The exact HTML resource ${confined} was not found among the selected application files.`,
+            ],
+        });
     const resolved = mode === "files-and-index"
         ? (resolveFileCandidates(input, [
             ...fileCandidates(confined),
@@ -47,13 +56,11 @@ const rejectDeclaration = (input) => {
         ]);
     return null;
 };
-/** Path syntax admitted for a canonical artifact path. */
-const admitsCanonicalPathSyntax = (value) => !value.includes("\0") &&
-    !value.includes("\\") &&
-    !/%(?:2e|2f|5c)/iu.test(value);
-const contextualCandidate = (input) => {
+const contextualCandidate = (input, exportsTargetUrl) => {
     const { context } = input;
-    const declared = context === "html-reference" ||
+    let declared = context === "html-reference" ||
+        context === "url-reference" ||
+        exportsTargetUrl ||
         (context === "module-specifier" && input.moduleKind !== "require")
         ? stripQueryAndFragment(input.declaredPath)
         : input.declaredPath;
@@ -70,10 +77,27 @@ const contextualCandidate = (input) => {
         if (!declared.startsWith(".") && !declared.startsWith("/"))
             return bareModuleCandidate(input, declared);
     }
-    else if (hasScheme(declared))
+    else if (looksExternal(declared))
         return unresolvedOutcome(input, "external", [
-            "URL schemes are outside this local artifact path context.",
+            "URL schemes and protocol-relative URLs are outside this local artifact path context.",
         ]);
+    // Exports targets use URL paths for both loaders; legacy main fields remain literal.
+    if (exportsTargetUrl ||
+        (context === "module-specifier" && input.moduleKind !== "require")) {
+        try {
+            declared = decodeURIComponent(declared);
+        }
+        catch (cause) {
+            void cause;
+            return unresolvedOutcome(input, "rejected", [
+                "The module URL path contains malformed percent encoding.",
+            ]);
+        }
+        if (declared.includes("\0"))
+            return unresolvedOutcome(input, "rejected", [
+                "The decoded module URL path contains NUL.",
+            ]);
+    }
     const relative = declared.startsWith("/") ? declared.slice(1) : declared;
     return declared.startsWith("/")
         ? relative
@@ -125,7 +149,7 @@ const hasContainerCandidate = (files, candidate, containerSha256) => [
 });
 const htmlCandidate = (input) => {
     const declared = stripQueryAndFragment(input.declaredPath);
-    if (hasScheme(declared) || declared.startsWith("//"))
+    if (looksExternal(declared))
         return unresolvedOutcome(input, "external", [
             "External HTML references are not mapped to local artifact assets.",
         ]);
@@ -133,9 +157,7 @@ const htmlCandidate = (input) => {
     const base = rawBase === undefined || rawBase === null
         ? rawBase
         : stripQueryAndFragment(rawBase);
-    if (base !== undefined &&
-        base !== null &&
-        (hasScheme(base) || base.startsWith("//")))
+    if (base !== undefined && base !== null && looksExternal(base))
         return unresolvedOutcome(input, "external", [
             "The document base href is external, so its script reference is not a local artifact path.",
         ]);
@@ -210,6 +232,12 @@ const resolveCandidate = (input, candidate, packageChain) => {
                 `Directory package metadata ${packagePath} is not valid package JSON.`,
             ],
         };
+    if (main.status === "rejected")
+        return {
+            resolvedPath: null,
+            status: "rejected",
+            limitations: [`Package metadata ${packagePath}: ${main.limitation}`],
+        };
     if (main.status === "unmatched")
         return {
             resolvedPath: null,
@@ -246,7 +274,7 @@ const resolveCandidate = (input, candidate, packageChain) => {
             return index;
     }
     // Preserve recursive artifact package lookup only after legacy file/index fallbacks.
-    return candidateOutcome(resolvePackagePath(entryInput, chain));
+    return candidateOutcome(resolvePackagePath(entryInput, chain, "full", main.source === "exports"));
 };
 const candidateOutcome = (nested) => nested.resolution_status === "resolved"
     ? {
@@ -303,23 +331,35 @@ const packageEntry = (text, moduleKind, useExports) => {
     }
 };
 const packageExport = (value, moduleKind) => {
-    if (typeof value === "string")
-        return packagePathValue(value);
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        return { status: "invalid" };
-    const root = Reflect.get(value, ".") ?? value;
-    if (typeof root === "string")
-        return packagePathValue(root);
-    if (typeof root !== "object" || root === null || Array.isArray(root))
-        return { status: "invalid" };
+    const root = typeof value === "object" && value !== null && Object.hasOwn(value, ".")
+        ? Reflect.get(value, ".")
+        : value;
     const flattened = exportTargets(root, packageExportConditions(moduleKind));
     if (flattened.kind === "invalid")
-        return { status: "invalid" };
+        return { status: "rejected", limitation: flattened.limitation };
     const first = flattened.kind === "unmatched" ? undefined : flattened.values[0];
     return first === undefined
-        ? { status: "unmatched", declared: Object.keys(root) }
+        ? {
+            status: "unmatched",
+            declared: typeof root === "object" && root !== null ? Object.keys(root) : [],
+        }
         : { status: "value", value: first };
 };
+const invalidExportTarget = (value, reason) => ({
+    kind: "invalid",
+    limitation: `The package exports target ${JSON.stringify(value) ?? String(value)} ${reason}.`,
+});
+// Node checks raw target segments before URL normalization. Compare encoded
+// segment names here; full URL decoding follows array target selection.
+const forbiddenExportSegment = (value) => value
+    .slice(2)
+    .split(/[\\/]/u)
+    .find((raw) => {
+    const segment = raw.replace(/%[0-9a-f]{2}/giu, (encoded) => String.fromCharCode(Number.parseInt(encoded.slice(1), 16)));
+    return (segment === "." ||
+        segment === ".." ||
+        segment.toLowerCase() === "node_modules");
+});
 /**
  * Resolve a target in Node's declared order. Explicit null blocks an active
  * condition, whereas an unmatched nested object permits the next condition.
@@ -327,30 +367,36 @@ const packageExport = (value, moduleKind) => {
  * preserves the final invalid-versus-null refusal if no string is selected.
  */
 const exportTargets = (value, conditions) => {
-    if (typeof value === "string")
-        return value.startsWith("./")
+    if (typeof value === "string") {
+        if (!value.startsWith("./"))
+            return invalidExportTarget(value, 'must start with "./"');
+        const forbidden = forbiddenExportSegment(value);
+        return forbidden === undefined
             ? { kind: "targets", values: [value] }
-            : { kind: "invalid" };
+            : invalidExportTarget(value, `contains forbidden path segment ${JSON.stringify(forbidden)} before URL normalization`);
+    }
     if (value === null)
         return { kind: "targets", values: [] };
     if (Array.isArray(value)) {
-        let invalid = false;
+        let invalid = null;
         for (const entry of value) {
             const nested = exportTargets(entry, conditions);
             if (nested.kind === "invalid") {
-                invalid = true;
+                invalid = nested.limitation;
                 continue;
             }
             if (nested.kind === "unmatched")
                 continue;
-            invalid = false;
+            invalid = null;
             if (nested.values.length > 0)
                 return nested;
         }
-        return invalid ? { kind: "invalid" } : { kind: "targets", values: [] };
+        return invalid === null
+            ? { kind: "targets", values: [] }
+            : { kind: "invalid", limitation: invalid };
     }
     if (typeof value !== "object")
-        return { kind: "invalid" };
+        return invalidExportTarget(value, "must be a relative string, object, array, or null");
     for (const [condition, target] of Object.entries(value)) {
         if (!conditions.has(condition))
             continue;
@@ -382,7 +428,6 @@ const notFoundCandidate = () => ({
         "No extension, directory package, or index candidate exists in the inventoried artifact container.",
     ],
 });
-const hasScheme = (value) => /^[A-Za-z][A-Za-z+.-]*:/u.test(value);
 const fileUrlPath = (value) => {
     if (!value.startsWith("file://"))
         return undefined;
@@ -398,7 +443,6 @@ const fileUrlPath = (value) => {
         return undefined;
     }
 };
-const stripQueryAndFragment = (value) => value.split("#", 1)[0]?.split("?", 1)[0] ?? "";
 const outcome = (input, resolution) => resolution.status === "resolved"
     ? {
         declared_path: input.declaredPath,

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

@@ -1,16 +1,18 @@
 import { lstat, realpath } from "node:fs/promises";
-import { AsarArtifactReader } from "../artifacts/AsarArtifactReader.js";
-import { ArtifactReaderFailure, } from "../artifacts/ArtifactReader.js";
-import { DirectoryArtifactReader } from "../artifacts/DirectoryArtifactReader.js";
-import { analyzeJavaScriptArtifactFiles } from "./JavaScriptArtifactAnalysis.js";
-import { readJavaScriptArtifactFiles } from "./JavaScriptArtifactFiles.js";
+import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
+import { createJavaScriptArtifactReader as createReader } from "../../artifacts/javascript/JavaScriptArtifactReader.js";
+import { analyzeAndProjectJavaScriptArtifactFiles } from "./JavaScriptArtifactAnalysis.js";
+import { readJavaScriptArtifactFiles } from "../../artifacts/javascript/JavaScriptArtifactFiles.js";
 import { buildJavaScriptArtifactGraph } from "./JavaScriptArtifactGraphBuilder.js";
 import { javascriptArtifactReconstructionInputSchema, } from "./JavaScriptArtifactReconstructionInput.js";
-import { scanCanonicalArtifactInventory } from "./ArtifactInventory.js";
+import { scanCanonicalArtifactInventory } from "../../artifacts/inventory/ArtifactInventory.js";
 import { summarizeElectronBoundaries } from "./ElectronBoundaryAnalysis.js";
-import { buildJavaScriptSemanticGraph } from "./JavaScriptSemanticGraphBuilder.js";
+import { createJavaScriptSemanticGraphProjection } from "./JavaScriptSemanticGraphBuilder.js";
 /** Reconstruct one local ASAR or extracted directory without executing code. */
-export const reconstructJavaScriptArtifact = async (rawInput, signal) => {
+export const reconstructJavaScriptArtifact = async (rawInput, signal, progress) => {
+    const reportPhase = async (phase, message) => {
+        await progress?.report({ phase, completed: 0, total: 1, message });
+    };
     const input = javascriptArtifactReconstructionInputSchema.parse(rawInput);
     abortIfNeeded(signal);
     const path = await realpath(input.input_path);
@@ -20,15 +22,25 @@ export const reconstructJavaScriptArtifact = async (rawInput, signal) => {
         throw new ArtifactReaderFailure("format", `Artifact inventory classified ${path} as ${snapshot.manifest.root_format}, not ${format}`);
     const reader = createReader(path, format);
     try {
+        await reportPhase("read_javascript_artifacts", "Reading inventoried JavaScript application sources");
         const files = await readJavaScriptArtifactFiles(reader, snapshot, signal);
-        const analysis = analyzeJavaScriptArtifactFiles(files);
+        await reportPhase("parse_javascript_sources", `Parsing and projecting ${String(files.files.length)} application source files`);
+        const semanticProjection = createJavaScriptSemanticGraphProjection();
+        const analysis = await analyzeAndProjectJavaScriptArtifactFiles(files, semanticProjection.projectFile, async (file, completed, total) => {
+            abortIfNeeded(signal);
+            await progress?.report({
+                phase: "parse_javascript_source",
+                completed: 0,
+                total: 1,
+                message: `Parsing and projecting ${file.path} (${String(completed + 1)}/${String(total)})`,
+            });
+            abortIfNeeded(signal);
+        });
         abortIfNeeded(signal);
+        await reportPhase("build_javascript_application_graph", "Constructing application and Electron boundary relationships");
         const graph = buildJavaScriptArtifactGraph(snapshot, files, analysis);
-        const semanticGraph = buildJavaScriptSemanticGraph({
-            rootArtifactSha256: snapshot.manifest.root_sha256,
-            applicationGraph: graph,
-            analysis,
-        });
+        await reportPhase("build_javascript_semantic_graph", "Binding and validating static semantic relationships");
+        const semanticGraph = semanticProjection.finish(snapshot.manifest.root_sha256, graph, analysis);
         return {
             input_path: path,
             format,
@@ -70,9 +82,6 @@ const resolveFormat = async (path, input) => {
         throw new ArtifactReaderFailure("format", `Requested ${input.format} input but observed ${observed}: ${path}`);
     return observed;
 };
-const createReader = (path, format) => format === "asar"
-    ? new AsarArtifactReader(path)
-    : new DirectoryArtifactReader(path);
 const abortIfNeeded = (signal) => {
     if (signal?.aborted === true)
         throw new ArtifactReaderFailure("cancelled", "JavaScript artifact reconstruction cancelled");

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

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../domain/canonicalOrdering.js";
+import { compareCodePoints } from "../../domain/canonicalOrdering.js";
 /** Parse one approved JSON module without evaluating JavaScript or resolving imports. */
 export const analyzeJavaScriptJsonModule = (file) => {
     if (!file.text.included)

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

@@ -1,6 +1,6 @@
 import { posix } from "node:path";
-import { compareCodePoints } from "../domain/canonicalOrdering.js";
-import { completeApplicationCoverage, partialApplicationCoverage, } from "../domain/javascriptApplicationEvidenceSchemas.js";
+import { compareCodePoints } from "../../domain/canonicalOrdering.js";
+import { completeApplicationCoverage, partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { addAstContainsEdge, artifactLocalIdentity, } from "./JavaScriptArtifactGraphContext.js";
 import { astObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { resolveArtifactPathByContext, } from "./JavaScriptArtifactPathResolution.js";

package/dist/application/javascript/JavaScriptRecoveryPort.js

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

package/dist/application/javascript/JavaScriptRecoveryService.js

@@ -0,0 +1,52 @@
+import { isAbsolute } from "node:path";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { javascriptRecoveryInputSchema, javascriptRecoveryResultSchema, } from "../../domain/javascript/javascriptRecovery.js";
+import { jsonObjectSchema } from "../../domain/jsonValue.js";
+import { projectInputIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+const OPERATION = "recover_javascript_sources";
+/** Shared CLI/MCP parsing and Evidence for derived JavaScript artifacts. */
+export class JavaScriptRecoveryService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Recover sources and bind the result to its original immutable input. */
+    async recover(input, options) {
+        if (options?.signal?.aborted === true)
+            return err(new AnalysisCancelledError(OPERATION));
+        const parsed = javascriptRecoveryInputSchema.safeParse(input);
+        if (!parsed.success)
+            return err(new AnalysisInputError(OPERATION, { cause: parsed.error }, projectInputIssues(parsed.error.issues, input)));
+        const invalidPaths = ["path", "output_directory"].filter((field) => !isAbsolute(parsed.data[field]));
+        if (invalidPaths.length > 0)
+            return err(new AnalysisInputError(OPERATION, undefined, invalidPaths.map((field) => ({
+                path: [field],
+                reason: "invalid_format",
+                message: `${field} must be an absolute filesystem path on this host.`,
+            }))));
+        const execution = await this.provider.recover(parsed.data, options);
+        if (!execution.ok)
+            return execution;
+        const result = javascriptRecoveryResultSchema.safeParse(execution.value.result);
+        if (!result.success || execution.value.subject === null)
+            return err(new AnalysisOutputError(OPERATION, "Recovery did not return a valid result bound to the original source"));
+        if (result.data.source.path !== parsed.data.path ||
+            execution.value.subject.path !== result.data.source.path ||
+            execution.value.subject.sha256 !== result.data.source.sha256 ||
+            execution.value.provider.id !== result.data.engine.id ||
+            execution.value.provider.version !== result.data.engine.version)
+            return err(new AnalysisOutputError(OPERATION, "Recovery source or engine identity disagrees with its Evidence binding"));
+        return ok(createEvidence(execution.value.subject, execution.value.provider, {
+            operation: OPERATION,
+            parameters: jsonObjectSchema.parse(parsed.data),
+            result: result.data,
+            rawResult: execution.value.rawResult,
+            locations: execution.value.locations,
+            limitations: execution.value.limitations,
+            confidence: "derived",
+            authority: "shipped-artifact",
+        }));
+    }
+}

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

@@ -1,6 +1,6 @@
-import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
-import { partialApplicationCoverage, truncatedApplicationCoverage, } from "../domain/javascriptApplicationEvidenceSchemas.js";
-import { flattenSemanticReturnValue } from "../domain/javascriptSemanticReturns.js";
+import { jsonObjectSchema, jsonValueSchema } from "../../domain/jsonValue.js";
+import { partialApplicationCoverage, truncatedApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
+import { flattenSemanticReturnValue } from "../../domain/javascript/javascriptSemanticReturns.js";
 /** Project one exact export/callable link into shallow bounded graph values. */
 export const projectJavaScriptExportReturnShapes = (input) => {
     if (input.link.callableId === null || input.link.exportedName === null)

package/dist/application/{JavaScriptRuntimeObservationEvidence.js → javascript/JavaScriptRuntimeObservationEvidence.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 deterministic Evidence for one passive Inspector operation. */
 export const createJavaScriptRuntimeObservationEvidence = (operation, input, result, provider) => createEvidence(undefined, provider, {
     predicateType: operation === "list_javascript_runtime_targets"

package/dist/application/javascript/JavaScriptRuntimeObservationPort.js

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

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

@@ -1,7 +1,7 @@
 import { createJavaScriptRuntimeObservationEvidence } from "./JavaScriptRuntimeObservationEvidence.js";
-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";
 /** List targets exposed by the explicitly selected loopback Inspector. */
 export const listJavaScriptRuntimeTargets = async (provider, input, options = {}) => {
     const ready = requireProvider(provider, "list_javascript_runtime_targets");

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

@@ -1,6 +1,6 @@
-import { createEvidence, } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER } from "./InvestigationProviders.js";
+import { createEvidence, } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER } from "../InvestigationProviders.js";
 /** Create derived Evidence for one exact set of static/runtime inputs. */
 export const createJavaScriptRuntimeReconciliationEvidence = (input, result) => createEvidence(undefined, JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER, {
     predicateType: "rea.javascript-runtime-reconciliation",

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

@@ -1,11 +1,11 @@
 import { resolve } from "node:path";
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
-import { projectInputIssues } from "../domain/inputIssueProjection.js";
-import { reconcileJavaScriptRuntime } from "../domain/javascriptRuntimeReconciliation.js";
-import { reconcileJavaScriptRuntimeInputSchema } from "../domain/javascriptRuntimeReconciliationSchemas.js";
-import { err, ok } from "../domain/result.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { projectInputIssues } from "../../domain/inputIssueProjection.js";
+import { reconcileJavaScriptRuntime } from "../../domain/javascript/javascriptRuntimeReconciliation.js";
+import { reconcileJavaScriptRuntimeInputSchema } from "../../domain/javascript/javascriptRuntimeReconciliationSchemas.js";
+import { err, ok } from "../../domain/result.js";
 import { createJavaScriptRuntimeReconciliationEvidence } from "./JavaScriptRuntimeReconciliationEvidence.js";
 const OPERATION = "reconcile_javascript_runtime";
 /** Derive a combined JAG from verified static and passive-runtime Evidence. */

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

@@ -1,5 +1,5 @@
-import { createJavaScriptSemanticGraphUnknown } from "../domain/javascriptSemanticGraph.js";
-import { addSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, constructSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
+import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
 import { semanticCallSiteAt, } from "./JavaScriptSemanticGraphFlowProjection.js";
 /** Project literal EventEmitter registrations, removals, and dispatches. */
@@ -34,7 +34,7 @@ export const projectSemanticEvents = (context) => {
             addEventUnknown(context, operation, event, relation);
     }
 };
-const addEventNode = (context, operation, eventKey) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+const addEventNode = (context, operation, eventKey) => retainSemanticGraphNode(context.state, context.file, {
     kind: "event",
     roleKey: `event:${eventKey}`,
     location: operation.eventName === null ? operation.location : null,
@@ -44,8 +44,8 @@ const addEventNode = (context, operation, eventKey) => addSemanticGraphNode(cont
         emitter_key: operation.emitterKey,
         event_name: operation.eventName,
     },
-}, context.state));
-const addListenerNode = (context, operation) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+});
+const addListenerNode = (context, operation) => retainSemanticGraphNode(context.state, context.file, {
     kind: "listener",
     roleKey: `listener:${operation.eventId}`,
     location: operation.listenerLocation ?? operation.location,
@@ -61,7 +61,7 @@ const addListenerNode = (context, operation) => addSemanticGraphNode(context.sta
         event_name: operation.eventName,
         method: operation.method,
     },
-}, context.state));
+});
 const eventEmitterNode = (context, operation) => (operation.emitterBindingId === null
     ? undefined
     : context.bindingNodes.get(operation.emitterBindingId)) ??
@@ -95,7 +95,7 @@ export const projectSemanticTimers = (context) => {
         const owner = operation.ownerCallableId === null
             ? undefined
             : context.callableNodes.get(operation.ownerCallableId);
-        const timer = addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+        const timer = retainSemanticGraphNode(context.state, context.file, {
             kind: "timer",
             roleKey: operation.timerId,
             location: operation.location,
@@ -105,7 +105,7 @@ export const projectSemanticTimers = (context) => {
                 delay_milliseconds: operation.delayMilliseconds,
                 method: operation.method,
             },
-        }, context.state));
+        });
         return timer === null ? [] : [[operation.timerId, timer]];
     }));
     for (const operation of context.ir.timerOperations)