refactor(javascript): own coverage facts and reuse block prefixes

Separate syntax, semantic uncertainty, examination limits and observed Electron applicability at the static producer, then preserve them through worker, graph and retained/inline summary views. Derive the established parse_status from the same facts and leave historical measurements unknown. Give semantic resource-limit classifications one schema owner.

Replace repeated block-prefix searches and copies with collector-scoped syntax indexes. Keep invocation environments separate, charge indexing/replay to the existing work budget and yield during prefix work. Remove the superseded synchronous collector entrypoint.

Validated producer, worker, CLI/MCP, historical and partial-coverage regressions, plus actual cancellation during indexing. Bounded authored 128/256-call controls preserved all prior facts while replacing repeated search/copy work with one index pass; this is not a throughput or agent-token benchmark.

src/application/javascript/JavaScriptArtifactGraphStructure.test.ts

@@ -130,6 +130,11 @@ describe("skipped JavaScript parse reporting", () => {
     const context = contextFor(file, analysisFor([skippedEntry(file)]));
     addJavaScriptArtifactFiles(context);
     expect(fileObservation(context).parse_status).toBe("skipped");
+    expect(fileObservation(context).analysis_coverage).toMatchObject({
+      syntax: { status: "not-examined", error_count: null },
+      semantics: { unknown_findings: null },
+      examination: { status: "not-examined" },
+    });
   });
 
   it("keeps parse_status null for a JavaScript file never attempted", () => {
@@ -157,6 +162,21 @@ describe("skipped JavaScript parse reporting", () => {
     const context = contextFor(file, analysisFor([entry]));
     addJavaScriptArtifactFiles(context);
     expect(fileObservation(context).parse_status).toBe(javascript.parse_status);
+    expect(fileObservation(context).analysis_coverage).toEqual(
+      javascript.analysis_coverage,
+    );
+  });
+
+  it("does not reconstruct coverage from a historical overall summary", () => {
+    const file = skippedFile();
+    const { analysis_coverage: _coverage, ...javascript } =
+      analyzeJavaScriptStaticSource(file.text.included ? file.text.value : "");
+    const context = contextFor(
+      file,
+      analysisFor([{ file, javascript, semantic: null }]),
+    );
+    addJavaScriptArtifactFiles(context);
+    expect(fileObservation(context)).not.toHaveProperty("analysis_coverage");
   });
 });
 

src/application/javascript/JavaScriptArtifactGraphStructure.ts

@@ -7,16 +7,19 @@ import {
   partialApplicationCoverage,
 } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import type { JavaScriptArtifactAnalysis } from "./JavaScriptArtifactAnalysisTypes.js";
-import { javascriptArtifactAnalysisScopes } from "./JavaScriptArtifactAnalysisTypes.js";
+import {
+  javascriptArtifactAnalysisScopes,
+  isSkippedJavaScriptAnalysis,
+} from "./JavaScriptArtifactAnalysisTypes.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { freezeJsonSnapshot } from "../../domain/immutableJson.js";
 import type { JavaScriptSourceRange } from "../../domain/javascript/javascriptStaticAnalysisTypes.js";
+import { unexaminedJavaScriptStaticCoverage } from "../../domain/javascript/javascriptStaticCoverage.js";
 import type {
   JavaScriptArtifactContainer,
   JavaScriptArtifactFile,
 } from "../../domain/javascript/javascriptArtifactFiles.js";
 import type { JavaScriptArtifactGraphAccumulator } from "./JavaScriptArtifactGraphAccumulator.js";
