fix(javascript): mark resource-skipped files parse_status skipped (#3852)

* fix(javascript): mark resource-skipped files parse_status skipped

Files above ~5 MB exhaust the worker heap during static analysis (or exceed
the 8 MB static-checkpoint budget with a larger heap). They were inventoried
with text included but never parsed, leaving parse_status null and no
counter, so the summary read as 'nothing there' instead of 'not analyzed'.

Report them as skipped: parse_status 'skipped' on the file observation and a
skipped_javascript_files statistics counter. The analysis-failure reason keeps
surfacing as a limitation entry.

Fixes #3670

* fix(javascript): default skipped_javascript_files when reading old saved evidence

Saved analysis evidence written before skipped_javascript_files existed failed validation against the strict reconstruction statistics schema, so users could not reuse old results for comparisons or runtime reconciliation. Accept the field's absence on read (defaulting to 0) while continuing to write it for new results.

* fix(javascript): preserve unknown skipped count for legacy evidence

The .default(0) gate fix fabricated a measured zero for saved
pre-change evidence, so comparisons would receive a definitive
"no files skipped" fact the producer never established. Use the
codebase's exactOptional idiom instead: legacy reads accept absence
and keep omission (unknown), while the producer still always writes
the field (required by JavaScriptArtifactReconstructionResult).

Tests: legacy payload now asserts the key stays absent/undefined;
current-output test keeps asserting the producer-written counter.

* fix(javascript): add required failure scope and status to graph fixture

---------

Co-authored-by: Saim Shafique <sx4im@users.noreply.github.com>

src/application/javascript/JavaScriptArtifactGraphStructure.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, it } from "vitest";
+
+import type { ArtifactInventorySnapshot } from "../../domain/artifactInventorySnapshot.js";
+import type { JavaScriptArtifactFile } from "../../domain/javascript/javascriptArtifactFiles.js";
+import { analyzeJavaScriptStaticSource } from "../../domain/javascript/javascriptStaticAnalysis.js";
+import type {
+  AnalyzedJavaScriptArtifactFile,
+  JavaScriptModuleArtifactAnalysis,
+} from "./JavaScriptArtifactAnalysisTypes.js";
+import { javascriptArtifactAnalysisScopes } from "./JavaScriptArtifactAnalysisTypes.js";
+import { JavaScriptArtifactGraphAccumulator } from "./JavaScriptArtifactGraphAccumulator.js";
+import type { JavaScriptArtifactGraphContext } from "./JavaScriptArtifactGraphContext.js";
+import {
+  addJavaScriptArtifactFiles,
+  createJavaScriptArtifactRootNode,
+} from "./JavaScriptArtifactGraphStructure.js";
+
+const SHA256 = "a".repeat(64);
+const REASON =
+  "main.js: Resource constraint during analyze_javascript_application: Owned JavaScript worker exhausted its heap while analyzing main.js during static";
+
+const skippedFile = (): JavaScriptArtifactFile => ({
+  path: "main.js",
+  container_sha256: SHA256,
+  sha256: SHA256,
+  bytes: 5000107,
+  inventory_artifact_id: `art_${SHA256}`,
+  kind: "javascript",
+  unpacked: false,
+  text: { included: true, value: "const {ipcMain}=require('electron');\n" },
+});
+
+const skippedEntry = (
+  file: JavaScriptArtifactFile,
+): AnalyzedJavaScriptArtifactFile => ({
+  file,
+  javascript: null,
+  semantic: null,
+  analysis_failure: {
+    scope: javascriptArtifactAnalysisScopes["javascript"],
+    status: "interrupted",
+    reason: REASON,
+    error: { code: "resource_constraint" },
+    limits: null,
+  },
+});
+
+const analysisFor = (
+  entries: readonly AnalyzedJavaScriptArtifactFile[],
+): JavaScriptModuleArtifactAnalysis => ({
+  files: entries,
+  packages: [],
+  json_modules: [],
+  html_scripts: [],
+  html_inline_scripts: [],
+  source_maps: [],
+  visited_ast_nodes: 0,
+  findings: 0,
+  modules: 0,
+  parse_failures: 0,
+  limitations: [],
+});
+
+const contextFor = (
+  file: JavaScriptArtifactFile,
+  analysis: JavaScriptModuleArtifactAnalysis,
+): JavaScriptArtifactGraphContext => {
+  const accumulator = new JavaScriptArtifactGraphAccumulator();
+  const snapshot = {
+    manifest: {
+      root_artifact_id: `art_${SHA256}`,
+      root_sha256: SHA256,
+      root_format: "directory",
+      manifest_id: `agm_${SHA256}`,
+      graph_sha256: SHA256,
+    },
+    nodes: [{ artifact_id: `art_${SHA256}`, sha256: SHA256, size: 1 }],
+  } as unknown as ArtifactInventorySnapshot;
+  const fileSet = {
+    files: [file],
+    unavailable_relevant_files: [],
+    containers: [],
+    text_bytes_read: file.bytes,
+    invalid_utf8_files: 0,
+  };
+  return {
+    accumulator,
+    snapshot,
+    fileSet,
+    analysis,
+    directoryPaths: new Set<string>(),
+    root: createJavaScriptArtifactRootNode(accumulator, snapshot),
+    filesByPath: new Map([[file.path, file]]),
+    unanalyzedFiles: undefined,
+    fileNodes: new Map(),
+    assetNodes: new Map(),
+    sourceModuleNodes: new Map(),
+    chunkNodes: new Map(),
+    moduleNodes: new Map(),
+    containerNodes: new Map(),
+  };
+};
+
+const fileObservation = (context: JavaScriptArtifactGraphContext) => {
+  const node = context.accumulator
+    .nodes()
+    .find(({ kind }) => kind === "javascript-asset");
+  if (node === undefined) throw new Error("Expected a javascript-asset node");
+  const observation = node.observations[0];
+  if (observation === undefined) throw new Error("Expected a file observation");
+  return observation.properties;
+};
+
+describe("skipped JavaScript parse reporting", () => {
+  it("marks parse_status skipped for a JavaScript file whose worker analysis failed", () => {
+    const file = skippedFile();
+    const context = contextFor(file, analysisFor([skippedEntry(file)]));
+    addJavaScriptArtifactFiles(context);
+    expect(fileObservation(context).parse_status).toBe("skipped");
+  });
+
+  it("keeps parse_status null for a JavaScript file never attempted", () => {
+    const file = skippedFile();
+    const entry: AnalyzedJavaScriptArtifactFile = {
+      file,
+      javascript: null,
+      semantic: null,
+    };
+    const context = contextFor(file, analysisFor([entry]));
+    addJavaScriptArtifactFiles(context);
+    expect(fileObservation(context).parse_status).toBeNull();
+  });
+
+  it("keeps the parsed status for an analyzed JavaScript file", () => {
+    const file = skippedFile();
+    const javascript = analyzeJavaScriptStaticSource(
+      "const {ipcMain}=require('electron');\n",
+    );
+    const entry: AnalyzedJavaScriptArtifactFile = {
+      file,
+      javascript,
+      semantic: null,
+    };
+    const context = contextFor(file, analysisFor([entry]));
+    addJavaScriptArtifactFiles(context);
+    expect(fileObservation(context).parse_status).toBe(javascript.parse_status);
+  });
+});