gitnexus 1.6.8-rc.8 → 1.6.8

package/dist/core/ingestion/language-provider.d.ts

@@ -19,6 +19,7 @@ import type { MethodExtractor } from './method-types.js';
 import type { VariableExtractor } from './variable-types.js';
 import type { ImportResolverFn } from './import-resolvers/types.js';
 import type { SyntaxNode } from './utils/ast-helpers.js';
+import type { CfgVisitor } from './cfg/types.js';
 import type { NodeLabel } from '../../_shared/index.js';
 import type Parser from 'tree-sitter';
 import type { ExtractedDecoratorRoute } from './workers/parse-worker.js';
@@ -147,6 +148,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;
     /** Override the default node label for definition.function captures.
@@ -268,12 +275,26 @@ 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).
      */
     readonly collectCaptureSideChannel?: (filePath: string) => unknown;
+    /**
+     * Per-language control-flow-graph builder (#2081 M1, PDG/taint substrate).
+     * Invoked IN THE PARSE WORKER (where the AST lives) for each function node,
+     * gated on the `--pdg` opt-in; the resulting per-function CFGs are serialized
+     * onto `ParsedFile.cfgSideChannel` and emitted as BasicBlock nodes + CFG
+     * edges during scope-resolution. `TNode` is `SyntaxNode` for the tree-sitter
+     * languages. Default: undefined (language has no CFG support yet — TS/JS are
+     * the M1 set).
+     */
+    readonly cfgVisitor?: CfgVisitor<SyntaxNode>;
     /**
      * Interpret a raw `@import.statement` capture group into a `ParsedImport`.
      * The central finalize algorithm resolves `ParsedImport.targetRaw` to a

package/dist/core/ingestion/languages/c-cpp.js

@@ -38,7 +38,9 @@ import { cCallConfig, cppCallConfig } from '../call-extractors/configs/c-cpp.js'
 import { stripUeMacros } from '../cpp-ue-preprocessor.js';
 import { emitCScopeCaptures, interpretCImport, interpretCTypeBinding, cArityCompatibility, cBindingScopeFor, cImportOwningScope, cReceiverBinding, collectCStaticLinkageSideChannel, } from './c/index.js';
 import { emitCppScopeCaptures, interpretCppImport, interpretCppTypeBinding, cppArityCompatibility, cppBindingScopeFor, cppImportOwningScope, cppReceiverBinding, collectCppCaptureSideChannel, } from './cpp/index.js';
-import { extractCppTemplateConstraints } from './cpp/constraint-extractor.js';
+import { extractCppTemplateConstraints, } from './cpp/constraint-extractor.js';
+import { assertCloneable } from '../workers/clone-safety.js';
+import { createCCfgVisitor, createCppCfgVisitor } from '../cfg/visitors/c-cpp.js';
 const C_BUILT_INS = new Set([
     'printf',
     'fprintf',
@@ -350,6 +352,7 @@ export const cProvider = defineLanguage({
     builtInNames: C_BUILT_INS,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     emitScopeCaptures: emitCScopeCaptures,
+    cfgVisitor: createCCfgVisitor(),
     // Worker-side: snapshot the module-level `static`-linkage marks
     // `emitCScopeCaptures` just populated for this file (`markStaticName` →
     // `staticNames`) into plain data on `ParsedFile.captureSideChannel`, so the
@@ -358,7 +361,10 @@ 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,
@@ -369,7 +375,9 @@ export const cProvider = defineLanguage({
 });
 export const cppProvider = defineLanguage({
     id: SupportedLanguages.CPlusPlus,
-    extensions: ['.cpp', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.hh'],
+    // CUDA files route through tree-sitter-cpp as a conservative C++-subset parser:
+    // definitions still extract, but CUDA launch syntax (`<<< >>>`) is not modeled as calls.
+    extensions: ['.cpp', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.hh', '.cu', '.cuh'],
     entryPointPatterns: [
         /^main$/,
         /^init_/,
@@ -427,11 +435,12 @@ export const cppProvider = defineLanguage({
     extractTemplateConstraints: extractCppTemplateConstraintsForProvider,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     emitScopeCaptures: emitCppScopeCaptures,
+    cfgVisitor: createCppCfgVisitor(),
     // Worker-side: snapshot the module-level capture marks `emitCppScopeCaptures`
     // 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,
@@ -482,5 +491,8 @@ function extractCppTemplateConstraintsForProvider(definitionNode) {
         }
         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));
 }

package/dist/core/ingestion/languages/cobol.js

@@ -27,6 +27,10 @@ export const cobolProvider = defineLanguage({
     },
     exportChecker: () => false,
     importResolver: () => null,
+    // No `cfgVisitor`: COBOL is the deliberate non-goal of the PDG-language
+    // rollout (#2195). There is no installed tree-sitter grammar and COBOL's
+    // PERFORM / GO-TO control flow is exotic; the worker's `provider.cfgVisitor &&`
+    // gate therefore emits no CFG/PDG layer for COBOL (see worker-roundtrip.test.ts).
     // ── Scope-resolution hooks ───────────────────────────────────────
     emitScopeCaptures: emitCobolScopeCaptures,
     interpretImport: interpretCobolImport,

package/dist/core/ingestion/languages/cpp/arity-metadata.js

@@ -173,6 +173,7 @@ export function classifyCppParameterType(rawType, declaratorText, fullParameterT
         cv,
         indirection,
         pointerDepth,
+        ...templateArgumentsFor(`${source} ${rawType} ${declaratorText ?? ''}`),
     };
 }
 function unknownTypeClass(base) {
@@ -183,6 +184,40 @@ function unknownTypeClass(base) {
         pointerDepth: 0,
     };
 }
+function templateArgumentsFor(rawType) {
+    const args = parseTopLevelTemplateArguments(rawType);
+    return args === undefined ? {} : { templateArguments: args };
+}
+function parseTopLevelTemplateArguments(rawType) {
+    const start = rawType.indexOf('<');
+    if (start < 0)
+        return undefined;
+    const args = [];
+    let depth = 0;
+    let argStart = start + 1;
+    for (let i = start + 1; i < rawType.length; i++) {
+        const ch = rawType[i];
+        if (ch === '<') {
+            depth++;
+        }
+        else if (ch === '>') {
+            if (depth === 0) {
+                const finalArg = rawType.slice(argStart, i).trim();
+                if (finalArg.length > 0)
+                    args.push(normalizeCppParamType(finalArg));
+                return args.length > 0 ? args : undefined;
+            }
+            depth--;
+        }
+        else if (ch === ',' && depth === 0) {
+            const arg = rawType.slice(argStart, i).trim();
+            if (arg.length > 0)
+                args.push(normalizeCppParamType(arg));
+            argStart = i + 1;
+        }
+    }
+    return undefined;
+}
 function findFuncDeclarator(node) {
     let decl = node.childForFieldName('declarator');
     if (decl === null) {
@@ -193,8 +228,12 @@ function findFuncDeclarator(node) {
         }
         return null;
     }
-    // Unwrap pointer_declarator / reference_declarator
-    while (decl.type === 'pointer_declarator' || decl.type === 'reference_declarator') {
+    // Unwrap declarator wrappers. Deleted free functions are represented as
+    // `init_declarator(function_declarator, delete_expression)` by
+    // tree-sitter-cpp 0.23.
+    while (decl.type === 'pointer_declarator' ||
+        decl.type === 'reference_declarator' ||
+        decl.type === 'init_declarator') {
         const next = decl.childForFieldName('declarator');
         if (next === null) {
             // reference_declarator may not use field name

package/dist/core/ingestion/languages/cpp/captures.js

@@ -11,6 +11,7 @@ import { markCppAdlSiteArgs, markCppAdlSiteNoAdl } from './adl.js';
 import { markCppInlineNamespaceRange } from './inline-namespaces.js';
 import { extractCppTemplateConstraints } from './constraint-extractor.js';
 import { captureCppMemberLookupFacts } from './member-lookup.js';
+import { CPP_BRACED_INIT_TYPE_PREFIX } from './conversion-rank.js';
 export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -113,6 +114,9 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
                 if (hasExplicitSpecifier(fnNode)) {
                     grouped['@declaration.is-explicit'] = syntheticCapture('@declaration.is-explicit', fnNode, 'true');
                 }
+                if (hasDeletedMethodClause(fnNode, grouped['@declaration.name']?.text)) {
+                    grouped['@declaration.is-deleted'] = syntheticCapture('@declaration.is-deleted', fnNode, 'true');
+                }
                 // Detect static storage class (file-local linkage)
                 if (hasStaticStorageClass(fnNode)) {
                     const nameText = grouped['@declaration.name']?.text;
@@ -547,6 +551,8 @@ function isFollowedByPackExpansion(baseClause, childIndex) {
             return true;
         if (sibling.type === ',' || sibling.type === 'access_specifier')
             return false;
+        if (sibling.type === 'comment')
+            continue;
         if (sibling.isNamed)
             return false;
     }
@@ -903,6 +909,8 @@ function unknownTypeClass(base) {
  */
 function inferCppLiteralType(node) {
     switch (node.type) {
+        case 'initializer_list':
+            return inferCppBracedInitType(node);
         case 'number_literal': {
             const text = node.text;
             // Floating-point literals contain '.', 'e', 'E', or end with 'f'/'F'
@@ -931,6 +939,27 @@ function inferCppLiteralType(node) {
             return '';
     }
 }
+function inferCppBracedInitType(node) {
+    const elementTypes = [];
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child === null)
+            continue;
+        if (child.type === ',' || child.type === '{' || child.type === '}')
+            continue;
+        const elementType = inferCppLiteralType(child);
+        if (elementType === '' || elementType.startsWith(CPP_BRACED_INIT_TYPE_PREFIX)) {
+            return `${CPP_BRACED_INIT_TYPE_PREFIX}unknown:${elementTypes.length + 1}`;
+        }
+        elementTypes.push(elementType);
+    }
+    if (elementTypes.length === 0)
+        return `${CPP_BRACED_INIT_TYPE_PREFIX}unknown:0`;
+    const first = elementTypes[0];
+    return elementTypes.every((type) => type === first)
+        ? `${CPP_BRACED_INIT_TYPE_PREFIX}${first}:${elementTypes.length}`
+        : `${CPP_BRACED_INIT_TYPE_PREFIX}unknown:${elementTypes.length}`;
+}
 /**
  * Look up the declared type of a variable by scanning sibling declarations
  * in the enclosing compound_statement (function body). Handles:
@@ -1562,8 +1591,11 @@ function extractDeclaratorLeafName(node) {
     let cur = node;
     let safety = 16;
     while (safety-- > 0) {
-        if (cur.type === 'identifier' || cur.type === 'type_identifier')
+        if (cur.type === 'identifier' ||
+            cur.type === 'type_identifier' ||
+            cur.type === 'operator_name') {
             return cur.text;
+        }
         // Common wrapper nodes — follow the 'declarator' field when present.
         const next = cur.childForFieldName('declarator') ??
             // parenthesized_declarator: single named child
@@ -1590,6 +1622,23 @@ function hasExplicitSpecifier(node) {
     }
     return /\bexplicit\b/.test(node.text.slice(0, 128));
 }
+function hasDeletedMethodClause(node, callableName) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'delete_method_clause')
+            return true;
+        // tree-sitter-cpp 0.23 parses a deleted free-function declaration as
+        // `declaration > init_declarator > delete_expression`, while class
+        // members use the dedicated `delete_method_clause`.
+        if (child?.type === 'init_declarator' &&
+            child.childForFieldName('value')?.type === 'delete_expression' &&
+            callableName !== undefined &&
+            extractDeclaratorLeafName(child.childForFieldName('declarator') ?? child) === callableName) {
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * Check if a C++ function_definition or declaration has `static` storage class.
  */