-import { isSkippedJavaScriptAnalysis } from "./JavaScriptArtifactAnalysisTypes.js";
 import {
   addArtifactContainsEdge,
   applicationManifestPath,
@@ -648,6 +651,21 @@ const createFileTarget = (
           text_status: file.text.included ? "included" : file.text.reason,
           parse_status:
             javascript?.parse_status ?? (skipped ? "skipped" : null),
+          ...(javascript?.analysis_coverage !== undefined
+            ? { analysis_coverage: javascript.analysis_coverage }
+            : javascript === null && file.kind === "javascript"
+              ? {
+                  analysis_coverage: unexaminedJavaScriptStaticCoverage(
+                    !file.text.included
+                      ? file.text.reason === "outside-analysis-scope"
+                        ? "Source is outside the caller-selected source_paths."
+                        : `JavaScript text was unavailable: ${file.text.reason}.`
+                      : skipped
+                        ? "JavaScript analysis did not complete."
+                        : "JavaScript source analysis was not performed.",
+                  ),
+                }
+              : {}),
           json_parse_status: json?.status ?? null,
           json_top_level_keys: json?.top_level_keys ?? [],
           omitted_json_top_level_keys:

src/application/javascript/JavaScriptWrappedCallPathCancellation.test.ts

@@ -0,0 +1,61 @@
+import { expect, it } from "vitest";
+import { completeJavaScriptAnalysisSteps } from "./JavaScriptAnalysisControl.js";
+import { collectElectronWrappedCallPathsSteps } from "../../domain/javascript/electronWrappedCallPaths.js";
+import {
+  indexJavaScriptBindingsWithReceiversSteps,
+  indexJavaScriptElectronIdentitySteps,
+} from "../../domain/javascript/javascriptSemanticAnalysis.js";
+import { completeSemanticSteps } from "../../domain/javascript/javascriptSemanticTraversal.js";
+import { parseJavaScriptSource } from "../../domain/javascript/javascriptSourceParser.js";
+import { createJavaScriptAnalysisAccumulator } from "../../domain/javascript/javascriptStaticAnalysisState.js";
+
+it("cancels actual call-path work while its first seed indexes a long block", async () => {
+  const source = `const e = require("electron"); {
+    e.ipcMain.on("first", event => event.sender.copy());
+    ${"0;".repeat(2048)}
+  }`;
+  const parsed = parseJavaScriptSource(source);
+  if (parsed === null) throw new Error("Expected parsed source");
+  const index = completeSemanticSteps(
+    indexJavaScriptBindingsWithReceiversSteps(parsed.program),
+  );
+  const identity = completeSemanticSteps(
+    indexJavaScriptElectronIdentitySteps(parsed.program, index.bindings),
+  );
+  const accumulator = createJavaScriptAnalysisAccumulator(source.length);
+  const work = collectElectronWrappedCallPathsSteps(
+    parsed.program,
+    index.bindings,
+    source,
+    accumulator,
+    identity,
+  );
+  // The first candidate has not yet been expanded: this checkpoint is inside
+  // its block indexing, before the walker's completed batch is yielded.
+  expect(work.next()).toEqual({ done: false, value: undefined });
+  expect(accumulator.ipc).toEqual([]);
+  const controller = new AbortController();
+  const reason = { request: "cancel prefix indexing" };
+  controller.abort(reason);
+  await expect(
+    completeJavaScriptAnalysisSteps(work, controller.signal),
+  ).rejects.toMatchObject({ reason: "cancelled", cause: reason });
+  expect(work.next()).toEqual({ done: true, value: undefined });
+  expect(accumulator.ipc).toEqual([]);
+  expect(accumulator.electronCallPathLimitReached).toBeUndefined();
+
+  // A new analysis owns a new index and can still complete the same source.
+  const completed = createJavaScriptAnalysisAccumulator(source.length);
+  expect(
+    completeSemanticSteps(
+      collectElectronWrappedCallPathsSteps(
+        parsed.program,
+        index.bindings,
+        source,
+        completed,
+        identity,
+      ),
+    ),
+  ).toContainEqual(expect.objectContaining({ entry: "first", conditions: [] }));
+  expect(completed.electronCallPathLimitReached).toBeUndefined();
+});