fix(javascript): retain package entrypoint provenance

tests/boundary/filesystem/javascript-applications/javascriptPackageRendererProvenance.test.ts

@@ -0,0 +1,105 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { expect, it } from "vitest";
+
+import { createTestTempDirectory } from "../../../fixtures/temporaryDirectory.js";
+import { analyzeJavaScriptApplication } from "../../../support/javascriptApplicationScope.js";
+import { javascriptApplicationAnalysisResultSchema } from "../../../../src/domain/javascript/javascriptApplicationAnalysis.js";
+
+const packageGraph = async (metadata: Record<string, unknown>) => {
+  const root = await createTestTempDirectory(
+    "rea-package-renderer-provenance-",
+  );
+  await Promise.all([
+    writeFile(join(root, "package.json"), JSON.stringify(metadata)),
+    writeFile(join(root, "entry.js"), "export const value = 42;"),
+  ]);
+  const result = await analyzeJavaScriptApplication({
+    input_path: root,
+    format: "directory",
+  });
+  if (!result.ok) throw result.error;
+  return javascriptApplicationAnalysisResultSchema.parse(
+    result.value.normalized_result,
+  ).graph;
+};
+
+it.each(["renderer", "browser", "module"] as const)(
+  "attributes the package renderer candidate to its actual %s field",
+  async (field) => {
+    const graph = await packageGraph({ [field]: "entry.js" });
+    const role = graph.nodes.find(({ kind }) => kind === "electron-renderer");
+    expect(role?.observations).toContainEqual(
+      expect.objectContaining({
+        properties: expect.objectContaining({
+          mechanism: `package.json:${field}`,
+          resolved_path: "entry.js",
+        }),
+      }),
+    );
+    const metadata = graph.nodes.find(({ kind }) => kind === "package");
+    expect(metadata?.observations).toContainEqual(
+      expect.objectContaining({
+        properties: expect.objectContaining({
+          renderer: "entry.js",
+          renderer_declarations: { [field]: "entry.js" },
+        }),
+      }),
+    );
+    expect(graph.edges).toContainEqual(
+      expect.objectContaining({
+        source_node_id: metadata?.node_id,
+        target_node_id: role?.node_id,
+        relation: "loads",
+        properties: expect.objectContaining({
+          source_field: field,
+          declared_path: "entry.js",
+        }),
+      }),
+    );
+    expect(metadata?.observations[0]?.properties.renderer_declarations).toEqual(
+      { [field]: "entry.js" },
+    );
+  },
+);
+
+it("keeps present browser mappings distinct from absent renderer metadata when module supplies the candidate", async () => {
+  const graph = await packageGraph({
+    browser: { "./server.js": "./client.js" },
+    module: "entry.js",
+  });
+  const metadata = graph.nodes.find(({ kind }) => kind === "package");
+  expect(metadata?.observations[0]?.properties).toMatchObject({
+    renderer: "entry.js",
+    renderer_declarations: {
+      browser: { status: "non-string" },
+      module: "entry.js",
+    },
+  });
+  expect(
+    graph.nodes.find(({ kind }) => kind === "electron-renderer")
+      ?.observations[0]?.properties.mechanism,
+  ).toBe("package.json:module");
+});
+
+it("retains simultaneous string declarations while keeping renderer priority", async () => {
+  const graph = await packageGraph({
+    renderer: "entry.js",
+    browser: "browser.js",
+    module: "module.js",
+  });
+  const metadata = graph.nodes.find(({ kind }) => kind === "package");
+  expect(metadata?.observations[0]?.properties).toMatchObject({
+    renderer: "entry.js",
+    renderer_declarations: {
+      renderer: "entry.js",
+      browser: "browser.js",
+      module: "module.js",
+    },
+  });
+  expect(
+    graph.nodes.find(({ kind }) => kind === "electron-renderer")
+      ?.observations[0]?.properties.mechanism,
+  ).toBe("package.json:renderer");
+});