test(javascript): classify artifact workflows as boundary tests

Move the six JavaScript application suites that read production artifacts or launch compiled analysis workers out of composition. Focused test planning now prepares their runtime prerequisites instead of treating them as source-only tests.

Validation: all six relocated suites and adjacent artifact/reference suites pass (70 tests across eight files); discovery finds every test exactly once.

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

@@ -0,0 +1,99 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { expect, it } from "vitest";
+
+import { reconstructJavaScriptArtifact } from "../../../support/javascriptApplicationScope.js";
+import { createTestTempDirectory } from "../../../fixtures/temporaryDirectory.js";
+
+it("resolves empty-path HTML script URLs against their canonical base path", async () => {
+  const root = await createTestTempDirectory("rea-html-empty-reference-");
+  await Promise.all([
+    mkdir(join(root, "base-file", "assets"), { recursive: true }),
+    mkdir(join(root, "base-directory", "assets"), { recursive: true }),
+    mkdir(join(root, "escaped"), { recursive: true }),
+  ]);
+  await Promise.all([
+    writeFile(
+      join(root, "document.html"),
+      '<script src="?document=1"></script><script src="#document-fragment"></script>',
+    ),
+    writeFile(
+      join(root, "base-file", "index.html"),
+      '<base href="assets/entry.html?base=1#base-fragment"><script src="?base-file=1#script-fragment"></script>',
+    ),
+    writeFile(join(root, "base-file", "assets", "entry.html"), "<main></main>"),
+    writeFile(
+      join(root, "base-directory", "index.html"),
+      '<base href="assets/"><script src="?base-directory=1"></script>',
+    ),
+    writeFile(
+      join(root, "base-directory", "assets", "index.js"),
+      "export const value = 1;",
+    ),
+    writeFile(
+      join(root, "escaped", "index.html"),
+      '<base href="../../outside/"><script src="?escape=1"></script>',
+    ),
+  ]);
+
+  const result = await reconstructJavaScriptArtifact({
+    input_path: root,
+    format: "directory",
+  });
+  const graph = result.graph;
+  const loadFor = (scriptPath: string) =>
+    graph.edges.find(
+      (edge) =>
+        edge.relation === "loads" && edge.properties.script_path === scriptPath,
+    );
+  const targetPath = (edge: NonNullable<ReturnType<typeof loadFor>>) =>
+    graph.nodes
+      .find(({ node_id }) => node_id === edge.target_node_id)
+      ?.observations.find(
+        ({ properties }) => typeof properties.path === "string",
+      )?.properties.path;
+  const unresolvedReference = (scriptPath: string) =>
+    graph.nodes
+      .flatMap(({ observations }) => observations)
+      .find(
+        ({ properties }) =>
+          properties.mechanism === "html-script-reference" &&
+          properties.script_path === scriptPath,
+      )?.properties;
+
+  for (const scriptPath of ["?document=1", "#document-fragment"]) {
+    const edge = loadFor(scriptPath);
+    expect(edge).toMatchObject({
+      properties: {
+        script_path: scriptPath,
+        resolved_path: "document.html",
+        resolution_status: "resolved",
+      },
+    });
+    if (edge !== undefined) expect(targetPath(edge)).toBe("document.html");
+  }
+
+  const baseFileEdge = loadFor("?base-file=1#script-fragment");
+  expect(baseFileEdge).toMatchObject({
+    properties: {
+      script_path: "?base-file=1#script-fragment",
+      base_href: "assets/entry.html?base=1#base-fragment",
+      resolved_path: "base-file/assets/entry.html",
+      resolution_status: "resolved",
+    },
+  });
+  if (baseFileEdge !== undefined)
+    expect(targetPath(baseFileEdge)).toBe("base-file/assets/entry.html");
+
+  expect(unresolvedReference("?base-directory=1")).toMatchObject({
+    resolution_status: "not-found",
+    limitations: [expect.stringContaining("resolves to directory")],
+  });
+  expect(unresolvedReference("?escape=1")).toMatchObject({
+    resolution_status: "rejected",
+    limitations: [
+      expect.stringContaining("escapes the canonical artifact root"),
+    ],
+  });
+});