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

@@ -147,7 +147,11 @@ it("preserves every direct observation in a long flat sibling block", () => {
   }`);
   expect(result.electron.ipc.map(({ channel }) => channel)).toEqual(channels);
   expect(result.electron.call_paths ?? []).toEqual([]);
-  expect(result.parse_status).toBe("complete");
+  expect(result.parse_status).toBe("partial");
+  expect(result.analysis_coverage?.syntax.status).toBe("complete");
+  expect(result.analysis_coverage?.semantics.unknown_findings).toBeGreaterThan(
+    0,
+  );
 });
 
 it("keeps sibling guards, definite exits and nested shadowing separate", () => {
@@ -370,7 +374,11 @@ it("preserves an observed empty contextBridge API object", () => {
   expect(result.electron.context_bridge_apis?.[0]).not.toHaveProperty(
     "resolution_basis",
   );
-  expect(result.parse_status).toBe("complete");
+  expect(result.parse_status).toBe("partial");
+  expect(result.analysis_coverage?.syntax.status).toBe("complete");
+  expect(result.analysis_coverage?.semantics.unknown_findings).toBeGreaterThan(
+    0,
+  );
 });
 
 it.each([
@@ -767,7 +775,11 @@ it("resolves a site-determined constant channel in place of its dynamic observat
     expect.objectContaining({ entry: "desktop.ping", channel: "ping" }),
   );
   // The syntax pass's unknown channel is resolved, not left as partial.
-  expect(result.parse_status).toBe("complete");
+  expect(result.parse_status).toBe("partial");
+  expect(result.analysis_coverage?.syntax.status).toBe("complete");
+  expect(result.analysis_coverage?.semantics.unknown_findings).toBeGreaterThan(
+    0,
+  );
 });
 it("resolves a site-determined registration whose handler is a named local", () => {
   const result = analyzeJavaScriptStaticSource(`
@@ -784,7 +796,11 @@ it("resolves a site-determined registration whose handler is a named local", ()
       handler_kind: "inline-function",
     }),
   ]);
-  expect(result.parse_status).toBe("complete");
+  expect(result.parse_status).toBe("partial");
+  expect(result.analysis_coverage?.syntax.status).toBe("complete");
+  expect(result.analysis_coverage?.semantics.unknown_findings).toBeGreaterThan(
+    0,
+  );
 });
 it("keeps an argument-supplied channel unresolved beside its resolved candidates", () => {
   const result = analyzeJavaScriptStaticSource(`
@@ -987,7 +1003,11 @@ it.each(["interface Shape { marker(): void }", "type Shape = typeof marker;"])(
           resolution_basis ?? "direct",
         ]),
     ).toEqual([["ch", "wrapper-substitution"]]);
-    expect(result.parse_status).toBe("complete");
+    expect(result.parse_status).toBe("partial");
+    expect(result.analysis_coverage?.syntax.status).toBe("complete");
+    expect(
+      result.analysis_coverage?.semantics.unknown_findings,
+    ).toBeGreaterThan(0);
   },
 );
 it("resolves a handler a module-level factory call created once in place", () => {
@@ -1005,7 +1025,11 @@ it("resolves a handler a module-level factory call created once in place", () =>
       resolution_basis ?? "direct",
     ]),
   ).toEqual([["ch", "wrapper-substitution"]]);
-  expect(result.parse_status).toBe("complete");
+  expect(result.parse_status).toBe("partial");
+  expect(result.analysis_coverage?.syntax.status).toBe("complete");
+  expect(result.analysis_coverage?.semantics.unknown_findings).toBeGreaterThan(
+    0,
+  );
 });
 it("keeps separate outer calls that pass one shared handler through a wrapper", () => {
   const result = analyzeJavaScriptStaticSource(`
@@ -1063,7 +1087,11 @@ it("resolves a module-level handler in place when the entry binds an unused para
       resolution_basis: "wrapper-substitution",
     }),
   ]);
-  expect(result.parse_status).toBe("complete");
+  expect(result.parse_status).toBe("partial");
+  expect(result.analysis_coverage?.syntax.status).toBe("complete");
+  expect(result.analysis_coverage?.semantics.unknown_findings).toBeGreaterThan(
+    0,
+  );
 });
 it.each([
   ["a named local", 'const handler = () => tag; register("same", handler);'],