package/dist/core/ingestion/languages/cpp/conversion-rank.d.ts

@@ -20,6 +20,8 @@
  * their own `ConversionRankFn` in the future.
  */
 import type { ParameterTypeClass } from '../../../../_shared/index.js';
+export declare const CPP_BRACED_INIT_TYPE_PREFIX = "braced-init:";
+export declare const CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES: readonly ["braced-init:"];
 /**
  * Return the conversion rank from `argType` to `paramType`.
  *

package/dist/core/ingestion/languages/cpp/conversion-rank.js

@@ -19,6 +19,7 @@
  * This function is intentionally C++-specific. Other languages may define
  * their own `ConversionRankFn` in the future.
  */
+import { normalizeCppParamType } from './arity-metadata.js';
 import { hasCppUserDefinedConversion } from './user-defined-conversions.js';
 /** Set of normalized arithmetic types that support implicit conversion. */
 const ARITHMETIC = new Set(['int', 'double', 'char', 'bool']);
@@ -27,6 +28,22 @@ const INTEGRAL_PROMOTION = new Map([
     ['char', 'int'],
     ['bool', 'int'],
 ]);
+export const CPP_BRACED_INIT_TYPE_PREFIX = 'braced-init:';
+export const CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES = [CPP_BRACED_INIT_TYPE_PREFIX];
+const BRACED_INIT_CONTAINER_TYPES = new Set([
+    'array',
+    'deque',
+    'list',
+    'set',
+    'std::array',
+    'std::deque',
+    'std::list',
+    'std::set',
+    'std::unordered_set',
+    'std::vector',
+    'unordered_set',
+    'vector',
+]);
 /**
  * Return the conversion rank from `argType` to `paramType`.
  *
@@ -36,6 +53,17 @@ const INTEGRAL_PROMOTION = new Map([
  *          for mismatch.
  */
 export function cppConversionRank(argType, paramType, argTypeClass, paramTypeClass) {
+    const bracedInitType = parseBracedInitArgType(argType);
+    if (bracedInitType !== undefined) {
+        if (bracedInitType.elementType === 'unknown')
+            return Infinity;
+        if (bracedInitType.elementCount === 1) {
+            const scalarRank = cppConversionRank(bracedInitType.elementType, paramType, undefined, paramTypeClass);
+            if (isFinite(scalarRank))
+                return scalarRank;
+        }
+        return bracedInitConversionRank(paramType, bracedInitType, paramTypeClass);
+    }
     if (argType === paramType) {
         return exactShapeCompatible(argTypeClass, paramTypeClass) ? 0 : Infinity;
     }
@@ -57,6 +85,67 @@ export function cppConversionRank(argType, paramType, argTypeClass, paramTypeCla
         return 4;
     return Infinity;
 }
+function parseBracedInitArgType(argType) {
+    if (!argType.startsWith(CPP_BRACED_INIT_TYPE_PREFIX))
+        return undefined;
+    const payload = argType.slice(CPP_BRACED_INIT_TYPE_PREFIX.length);
+    if (payload === '')
+        return undefined;
+    const separator = payload.lastIndexOf(':');
+    if (separator > 0) {
+        const countText = payload.slice(separator + 1);
+        if (/^\d+$/.test(countText)) {
+            return {
+                elementType: payload.slice(0, separator),
+                elementCount: Number(countText),
+            };
+        }
+    }
+    return { elementType: payload };
+}
+function bracedInitConversionRank(paramType, argType, paramTypeClass) {
+    const targetBase = bracedInitTargetBase(paramType);
+    if (targetBase === 'initializer_list' || targetBase === 'std::initializer_list') {
+        return bracedInitValueTypeMatches(paramType, argType, paramTypeClass) ? 0 : Infinity;
+    }
+    if (BRACED_INIT_CONTAINER_TYPES.has(targetBase)) {
+        return bracedInitValueTypeMatches(paramType, argType, paramTypeClass) ? 4 : Infinity;
+    }
+    return Infinity;
+}
+function bracedInitValueTypeMatches(paramType, argType, paramTypeClass) {
+    const valueType = bracedInitTargetValueType(paramType, paramTypeClass);
+    if (valueType === undefined)
+        return false;
+    return isFinite(cppConversionRank(argType.elementType, valueType));
+}
+function bracedInitTargetValueType(paramType, paramTypeClass) {
+    return firstTemplateArgument(paramType) ?? paramTypeClass?.templateArguments?.[0];
+}
+function firstTemplateArgument(rawType) {
+    const start = rawType.indexOf('<');
+    if (start < 0)
+        return undefined;
+    let depth = 0;
+    for (let i = start + 1; i < rawType.length; i++) {
+        const ch = rawType[i];
+        if (ch === '<') {
+            depth++;
+        }
+        else if (ch === '>') {
+            if (depth === 0)
+                return bracedInitTargetBase(rawType.slice(start + 1, i));
+            depth--;
+        }
+        else if (ch === ',' && depth === 0) {
+            return bracedInitTargetBase(rawType.slice(start + 1, i));
+        }
+    }
+    return undefined;
+}
+function bracedInitTargetBase(paramType) {
+    return normalizeCppParamType(paramType);
+}
 function isPointer(typeClass) {
     return typeClass?.indirection === 'pointer' && typeClass.pointerDepth > 0;
 }

package/dist/core/ingestion/languages/cpp/header-scan.d.ts

@@ -3,6 +3,6 @@
  * Used by `loadResolutionConfig` so the C++ resolver can resolve `#include`
  * targets that live in header files.
  *
- * Scans for: .h, .hpp, .hxx, .hh
+ * Scans for: .h, .hpp, .hxx, .hh, .cuh
  */
 export declare function scanCppHeaderFiles(repoPath: string): ReadonlySet<string>;

package/dist/core/ingestion/languages/cpp/header-scan.js

@@ -1,13 +1,13 @@
 import { readdirSync } from 'fs';
 import { join, relative } from 'path';
 /** C++ header extensions to scan for in the workspace. */
-const HEADER_EXTENSIONS = new Set(['.h', '.hpp', '.hxx', '.hh']);
+const HEADER_EXTENSIONS = new Set(['.h', '.hpp', '.hxx', '.hh', '.cuh']);
 /**
  * Walk `repoPath` recursively and return relative paths of all C++ header files.
  * Used by `loadResolutionConfig` so the C++ resolver can resolve `#include`
  * targets that live in header files.
  *
- * Scans for: .h, .hpp, .hxx, .hh
+ * Scans for: .h, .hpp, .hxx, .hh, .cuh
  */
 export function scanCppHeaderFiles(repoPath) {
     const headers = new Set();

package/dist/core/ingestion/languages/cpp/inline-namespaces.js

@@ -27,7 +27,7 @@
  * declaration transparently.
  */
 import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
-import { cppConversionRank } from './conversion-rank.js';
+import { CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES, cppConversionRank } from './conversion-rank.js';
 const inlineNamespaceRangesByFile = new Map();
 const inlineNamespaceScopeIds = new Set();
 function rangeKey(r) {
@@ -142,7 +142,12 @@ export function resolveCppQualifiedNamespaceMember(receiverName, memberName, par
     // can disambiguate via exact-type match and, when available, conversion-rank
     // scoring (`cppConversionRank`). Same-signature ambiguity is still detected
     // by `isOverloadAmbiguousAfterNormalization` below.
-    const narrowed = narrowOverloadCandidates(allHits, callsite?.arity, callsite?.argumentTypes, callsite !== undefined ? { conversionRankFn: cppConversionRank } : undefined);
+    const narrowed = narrowOverloadCandidates(allHits, callsite?.arity, callsite?.argumentTypes, callsite !== undefined
+        ? {
+            conversionRankFn: cppConversionRank,
+            conversionOnlyArgTypePrefixes: CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES,
+        }
+        : undefined);
     if (narrowed.length === 1)
         return narrowed[0];
     if (narrowed.length === 0)

package/dist/core/ingestion/languages/cpp/member-lookup.js

@@ -3,7 +3,7 @@ import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js
 import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
 import { isClassLike } from '../../scope-resolution/scope/walkers.js';
 import { cppConstraintCompatibility } from './constraint-filter.js';
-import { cppConversionRank } from './conversion-rank.js';
+import { CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES, cppConversionRank } from './conversion-rank.js';
 const capturedByFile = new Map();
 let directParentsByDefId = new Map();
 let virtualEdges = new Set();
@@ -193,6 +193,7 @@ function chooseOverload(candidates, callsite) {
     const narrowed = narrowOverloadCandidates(candidates, callsite.arity, callsite.argumentTypes, {
         argumentTypeClasses: callsite.argumentTypeClasses,
         conversionRankFn: cppConversionRank,
+        conversionOnlyArgTypePrefixes: CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES,
         constraintCompatibility: cppConstraintCompatibility,
     });
     if (narrowed.length === 1)

package/dist/core/ingestion/languages/cpp/query.js

@@ -193,6 +193,29 @@ const CPP_SCOPE_QUERY = `
   declarator: (function_declarator
     declarator: (identifier) @declaration.name)) @declaration.function
 
+;; tree-sitter-cpp 0.23 represents a deleted free function as an
+;; init_declarator whose value is a delete_expression.
+(declaration
+  declarator: (init_declarator
+    declarator: (function_declarator
+      declarator: (identifier) @declaration.name)
+    value: (delete_expression))) @declaration.function
+
+;; Deleted free operator declaration.
+(declaration
+  declarator: (init_declarator
+    declarator: (function_declarator
+      declarator: (operator_name) @declaration.name)
+    value: (delete_expression))) @declaration.function
+
+;; Deleted free function with a pointer return type.
+(declaration
+  declarator: (init_declarator
+    declarator: (pointer_declarator
+      declarator: (function_declarator
+        declarator: (identifier) @declaration.name))
+    value: (delete_expression))) @declaration.function
+
 ;; Free operator prototype: std::ostream& operator<<(std::ostream&, T)
 (declaration
   declarator: (function_declarator

package/dist/core/ingestion/languages/cpp/scope-resolver.js

@@ -3,7 +3,7 @@ import { SupportedLanguages } from '../../../../_shared/index.js';
 import { populateClassOwnedMembers, tagNamespacePrefixes, } from '../../scope-resolution/scope/walkers.js';
 import { cppProvider } from '../c-cpp.js';
 import { cppArityCompatibility } from './arity.js';
-import { cppConversionRank } from './conversion-rank.js';
+import { CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES, cppConversionRank } from './conversion-rank.js';
 import { cppMergeBindings } from './merge-bindings.js';
 import { resolveCppImportTarget } from './import-target.js';
 import { scanCppHeaderFiles } from './header-scan.js';
@@ -205,6 +205,7 @@ export const cppScopeResolver = {
     // Disambiguates `f(int)` vs `f(double)` called with `f(2.5)` by scoring
     // each candidate's conversion cost; exact match wins over standard conversion.
     conversionRankFn: cppConversionRank,
+    conversionOnlyArgTypePrefixes: CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES,
     // Range-for element type inference: for (auto& user : users) → bind user to User
     populateRangeBindings: populateCppRangeBindings,
     // C++ method return-type bindings need to be visible from module scope

package/dist/core/ingestion/languages/csharp.js

@@ -22,6 +22,7 @@ import { createMethodExtractor } from '../method-extractors/generic.js';
 import { csharpMethodConfig } from '../method-extractors/configs/csharp.js';
 import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { csharpVariableConfig } from '../variable-extractors/configs/csharp.js';
+import { createCsharpCfgVisitor } from '../cfg/visitors/csharp.js';
 import { emitCsharpScopeCaptures, interpretCsharpImport, interpretCsharpTypeBinding, csharpBindingScopeFor, csharpImportOwningScope, csharpMergeBindings, csharpReceiverBinding, csharpArityCompatibility, resolveCsharpImportTarget, } from './csharp/index.js';
 const BUILT_INS = new Set([
     'Console',
@@ -185,6 +186,7 @@ export const csharpProvider = defineLanguage({
     // the full per-hook rationale and the canonical capture vocabulary
     // in ./csharp/query.ts (CSHARP_SCOPE_QUERY constant).
     emitScopeCaptures: emitCsharpScopeCaptures,
+    cfgVisitor: createCsharpCfgVisitor(),
     interpretImport: interpretCsharpImport,
     interpretTypeBinding: interpretCsharpTypeBinding,
     bindingScopeFor: csharpBindingScopeFor,

package/dist/core/ingestion/languages/dart.js

@@ -18,6 +18,7 @@ import { dartExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { dartImportConfig } from '../import-resolvers/configs/dart.js';
 import { DART_QUERIES } from '../tree-sitter-queries.js';
+import { createDartCfgVisitor } from '../cfg/visitors/dart.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { dartConfig as dartFieldConfig } from '../field-extractors/configs/dart.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
@@ -114,6 +115,7 @@ export const dartProvider = defineLanguage({
     // emit-side `ScopeResolver` lives in `dart/scope-resolver.ts`; the same
     // function references flow through both interfaces.
     emitScopeCaptures: emitDartScopeCaptures,
+    cfgVisitor: createDartCfgVisitor(),
     interpretImport: interpretDartImport,
     interpretTypeBinding: interpretDartTypeBinding,
     bindingScopeFor: dartBindingScopeFor,

package/dist/core/ingestion/languages/go.js

@@ -10,6 +10,7 @@
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
 import { goClassConfig } from '../class-extractors/configs/go.js';
+import { createGoCfgVisitor } from '../cfg/visitors/go.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as goConfig } from '../type-extractors/go.js';
 import { goExportChecker } from '../export-detection.js';
@@ -128,6 +129,7 @@ export const goProvider = defineLanguage({
     builtInNames: GO_BUILT_INS,
     // ── RFC #909 Ring 3: scope-based resolution hooks ──────────
     emitScopeCaptures: emitGoScopeCaptures,
+    cfgVisitor: createGoCfgVisitor(),
     interpretImport: interpretGoImport,
     interpretTypeBinding: interpretGoTypeBinding,
     bindingScopeFor: goBindingScopeFor,

package/dist/core/ingestion/languages/java.js

@@ -24,6 +24,7 @@ import { createMethodExtractor } from '../method-extractors/generic.js';
 import { javaMethodConfig } from '../method-extractors/configs/jvm.js';
 import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { javaVariableConfig } from '../variable-extractors/configs/jvm.js';
+import { createJavaCfgVisitor } from '../cfg/visitors/java.js';
 import { emitJavaScopeCaptures, interpretJavaImport, interpretJavaTypeBinding, javaBindingScopeFor, javaImportOwningScope, javaMergeBindings, javaReceiverBinding, javaArityCompatibility, resolveJavaImportTarget, } from './java/index.js';
 const orderJavaSameNameTypeCandidates = ({ callSiteFilePath, candidates, }) => {
     if (!callSiteFilePath.endsWith('.java'))
@@ -95,6 +96,8 @@ export const javaProvider = defineLanguage({
     classExtractor: createClassExtractor(javaClassConfig),
     // ── RFC #909 Ring 3: scope-based resolution hooks ──
     emitScopeCaptures: emitJavaScopeCaptures,
+    // ── PDG: per-function CFG + def/use harvest (#2195 U4) ──
+    cfgVisitor: createJavaCfgVisitor(),
     interpretImport: interpretJavaImport,
     interpretTypeBinding: interpretJavaTypeBinding,
     bindingScopeFor: javaBindingScopeFor,

package/dist/core/ingestion/languages/kotlin/query.js

@@ -1,7 +1,8 @@
 import Parser from 'tree-sitter';
 import { SupportedLanguages } from '../../../../_shared/index.js';
-// `tree-sitter-kotlin` is an optionalDependency that may be absent on a default
-// install (or fail its native build). Loaded lazily + guarded via parser-loader
+// `tree-sitter-kotlin` is a vendored grammar (loaded from vendor/ by absolute
+// path, never node_modules — vendored-grammars.ts / #2111) that may be absent on
+// a platform without a matching prebuild. Loaded lazily + guarded via parser-loader
 // rather than statically imported: this module is pulled onto the main thread
 // eagerly by the scope-resolution registry and the language-provider index, so
 // a top-level `import Kotlin from 'tree-sitter-kotlin'` would throw

package/dist/core/ingestion/languages/kotlin.js

@@ -10,6 +10,7 @@ import { SupportedLanguages } from '../../../_shared/index.js';
 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';
@@ -18,6 +19,7 @@ import { appendKotlinWildcard } from '../import-resolvers/jvm.js';
 import { KOTLIN_QUERIES } from '../tree-sitter-queries.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { kotlinCallConfig } from '../call-extractors/configs/jvm.js';
+import { createKotlinCfgVisitor } from '../cfg/visitors/kotlin.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { kotlinConfig } from '../field-extractors/configs/jvm.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
@@ -160,13 +162,18 @@ export const kotlinProvider = defineLanguage({
     },
     // ── RFC #909 Ring 3: scope-based resolution hooks ──
     emitScopeCaptures: emitKotlinScopeCaptures,
+    // ── #2195 PDG layer: Kotlin CFG visitor (vendored grammar) ──
+    cfgVisitor: createKotlinCfgVisitor(),
     // Worker-side: snapshot the module-level companion-scope marks
     // `emitKotlinScopeCaptures` just populated for this file (`markCompanionScope`
     // → `companionScopesByFile`) into plain data on `ParsedFile.captureSideChannel`,
     // 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,