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/javascriptStaticAnalysisInvocationReadSite.test.ts

@@ -27,7 +27,7 @@ it.each([
   expect(result.parse_status).toBe("partial");
 });
 
-it("retains complete coverage for an inline Electron factory export", () => {
+it("retains conditional coverage for an inline Electron factory export", () => {
   const result = analyzeJavaScriptStaticSource(`(() => {
     const modules={
       5(module,exports){
@@ -46,14 +46,42 @@ it("retains complete coverage for an inline Electron factory export", () => {
     }
     load(9);
   })();`);
-  expect(result.parse_status).toBe("complete");
+  expect(result.parse_status).toBe("partial");
   expect(result.references).toContainEqual(
-    expect.objectContaining({ kind: "require", specifier: "electron" }),
+    expect.objectContaining({
+      kind: "require",
+      specifier: "electron",
+      loader_authority: "candidate",
+    }),
   );
   expect(result.references.every(({ specifier }) => specifier !== null)).toBe(
     true,
   );
   expect(result.electron.ipc).toContainEqual(
-    expect.objectContaining({ channel: "test:copy", side: "main" }),
+    expect.objectContaining({
+      channel: "test:copy",
+      side: "main",
+      loader_authority: "candidate",
+    }),
   );
 });
+
+it("keeps captured unknown-host loader authority without promoting shadowed values", () => {
+  const cases = [
+    ['const load=require;load("./candidate.cjs");', true],
+    ['const load=require;require=()=>0;load("./candidate.cjs");', true],
+    ['const require=()=>0;const load=require;load("./candidate.cjs");', false],
+    ['require=()=>0;const load=require;load("./candidate.cjs");', false],
+  ] as const;
+  for (const [source, candidate] of cases) {
+    const result = analyzeJavaScriptStaticSource(source);
+    expect(
+      result.references.some(
+        (reference) =>
+          reference.specifier === "./candidate.cjs" &&
+          reference.loader_authority === "candidate",
+      ),
+      source,
+    ).toBe(candidate);
+  }
+});