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/javascript/analysis/JavaScriptAnalysisWorkerSchemas.test.ts

@@ -10,6 +10,28 @@ import { analyzeJavaScriptSemantics } from "../../domain/javascript/javascriptSe
 import { getterExpansionSource } from "../../../tests/fixtures/javascriptGetterExpansion.js";
 import { aliasSelectionBudgetSource } from "../../../tests/fixtures/javascriptAliasSelectionBudget.js";
 
+it("preserves independent static coverage and historical unmeasured facts", () => {
+  const facts = analyzeJavaScriptStaticSource("require(moduleName);");
+  expect(
+    javaScriptWorkerStaticAnalysisSchema.parse(
+      JSON.parse(JSON.stringify(facts)),
+    ),
+  ).toEqual(facts);
+  const { analysis_coverage: _coverage, ...historical } = facts;
+  expect(javaScriptWorkerStaticAnalysisSchema.parse(historical)).toEqual(
+    historical,
+  );
+  expect(
+    javaScriptWorkerStaticAnalysisSchema.safeParse({
+      ...facts,
+      analysis_coverage: {
+        ...facts.analysis_coverage,
+        syntax: { status: "complete", error_count: -1 },
+      },
+    }).success,
+  ).toBe(false);
+});
+
 it("transfers bounded alias selection coverage across the worker boundary", () => {
   const source = aliasSelectionBudgetSource();
   const facts = analyzeJavaScriptStaticSource(source);

src/javascript/analysis/JavaScriptAnalysisWorkerSchemas.ts

@@ -1,20 +1,22 @@
-import { javaScriptSemanticUnknownOmissionsSchema } from "../../domain/javascript/javascriptSemanticGraphSchemas.js";
-import { z } from "zod";
-import { digestSchema } from "../../domain/digests.js";
-import type { JavaScriptStaticAnalysis } from "../../domain/javascript/javascriptStaticAnalysisTypes.js";
-import { javaScriptRouteSourceFactsSchema } from "../../domain/javascript/javascriptRouteFacts.js";
-import { JAVASCRIPT_AST_FINGERPRINT_ALGORITHM } from "../../domain/javascript/javascriptStaticAnalysisTypes.js";
-import type {
-  JavaScriptSemanticProperty,
-  JavaScriptSemanticValue,
-} from "../../domain/javascript/javascriptSemanticValueTypes.js";
 import {
+  javaScriptSemanticUnknownOmissionsSchema,
   javaScriptSemanticNodeSchema,
   javaScriptSemanticRelationSchema,
   javaScriptSemanticUnknownSchema,
   javaScriptSemanticFingerprintSchema,
   javaScriptSemanticEvidenceContextSchema,
 } from "../../domain/javascript/javascriptSemanticGraphSchemas.js";
+import { z } from "zod";
+import { digestSchema } from "../../domain/digests.js";
+import type { JavaScriptStaticAnalysis } from "../../domain/javascript/javascriptStaticAnalysisTypes.js";
+import { javaScriptRouteSourceFactsSchema } from "../../domain/javascript/javascriptRouteFacts.js";
+import { javaScriptStaticCoverageSchema } from "../../domain/javascript/javascriptStaticCoverage.js";
+import { JAVASCRIPT_AST_FINGERPRINT_ALGORITHM } from "../../domain/javascript/javascriptStaticAnalysisTypes.js";
+import type {
+  JavaScriptSemanticProperty,
+  JavaScriptSemanticValue,
+} from "../../domain/javascript/javascriptSemanticValueTypes.js";
+import { javaScriptSemanticResourceLimitSchema } from "../../domain/javascript/javascriptSemanticValueTypes.js";
 
 const range =
   javaScriptSemanticNodeSchema.shape.identity.shape.source_range.unwrap();
@@ -319,6 +321,7 @@ const referenceShape = {
 export const javaScriptWorkerStaticAnalysisSchema = z
   .strictObject({
     parse_status: z.enum(["complete", "partial", "failed"]),
+    analysis_coverage: javaScriptStaticCoverageSchema.exactOptional(),
     routes: javaScriptRouteSourceFactsSchema.exactOptional(),
     parse_error_count: count,
     visited_ast_nodes: count,
@@ -433,13 +436,6 @@ export const javaScriptWorkerStaticAnalysisSchema = z
     },
   })) satisfies z.ZodType<JavaScriptStaticAnalysis>;
 
-const resourceLimit = z.enum([
-  "primitive-candidates",
-  "primitive-bytes",
-  "expression-depth",
-  "getter-expansion",
-  "alias-selections",
-]);
 const primitive = z.union([z.string(), z.number(), z.boolean(), z.null()]);
 const property: z.ZodType<JavaScriptSemanticProperty> = z.lazy(() =>
   z.strictObject({
@@ -487,7 +483,7 @@ const semanticValue: z.ZodType<JavaScriptSemanticValue> = z.lazy(() =>
       z.strictObject({
         status: z.enum(["unknown", "ambiguous", "cycle"]),
         reason: z.string(),
-        resourceLimit: resourceLimit.optional(),
+        resourceLimit: javaScriptSemanticResourceLimitSchema.optional(),
       }),
     ])
     .transform((value) => {
@@ -544,19 +540,19 @@ const coverage = z
     z.strictObject({
       status: z.literal("complete"),
       omittedCount: z.literal(0),
-      resourceLimits: z.array(resourceLimit).optional(),
+      resourceLimits: z.array(javaScriptSemanticResourceLimitSchema).optional(),
       widenedReturnedReferences: z.array(range).optional(),
     }),
     z.strictObject({
       status: z.literal("partial"),
       omittedCount: z.union([z.literal(0), z.null()]),
-      resourceLimits: z.array(resourceLimit).optional(),
+      resourceLimits: z.array(javaScriptSemanticResourceLimitSchema).optional(),
       widenedReturnedReferences: z.array(range).optional(),
     }),
     z.strictObject({
       status: z.literal("failed"),
       omittedCount: z.null(),
-      resourceLimits: z.array(resourceLimit).optional(),
+      resourceLimits: z.array(javaScriptSemanticResourceLimitSchema).optional(),
       widenedReturnedReferences: z.array(range).optional(),
     }),
   ])