gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

package/dist/core/ingestion/cluster-enricher.js

@@ -4,6 +4,7 @@
  * LLM-based enrichment for community clusters.
  * Generates semantic names, keywords, and descriptions using an LLM.
  */
+import { chunk } from '../../lib/utils.js';
 import { logger } from '../logger.js';
 // ============================================================================
 // PROMPT TEMPLATE
@@ -104,10 +105,13 @@ export const enrichClustersBatch = async (communities, memberMap, llmClient, bat
     const enrichments = new Map();
     let tokensUsed = 0;
     // Process in batches
-    for (let i = 0; i < communities.length; i += batchSize) {
-        // Report progress
-        onProgress?.(Math.min(i + batchSize, communities.length), communities.length);
-        const batch = communities.slice(i, i + batchSize);
+    let reported = 0;
+    for (const batch of chunk(communities, batchSize)) {
+        // Report progress. `reported` after each whole batch equals the old
+        // `Math.min(i + batchSize, communities.length)` — the last batch is short
+        // exactly when that clamp used to bite.
+        reported += batch.length;
+        onProgress?.(reported, communities.length);
         const batchPrompt = batch
             .map((community, idx) => {
             const members = memberMap.get(community.id) || [];

package/dist/core/ingestion/cobol/cobol-preprocessor.js

@@ -363,7 +363,7 @@ function parseDataItemClauses(rest) {
         result.pic = picMatch[1];
     }
     // USAGE [IS] <usage-type> — including non-standard COMP-6, COMP-X etc.
-    const usageMatch = text.match(/\bUSAGE\s+(?:IS\s+)?(COMP(?:UTATIONAL)?(?:-[0-9X])?|BINARY|PACKED-DECIMAL|DISPLAY|INDEX|POINTER|NATIONAL)\b/i);
+    const usageMatch = text.match(/\bUSAGE\s+(?:IS\s+)?(PROCEDURE-POINTER|FUNCTION-POINTER|COMP(?:UTATIONAL)?(?:-[0-9X])?|BINARY|PACKED-DECIMAL|DISPLAY|INDEX|POINTER|NATIONAL)\b/i);
     if (usageMatch) {
         result.usage = usageMatch[1].toUpperCase();
     }

package/dist/core/ingestion/community-processor.d.ts

@@ -16,9 +16,12 @@ type CommunityEngine = 'graphology' | 'icebug';
 export type CommunityDetectionEngine = CommunityEngine | 'auto';
 export interface CommunityDetectionOptions {
     /**
-     * Graphology remains the default. `icebug`/`auto` are guarded prototype
-     * paths for #2337 and fall back to Graphology if the optional native module
-     * is not available or does not expose the expected API.
+     * Graphology is the supported default. `icebug`/`auto` are **experimental**:
+     * they route through the optional `@ladybugmem/icebug` native Leiden (#2337)
+     * and fall back to Graphology if it is not installed, cannot load, or
+     * predates the thread/seed controls determinism requires. The two engines
+     * partition differently, so switching changes community IDs — and with them
+     * any generated context keyed on those IDs. No stability guarantee.
      */
     engine?: CommunityDetectionEngine;
     icebug?: {
@@ -86,4 +89,19 @@ export declare const processCommunities: (knowledgeGraph: KnowledgeGraph, onProg
 export declare const buildCommunityProjection: (knowledgeGraph: KnowledgeGraph) => CommunityProjection;
 export declare const buildCommunityCsr: (projection: CommunityProjection) => CommunityCsr;
 export declare const buildGraphologyGraph: (projection: CommunityProjection) => GraphInstance;
+/**
+ * Runs Leiden in a worker so a native crash cannot take the analyze process
+ * with it. Written against @ladybugmem/icebug's published surface (lib/index.js
+ * + index.d.ts): `GraphR(n, directed, outIndices, outIndptr)` pins the CSR
+ * buffers zero-copy, and `Leiden(graph, iterations, randomize, gamma)` — note
+ * `randomize` precedes `gamma` — returns `{membership, count}` from
+ * `getPartition()`.
+ *
+ * The thread/seed controls are required, not optional: community IDs feed
+ * generated context, so a build without them would give non-reproducible
+ * output. They exist at icebug-nodejs HEAD but are missing from the published
+ * 12.8.0 tarball, so today this guard is what trips and sends us back to
+ * Graphology.
+ */
+export declare const buildIcebugWorkerSource: (moduleSpecifier: string) => string;
 export {};

package/dist/core/ingestion/community-processor.js

@@ -39,6 +39,12 @@ function createSeededRng(seed) {
     };
 }
 const COMMUNITY_ENGINE_ENV = 'GITNEXUS_COMMUNITY_ENGINE';
+/**
+ * Not a declared dependency: the prebuilds need system Arrow 24, libomp and
+ * glibc >= 2.38, so it stays an opt-in `npm i @ladybugmem/icebug` alongside
+ * GitNexus rather than 30MB every install pays for.
+ */
+const ICEBUG_MODULE = '@ladybugmem/icebug';
 const DEFAULT_COMMUNITY_ENGINE = 'graphology';
 const LEIDEN_TIMEOUT_MS = 60_000;
 const ICEBUG_TIMEOUT_MS = 60_000;
@@ -147,18 +153,21 @@ export const buildCommunityProjection = (knowledgeGraph) => {
     const isLarge = symbolCount > 10_000;
     const connectedNodes = new Set();
     const nodeDegree = new Map();
-    knowledgeGraph.forEachRelationship((rel) => {
-        if (!isClusteringRelationship(rel.type) || rel.sourceId === rel.targetId)
+    // Field-wise scan (#2680): this walks every edge and reads only these four,
+    // so taking objects would allocate one per edge for nothing.
+    knowledgeGraph.forEachRelationshipFields((sourceId, targetId, type, confidence) => {
+        if (!isClusteringRelationship(type) || sourceId === targetId)
             return;
-        if (isLarge && rel.confidence < MIN_CONFIDENCE_LARGE)
+        if (isLarge && confidence < MIN_CONFIDENCE_LARGE)
             return;
-        connectedNodes.add(rel.sourceId);
-        connectedNodes.add(rel.targetId);
-        nodeDegree.set(rel.sourceId, (nodeDegree.get(rel.sourceId) || 0) + 1);
-        nodeDegree.set(rel.targetId, (nodeDegree.get(rel.targetId) || 0) + 1);
+        connectedNodes.add(sourceId);
+        connectedNodes.add(targetId);
+        nodeDegree.set(sourceId, (nodeDegree.get(sourceId) || 0) + 1);
+        nodeDegree.set(targetId, (nodeDegree.get(targetId) || 0) + 1);
     });
     const nodes = [];
     const nodeIndexById = new Map();
+    const eligibleNodes = [];
     knowledgeGraph.forEachNode((node) => {
         if (!isCommunitySymbol(node) || !connectedNodes.has(node.id))
             return;
@@ -166,6 +175,10 @@ export const buildCommunityProjection = (knowledgeGraph) => {
         // get absorbed into their single neighbor's community, but cost iteration time.
         if (isLarge && (nodeDegree.get(node.id) || 0) < 2)
             return;
+        eligibleNodes.push(node);
+    });
+    eligibleNodes.sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+    for (const node of eligibleNodes) {
         nodeIndexById.set(node.id, nodes.length);
         nodes.push({
             id: node.id,
@@ -173,16 +186,16 @@ export const buildCommunityProjection = (knowledgeGraph) => {
             filePath: node.properties.filePath,
             type: node.label,
         });
-    });
+    }
     const seenEdges = new Set();
     const edges = [];
-    knowledgeGraph.forEachRelationship((rel) => {
-        if (!isClusteringRelationship(rel.type) || rel.sourceId === rel.targetId)
+    knowledgeGraph.forEachRelationshipFields((sourceId, targetId, type, confidence) => {
+        if (!isClusteringRelationship(type) || sourceId === targetId)
             return;
-        if (isLarge && rel.confidence < MIN_CONFIDENCE_LARGE)
+        if (isLarge && confidence < MIN_CONFIDENCE_LARGE)
             return;
-        const sourceIndex = nodeIndexById.get(rel.sourceId);
-        const targetIndex = nodeIndexById.get(rel.targetId);
+        const sourceIndex = nodeIndexById.get(sourceId);
+        const targetIndex = nodeIndexById.get(targetId);
         if (sourceIndex === undefined || targetIndex === undefined || sourceIndex === targetIndex)
             return;
         const [a, b] = sourceIndex < targetIndex ? [sourceIndex, targetIndex] : [targetIndex, sourceIndex];
@@ -192,6 +205,7 @@ export const buildCommunityProjection = (knowledgeGraph) => {
         seenEdges.add(edgeKey);
         edges.push([a, b]);
     });
+    edges.sort(([leftA, leftB], [rightA, rightB]) => leftA - rightA || leftB - rightB);
     return { nodes, edges, symbolCount, isLarge };
 };
 export const buildCommunityCsr = (projection) => {
@@ -238,6 +252,11 @@ const runCommunityEngine = async (graph, projection, engineRequested, options, o
     if (engineRequested === 'graphology') {
         return runGraphologyLeiden(graph, projection.isLarge, engineRequested);
     }
+    // Announced on request, not just on fallback: a run that succeeds is the case
+    // where the user most needs to know the partition came from the experimental
+    // engine, since community IDs feed generated context.
+    onProgress?.(`Experimental ${engineRequested} community engine requested — unsupported, and its ` +
+        'communities will not match the Graphology default.', 32);
     try {
         return await runIcebugLeiden(projection, engineRequested, options);
     }
@@ -286,8 +305,7 @@ const runIcebugLeiden = async (projection, engineRequested, options) => {
     if (!Number.isFinite(nativeResult.modularity)) {
         throw new Error('optional icebug modularity was not finite');
     }
-    if (partition.length !== projection.nodes.length ||
-        partition.some((community) => !Number.isSafeInteger(community))) {
+    if (partition.length !== projection.nodes.length || !isIntegerPartition(partition)) {
         throw new Error(`optional icebug partition was malformed for ${projection.nodes.length} projected nodes`);
     }
     const communities = normalizePartition(projection, partition);
@@ -299,6 +317,13 @@ const runIcebugLeiden = async (projection, engineRequested, options) => {
         engineRequested,
     };
 };
+const isIntegerPartition = (partition) => {
+    for (let index = 0; index < partition.length; index++) {
+        if (!Number.isSafeInteger(partition[index]))
+            return false;
+    }
+    return true;
+};
 const runIcebugWorker = (nodeCount, csr, options) => {
     const threads = options.icebug?.threads ?? 1;
     if (!Number.isSafeInteger(threads) || threads !== 1) {
@@ -324,13 +349,20 @@ const runIcebugWorker = (nodeCount, csr, options) => {
         let settled = false;
         const timeout = setTimeout(() => {
             settled = true;
-            void worker.terminate();
+            // Deliberately NOT terminate(): every millisecond of this worker's life is
+            // spent inside an N-API call (dlopen, GraphR, Leiden, run), and killing a
+            // thread mid-N-API aborts the whole process — Napi::Error → std::terminate
+            // → SIGABRT (#2432, see worker-pool.ts `shutdownDrainMs`). A timeout must
+            // degrade to the Graphology fallback, not take analyze down with it.
+            // unref() so a wedged native run cannot hold the process open either.
+            worker.unref();
             reject(new Error(`optional icebug community engine timed out after ${ICEBUG_TIMEOUT_MS}ms`));
         }, ICEBUG_TIMEOUT_MS);
+        // No terminate() on the settled paths either: the worker script ends after
+        // its single postMessage, so the thread exits on its own.
         worker.once('message', (message) => {
             settled = true;
             clearTimeout(timeout);
-            void worker.terminate();
             if (message.ok === true) {
                 resolve(message);
             }
@@ -341,7 +373,6 @@ const runIcebugWorker = (nodeCount, csr, options) => {
         worker.once('error', (error) => {
             settled = true;
             clearTimeout(timeout);
-            void worker.terminate();
             reject(error);
         });
         worker.once('exit', (code) => {
@@ -356,85 +387,59 @@ const runIcebugWorker = (nodeCount, csr, options) => {
         });
     });
 };
-const ICEBUG_WORKER_SOURCE = `
+/**
+ * Runs Leiden in a worker so a native crash cannot take the analyze process
+ * with it. Written against @ladybugmem/icebug's published surface (lib/index.js
+ * + index.d.ts): `GraphR(n, directed, outIndices, outIndptr)` pins the CSR
+ * buffers zero-copy, and `Leiden(graph, iterations, randomize, gamma)` — note
+ * `randomize` precedes `gamma` — returns `{membership, count}` from
+ * `getPartition()`.
+ *
+ * The thread/seed controls are required, not optional: community IDs feed
+ * generated context, so a build without them would give non-reproducible
+ * output. They exist at icebug-nodejs HEAD but are missing from the published
+ * 12.8.0 tarball, so today this guard is what trips and sends us back to
+ * Graphology.
+ */
+export const buildIcebugWorkerSource = (moduleSpecifier) => `
 const { parentPort, workerData } = require('node:worker_threads');
 
-const isNumericArrayLike = (value) =>
-  typeof value === 'object' &&
-  value !== null &&
-  'length' in value &&
-  typeof value.length === 'number';
-
-const readPartition = (runner) => {
-  const candidates = [
-    typeof runner.getPartition === 'function' ? runner.getPartition() : runner.partition,
-    typeof runner.getCommunities === 'function' ? runner.getCommunities() : undefined,
-    typeof runner.getMembership === 'function' ? runner.getMembership() : undefined,
-    typeof runner.getMemberships === 'function' ? runner.getMemberships() : undefined,
-  ];
-
-  for (const candidate of candidates) {
-    if (isNumericArrayLike(candidate)) {
-      return Array.from(candidate, Number);
-    }
-  }
-
-  throw new Error('optional icebug ParallelLeidenView did not expose a partition array');
-};
-
-const readModularity = (runner) => {
-  if (typeof runner.getModularity === 'function') return runner.getModularity();
-  if (typeof runner.modularity === 'function') return runner.modularity();
-  if (typeof runner.modularity === 'number') return runner.modularity;
-  return 0;
-};
-
-(async () => {
-  const imported = await import('icebug');
-  const icebug = imported.default ?? imported;
-  const fromCSR = icebug.Graph?.fromCSR;
-  const ParallelLeidenView = icebug.community?.ParallelLeidenView;
-  if (!fromCSR || !ParallelLeidenView) {
-    throw new Error('optional icebug module does not expose Graph.fromCSR/ParallelLeidenView');
-  }
+try {
+  const icebug = require(${JSON.stringify(moduleSpecifier)});
 
   if (typeof icebug.setNumberOfThreads !== 'function' || typeof icebug.setSeed !== 'function') {
-    throw new Error('optional icebug module does not expose deterministic thread/seed controls');
+    throw new Error(
+      'optional icebug build predates the deterministic thread/seed controls (icebug-nodejs#6)',
+    );
   }
+
   icebug.setNumberOfThreads(workerData.threads);
   icebug.setSeed(workerData.seed, false);
 
-  const nativeGraph = fromCSR(workerData.nodeCount, false, workerData.indices, workerData.indptr);
-  let runner;
-  try {
-    runner = new ParallelLeidenView(nativeGraph, {
-      iterations: workerData.iterations,
-      gamma: workerData.gamma,
-      randomize: workerData.randomize,
-    });
-  } catch {
-    runner = new ParallelLeidenView(
-      nativeGraph,
-      workerData.iterations,
-      workerData.gamma,
-      workerData.randomize,
-    );
-  }
+  const graph = new icebug.GraphR(
+    workerData.nodeCount,
+    false,
+    workerData.indices,
+    workerData.indptr,
+  );
+  const leiden = new icebug.Leiden(
+    graph,
+    workerData.iterations,
+    workerData.randomize,
+    workerData.gamma,
+  );
+  leiden.run();
 
-  if (typeof runner.run !== 'function') {
-    throw new Error('optional icebug ParallelLeidenView does not expose run()');
-  }
-
-  runner.run();
   parentPort.postMessage({
     ok: true,
-    partition: readPartition(runner),
-    modularity: readModularity(runner),
+    partition: leiden.getPartition().membership,
+    modularity: leiden.modularity(),
   });
-})().catch((error) => {
+} catch (error) {
   parentPort.postMessage({ ok: false, error: error instanceof Error ? error.message : String(error) });
-});
+}
 `;
+const ICEBUG_WORKER_SOURCE = buildIcebugWorkerSource(ICEBUG_MODULE);
 const normalizePartition = (projection, partition) => {
     const remap = new Map();
     const communities = {};

package/dist/core/ingestion/di-extractors/index.d.ts

@@ -1,47 +1,35 @@
 /**
- * Per-language DI field-matcher registry — the lookup the generic `di`
- * pipeline phase uses to decide whether a `Property` node is a
- * dependency-injection fan-out candidate.
+ * Per-language DI resolver registry — the lookup the generic `di` pipeline
+ * phase uses to discover injection sites and provider metadata on graph nodes.
  *
  * Mirrors `scope-resolution/pipeline/registry.ts` (`SCOPE_RESOLVERS`): a
- * single-valued `ReadonlyMap<SupportedLanguages, DiFieldMatcher>` consumed by
+ * single-valued `ReadonlyMap<SupportedLanguages, DiResolver>` consumed by
  * a framework-neutral phase, so no language or framework names leak into
- * shared pipeline code. Adding a framework is two lines: implement a
- * `DiFieldMatcher` in `di-extractors/<framework>.ts` and register it here.
+ * shared pipeline code. Adding a framework means implementing a `DiResolver`
+ * in `di-extractors/<framework>.ts` and registering it here.
  *
- * Scope honesty: matchers are per-language *field-injection* matchers.
- * Constructor injection (the dominant modern Spring idiom) lives on
- * Method/parameter nodes and would require widening the phase's routing —
- * deliberately out of scope (see the plan's Deferred work). The registry is
- * single-valued per language, matching the `SCOPE_RESOLVERS` shape; widen the
- * value type to arrays only when a second same-language framework actually
- * lands (a one-line type change then).
+ * The registry is single-valued per language, matching the `SCOPE_RESOLVERS`
+ * shape; widen the value type to arrays only when a second same-language
+ * framework actually lands. Java and Kotlin share Spring's attached metadata
+ * contract while retaining language-specific syntax capture.
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
-import type { GraphNode } from '../../../_shared/index.js';
-/** A successful DI field match, produced by a per-language matcher. */
-export interface DiFieldMatch {
-    /** The element type name `T` — the injected bean interface. */
-    elementTypeName: string;
-    /** Human-readable edge reason. Framework specifics (names, idioms,
-     *  collection wrapper, gating annotation) live in this payload so the
-     *  shared `di` phase stays framework-neutral. */
-    reason: string;
-}
-/**
- * A per-language field-injection matcher: given a `Property` node, return the
- * parsed DI match or `null` when the field is not container-injected. The
- * matcher receives the whole node (not pre-plucked fields) so the shared
- * phase stays ignorant of which properties matter.
- */
-export type DiFieldMatcher = (node: GraphNode) => DiFieldMatch | null;
+import type { DiResolver } from './types.js';
+/** The resolver contract lives in the leaf `./types.js` so an implementation
+ *  can depend on it without depending on this registry (which imports every
+ *  implementation). The two match shapes are re-exported here because consumers
+ *  of the registry read them off its results — `pipeline-phases/di.ts` and the
+ *  Spring metadata modules import them from this module alongside
+ *  `DI_RESOLVERS`. `DiResolver` itself is NOT re-exported: only implementations
+ *  need it, and they import it from `./types.js` directly. */
+export type { DiInjectionMatch, DiProviderMatch } from './types.js';
 /**
  * Type guard narrowing an arbitrary graph `language` string to
- * `SupportedLanguages`, so `DI_MATCHERS.get()` needs no cast.
+ * `SupportedLanguages`, so `DI_RESOLVERS.get()` needs no cast.
  */
 export declare function isSupportedLanguage(value: string): value is SupportedLanguages;
-/** Map of `SupportedLanguages` → `DiFieldMatcher`. The `di` phase routes each
- *  `Property` node here by `node.properties.language`; no entry ⇒ the node is
+/** Map of `SupportedLanguages` → `DiResolver`. The `di` phase routes each
+ *  graph node here by `node.properties.language`; no entry ⇒ the node is
  *  skipped. This is the single source of truth for which languages (and,
  *  transitively, frameworks) produce INJECTS edges. */
-export declare const DI_MATCHERS: ReadonlyMap<SupportedLanguages, DiFieldMatcher>;
+export declare const DI_RESOLVERS: ReadonlyMap<SupportedLanguages, DiResolver>;

package/dist/core/ingestion/di-extractors/index.js

@@ -1,35 +1,34 @@
 /**
- * Per-language DI field-matcher registry — the lookup the generic `di`
- * pipeline phase uses to decide whether a `Property` node is a
- * dependency-injection fan-out candidate.
+ * Per-language DI resolver registry — the lookup the generic `di` pipeline
+ * phase uses to discover injection sites and provider metadata on graph nodes.
  *
  * Mirrors `scope-resolution/pipeline/registry.ts` (`SCOPE_RESOLVERS`): a
- * single-valued `ReadonlyMap<SupportedLanguages, DiFieldMatcher>` consumed by
+ * single-valued `ReadonlyMap<SupportedLanguages, DiResolver>` consumed by
  * a framework-neutral phase, so no language or framework names leak into
- * shared pipeline code. Adding a framework is two lines: implement a
- * `DiFieldMatcher` in `di-extractors/<framework>.ts` and register it here.
+ * shared pipeline code. Adding a framework means implementing a `DiResolver`
+ * in `di-extractors/<framework>.ts` and registering it here.
  *
- * Scope honesty: matchers are per-language *field-injection* matchers.
- * Constructor injection (the dominant modern Spring idiom) lives on
- * Method/parameter nodes and would require widening the phase's routing —
- * deliberately out of scope (see the plan's Deferred work). The registry is
- * single-valued per language, matching the `SCOPE_RESOLVERS` shape; widen the
- * value type to arrays only when a second same-language framework actually
- * lands (a one-line type change then).
+ * The registry is single-valued per language, matching the `SCOPE_RESOLVERS`
+ * shape; widen the value type to arrays only when a second same-language
+ * framework actually lands. Java and Kotlin share Spring's attached metadata
+ * contract while retaining language-specific syntax capture.
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
-import { springDiFieldMatcher } from './spring.js';
+import { springDiResolver } from './spring.js';
 /** All `SupportedLanguages` string values, for narrowing raw graph strings. */
 const SUPPORTED_LANGUAGE_VALUES = new Set(Object.values(SupportedLanguages));
 /**
  * Type guard narrowing an arbitrary graph `language` string to
- * `SupportedLanguages`, so `DI_MATCHERS.get()` needs no cast.
+ * `SupportedLanguages`, so `DI_RESOLVERS.get()` needs no cast.
  */
 export function isSupportedLanguage(value) {
     return SUPPORTED_LANGUAGE_VALUES.has(value);
 }
-/** Map of `SupportedLanguages` → `DiFieldMatcher`. The `di` phase routes each
- *  `Property` node here by `node.properties.language`; no entry ⇒ the node is
+/** Map of `SupportedLanguages` → `DiResolver`. The `di` phase routes each
+ *  graph node here by `node.properties.language`; no entry ⇒ the node is
  *  skipped. This is the single source of truth for which languages (and,
  *  transitively, frameworks) produce INJECTS edges. */
-export const DI_MATCHERS = new Map([[SupportedLanguages.Java, springDiFieldMatcher]]);
+export const DI_RESOLVERS = new Map([
+    [SupportedLanguages.Java, springDiResolver],
+    [SupportedLanguages.Kotlin, springDiResolver],
+]);

package/dist/core/ingestion/di-extractors/spring.d.ts

@@ -51,11 +51,22 @@
  *   between `<` and the element) are NOT stripped and fail closed —
  *   acceptable.
  *
- * Registered under `SupportedLanguages.Java` in `./index.ts` (`DI_MATCHERS`);
- * language routing is the registry's job, so the matcher itself never reads
- * `node.properties.language`.
+ * Registered for Java and Kotlin in `./index.ts` (`DI_RESOLVERS`); language
+ * routing is the registry's job, so the matcher itself never reads
+ * `node.properties.language`. Kotlin's AST-backed class metadata is the
+ * primary path because Kotlin Property extraction intentionally exposes less
+ * annotation/type syntax than Java's legacy field contract.
  */
-import type { DiFieldMatcher } from './index.js';
+import type { GraphNode } from '../../../_shared/index.js';
+import type { DiResolver } from './types.js';
+/** Ephemeral Class-node property populated by Java's post-resolution Spring
+ * metadata hook. It is consumed in the same pipeline run before persistence. */
+export declare const SPRING_DI_INJECTION_SITES_PROPERTY = "springDiInjectionSites";
+/** Ephemeral Class-node property carrying Spring bean names / @Primary. */
+export declare const SPRING_DI_PROVIDER_PROPERTY = "springDiProvider";
+/** Marker placed on Property nodes whose richer AST-backed field fact was
+ * attached to the owning Class, suppressing the legacy collection fallback. */
+export declare const SPRING_DI_CAPTURED_FIELD_PROPERTY = "springDiCapturedField";
 /**
  * Parse a Spring DI collection field's raw declared type (verbatim source
  * text, generics preserved) and return the injected bean type name.
@@ -73,10 +84,21 @@ export declare function parseSpringCollectionType(rawDeclaredType: string): {
     collectionType: string;
     elementTypeName: string;
 } | null;
+/** Parse either a supported collect-all type or a standard single bean type. */
+export declare function parseSpringInjectionType(rawDeclaredType: string): {
+    targetTypeName: string;
+    cardinality: 'single' | 'collection';
+    displayType: string;
+} | null;
 /**
  * Match a `Property` node against Spring's collection-injection shape.
  *
  * Returns the parsed match (with a Spring-specific human-readable `reason`
  * payload) or `null` when the field is not container-injected.
  */
-export declare const springDiFieldMatcher: DiFieldMatcher;
+export declare const springDiFieldMatcher: (node: GraphNode) => {
+    elementTypeName: string;
+    reason: string;
+} | null;
+/** JVM/Spring resolver registered behind the framework-neutral DI seam. */
+export declare const springDiResolver: DiResolver;

package/dist/core/ingestion/di-extractors/spring.js

@@ -51,9 +51,11 @@
  *   between `<` and the element) are NOT stripped and fail closed —
  *   acceptable.
  *
- * Registered under `SupportedLanguages.Java` in `./index.ts` (`DI_MATCHERS`);
- * language routing is the registry's job, so the matcher itself never reads
- * `node.properties.language`.
+ * Registered for Java and Kotlin in `./index.ts` (`DI_RESOLVERS`); language
+ * routing is the registry's job, so the matcher itself never reads
+ * `node.properties.language`. Kotlin's AST-backed class metadata is the
+ * primary path because Kotlin Property extraction intentionally exposes less
+ * annotation/type syntax than Java's legacy field contract.
  */
 import { isDev } from '../utils/env.js';
 import { logger } from '../../logger.js';
@@ -76,6 +78,14 @@ const WILDCARD_SUPER_PREFIX = '? super ';
  *  parser accepts. Everything else (wildcards, arrays, comments, stray
  *  punctuation) fails closed. */
 const JAVA_TYPE_NAME_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/;
+/** Ephemeral Class-node property populated by Java's post-resolution Spring
+ * metadata hook. It is consumed in the same pipeline run before persistence. */
+export const SPRING_DI_INJECTION_SITES_PROPERTY = 'springDiInjectionSites';
+/** Ephemeral Class-node property carrying Spring bean names / @Primary. */
+export const SPRING_DI_PROVIDER_PROPERTY = 'springDiProvider';
+/** Marker placed on Property nodes whose richer AST-backed field fact was
+ * attached to the owning Class, suppressing the legacy collection fallback. */
+export const SPRING_DI_CAPTURED_FIELD_PROPERTY = 'springDiCapturedField';
 /**
  * Split a generic-argument list on TOP-LEVEL commas only, tracking `<`/`>`
  * bracket depth so nested generics (e.g. the `Pair<A,B>` key in
@@ -179,6 +189,21 @@ export function parseSpringCollectionType(rawDeclaredType) {
         return null;
     return { collectionType: wrapper, elementTypeName };
 }
+/** Parse either a supported collect-all type or a standard single bean type. */
+export function parseSpringInjectionType(rawDeclaredType) {
+    const collection = parseSpringCollectionType(rawDeclaredType);
+    if (collection !== null) {
+        return {
+            targetTypeName: collection.elementTypeName,
+            cardinality: 'collection',
+            displayType: `${collection.collectionType}<${collection.elementTypeName}>`,
+        };
+    }
+    const normalized = rawDeclaredType.replace(/\s+/g, '').trim();
+    if (!JAVA_TYPE_NAME_PATTERN.test(normalized))
+        return null;
+    return { targetTypeName: normalized, cardinality: 'single', displayType: normalized };
+}
 /**
  * Match a `Property` node against Spring's collection-injection shape.
  *
@@ -218,3 +243,62 @@ export const springDiFieldMatcher = (node) => {
         reason: `Spring DI: ${matchedAnnotation} ${parsed.collectionType}<${parsed.elementTypeName}>`,
     };
 };
+function isInjectionMatch(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const match = value;
+    const namedSelection = match.namedSelection;
+    return (typeof match.targetTypeName === 'string' &&
+        (match.cardinality === 'single' || match.cardinality === 'collection') &&
+        typeof match.reason === 'string' &&
+        (match.edgeSource === undefined ||
+            match.edgeSource === 'owner-class' ||
+            match.edgeSource === 'site') &&
+        (namedSelection === undefined ||
+            (typeof namedSelection === 'object' &&
+                namedSelection !== null &&
+                typeof namedSelection.name === 'string' &&
+                typeof namedSelection.reason === 'string' &&
+                (namedSelection.fallbackToType === undefined ||
+                    typeof namedSelection.fallbackToType === 'boolean'))));
+}
+function isProviderMatch(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const provider = value;
+    return (Array.isArray(provider.names) &&
+        provider.names.every((name) => typeof name === 'string') &&
+        (provider.providedTypeName === undefined || typeof provider.providedTypeName === 'string') &&
+        (provider.declaredByNodeId === undefined || typeof provider.declaredByNodeId === 'string') &&
+        (provider.preferenceReason === undefined || typeof provider.preferenceReason === 'string'));
+}
+/** JVM/Spring resolver registered behind the framework-neutral DI seam. */
+export const springDiResolver = {
+    matchInjectionSites(node) {
+        const matches = [];
+        // Preserve the existing Property-node collection contract for hand-built
+        // graphs and for compatibility with pre-#2414 extraction fixtures.
+        if (node.label === 'Property' && node.properties[SPRING_DI_CAPTURED_FIELD_PROPERTY] !== true) {
+            const field = springDiFieldMatcher(node);
+            if (field !== null) {
+                matches.push({
+                    targetTypeName: field.elementTypeName,
+                    cardinality: 'collection',
+                    reason: field.reason,
+                });
+            }
+        }
+        const attached = node.properties[SPRING_DI_INJECTION_SITES_PROPERTY];
+        if (Array.isArray(attached)) {
+            for (const candidate of attached) {
+                if (isInjectionMatch(candidate))
+                    matches.push(candidate);
+            }
+        }
+        return matches;
+    },
+    matchProvider(node) {
+        const attached = node.properties[SPRING_DI_PROVIDER_PROPERTY];
+        return isProviderMatch(attached) ? attached : null;
+    },
+};