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 <1836656514@qq.com>

src/domain/javascript/javascriptSemanticAnalysis.require_links.test.ts

@@ -277,14 +277,19 @@ describe("CommonJS dependency links", () => {
   });
 
   it("keeps bindings and re-exports without extra dependency links", () => {
-    const ir = analyzeJavaScriptSemantics(`
+    const ir = analyzeParsedJavaScriptSemantics(
+      parseJavaScriptSource(
+        `
       const bound = (require("bound") as unknown);
       const { left, right } = require("destructured");
       module.exports = require("forwarded");
       exports = module.exports;
       exports.member = require("member").value;
       exports.first = exports.second = require("chained");
-    `);
+    `,
+        "entry.cts",
+      )!,
+    );
     expect(
       ir.moduleLinks.map(({ kind, specifier, localName, exportedName }) => ({
         kind,
@@ -342,31 +347,36 @@ describe("CommonJS dependency links", () => {
       { specifier: "bound", importedPath: [], resolutionMode: "require" },
     ]);
   });
+});
 
-  it.each([
-    'require("outer", require("inner"));',
-    'const bound = require("outer", require("inner"));',
-    'module.exports = require("outer", require("inner"));',
-  ])("retains a distinct nested call in %s", (source) => {
-    const links = analyzeJavaScriptSemantics(source).moduleLinks;
-    expect(links.map(({ specifier }) => specifier)).toEqual(["outer", "inner"]);
-    expect(links[1]).toMatchObject({
-      kind: "require",
-      importedName: null,
-      localName: null,
-      exportedName: null,
-    });
+it.each([
+  'require("outer", require("inner"));',
+  'const bound = require("outer", require("inner"));',
+  'module.exports = require("outer", require("inner"));',
+])("retains a distinct nested call in %s", (source) => {
+  const links = analyzeJavaScriptSemantics(source).moduleLinks;
+  expect(links.map(({ specifier }) => specifier)).toEqual(["outer", "inner"]);
+  expect(links[1]).toMatchObject({
+    kind: "require",
+    importedName: null,
+    localName: null,
+    exportedName: null,
   });
 });
 
 it("preserves unshadowed require origins through aliases and assignments", () => {
-  const ir = analyzeJavaScriptSemantics(`
+  const ir = analyzeParsedJavaScriptSemantics(
+    parseJavaScriptSource(
+      `
     const { ipcMain: bus } = require("electron");
     const forwarded = bus;
     let assigned;
     assigned = require("electron").ipcMain;
     { const require = localLoader; require("./local.js"); }
-  `);
+  `,
+      "entry.cts",
+    )!,
+  );
   for (const name of ["bus", "forwarded"])
     expect(origin(topLevelBinding(ir, name))).toEqual({
       specifier: "electron",