gitnexus 1.6.0 → 1.6.1

package/dist/core/ingestion/binding-accumulator.d.ts

@@ -36,9 +36,12 @@
  * or (b) post-process worker-path entries through a follow-up resolution
  * pass after the main-thread `SymbolTable` is complete.
  *
- * **Lifecycle contract**: `append → finalize → consume → dispose`. See
- * `finalize()` and `dispose()` for the state machine. Disposal is
- * orthogonal to finalization: either order is legal.
+ * **Lifecycle contract**: single-use — `append* → finalize → consume → dispose`.
+ * After `dispose()` the accumulator is permanently dead: any mutating call
+ * (`appendFile`) throws, and read methods return empty/undefined as if the
+ * accumulator had never been appended to. The instance is not recyclable;
+ * construct a new one for a new pipeline run. Finalization and disposal are
+ * orthogonal state dimensions and may be invoked in either order.
  */
 export interface BindingEntry {
     readonly scope: string;
@@ -119,28 +122,30 @@ export declare class BindingAccumulator {
     finalize(): void;
     /**
      * Release the accumulator's heap footprint. Clears both internal storage
-     * maps and resets `_totalBindings` to zero. Idempotent and orthogonal to
-     * `finalize()` — calling `dispose()` does not change the finalized state.
+     * maps and resets `_totalBindings` to zero. Idempotent — calling twice
+     * is a no-op. Orthogonal to `finalize()` — calling `dispose()` does not
+     * change the finalized state.
      *
-     * Post-dispose contract: all read methods return empty/undefined state
-     * matching a never-appended-to accumulator. Specifically:
+     * **Single-use lifecycle.** This is a one-way terminal transition: the
+     * accumulator is not recyclable. Any subsequent `appendFile` call throws
+     * (`'BindingAccumulator: use after dispose'`), regardless of whether
+     * `finalize()` was called first. Post-dispose reads do not throw —
+     * they return empty/undefined state matching a never-appended-to
+     * accumulator:
      *   - `fileCount === 0`
      *   - `totalBindings === 0`
      *   - `files()` yields an empty iterator
      *   - `getFile(x)` returns `undefined` for all `x`
      *   - `fileScopeEntries(x)` returns `[]` for all `x`
+     *   - `fileScopeGet(x, y)` returns `undefined` for all `x, y`
      *   - `estimateMemoryBytes()` returns `0`
      *
-     * If `dispose()` is called **before** `finalize()`, subsequent `appendFile`
-     * calls succeed — the accumulator behaves like a fresh one. If called
-     * **after** `finalize()`, subsequent `appendFile` calls throw the existing
-     * "finalized" error.
-     *
-     * Lifecycle note: the pipeline disposes the accumulator after both Phase 9
-     * consumers (`processCallsFromExtracted`, `processAssignmentsFromExtracted`)
-     * and the ExportedTypeMap enrichment loop have completed, so the heap is
-     * released before Phase 14 (`runCrossFileBindingPropagation`) and
-     * `runGraphAnalysisPhases` begin their long-running work.
+     * Lifecycle note: the pipeline disposes the accumulator inside the
+     * `finally` of the `crossFile` phase, which is scheduled after every
+     * other accumulator consumer (Phase 9 call/assignment processing and
+     * the ExportedTypeMap enrichment loop). The dispose call therefore
+     * runs once, on both the happy path and the throw path of the
+     * crossFile phase.
      */
     dispose(): void;
     /** Get all bindings for a file, or undefined if the file is unknown. */

package/dist/core/ingestion/binding-accumulator.js

@@ -36,9 +36,12 @@
  * or (b) post-process worker-path entries through a follow-up resolution
  * pass after the main-thread `SymbolTable` is complete.
  *
- * **Lifecycle contract**: `append → finalize → consume → dispose`. See
- * `finalize()` and `dispose()` for the state machine. Disposal is
- * orthogonal to finalization: either order is legal.
+ * **Lifecycle contract**: single-use — `append* → finalize → consume → dispose`.
+ * After `dispose()` the accumulator is permanently dead: any mutating call
+ * (`appendFile`) throws, and read methods return empty/undefined as if the
+ * accumulator had never been appended to. The instance is not recyclable;
+ * construct a new one for a new pipeline run. Finalization and disposal are
+ * orthogonal state dimensions and may be invoked in either order.
  */
 /**
  * Merge file-scope bindings from a (finalized) `BindingAccumulator` into an
@@ -137,17 +140,16 @@ export class BindingAccumulator {
         if (this._finalized) {
             throw new Error('[BindingAccumulator] appendFile after finalize — no further appends allowed');
         }
+        // Single-use lifecycle: once disposed, the accumulator is dead. A
+        // post-dispose append almost always indicates a missed wiring step
+        // (the consumer is reading state that was supposed to be released),
+        // so convert the silent use-after-dispose into a loud failure.
+        if (this._disposed) {
+            throw new Error('BindingAccumulator: use after dispose');
+        }
         if (entries.length === 0) {
             return;
         }
-        // Contract consistency: if this accumulator was previously disposed
-        // without being finalized, `dispose()` is documented to leave it
-        // "behaving like a fresh one" for subsequent appends. Clear the
-        // `_disposed` flag here so the `disposed` getter tracks the actual
-        // live state, not a stale signal from the prior lifecycle cycle.
-        if (this._disposed) {
-            this._disposed = false;
-        }
         // Note on the file-scope-only invariant:
         // The accumulator does NOT reject function-scope entries at this
         // boundary. The narrowing contract is enforced by the two production
@@ -213,28 +215,30 @@ export class BindingAccumulator {
     }
     /**
      * Release the accumulator's heap footprint. Clears both internal storage
-     * maps and resets `_totalBindings` to zero. Idempotent and orthogonal to
-     * `finalize()` — calling `dispose()` does not change the finalized state.
+     * maps and resets `_totalBindings` to zero. Idempotent — calling twice
+     * is a no-op. Orthogonal to `finalize()` — calling `dispose()` does not
+     * change the finalized state.
      *
-     * Post-dispose contract: all read methods return empty/undefined state
-     * matching a never-appended-to accumulator. Specifically:
+     * **Single-use lifecycle.** This is a one-way terminal transition: the
+     * accumulator is not recyclable. Any subsequent `appendFile` call throws
+     * (`'BindingAccumulator: use after dispose'`), regardless of whether
+     * `finalize()` was called first. Post-dispose reads do not throw —
+     * they return empty/undefined state matching a never-appended-to
+     * accumulator:
      *   - `fileCount === 0`
      *   - `totalBindings === 0`
      *   - `files()` yields an empty iterator
      *   - `getFile(x)` returns `undefined` for all `x`
      *   - `fileScopeEntries(x)` returns `[]` for all `x`
+     *   - `fileScopeGet(x, y)` returns `undefined` for all `x, y`
      *   - `estimateMemoryBytes()` returns `0`
      *
-     * If `dispose()` is called **before** `finalize()`, subsequent `appendFile`
-     * calls succeed — the accumulator behaves like a fresh one. If called
-     * **after** `finalize()`, subsequent `appendFile` calls throw the existing
-     * "finalized" error.
-     *
-     * Lifecycle note: the pipeline disposes the accumulator after both Phase 9
-     * consumers (`processCallsFromExtracted`, `processAssignmentsFromExtracted`)
-     * and the ExportedTypeMap enrichment loop have completed, so the heap is
-     * released before Phase 14 (`runCrossFileBindingPropagation`) and
-     * `runGraphAnalysisPhases` begin their long-running work.
+     * Lifecycle note: the pipeline disposes the accumulator inside the
+     * `finally` of the `crossFile` phase, which is scheduled after every
+     * other accumulator consumer (Phase 9 call/assignment processing and
+     * the ExportedTypeMap enrichment loop). The dispose call therefore
+     * runs once, on both the happy path and the throw path of the
+     * crossFile phase.
      */
     dispose() {
         this._allByFile.clear();

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

@@ -50,5 +50,5 @@ export declare function isJclFile(filePath: string): boolean;
  * @param allPathSet - Set of all file paths in the repository
  * @returns Summary of what was extracted
  */
-export declare const processCobol: (graph: KnowledgeGraph, files: CobolFile[], allPathSet: Set<string>) => CobolProcessResult;
+export declare const processCobol: (graph: KnowledgeGraph, files: CobolFile[], allPathSet: ReadonlySet<string>) => CobolProcessResult;
 export {};

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

@@ -8,7 +8,7 @@ import { yieldToEventLoop } from './utils/event-loop.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { loadImportConfigs } from './language-config.js';
 import { buildSuffixIndex } from './import-resolvers/utils.js';
-const isDev = process.env.NODE_ENV === 'development';
+import { isDev } from './utils/env.js';
 /** Group files by provider (only those with implicit import wiring), then call each wirer
  *  with its own language's files. O(n) over files, O(1) per provider lookup. */
 function wireImplicitImports(files, importMap, addImportEdge, projectConfig) {

package/dist/core/ingestion/language-config.js

@@ -1,6 +1,6 @@
 import fs from 'fs/promises';
 import path from 'path';
-const isDev = process.env.NODE_ENV === 'development';
+import { isDev } from './utils/env.js';
 // ============================================================================
 // LANGUAGE-SPECIFIC CONFIG LOADERS
 // ============================================================================

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

@@ -66,6 +66,14 @@ interface LanguageProviderConfig {
      *  Called with only THIS language's files (pre-grouped by the processor).
      *  Default: undefined (no implicit imports). */
     readonly implicitImportWirer?: (languageFiles: string[], importMap: ReadonlyMap<string, ReadonlySet<string>>, addImportEdge: (src: string, target: string) => void, projectConfig: unknown) => void;
+    /** Resolve a container node during enclosing-owner tree walks.
+     *  Called when a CLASS_CONTAINER_TYPES node is found while walking up.
+     *  - Return a different SyntaxNode to remap the container (e.g., Ruby
+     *    singleton_class → enclosing class/module).
+     *  - Return null to skip this container and keep walking up.
+     *  - Omit (undefined) to use the container node as-is (default).
+     *  Default: undefined (no remapping). */
+    readonly resolveEnclosingOwner?: (node: SyntaxNode) => SyntaxNode | null;
     /** Resolve the enclosing function name + label from an AST ancestor node
      *  that is NOT a standard FUNCTION_NODE_TYPE.  For languages where the
      *  function body is a sibling of the signature (e.g. Dart: function_body ↔

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

@@ -100,6 +100,21 @@ export const rubyProvider = defineLanguage({
     importResolver: resolveRubyImport,
     callRouter: routeRubyCall,
     importSemantics: 'wildcard',
+    resolveEnclosingOwner(node) {
+        // Ruby singleton_class (class << self) should resolve to the enclosing
+        // class or module for owner/container resolution (HAS_METHOD edges, class IDs).
+        if (node.type === 'singleton_class') {
+            let ancestor = node.parent;
+            while (ancestor) {
+                if (ancestor.type === 'class' || ancestor.type === 'module') {
+                    return ancestor;
+                }
+                ancestor = ancestor.parent;
+            }
+            return null; // no enclosing class/module — skip
+        }
+        return node; // use as-is for all other container types
+    },
     fieldExtractor: createFieldExtractor(rubyFieldConfig),
     methodExtractor: createMethodExtractor({
         ...rubyMethodConfig,

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

@@ -10,7 +10,7 @@ interface MdFile {
     path: string;
     content: string;
 }
-export declare const processMarkdown: (graph: KnowledgeGraph, files: MdFile[], allPathSet: Set<string>) => {
+export declare const processMarkdown: (graph: KnowledgeGraph, files: MdFile[], allPathSet: ReadonlySet<string>) => {
     sections: number;
     links: number;
 };

package/dist/core/ingestion/method-extractors/configs/jvm.js

@@ -248,6 +248,7 @@ export const kotlinMethodConfig = {
     typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
     methodNodeTypes: ['function_declaration'],
     bodyNodeTypes: ['class_body'],
+    staticOwnerTypes: new Set(['companion_object', 'object_declaration']),
     extractName(node) {
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);

package/dist/core/ingestion/method-extractors/configs/ruby.js

@@ -202,6 +202,7 @@ export const rubyMethodConfig = {
     typeDeclarationNodes: ['class', 'module', 'singleton_class'],
     methodNodeTypes: ['method', 'singleton_method'],
     bodyNodeTypes: ['body_statement'],
+    staticOwnerTypes: new Set(['singleton_class']),
     extractOwnerName(node) {
         // singleton_class (class << self) inherits the enclosing class/module name
         if (node.type === 'singleton_class') {

package/dist/core/ingestion/method-extractors/generic.d.ts

@@ -1,5 +1,11 @@
 import type { MethodExtractor, MethodExtractionConfig } from '../method-types.js';
 /**
  * Create a MethodExtractor from a declarative config.
+ *
+ * @throws {Error} if `typeDeclarationNodes` contains a static-implying owner
+ *   type (companion_object / object_declaration / singleton_class) that is
+ *   not covered by `staticOwnerTypes`. The guard fires once per language at
+ *   provider construction to prevent silent `isStatic=false` regressions. See
+ *   `STATIC_IMPLYING_OWNER_TYPES` for the exact opt-out convention.
  */
 export declare function createMethodExtractor(config: MethodExtractionConfig): MethodExtractor;

package/dist/core/ingestion/method-extractors/generic.js

@@ -1,10 +1,53 @@
 // gitnexus/src/core/ingestion/method-extractors/generic.ts
-/** Owner node types where member functions are effectively static (JVM/Ruby semantics). */
-const STATIC_OWNER_TYPES = new Set(['companion_object', 'object_declaration', 'singleton_class']);
+/**
+ * Node types that imply static member semantics when they appear as the owner
+ * of a method (Kotlin companion objects, Kotlin top-level `object` declarations,
+ * Ruby `class << self` singleton classes). A config that lists any of these in
+ * `typeDeclarationNodes` MUST also include the same node type in
+ * `staticOwnerTypes` — otherwise methods inside these containers silently get
+ * `isStatic=false`, which is a correctness bug that previously only surfaced
+ * at analysis time on large repos.
+ *
+ * Opt-out: a config that sets `staticOwnerTypes: new Set()` (explicit empty
+ * set) signals "I handle static-ness entirely via isStatic()" and is exempt
+ * from the guard.
+ */
+const STATIC_IMPLYING_OWNER_TYPES = new Set([
+    'companion_object',
+    'object_declaration',
+    'singleton_class',
+]);
 /**
  * Create a MethodExtractor from a declarative config.
+ *
+ * @throws {Error} if `typeDeclarationNodes` contains a static-implying owner
+ *   type (companion_object / object_declaration / singleton_class) that is
+ *   not covered by `staticOwnerTypes`. The guard fires once per language at
+ *   provider construction to prevent silent `isStatic=false` regressions. See
+ *   `STATIC_IMPLYING_OWNER_TYPES` for the exact opt-out convention.
  */
 export function createMethodExtractor(config) {
+    // Runtime invariant: each static-implying container type declared in
+    // typeDeclarationNodes must be covered by staticOwnerTypes. An explicit
+    // empty Set is treated as intentional opt-out.
+    if (config.staticOwnerTypes === undefined) {
+        const missing = config.typeDeclarationNodes.filter((t) => STATIC_IMPLYING_OWNER_TYPES.has(t));
+        if (missing.length > 0) {
+            throw new Error(`[MethodExtractionConfig:${config.language}] typeDeclarationNodes includes static-implying owner type(s) ` +
+                `${JSON.stringify(missing)} but staticOwnerTypes is not set. Add ` +
+                `'staticOwnerTypes: new Set([${missing.map((t) => `'${t}'`).join(', ')}])' ` +
+                `to the config, or set 'staticOwnerTypes: new Set()' to opt out explicitly.`);
+        }
+    }
+    else {
+        const missing = config.typeDeclarationNodes.filter((t) => STATIC_IMPLYING_OWNER_TYPES.has(t) && !config.staticOwnerTypes.has(t));
+        // Explicit empty Set is the opt-out signal; don't second-guess it.
+        if (missing.length > 0 && config.staticOwnerTypes.size > 0) {
+            throw new Error(`[MethodExtractionConfig:${config.language}] typeDeclarationNodes includes static-implying owner type(s) ` +
+                `${JSON.stringify(missing)} that are missing from staticOwnerTypes. ` +
+                `Either add them to staticOwnerTypes, or set 'staticOwnerTypes: new Set()' to opt out explicitly.`);
+        }
+    }
     const typeDeclarationSet = new Set(config.typeDeclarationNodes);
     const methodNodeSet = new Set(config.methodNodeTypes);
     const bodyNodeSet = new Set(config.bodyNodeTypes);
@@ -137,8 +180,9 @@ function buildMethod(node, ownerNode, context, config) {
     // Domain invariant: abstract methods cannot be final
     if (isAbstract)
         isFinal = false;
-    // companion_object / object_declaration members are effectively static on JVM
-    const isStatic = STATIC_OWNER_TYPES.has(ownerNode.type) || config.isStatic(node);
+    // Static-owner detection is config-driven: each language declares which
+    // container node types imply static (e.g. Ruby singleton_class, Kotlin companion_object).
+    const isStatic = (config.staticOwnerTypes?.has(ownerNode.type) ?? false) || config.isStatic(node);
     return {
         name,
         receiverType: config.extractReceiverType?.(node) ?? null,

package/dist/core/ingestion/method-types.d.ts

@@ -73,6 +73,10 @@ export interface MethodExtractionConfig {
     isAsync?: (node: SyntaxNode) => boolean;
     isPartial?: (node: SyntaxNode) => boolean;
     isConst?: (node: SyntaxNode) => boolean;
+    /** Owner node types where member functions are effectively static (e.g.
+     *  Ruby singleton_class, Kotlin companion_object / object_declaration).
+     *  When the ownerNode matches one of these types, isStatic is forced true. */
+    staticOwnerTypes?: ReadonlySet<string>;
     /** Resolve the owner name from a standalone method node (e.g. Go receiver type). */
     extractOwnerName?: (node: SyntaxNode) => string | undefined;
     /** Extract a primary constructor from the owner node itself (e.g. C# 12 class Point(int x, int y)). */

package/dist/core/ingestion/model/resolve.js

@@ -47,63 +47,118 @@ function gatherAncestors(classId, parentMap) {
 export function c3Linearize(classId, parentMap, cache, inProgress) {
     if (cache.has(classId))
         return cache.get(classId);
-    // Cycle detection: if we're already computing this class, the hierarchy is cyclic
+    // Iterative C3 linearization using an explicit work stack. The recursive
+    // version overflows the call stack on deep class hierarchies (10K+
+    // levels in large Android/Java codebases).
+    //
+    // Strategy: maintain a stack of { classId, phase } frames. Each frame
+    // goes through two phases:
+    //   ENTER (0) – check cache / cycle, push parent frames to compute first
+    //   MERGE (1) – all parent linearizations are cached, merge them C3-style
     const visiting = inProgress ?? new Set();
-    if (visiting.has(classId)) {
-        cache.set(classId, null);
-        return null;
-    }
-    visiting.add(classId);
-    const directParents = parentMap.get(classId);
-    if (!directParents || directParents.length === 0) {
-        visiting.delete(classId);
-        cache.set(classId, []);
-        return [];
-    }
-    // Compute linearization for each parent first
-    const parentLinearizations = [];
-    for (const pid of directParents) {
-        const pLin = c3Linearize(pid, parentMap, cache, visiting);
-        if (pLin === null) {
-            visiting.delete(classId);
-            cache.set(classId, null);
-            return null;
-        }
-        parentLinearizations.push([pid, ...pLin]);
-    }
-    // Add the direct parents list as the final sequence
-    const sequences = [...parentLinearizations, [...directParents]];
-    const result = [];
-    while (sequences.some((s) => s.length > 0)) {
-        // Find a good head: one that doesn't appear in the tail of any other sequence
-        let head = null;
-        for (const seq of sequences) {
-            if (seq.length === 0)
+    const ENTER = 0;
+    const MERGE = 1;
+    const stack = [{ id: classId, phase: ENTER }];
+    while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        if (frame.phase === ENTER) {
+            // ── ENTER phase ─────────────────────────────────────────────
+            if (cache.has(frame.id)) {
+                stack.pop();
+                continue;
+            }
+            if (visiting.has(frame.id)) {
+                // Cycle detected
+                cache.set(frame.id, null);
+                stack.pop();
+                continue;
+            }
+            visiting.add(frame.id);
+            const directParents = parentMap.get(frame.id);
+            if (!directParents || directParents.length === 0) {
+                visiting.delete(frame.id);
+                cache.set(frame.id, []);
+                stack.pop();
+                continue;
+            }
+            // Switch to MERGE phase and push parents that still need computing
+            frame.phase = MERGE;
+            let allParentsCached = true;
+            for (let i = directParents.length - 1; i >= 0; i--) {
+                const pid = directParents[i];
+                if (!cache.has(pid)) {
+                    stack.push({ id: pid, phase: ENTER });
+                    allParentsCached = false;
+                }
+            }
+            // If all parents are already cached, proceed directly to the MERGE
+            // phase below (frame.phase is already MERGE, frame is at stack top).
+            // Otherwise, loop back to process the newly-pushed parent frames first.
+            if (!allParentsCached) {
                 continue;
-            const candidate = seq[0];
-            const inTail = sequences.some((other) => other.length > 1 && other.indexOf(candidate, 1) !== -1);
-            if (!inTail) {
-                head = candidate;
+            }
+        }
+        // ── MERGE phase ───────────────────────────────────────────────
+        // directParents is guaranteed non-empty here — the ENTER phase already
+        // handles the empty-parents case and pops the frame before switching
+        // to MERGE.
+        stack.pop();
+        const directParents = parentMap.get(frame.id);
+        // Build parent linearizations from cache
+        const parentLinearizations = [];
+        let failed = false;
+        for (const pid of directParents) {
+            const pLin = cache.get(pid);
+            if (pLin === undefined) {
+                // Should not happen if phases are ordered correctly, but guard anyway
+                failed = true;
+                break;
+            }
+            if (pLin === null) {
+                // Parent linearization failed (cycle or inconsistent)
+                failed = true;
                 break;
             }
+            parentLinearizations.push([pid, ...pLin]);
         }
-        if (head === null) {
-            // Inconsistent hierarchy
-            visiting.delete(classId);
-            cache.set(classId, null);
-            return null;
+        if (failed) {
+            visiting.delete(frame.id);
+            cache.set(frame.id, null);
+            continue;
         }
-        result.push(head);
-        // Remove the chosen head from all sequences
-        for (const seq of sequences) {
-            if (seq.length > 0 && seq[0] === head) {
-                seq.shift();
+        // Add the direct parents list as the final sequence
+        const sequences = [...parentLinearizations, [...directParents]];
+        const result = [];
+        let inconsistent = false;
+        while (sequences.some((s) => s.length > 0)) {
+            // Find a good head: one that doesn't appear in the tail of any other sequence
+            let head = null;
+            for (const seq of sequences) {
+                if (seq.length === 0)
+                    continue;
+                const candidate = seq[0];
+                const inTail = sequences.some((other) => other.length > 1 && other.indexOf(candidate, 1) !== -1);
+                if (!inTail) {
+                    head = candidate;
+                    break;
+                }
+            }
+            if (head === null) {
+                inconsistent = true;
+                break;
+            }
+            result.push(head);
+            // Remove the chosen head from all sequences
+            for (const seq of sequences) {
+                if (seq.length > 0 && seq[0] === head) {
+                    seq.shift();
+                }
             }
         }
+        visiting.delete(frame.id);
+        cache.set(frame.id, inconsistent ? null : result);
     }
-    visiting.delete(classId);
-    cache.set(classId, result);
-    return result;
+    return cache.get(classId) ?? null;
 }
 // `gatherAncestors` is exported so mro-processor.ts can reuse the same
 // BFS traversal for graph-level MRO emission.

package/dist/core/ingestion/model/semantic-model.d.ts

@@ -7,7 +7,7 @@
  *   - A nested SymbolTable (file + callable name indexes) wrapped so
  *     that `add()` fans out into the registries via the dispatch table
  *
- * ## DAG direction
+ * ## Dependency direction
  *
  *     gitnexus-shared (NodeLabel)             — leaf
  *          ↑

package/dist/core/ingestion/model/semantic-model.js

@@ -7,7 +7,7 @@
  *   - A nested SymbolTable (file + callable name indexes) wrapped so
  *     that `add()` fans out into the registries via the dispatch table
  *
- * ## DAG direction
+ * ## Dependency direction
  *
  *     gitnexus-shared (NodeLabel)             — leaf
  *          ↑

package/dist/core/ingestion/model/symbol-table.d.ts

@@ -1,8 +1,8 @@
 /**
  * Symbol Table — file-indexed + callable-name symbol storage.
  *
- * This module is a PURE LEAF in the ingestion DAG. It owns two orthogonal
- * O(1) indexes:
+ * This module is a PURE LEAF in the ingestion dependency hierarchy. It owns
+ * two orthogonal O(1) indexes:
  *
  *   1. fileIndex      — Map<filePath, Map<name, SymbolDefinition[]>>
  *                       for same-file lookups (Tier 1 resolution)
@@ -10,12 +10,12 @@
  *                       for name-keyed callable lookups (Tier 3 widen)
  *
  * SymbolTable deliberately knows NOTHING about the owner-scoped registries
- * (types, methods, fields) that sit above it in the DAG. Those registries
- * live in `model/` and depend on SymbolTable, not the other way around.
- * {@link createSemanticModel} composes this pure SymbolTable with the
+ * (types, methods, fields) that sit above it in the dependency graph. Those
+ * registries live in `model/` and depend on SymbolTable, not the other way
+ * around. {@link createSemanticModel} composes this pure SymbolTable with the
  * registries and wraps `add()` to fan out registrations into both layers.
  *
- * DAG direction (strictly enforced):
+ * Dependency direction (strictly enforced):
  *
  *     gitnexus-shared (NodeLabel)       — leaf type
  *          ↑
@@ -31,7 +31,7 @@
  *
  * No arrow ever points downward from this file. If you are tempted to
  * import from `./model/` here, you are going the wrong way — move the
- * logic up the DAG instead.
+ * logic up the dependency chain instead.
  */
 import type { NodeLabel } from '../../../_shared/index.js';
 /**

package/dist/core/ingestion/model/symbol-table.js

@@ -1,8 +1,8 @@
 /**
  * Symbol Table — file-indexed + callable-name symbol storage.
  *
- * This module is a PURE LEAF in the ingestion DAG. It owns two orthogonal
- * O(1) indexes:
+ * This module is a PURE LEAF in the ingestion dependency hierarchy. It owns
+ * two orthogonal O(1) indexes:
  *
  *   1. fileIndex      — Map<filePath, Map<name, SymbolDefinition[]>>
  *                       for same-file lookups (Tier 1 resolution)
@@ -10,12 +10,12 @@
  *                       for name-keyed callable lookups (Tier 3 widen)
  *
  * SymbolTable deliberately knows NOTHING about the owner-scoped registries
- * (types, methods, fields) that sit above it in the DAG. Those registries
- * live in `model/` and depend on SymbolTable, not the other way around.
- * {@link createSemanticModel} composes this pure SymbolTable with the
+ * (types, methods, fields) that sit above it in the dependency graph. Those
+ * registries live in `model/` and depend on SymbolTable, not the other way
+ * around. {@link createSemanticModel} composes this pure SymbolTable with the
  * registries and wraps `add()` to fan out registrations into both layers.
  *
- * DAG direction (strictly enforced):
+ * Dependency direction (strictly enforced):
  *
  *     gitnexus-shared (NodeLabel)       — leaf type
  *          ↑
@@ -31,7 +31,7 @@
  *
  * No arrow ever points downward from this file. If you are tempted to
  * import from `./model/` here, you are going the wrong way — move the
- * logic up the DAG instead.
+ * logic up the dependency chain instead.
  */
 /**
  * Class-like NodeLabels — used for qualifiedName fallback inside

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

@@ -1,7 +1,7 @@
 /**
  * MRO (Method Resolution Order) Processor
  *
- * Walks the inheritance DAG (EXTENDS/IMPLEMENTS edges), collects methods from
+ * Walks the inheritance graph (EXTENDS/IMPLEMENTS edges), collects methods from
  * each ancestor via HAS_METHOD edges, detects method-name collisions across
  * parents, and applies language-specific resolution rules to emit METHOD_OVERRIDES edges.
  *

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

@@ -1,7 +1,7 @@
 /**
  * MRO (Method Resolution Order) Processor
  *
- * Walks the inheritance DAG (EXTENDS/IMPLEMENTS edges), collects methods from
+ * Walks the inheritance graph (EXTENDS/IMPLEMENTS edges), collects methods from
  * each ancestor via HAS_METHOD edges, detects method-name collisions across
  * parents, and applies language-specific resolution rules to emit METHOD_OVERRIDES edges.
  *