fix(javascript): preserve loader authority for exact suffixes (#9477)

* fix(javascript): require exact loader suffix case

* fix(javascript): share exact loader mode across import resolution

* test(process): align symlink fixture with filesystem checkpoints

* test(javascript): normalize the module resolution oracle path separators

* test(frida): assert the CLI spawn Evidence contract

* test(mcp): use an unsupported analysis-view parent

* test(browser): separate source-location line bounds from parity

* fix(javascript): preserve uncertain loader provenance

* test(javascript): cover uncertain require resolution

* fix(javascript): retain conditional Electron evidence

* fix(javascript): preserve timed semantic provenance

* fix(javascript): retain conditional builtin effects

* test(javascript): distinguish bundled host authority

* fix(javascript): preserve nested loader invocation identity

* test(javascript): qualify Electron fixture authority

* fix(javascript): preserve loader invocation authority

* fix(javascript): respect source order for resolver escapes

* fix(javascript): check nested loader callable mutations

* fix(javascript): retain conditional constructor requests

* fix(reference): retain constructor loader relationships

* fix(reference): follow nested loader callable paths

* refactor(javascript): share callable mutation interpretation

* fix(javascript): require exact package loader suffixes

* refactor(javascript): unify conditional relation evidence

* refactor(javascript): unify conditional node evidence

* fix(javascript): retain unknown authority for mixed case sources

* fix(javascript): preserve loader uncertainty for dotfiles

* fix(reference): classify javascript suffix dotfiles

* test(reference): cover suffix dotfiles through cli

* fix(javascript): retain equivalent conditional built-in origins

* fix(javascript): preserve wrapped resolver operation

* fix(javascript): retain nested conditional built-in receivers

* test(javascript): declare CommonJS in native addon fixtures

* fix(javascript): retain wrapped resolver candidates

* style: format merged native command schema

* fix(javascript): preserve uncertain loader authority

* test(javascript): require candidate preload evidence

* test(javascript): cover reference loader member writes

---------

Co-authored-by: ShuaixinHuang <[email protected]>

src/application/javascript/JavaScriptSemanticGraphAsyncProjection.ts

@@ -9,7 +9,11 @@ import {
   addSemanticGraphRelation,
   addSemanticGraphUnknown,
 } from "./JavaScriptSemanticGraphConstruction.js";
-import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import {
+  unknownSemanticEvidence,
+  builtinSemanticNode,
+  builtinSemanticRelation,
+} from "./JavaScriptSemanticGraphEvidence.js";
 import {
   projectSemanticResultBindings,
   type SemanticFlowProjectionContext,
@@ -158,10 +162,10 @@ export const projectSemanticTimers = (
         location: operation.location,
         label: operation.method,
         functionNodeId: owner?.node_id ?? null,
-        properties: {
+        ...builtinSemanticNode(context.file, operation, {
           delay_milliseconds: operation.delayMilliseconds,
           method: operation.method,
-        },
+        }),
       });
       return timer === null ? [] : [[operation.timerId, timer] as const];
     }),
@@ -177,17 +181,39 @@ const projectTimerSchedule = (
   operation: JavaScriptSemanticTimerOperation,
   timerNodes: ReadonlyMap<string, JavaScriptSemanticGraphNode>,
 ): void => {
+  const authority = builtinSemanticRelation(
+    context.file,
+    operation,
+    "resolved",
+  );
+  const candidateEvidence = authority.evidence;
   addSemanticGraphRelation(context.state, {
     source: context.callSiteAt(operation.location),
     target: timerNodes.get(operation.timerId),
     relation: "schedules-timer",
-    resolution: "resolved",
+    ...authority,
+    ...(candidateEvidence === undefined
+      ? {}
+      : {
+          properties: { builtin_authority: "candidate" },
+        }),
   });
   projectSemanticResultBindings(
     context,
     timerNodes.get(operation.timerId),
     operation.projectedResultBindings,
+    candidateEvidence,
   );
+  if (candidateEvidence !== undefined)
+    addSemanticGraphUnknown(context.state, {
+      node_id: timerNodes.get(operation.timerId)?.node_id ?? null,
+      family: "timer",
+      relation_kinds: ["schedules-timer"],
+      reason: "ambiguous-target",
+      detail: "The timer identity is conditional on loader or mutation facts.",
+      candidate_node_ids: [],
+      evidence: unknownSemanticEvidence(context.file, operation.location),
+    });
 };
 
 const projectTimerCancellation = (
@@ -196,6 +222,12 @@ const projectTimerCancellation = (
   timerNodes: ReadonlyMap<string, JavaScriptSemanticGraphNode>,
 ): void => {
   const callSite = context.callSiteAt(operation.location);
+  const authority = builtinSemanticRelation(
+    context.file,
+    operation,
+    operation.resolution === "complete" ? "resolved" : "candidate",
+  );
+  const candidateEvidence = authority.evidence;
   const target =
     operation.linkedTimerId === null
       ? undefined
@@ -204,15 +236,24 @@ const projectTimerCancellation = (
     source: callSite,
     target,
     relation: "cancels-timer",
-    resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+    ...authority,
+    ...(candidateEvidence === undefined
+      ? {}
+      : {
+          properties: { builtin_authority: "candidate" },
+        }),
   });
-  if (operation.resolution === "complete") return;
+  if (operation.resolution === "complete" && candidateEvidence === undefined)
+    return;
   addSemanticGraphUnknown(context.state, {
     node_id: callSite?.node_id ?? null,
     family: "timer",
     relation_kinds: ["cancels-timer"],
     reason: "ambiguous-target",
-    detail: `Static ${operation.method} handle resolution was ${operation.resolution}.`,
+    detail:
+      candidateEvidence === undefined
+        ? `Static ${operation.method} handle resolution was ${operation.resolution}.`
+        : `The ${operation.method} identity is conditional on loader or mutation facts.`,
     candidate_node_ids: [],
     evidence: unknownSemanticEvidence(context.file, operation.location),
   });