fix(parse): survive non-cloneable worker results so large-repo analyze doesn't crash (#2112)

gitnexus/src/core/ingestion/language-provider.ts

@@ -187,6 +187,12 @@ interface LanguageProviderConfig {
    * `undefined` when no constraints exist / the node isn't a templated
    * function. Languages without SFINAE / concept semantics leave this
    * undefined and the disambiguation is a pass-through.
+   *
+   * Cloneability contract: the returned payload crosses the worker boundary
+   * via structured clone, so it MUST be structured-clone-safe (no functions,
+   * symbols, or tree-sitter `SyntaxNode`s — only plain data). Wrap the return
+   * with `assertCloneable` from `workers/clone-safety.ts` so a future leak is a
+   * compile error at the source instead of a runtime DataCloneError (#2143).
    */
   readonly extractTemplateConstraints?: (definitionNode: SyntaxNode) => unknown;
 
@@ -343,8 +349,12 @@ interface LanguageProviderConfig {
    * disk store WITHOUT a main-thread re-parse. The main thread restores them
    * via the matching `ScopeResolver.applyCaptureSideChannel` hook.
    *
-   * MUST return plain data (objects / arrays / primitives) so it round-trips
-   * through `JSON.stringify` + the parsedfile-store interning reviver.
+   * Cloneability contract: MUST return plain data (objects / arrays /
+   * primitives — no functions, symbols, or tree-sitter `SyntaxNode`s) so it
+   * survives BOTH the worker→main structured clone AND `JSON.stringify` + the
+   * parsedfile-store interning reviver. Wrap the return with `assertCloneable`
+   * from `workers/clone-safety.ts` so a future non-serializable leak is a
+   * compile error at the source instead of a runtime DataCloneError (#2143).
    *
    * Default: undefined (provider has no capture-time module-level side effects).
    */

gitnexus/src/core/ingestion/languages/c-cpp.ts

@@ -65,7 +65,11 @@ import {
   cppReceiverBinding,
   collectCppCaptureSideChannel,
 } from './cpp/index.js';
-import { extractCppTemplateConstraints } from './cpp/constraint-extractor.js';
+import {
+  extractCppTemplateConstraints,
+  type CppConstraintPayload,
+} from './cpp/constraint-extractor.js';
+import { assertCloneable } from '../workers/clone-safety.js';
 
 const C_BUILT_INS: ReadonlySet<string> = new Set([
   'printf',
@@ -405,7 +409,11 @@ export const cProvider = defineLanguage({
   // `static` functions look non-file-local on the main thread and leak into
   // cross-file global free-call resolution / wildcard imports. See
   // `c/capture-side-channel.ts`.
-  collectCaptureSideChannel: collectCStaticLinkageSideChannel,
+  // `assertCloneable` is a runtime identity; it makes a future non-serializable
+  // value in the side-channel payload a compile error here, at the source, rather
+  // than a DataCloneError at the worker boundary (#2143).
+  collectCaptureSideChannel: (filePath) =>
+    assertCloneable(collectCStaticLinkageSideChannel(filePath)),
   interpretImport: interpretCImport,
   interpretTypeBinding: interpretCTypeBinding,
   bindingScopeFor: cBindingScopeFor,
@@ -480,7 +488,7 @@ export const cppProvider = defineLanguage({
   // just populated for this file into plain data on `ParsedFile.captureSideChannel`,
   // so the main thread can restore them via `applyCaptureSideChannel` WITHOUT a
   // re-parse (#1983). See `cpp/capture-side-channel.ts`.
-  collectCaptureSideChannel: collectCppCaptureSideChannel,
+  collectCaptureSideChannel: (filePath) => assertCloneable(collectCppCaptureSideChannel(filePath)),
   interpretImport: interpretCppImport,
   interpretTypeBinding: interpretCppTypeBinding,
   bindingScopeFor: cppBindingScopeFor,
@@ -501,7 +509,9 @@ export const cppProvider = defineLanguage({
  * functions whose constraints the extractor can't model — both cases
  * result in no constraint suffix on the node ID.
  */
-function extractCppTemplateConstraintsForProvider(definitionNode: SyntaxNode): unknown {
+function extractCppTemplateConstraintsForProvider(
+  definitionNode: SyntaxNode,
+): CppConstraintPayload | undefined {
   // Walk up to the enclosing template_declaration. Bound the walk so we
   // can't accidentally land on a far-ancestor template_declaration that
   // wraps an unrelated function.
@@ -530,5 +540,8 @@ function extractCppTemplateConstraintsForProvider(definitionNode: SyntaxNode): u
     }
     break;
   }
-  return extractCppTemplateConstraints(templateDecl, declarator);
+  // Guard the boundary at the source: a future non-cloneable member of the
+  // constraint payload becomes a compile error here, not a runtime
+  // DataCloneError at the worker post (#2143).
+  return assertCloneable(extractCppTemplateConstraints(templateDecl, declarator));
 }

gitnexus/src/core/ingestion/languages/kotlin.ts

@@ -11,6 +11,7 @@ import { SupportedLanguages } from 'gitnexus-shared';
 import { createClassExtractor } from '../class-extractors/generic.js';
 import { kotlinClassConfig } from '../class-extractors/configs/jvm.js';
 import { defineLanguage } from '../language-provider.js';
+import { assertCloneable } from '../workers/clone-safety.js';
 import { kotlinTypeConfig } from '../type-extractors/jvm.js';
 import { kotlinExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
@@ -182,7 +183,11 @@ export const kotlinProvider = defineLanguage({
   // so the main thread can restore them via `applyCaptureSideChannel` WITHOUT a
   // re-parse (#1983). Without this, companion/static dispatch emits no CALLS
   // edges on the worker path. See `kotlin/capture-side-channel.ts`.
-  collectCaptureSideChannel: collectKotlinCaptureSideChannel,
+  // `assertCloneable` is a runtime identity; it makes a future non-serializable
+  // value in the side-channel payload a compile error here, at the source, rather
+  // than a DataCloneError at the worker boundary (#2143).
+  collectCaptureSideChannel: (filePath) =>
+    assertCloneable(collectKotlinCaptureSideChannel(filePath)),
   interpretImport: interpretKotlinImport,
   interpretTypeBinding: interpretKotlinTypeBinding,
   bindingScopeFor: kotlinBindingScopeFor,

gitnexus/src/core/ingestion/parsing-processor.ts

@@ -7,6 +7,7 @@ import { accumulateExportedTypesFromParsedNode, type ExportedTypeMap } from './c
 
 import type { ParsedFile } from 'gitnexus-shared';
 import { WorkerPool } from './workers/worker-pool.js';
+import type { SkippedPath } from './workers/clone-safety.js';
 import { logger } from '../logger.js';
 import type {
   ParseWorkerResult,
@@ -196,6 +197,29 @@ export const dispatchChunkParse = async (
     logger.warn(`  Skipped unsupported languages: ${summary}`);
   }
 
+  // Clone-safety telemetry (#2112): files whose parse output carried a value
+  // the structured-clone algorithm couldn't serialize across the worker
+  // boundary. The worker sanitized/dropped the offending value so the run
+  // could complete; surface the (rare) data loss so it's visible and the
+  // offending extractor can be fixed at source.
+  const skippedPaths: SkippedPath[] = [];
+  for (const result of chunkResults) {
+    for (const entry of result.skippedPaths ?? []) skippedPaths.push(entry);
+  }
+  if (skippedPaths.length > 0) {
+    // Keep the per-file reason ("stripped N value(s) from nodes" /
+    // "dropped non-serializable parsedFiles entry") — it distinguishes a
+    // recoverable strip from a whole-record drop, which a path-only line loses.
+    const shown = skippedPaths
+      .slice(0, 10)
+      .map((e) => `${e.path} (${e.reason})`)
+      .join(', ');
+    const more = skippedPaths.length > 10 ? ` …and ${skippedPaths.length - 10} more` : '';
+    logger.warn(
+      `  Sanitized ${skippedPaths.length} file(s) with non-serializable parse output: ${shown}${more}`,
+    );
+  }
+
   onFileProgress?.(total, total, 'done');
   return chunkResults;
 };