gitnexus 1.6.4-rc.3 → 1.6.4-rc.4

package/dist/_shared/scope-resolution/types.d.ts

@@ -10,8 +10,16 @@
  * Lifecycle contract (RFC §2.8): scopes are **constructed during extraction,
  * linked during finalize, immutable after finalize**. All fields are
  * `readonly` at the type level; `Object.freeze` is applied at runtime in dev
- * builds. `ReferenceIndex` is the sole structure populated after freeze — by
- * resolution, before emission.
+ * builds.
+ *
+ * Two structures are populated after freeze:
+ *   1. `ReferenceIndex` — by resolution, before emission.
+ *   2. `ScopeResolutionIndexes.bindingAugmentations` — the dedicated
+ *      append-only post-finalize binding channel (e.g. C# same-namespace
+ *      cross-file fanout). The companion `indexes.bindings` is the
+ *      finalize-output channel and is deep-frozen by `materializeBindings`;
+ *      walkers consult both via `lookupBindingsAt`. See `ScopeResolver`
+ *      Invariant I8 for the full lifecycle contract.
  */
 import type { NodeLabel } from '../graph/types.js';
 import type { SymbolDefinition } from './symbol-definition.js';

package/dist/_shared/scope-resolution/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI/D,4FAA4F;AAC5F,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B,0DAA0D;AAC1D,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC;AAE3B,2DAA2D;AAC3D,MAAM,MAAM,SAAS,GACjB,QAAQ,GACR,WAAW,GACX,OAAO,GACP,UAAU,GACV,OAAO,GACP,YAAY,CAAC;AAIjB,qFAAqF;AACrF,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAI7D;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY;AACtB;;;;;;;GAOG;AACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AACH;;;;;;GAMG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AACH;;;;;;;;;;GAUG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,wFAAwF;IACxF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AACH;;;;;;;;;;GAUG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iCAAiC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uFAAuF;IACvF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AACH;;;;;;;;;;GAUG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AACH;;;;;;;;;GASG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iFAAiF;IACjF,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AACH;;;;;;;;;;;;;;;;GAgBG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AACH;;;;;;;;;;GAUG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEN;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;CACpC;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC;AAMrC;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,OAAO,GAAG,KAAK,GAAG,SAAS,CAAC;CAC1C;AAED,4DAA4D;AAC5D,MAAM,WAAW,QAAQ;IACvB,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAID;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,2DAA2D;IAC3D,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,wEAAwE;IACxE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;IAC7B,QAAQ,CAAC,IAAI,EACT,OAAO,GACP,OAAO,GACP,WAAW,GACX,mBAAmB,GACnB,UAAU,GACV,oBAAoB,GACpB,kBAAkB,GAClB,aAAa,CAAC;IAClB,oFAAoF;IACpF,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC;CACpC;AAID;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC;IAC5E,sGAAsG;IACtG,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B;AAID;;;;;;;;GAQG;AACH,MAAM,WAAW,OAAO;IACtB,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,6FAA6F;IAC7F,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,MAAM,EACX,YAAY,GACZ,sBAAsB,GACtB,mBAAmB,GACnB,MAAM,GACN,qBAAqB,GACrB,sBAAsB,GACtB,qBAAqB,CAAC;IAC1B,iGAAiG;IACjG,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CACxC;AAID;;;;;GAKG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,mFAAmF;IACnF,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC,CAAC;IAE9D,yFAAyF;IACzF,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAEhD;;kDAE8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IAExC,8FAA8F;IAC9F,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrD;AAID;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EACT,OAAO,GACP,aAAa,GACb,QAAQ,GACR,cAAc,GACd,aAAa,GACb,YAAY,GACZ,aAAa,GACb,aAAa,GACb,kBAAkB,GAClB,2BAA2B,CAAC;IAChC,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,EAAE,gBAAgB,CAAC;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACjD,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CACpC;AAID;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,gBAAgB,GAAG,UAAU,GAAG,YAAY,CAAC;IACxF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAClD;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC,CAAC;IACnE,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC,CAAC;CAChE;AAID;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC;AAE1C;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,aAAa,EAAE,SAAS,SAAS,EAAE,CAAC;IAC7C,wDAAwD;IACxD,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;IACzC,QAAQ,CAAC,sBAAsB,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC5D,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;gFAE4E;IAC5E,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACvD"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"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"}

package/dist/_shared/scope-resolution/types.js

@@ -10,8 +10,16 @@
  * Lifecycle contract (RFC §2.8): scopes are **constructed during extraction,
  * linked during finalize, immutable after finalize**. All fields are
  * `readonly` at the type level; `Object.freeze` is applied at runtime in dev
- * builds. `ReferenceIndex` is the sole structure populated after freeze — by
- * resolution, before emission.
+ * builds.
+ *
+ * Two structures are populated after freeze:
+ *   1. `ReferenceIndex` — by resolution, before emission.
+ *   2. `ScopeResolutionIndexes.bindingAugmentations` — the dedicated
+ *      append-only post-finalize binding channel (e.g. C# same-namespace
+ *      cross-file fanout). The companion `indexes.bindings` is the
+ *      finalize-output channel and is deep-frozen by `materializeBindings`;
+ *      walkers consult both via `lookupBindingsAt`. See `ScopeResolver`
+ *      Invariant I8 for the full lifecycle contract.
  */
 export {};
 //# sourceMappingURL=types.js.map

package/dist/_shared/scope-resolution/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG"}

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

@@ -613,7 +613,7 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
         if (!tree) {
             try {
                 tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                    bufferSize: getTreeSitterBufferSize(file.content),
                 });
             }
             catch (parseError) {
@@ -2591,7 +2591,7 @@ export const extractFetchCallsFromFiles = async (files, astCache) => {
         if (!tree) {
             try {
                 tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                    bufferSize: getTreeSitterBufferSize(file.content),
                 });
             }
             catch {

package/dist/core/ingestion/constants.d.ts

@@ -10,7 +10,8 @@ export declare const TREE_SITTER_BUFFER_SIZE: number;
 export declare const TREE_SITTER_MAX_BUFFER: number;
 /**
  * Compute adaptive buffer size for tree-sitter parsing.
- * Uses 2× file size, clamped between 512 KB and 32 MB.
- * Previous 256 KB fixed limit silently skipped files > ~200 KB (e.g., imgui.h at 411 KB).
+ * Uses 2x UTF-8 byte size, clamped between 512 KB and 32 MB.
+ * Keeps tree-sitter's byte-sized buffer above large ASCII and multibyte sources.
  */
-export declare const getTreeSitterBufferSize: (contentLength: number) => number;
+export declare const getTreeSitterContentByteLength: (sourceText: string) => number;
+export declare const getTreeSitterBufferSize: (sourceText: string) => number;

package/dist/core/ingestion/constants.js

@@ -1,3 +1,4 @@
+import { Buffer } from 'node:buffer';
 /**
  * Default minimum buffer size for tree-sitter parsing (512 KB).
  * tree-sitter requires bufferSize >= file size in bytes.
@@ -10,7 +11,11 @@ export const TREE_SITTER_BUFFER_SIZE = 512 * 1024;
 export const TREE_SITTER_MAX_BUFFER = 32 * 1024 * 1024;
 /**
  * Compute adaptive buffer size for tree-sitter parsing.
- * Uses 2× file size, clamped between 512 KB and 32 MB.
- * Previous 256 KB fixed limit silently skipped files > ~200 KB (e.g., imgui.h at 411 KB).
+ * Uses 2x UTF-8 byte size, clamped between 512 KB and 32 MB.
+ * Keeps tree-sitter's byte-sized buffer above large ASCII and multibyte sources.
  */
-export const getTreeSitterBufferSize = (contentLength) => Math.min(Math.max(contentLength * 2, TREE_SITTER_BUFFER_SIZE), TREE_SITTER_MAX_BUFFER);
+export const getTreeSitterContentByteLength = (sourceText) => Buffer.byteLength(sourceText, 'utf8');
+export const getTreeSitterBufferSize = (sourceText) => {
+    const byteLength = getTreeSitterContentByteLength(sourceText);
+    return Math.min(Math.max(byteLength * 2, TREE_SITTER_BUFFER_SIZE), TREE_SITTER_MAX_BUFFER);
+};

package/dist/core/ingestion/finalize-orchestrator.js

@@ -91,6 +91,11 @@ export function finalizeScopeModel(parsedFiles, options = {}) {
         methodDispatch,
         imports: finalizeOut.imports,
         bindings: finalizeOut.bindings,
+        // Empty post-finalize augmentation channel. Populated (if at all)
+        // by language hooks like `populateCsharpNamespaceSiblings` running
+        // AFTER `finalizeScopeModel` returns, before `resolveReferenceSites`
+        // consumes the bundle. Most languages leave it empty.
+        bindingAugmentations: new Map(),
         referenceSites: Object.freeze([...allReferenceSites]),
         sccs: finalizeOut.sccs,
         stats: finalizeOut.stats,

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

@@ -148,7 +148,7 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
             // Use larger bufferSize for files > 32KB
             try {
                 tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                    bufferSize: getTreeSitterBufferSize(file.content),
                 });
             }
             catch (parseError) {
@@ -295,7 +295,7 @@ export async function extractExtractedHeritageFromFiles(files, astCache) {
         if (!tree) {
             try {
                 tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                    bufferSize: getTreeSitterBufferSize(file.content),
                 });
             }
             catch {

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

@@ -242,7 +242,7 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
         if (!tree) {
             try {
                 tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                    bufferSize: getTreeSitterBufferSize(file.content),
                 });
             }
             catch (parseError) {

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

@@ -21,6 +21,7 @@ import { computeCsharpArityMetadata } from './arity-metadata.js';
 import { synthesizeCsharpReceiverBinding } from './receiver-binding.js';
 import { getCsharpParser, getCsharpScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
+import { getTreeSitterBufferSize } from '../../constants.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = [
     '@declaration.method',
@@ -43,7 +44,9 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
     // the LanguageProvider contract layer; cast here at the use site.
     let tree = cachedTree;
     if (tree === undefined) {
-        tree = getCsharpParser().parse(sourceText);
+        tree = getCsharpParser().parse(sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(sourceText),
+        });
         recordCacheMiss();
     }
     else {

package/dist/core/ingestion/languages/csharp/namespace-siblings.d.ts

@@ -11,17 +11,18 @@
  * field-chain resolution fails at `findClassBindingInScope('User')`
  * in the Service.cs scope chain.
  *
- * Implementation: after the finalize pass populates `indexes.bindings`
- * (from explicit `using` directives), walk each file's tree-sitter
- * AST for `namespace_declaration` / `file_scoped_namespace_declaration`
- * and `using_directive` nodes. The orchestrator hands us its
- * `treeCache` so files already parsed by `extractParsedFile` are
- * re-used instead of re-parsed — `ParsedFile`'s underlying tree is
- * the single source of truth. Group classes by namespace, and inject
- * cross-file sibling classes into each Namespace scope's finalized
- * bindings with `origin: 'namespace'` — a tier below `local` so a
- * local declaration still shadows a cross-file sibling with the same
- * name.
+ * Implementation: after the finalize pass populates immutable
+ * `indexes.bindings` (from explicit `using` directives), walk each
+ * file's tree-sitter AST for `namespace_declaration` /
+ * `file_scoped_namespace_declaration` and `using_directive` nodes.
+ * The orchestrator hands us its `treeCache` so files already parsed
+ * by `extractParsedFile` are re-used instead of re-parsed —
+ * `ParsedFile`'s underlying tree is the single source of truth.
+ * Group classes by namespace, and append cross-file sibling classes
+ * into each Namespace scope's `bindingAugmentations` bucket with
+ * `origin: 'namespace'`. Finalized bindings remain first in
+ * `lookupBindingsAt`, and local lexical `Scope.bindings` remains the
+ * first-tier shadowing channel.
  *
  * The tree-sitter walk is authoritative: it sees `global using static`,
  * aliased `using static X = Y.Z;`, attributed namespace declarations,
@@ -42,8 +43,8 @@ export interface CsharpSiblingInputs {
     };
 }
 /**
- * Mutate `indexes.bindings` in-place, adding cross-file sibling class
- * defs to each Namespace scope. Class-like defs (Class / Interface /
+ * Append cross-file sibling class defs to each Namespace scope's
+ * `bindingAugmentations` bucket. Class-like defs (Class / Interface /
  * Struct / Record / Enum) are visible cross-file; method / field
  * members are not.
  */

package/dist/core/ingestion/languages/csharp/namespace-siblings.js

@@ -11,17 +11,18 @@
  * field-chain resolution fails at `findClassBindingInScope('User')`
  * in the Service.cs scope chain.
  *
- * Implementation: after the finalize pass populates `indexes.bindings`
- * (from explicit `using` directives), walk each file's tree-sitter
- * AST for `namespace_declaration` / `file_scoped_namespace_declaration`
- * and `using_directive` nodes. The orchestrator hands us its
- * `treeCache` so files already parsed by `extractParsedFile` are
- * re-used instead of re-parsed — `ParsedFile`'s underlying tree is
- * the single source of truth. Group classes by namespace, and inject
- * cross-file sibling classes into each Namespace scope's finalized
- * bindings with `origin: 'namespace'` — a tier below `local` so a
- * local declaration still shadows a cross-file sibling with the same
- * name.
+ * Implementation: after the finalize pass populates immutable
+ * `indexes.bindings` (from explicit `using` directives), walk each
+ * file's tree-sitter AST for `namespace_declaration` /
+ * `file_scoped_namespace_declaration` and `using_directive` nodes.
+ * The orchestrator hands us its `treeCache` so files already parsed
+ * by `extractParsedFile` are re-used instead of re-parsed —
+ * `ParsedFile`'s underlying tree is the single source of truth.
+ * Group classes by namespace, and append cross-file sibling classes
+ * into each Namespace scope's `bindingAugmentations` bucket with
+ * `origin: 'namespace'`. Finalized bindings remain first in
+ * `lookupBindingsAt`, and local lexical `Scope.bindings` remains the
+ * first-tier shadowing channel.
  *
  * The tree-sitter walk is authoritative: it sees `global using static`,
  * aliased `using static X = Y.Z;`, attributed namespace declarations,
@@ -30,13 +31,17 @@
  * coincidences).
  */
 import { getCsharpParser } from './query.js';
+import { getTreeSitterBufferSize } from '../../constants.js';
 /** Build a structural view of a C# file by walking the tree-sitter
  *  AST. Prefers `cachedTree` (handed in via `treeCache`) so we don't
  *  re-parse files the orchestrator already parsed for `extractParsedFile`;
  *  falls back to a fresh parse on cache miss. Parser singleton is
  *  shared across calls. */
 function extractFileStructure(content, cachedTree) {
-    const tree = cachedTree ?? getCsharpParser().parse(content);
+    const tree = cachedTree ??
+        getCsharpParser().parse(content, undefined, {
+            bufferSize: getTreeSitterBufferSize(content),
+        });
     const namespaces = [];
     const usingStaticPaths = [];
     const visit = (node) => {
@@ -81,8 +86,8 @@ function extractFileStructure(content, cachedTree) {
     return { namespaces, usingStaticPaths };
 }
 /**
- * Mutate `indexes.bindings` in-place, adding cross-file sibling class
- * defs to each Namespace scope. Class-like defs (Class / Interface /
+ * Append cross-file sibling class defs to each Namespace scope's
+ * `bindingAugmentations` bucket. Class-like defs (Class / Interface /
  * Struct / Record / Enum) are visible cross-file; method / field
  * members are not.
  */
@@ -161,12 +166,15 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
             }
         }
     }
-    // Inject cross-file siblings into each namespace scope's finalized
-    // bindings. `indexes.bindings` is typed `ReadonlyMap<ScopeId, ...>`
-    // but is a plain Map at runtime; mutating here is the established
-    // pattern (see `propagateImportedReturnTypes` which does the same
-    // for module-scope typeBindings).
-    const finalized = indexes.bindings;
+    // Inject cross-file siblings into each namespace scope's
+    // post-finalize augmentation channel (per I8). The
+    // `indexes.bindingAugmentations` map is the dedicated mutable
+    // append-only buffer for post-finalize hooks: inner `BindingRef[]`
+    // arrays here are NEVER frozen (unlike `indexes.bindings`, which
+    // `materializeBindings` freezes). Walkers consult both channels
+    // via `lookupBindingsAt`; we never need to consult or mutate
+    // `indexes.bindings`.
+    const augmentations = indexes.bindingAugmentations;
     // Cross-namespace type-binding propagation: for each file, mirror
     // method return-type bindings from same-namespace sibling files and
     // from files in namespaces the importer `using`s, into the
@@ -268,18 +276,14 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 const simpleName = mq.includes('.') ? mq.slice(mq.lastIndexOf('.') + 1) : mq;
                 if (simpleName === '')
                     continue;
-                // Add to `indexes.bindings[moduleScope]` so
-                // `findCallableBindingInScope` picks it up.
-                let scopeBindings = finalized.get(moduleScope.id);
-                if (scopeBindings === undefined) {
-                    scopeBindings = new Map();
-                    finalized.set(moduleScope.id, scopeBindings);
-                }
-                const existing = scopeBindings.get(simpleName) ?? [];
-                if (existing.some((b) => b.def.nodeId === memberDef.nodeId))
+                // Append to the augmentation bucket for the importer's module
+                // scope. `findCallableBindingInScope` reads via
+                // `lookupBindingsAt`, which fans out across `bindings` +
+                // `bindingAugmentations`.
+                const bucketArr = getAugmentationBucket(augmentations, moduleScope.id, simpleName);
+                if (bucketArr.some((b) => b.def.nodeId === memberDef.nodeId))
                     continue;
-                existing.push({ def: memberDef, origin: 'import' });
-                scopeBindings.set(simpleName, existing);
+                bucketArr.push({ def: memberDef, origin: 'import' });
             }
         }
     }
@@ -310,16 +314,10 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 const simpleName = q.includes('.') ? q.slice(q.lastIndexOf('.') + 1) : q;
                 if (simpleName === '')
                     continue;
-                let scopeBindings = finalized.get(moduleScope.id);
-                if (scopeBindings === undefined) {
-                    scopeBindings = new Map();
-                    finalized.set(moduleScope.id, scopeBindings);
-                }
-                const existing = scopeBindings.get(simpleName) ?? [];
-                if (existing.some((b) => b.def.nodeId === def.nodeId))
+                const bucketArr = getAugmentationBucket(augmentations, moduleScope.id, simpleName);
+                if (bucketArr.some((b) => b.def.nodeId === def.nodeId))
                     continue;
-                existing.push({ def, origin: 'namespace' });
-                scopeBindings.set(simpleName, existing);
+                bucketArr.push({ def, origin: 'namespace' });
             }
         }
     }
@@ -339,11 +337,6 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
             defsByName.set(key, arr);
         }
         for (const { scopeId, filePath } of bucket.scopes) {
-            let scopeBindings = finalized.get(scopeId);
-            if (scopeBindings === undefined) {
-                scopeBindings = new Map();
-                finalized.set(scopeId, scopeBindings);
-            }
             for (const [name, defs] of defsByName) {
                 // Skip names already present locally — `origin: 'local'` in
                 // scope.bindings would naturally shadow the cross-file
@@ -351,20 +344,39 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 const local = bucket.scopes.find((s) => s.filePath === filePath)?.scope.bindings.get(name);
                 if (local !== undefined && local.some((b) => b.origin === 'local'))
                     continue;
-                const existing = scopeBindings.get(name) ?? [];
+                let bucketArr = null;
                 for (const def of defs) {
                     if (def.filePath === filePath)
                         continue; // don't self-reference
-                    if (existing.some((b) => b.def.nodeId === def.nodeId))
+                    if (bucketArr === null)
+                        bucketArr = getAugmentationBucket(augmentations, scopeId, name);
+                    if (bucketArr.some((b) => b.def.nodeId === def.nodeId))
                         continue;
-                    existing.push({ def, origin: 'namespace' });
+                    bucketArr.push({ def, origin: 'namespace' });
                 }
-                if (existing.length > 0)
-                    scopeBindings.set(name, existing);
             }
         }
     }
 }
+/** Get-or-create a mutable inner bucket inside the `bindingAugmentations`
+ *  channel. The inner arrays here are mutable by contract (see
+ *  `ScopeResolutionIndexes.bindingAugmentations` doc + scope-resolver I8);
+ *  callers may `push` directly. Allocating the outer/inner Maps lazily
+ *  keeps the augmentation footprint zero for files with no cross-file
+ *  fanout. */
+function getAugmentationBucket(augmentations, scopeId, name) {
+    let scopeBindings = augmentations.get(scopeId);
+    if (scopeBindings === undefined) {
+        scopeBindings = new Map();
+        augmentations.set(scopeId, scopeBindings);
+    }
+    let bucketArr = scopeBindings.get(name);
+    if (bucketArr === undefined) {
+        bucketArr = [];
+        scopeBindings.set(name, bucketArr);
+    }
+    return bucketArr;
+}
 function isTypeDef(def) {
     return (def.type === 'Class' ||
         def.type === 'Interface' ||

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

@@ -21,6 +21,7 @@ import { getPythonParser, getPythonScopeQuery } from './query.js';
 import { synthesizeReceiverTypeBinding } from './receiver-binding.js';
 import { computePythonArityMetadata } from './arity-metadata.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
+import { getTreeSitterBufferSize } from '../../constants.js';
 export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
     // Skip the parse when the caller (parse phase's ASTCache) already
     // produced a Tree for this source. Cache miss = re-parse, same as
@@ -29,7 +30,9 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
     // here at the use site.
     let tree = cachedTree;
     if (tree === undefined) {
-        tree = getPythonParser().parse(sourceText);
+        tree = getPythonParser().parse(sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(sourceText),
+        });
         recordCacheMiss();
     }
     else {

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

@@ -30,6 +30,7 @@ import { getTsParser, getTsScopeQuery, tsCachedTreeMatchesGrammar } from './quer
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { synthesizeTsReceiverBinding } from './receiver-binding.js';
 import { computeTsArityMetadata } from './arity-metadata.js';
+import { getTreeSitterBufferSize } from '../../constants.js';
 /** tree-sitter-typescript node types for function-like scopes that may
  *  carry a synthesized `this` binding. Kept in sync with the
  *  `@scope.function` patterns in `query.ts`. */
@@ -110,7 +111,9 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
         tree = undefined;
     }
     if (tree === undefined) {
-        tree = getTsParser(filePath).parse(sourceText);
+        tree = getTsParser(filePath).parse(sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(sourceText),
+        });
         recordCacheMiss();
     }
     else {

package/dist/core/ingestion/model/scope-resolution-indexes.d.ts

@@ -48,8 +48,21 @@ export interface ScopeResolutionIndexes {
     readonly methodDispatch: MethodDispatchIndex;
     /** Finalized `ImportEdge[]` per module scope. */
     readonly imports: ReadonlyMap<ScopeId, readonly ImportEdge[]>;
-    /** Merged bindings (local + imports + wildcards) per module scope. */
+    /** Finalize-output bindings (local + imports + wildcards) per module scope.
+     *  Inner `BindingRef[]` arrays are frozen by `materializeBindings`;
+     *  this channel is permanently immutable post-finalize. Consumers
+     *  MUST read via `lookupBindingsAt` so the augmentation channel is
+     *  consulted alongside. See I8 in `contract/scope-resolver.ts`. */
     readonly bindings: ReadonlyMap<ScopeId, ReadonlyMap<string, readonly BindingRef[]>>;
+    /** Append-only post-finalize augmentation channel. Populated by
+     *  language hooks such as `populateNamespaceSiblings` for cross-file
+     *  bindings synthesized after finalize (e.g. C# same-namespace
+     *  visibility, `using static` member exposure). Inner arrays are
+     *  NOT frozen — hooks `push()` directly. Walkers must consult both
+     *  this map and `bindings` via `lookupBindingsAt`; finalized refs
+     *  are returned first and win duplicate `def.nodeId` metadata, with
+     *  unique augmentations appended after. See I8. */
+    readonly bindingAugmentations: ReadonlyMap<ScopeId, ReadonlyMap<string, readonly BindingRef[]>>;
     /** Pre-resolution usage facts; consumed by the resolution phase. */
     readonly referenceSites: readonly ReferenceSite[];
     /** SCC condensation of the file-level import graph — callers that want

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

@@ -10,7 +10,7 @@ import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, getLabelFromCapt
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { buildTypeEnv } from './type-env.js';
 import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, } from './utils/method-props.js';
-import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
+import { getTreeSitterBufferSize, getTreeSitterContentByteLength, TREE_SITTER_MAX_BUFFER, } from './constants.js';
 // ============================================================================
 // Worker-based parallel parsing
 // ============================================================================
@@ -247,7 +247,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
             continue;
         }
         // Skip files larger than the max tree-sitter buffer (32 MB)
-        if (file.content.length > TREE_SITTER_MAX_BUFFER)
+        if (getTreeSitterContentByteLength(file.content) > TREE_SITTER_MAX_BUFFER)
             continue;
         // Vue SFC preprocessing: extract <script> block content
         let parseContent = file.content;
@@ -270,7 +270,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
         let tree;
         try {
             tree = parser.parse(parseContent, undefined, {
-                bufferSize: getTreeSitterBufferSize(parseContent.length),
+                bufferSize: getTreeSitterBufferSize(parseContent),
             });
         }
         catch (parseError) {

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -136,14 +136,45 @@
  *     once per workspace at resolve time), and merging would create a
  *     god-interface that complicates future migrations.
  *
- *   - **I8 — Post-finalize hooks may mutate `Scope.typeBindings` and
- *     `indexes.bindings`.** `propagateImportedReturnTypes` and
- *     `populateNamespaceSiblings` both write to these structures via
- *     `as Map<...>` casts through `ReadonlyMap` facades. Downstream
- *     consumers MUST NOT freeze or snapshot these maps before all
- *     post-finalize hooks have run. The `ReadonlyMap<...>` type on
- *     `ScopeResolutionIndexes` is a read-guidance surface for
- *     consumers, NOT an immutability promise during the resolve phase.
+ *   - **I8 — Two-channel binding lifecycle.**
+ *     `indexes.bindings` is the **finalize-output channel**. After
+ *     `finalizeScopeModel` returns, its inner `BindingRef[]` arrays
+ *     are deep-frozen by `materializeBindings` and MUST NOT be
+ *     mutated by any post-finalize hook. Treat `indexes.bindings` as
+ *     immutable from the moment `finalizeScopeModel` returns.
+ *
+ *     `indexes.bindingAugmentations` is the **post-finalize
+ *     append-only channel**. Hooks like `populateNamespaceSiblings`
+ *     append cross-file bindings synthesized after finalize (C#
+ *     same-namespace visibility, `using static` member exposure)
+ *     into this channel, NOT into `indexes.bindings`. Inner arrays
+ *     here are NEVER frozen — hooks `push()` directly. Any consumer
+ *     that reads post-finalize workspace bindings MUST query both
+ *     index channels via `lookupBindingsAt`
+ *     (`scope-resolution/scope/walkers.ts`); the helper returns
+ *     finalized refs first, appends unique augmentation refs after,
+ *     and dedupes by `def.nodeId` so finalized metadata wins on
+ *     duplicate defs. Per-`Scope.bindings` local declarations are the
+ *     lexical extraction channel and remain a separate first-tier
+ *     lookup for local shadowing.
+ *
+ *     `Scope.typeBindings` remains mutable post-finalize per I6 (it
+ *     is intentionally not frozen at any point).
+ *
+ *     The `ReadonlyMap<...>` types on `ScopeResolutionIndexes` are
+ *     compile-time read-guidance for consumers; structural mutation
+ *     of `bindingAugmentations` is performed via a deliberate
+ *     `as Map<...>` cast inside the hook implementations and is the
+ *     ONLY sanctioned channel for post-finalize binding fanout.
+ *
+ *     The dev-mode runtime validator
+ *     (`validateBindingsImmutability` in
+ *     `scope-resolution/validate-bindings-immutability.ts`) surfaces
+ *     any drift — i.e. a hook writing to `indexes.bindings` instead
+ *     of `bindingAugmentations`, or producing a non-frozen finalized
+ *     bucket — via `onWarn` when explicitly enabled by
+ *     `NODE_ENV === 'development' || VALIDATE_SEMANTIC_MODEL === '1'`
+ *     (`VALIDATE_SEMANTIC_MODEL=0` is an explicit off switch).
  *
  *   - **I9 — `SemanticModel` is the single authoritative symbol store.**
  *     Every symbol-indexed lookup (key = `nodeId | simpleName |

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.js

@@ -136,14 +136,45 @@
  *     once per workspace at resolve time), and merging would create a
  *     god-interface that complicates future migrations.
  *
- *   - **I8 — Post-finalize hooks may mutate `Scope.typeBindings` and
- *     `indexes.bindings`.** `propagateImportedReturnTypes` and
- *     `populateNamespaceSiblings` both write to these structures via
- *     `as Map<...>` casts through `ReadonlyMap` facades. Downstream
- *     consumers MUST NOT freeze or snapshot these maps before all
- *     post-finalize hooks have run. The `ReadonlyMap<...>` type on
- *     `ScopeResolutionIndexes` is a read-guidance surface for
- *     consumers, NOT an immutability promise during the resolve phase.
+ *   - **I8 — Two-channel binding lifecycle.**
+ *     `indexes.bindings` is the **finalize-output channel**. After
+ *     `finalizeScopeModel` returns, its inner `BindingRef[]` arrays
+ *     are deep-frozen by `materializeBindings` and MUST NOT be
+ *     mutated by any post-finalize hook. Treat `indexes.bindings` as
+ *     immutable from the moment `finalizeScopeModel` returns.
+ *
+ *     `indexes.bindingAugmentations` is the **post-finalize
+ *     append-only channel**. Hooks like `populateNamespaceSiblings`
+ *     append cross-file bindings synthesized after finalize (C#
+ *     same-namespace visibility, `using static` member exposure)
+ *     into this channel, NOT into `indexes.bindings`. Inner arrays
+ *     here are NEVER frozen — hooks `push()` directly. Any consumer
+ *     that reads post-finalize workspace bindings MUST query both
+ *     index channels via `lookupBindingsAt`
+ *     (`scope-resolution/scope/walkers.ts`); the helper returns
+ *     finalized refs first, appends unique augmentation refs after,
+ *     and dedupes by `def.nodeId` so finalized metadata wins on
+ *     duplicate defs. Per-`Scope.bindings` local declarations are the
+ *     lexical extraction channel and remain a separate first-tier
+ *     lookup for local shadowing.
+ *
+ *     `Scope.typeBindings` remains mutable post-finalize per I6 (it
+ *     is intentionally not frozen at any point).
+ *
+ *     The `ReadonlyMap<...>` types on `ScopeResolutionIndexes` are
+ *     compile-time read-guidance for consumers; structural mutation
+ *     of `bindingAugmentations` is performed via a deliberate
+ *     `as Map<...>` cast inside the hook implementations and is the
+ *     ONLY sanctioned channel for post-finalize binding fanout.
+ *
+ *     The dev-mode runtime validator
+ *     (`validateBindingsImmutability` in
+ *     `scope-resolution/validate-bindings-immutability.ts`) surfaces
+ *     any drift — i.e. a hook writing to `indexes.bindings` instead
+ *     of `bindingAugmentations`, or producing a non-frozen finalized
+ *     bucket — via `onWarn` when explicitly enabled by
+ *     `NODE_ENV === 'development' || VALIDATE_SEMANTIC_MODEL === '1'`
+ *     (`VALIDATE_SEMANTIC_MODEL=0` is an explicit off switch).
  *
  *   - **I9 — `SemanticModel` is the single authoritative symbol store.**
  *     Every symbol-indexed lookup (key = `nodeId | simpleName |

package/dist/core/ingestion/scope-resolution/passes/imported-return-types.js

@@ -38,6 +38,7 @@
  * Generic; promoted from `languages/python/scope-resolver.ts` per the
  * scope-resolution generalization plan.
  */
+import { lookupBindingsAt, namesAtScope } from '../scope/walkers.js';
 /**
  * Max chain depth for the post-finalize re-follow. Effective end-to-end
  * depth is roughly 2× this number, because chain-following runs once
@@ -126,14 +127,18 @@ export function propagateImportedReturnTypes(parsedFiles, indexes, index) {
             const importerModule = moduleScopeByFile.get(filePath);
             if (importerModule === undefined)
                 continue;
-            const finalizedBindings = indexes.bindings.get(importerModule.id);
-            if (finalizedBindings === undefined)
-                continue;
-            for (const [localName, refs] of finalizedBindings) {
+            // Iterate finalized + augmented binding names at this scope so
+            // post-finalize hooks (e.g. `using static` augmentations from
+            // `populateCsharpNamespaceSiblings`) are visible to the
+            // import-derived typeBinding mirror. Both helpers fast-path when
+            // no augmentations exist for the scope, so the common case is
+            // allocation-free. See I8.
+            for (const localName of namesAtScope(importerModule.id, indexes)) {
                 // Skip if importer already has a typeBinding for this name —
                 // an explicit local annotation must win over import-derived.
                 if (importerModule.typeBindings.has(localName))
                     continue;
+                const refs = lookupBindingsAt(importerModule.id, localName, indexes);
                 for (const ref of refs) {
                     if (ref.origin !== 'import' && ref.origin !== 'reexport')
                         continue;

package/dist/core/ingestion/scope-resolution/pipeline/phase.js

@@ -32,7 +32,7 @@ import { getLanguageFromFilename } from '../../../../_shared/index.js';
 import { readFileContents } from '../../filesystem-walker.js';
 import { runScopeResolution } from './run.js';
 import { SCOPE_RESOLVERS } from './registry.js';
-import { isDev } from '../../utils/env.js';
+import { isDev, isSemanticModelValidatorEnabled } from '../../utils/env.js';
 const NOOP_OUTPUT = Object.freeze({
     ran: false,
     filesProcessed: 0,
@@ -101,8 +101,9 @@ export const scopeResolutionPhase = {
                 treeCache: scopeTreeCache,
                 resolutionConfig,
                 onWarn: (msg) => {
-                    if (isDev)
+                    if (isSemanticModelValidatorEnabled()) {
                         console.warn(`[scope-resolution:${lang}] ${msg}`);
+                    }
                 },
             }, provider);
             anyRan = true;

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -23,6 +23,7 @@
  * Plan: `docs/plans/2026-04-20-001-refactor-emit-pipeline-generalization-plan.md`.
  */
 import { reconcileOwnership, validateOwnershipParity } from './reconcile-ownership.js';
+import { validateBindingsImmutability } from './validate-bindings-immutability.js';
 import { extractParsedFile } from '../../scope-extractor-bridge.js';
 import { finalizeScopeModel } from '../../finalize-orchestrator.js';
 import { resolveReferenceSites } from '../../resolve-references.js';
@@ -107,6 +108,8 @@ export function runScopeResolution(input, provider) {
     // Cross-file implicit-namespace visibility (C#). Must run before
     // propagateImportedReturnTypes so the latter pass sees siblings'
     // class bindings when chasing return-type chains across files.
+    // The hook writes to `bindingAugmentations` only; finalized
+    // `indexes.bindings` remains immutable post-finalize (I8).
     if (provider.populateNamespaceSiblings !== undefined) {
         const fileContents = new Map();
         for (const f of files)
@@ -126,6 +129,13 @@ export function runScopeResolution(input, provider) {
         propagateImportedReturnTypes(parsedFiles, indexes, workspaceIndex);
     }
     const tPropagate = PROF ? process.hrtime.bigint() : 0n;
+    // Opt-in I8 invariant guard. Runs once after all post-finalize hooks
+    // (`populateNamespaceSiblings`, `propagateImportedReturnTypes`) have
+    // had a chance to drift, so a single sweep covers the full
+    // post-finalize surface visible to `resolveReferenceSites`. No-op in
+    // default CLI runs; enabled by NODE_ENV=development or
+    // VALIDATE_SEMANTIC_MODEL=1.
+    validateBindingsImmutability(indexes, onWarn);
     // ── Phase 3: resolve references via Registry.lookup ────────────────────
     const registryProviders = {
         arityCompatibility: provider.arityCompatibility,

package/dist/core/ingestion/scope-resolution/pipeline/validate-bindings-immutability.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Dev-mode runtime validator for the two-channel binding lifecycle
+ * (Contract Invariant I8 in `contract/scope-resolver.ts`).
+ *
+ * The two channels:
+ *   - `indexes.bindings` — finalize-output channel. After
+ *     `finalizeScopeModel` returns, every inner `BindingRef[]` array
+ *     here is deep-frozen by `materializeBindings`. NO post-finalize
+ *     hook should ever mutate this map's inner arrays — drift here
+ *     manifests at runtime as the `Cannot add property N, object is
+ *     not extensible` crash (issue #1066) or, more insidiously, as
+ *     a hook silently mutating one of the frozen arrays (a no-op in
+ *     production where freezes can be elided, a `TypeError` in dev).
+ *
+ *   - `indexes.bindingAugmentations` — post-finalize append-only
+ *     channel. Inner arrays here are NEVER frozen; hooks like
+ *     `populateNamespaceSiblings` `push()` directly. Walkers consult
+ *     both channels via `lookupBindingsAt`.
+ *
+ * This validator runs after every post-finalize hook has executed
+ * (so the dev-mode envelope captures the FULL surface area visible
+ * to `resolveReferenceSites`) and asserts:
+ *
+ *   1. Every inner `BindingRef[]` array in `indexes.bindings` is
+ *      `Object.isFrozen` — i.e. finalize produced a frozen bucket
+ *      AND no hook accidentally `set()`-back a mutable replacement.
+ *
+ *   2. Every inner `BindingRef[]` array in
+ *      `indexes.bindingAugmentations` is NOT frozen — i.e. the
+ *      hook used the augmentation channel as designed (mutable
+ *      `push()`) and didn't accidentally freeze its own scratch
+ *      arrays. Self-documenting; mostly a sanity net.
+ *
+ * Mirrors `validateOwnershipParity` (#909): warns via `onWarn`,
+ * never throws, and is opt-in outside development. Gated by
+ * `isSemanticModelValidatorEnabled()` (`utils/env.ts`).
+ */
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+export declare function validateBindingsImmutability(indexes: ScopeResolutionIndexes, onWarn: (message: string) => void): number;

package/dist/core/ingestion/scope-resolution/pipeline/validate-bindings-immutability.js

@@ -0,0 +1,65 @@
+/**
+ * Dev-mode runtime validator for the two-channel binding lifecycle
+ * (Contract Invariant I8 in `contract/scope-resolver.ts`).
+ *
+ * The two channels:
+ *   - `indexes.bindings` — finalize-output channel. After
+ *     `finalizeScopeModel` returns, every inner `BindingRef[]` array
+ *     here is deep-frozen by `materializeBindings`. NO post-finalize
+ *     hook should ever mutate this map's inner arrays — drift here
+ *     manifests at runtime as the `Cannot add property N, object is
+ *     not extensible` crash (issue #1066) or, more insidiously, as
+ *     a hook silently mutating one of the frozen arrays (a no-op in
+ *     production where freezes can be elided, a `TypeError` in dev).
+ *
+ *   - `indexes.bindingAugmentations` — post-finalize append-only
+ *     channel. Inner arrays here are NEVER frozen; hooks like
+ *     `populateNamespaceSiblings` `push()` directly. Walkers consult
+ *     both channels via `lookupBindingsAt`.
+ *
+ * This validator runs after every post-finalize hook has executed
+ * (so the dev-mode envelope captures the FULL surface area visible
+ * to `resolveReferenceSites`) and asserts:
+ *
+ *   1. Every inner `BindingRef[]` array in `indexes.bindings` is
+ *      `Object.isFrozen` — i.e. finalize produced a frozen bucket
+ *      AND no hook accidentally `set()`-back a mutable replacement.
+ *
+ *   2. Every inner `BindingRef[]` array in
+ *      `indexes.bindingAugmentations` is NOT frozen — i.e. the
+ *      hook used the augmentation channel as designed (mutable
+ *      `push()`) and didn't accidentally freeze its own scratch
+ *      arrays. Self-documenting; mostly a sanity net.
+ *
+ * Mirrors `validateOwnershipParity` (#909): warns via `onWarn`,
+ * never throws, and is opt-in outside development. Gated by
+ * `isSemanticModelValidatorEnabled()` (`utils/env.ts`).
+ */
+import { isSemanticModelValidatorEnabled } from '../../utils/env.js';
+export function validateBindingsImmutability(indexes, onWarn) {
+    if (!isSemanticModelValidatorEnabled())
+        return 0;
+    let violations = 0;
+    for (const [scopeId, bucketMap] of indexes.bindings) {
+        for (const [name, bucket] of bucketMap) {
+            if (!Object.isFrozen(bucket)) {
+                onWarn(`binding-immutability: indexes.bindings[${scopeId}][${name}] is NOT frozen — ` +
+                    `finalize produced a mutable bucket OR a post-finalize hook replaced a frozen ` +
+                    `bucket with a mutable one. Hooks must write to indexes.bindingAugmentations ` +
+                    `instead. See ScopeResolver Invariant I8.`);
+                violations++;
+            }
+        }
+    }
+    for (const [scopeId, bucketMap] of indexes.bindingAugmentations) {
+        for (const [name, bucket] of bucketMap) {
+            if (Object.isFrozen(bucket)) {
+                onWarn(`binding-immutability: indexes.bindingAugmentations[${scopeId}][${name}] is FROZEN — ` +
+                    `the augmentation channel is mutable by contract; freezing it defeats the ` +
+                    `append-only purpose. See ScopeResolver Invariant I8.`);
+                violations++;
+            }
+        }
+    }
+    return violations;
+}

package/dist/core/ingestion/scope-resolution/scope/walkers.d.ts

@@ -1,13 +1,14 @@
 /**
  * Scope-chain lookup primitives shared across language providers.
  *
- * Four functions:
+ * Five functions:
  *   - `findReceiverTypeBinding` — walk scope.typeBindings up the chain
  *     for a receiver name.
- *   - `findClassBindingInScope` — walk scope.bindings + indexes.bindings
- *     (pre-finalize + post-finalize) for a class-kind binding. Dual-
- *     source is required because the cross-file finalize pass produces
- *     a separate bindings map that is not merged back into scope.bindings.
+ *   - `lookupBindingsAt` — read finalized + augmented binding refs at
+ *     one scope, deduped by `def.nodeId`. The dual-source-aware
+ *     primitive every other binding lookup composes with.
+ *   - `findClassBindingInScope` — walk scope.bindings + the indexes via
+ *     `lookupBindingsAt` for a class-kind binding.
  *   - `findOwnedMember` — find a method/field owned by a class def
  *     across all parsed files by (ownerId, simpleName).
  *   - `findExportedDef` — find a file-level exported def (top-of-module
@@ -18,10 +19,44 @@
  * "resolve member on owner with MRO" pattern. All four are reusable
  * as-is for TypeScript, Java, Kotlin, Ruby, etc.
  */
-import type { ParsedFile, ScopeId, SymbolDefinition, TypeRef } from '../../../../_shared/index.js';
+import type { BindingRef, ParsedFile, ScopeId, SymbolDefinition, TypeRef } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
 import type { SemanticModel } from '../../model/semantic-model.js';
 import type { WorkspaceResolutionIndex } from '../workspace-index.js';
+/**
+ * Look up binding refs at `scopeId` for `name`, consulting both the
+ * finalize-owned `bindings` channel and the post-finalize
+ * `bindingAugmentations` channel (see invariant I8 in
+ * `contract/scope-resolver.ts`). Finalized refs come first; augmented
+ * refs append, deduped by `def.nodeId` so a sibling that's also
+ * explicitly imported doesn't double-emit.
+ *
+ * Returns a shared frozen empty array when neither channel has the
+ * name — callers can compare against `=== EMPTY_BINDINGS` if they
+ * want a fast-path miss check. The bucket arrays are returned by
+ * reference when only one channel populates them; the merged path
+ * allocates a fresh array.
+ *
+ * Walker primitives (`findClassBindingInScope`,
+ * `findCallableBindingInScope`, `findExportedDefByName`) and
+ * post-finalize passes that read finalized bindings (e.g.
+ * `propagateImportedReturnTypes`, `namespace-targets`) MUST go
+ * through this helper instead of `scopes.bindings.get(...)` directly,
+ * so the augmentation channel is always visible.
+ */
+export declare function lookupBindingsAt(scopeId: ScopeId, name: string, scopes: ScopeResolutionIndexes): readonly BindingRef[];
+/**
+ * Return the union of bound names at `scopeId` across both the
+ * finalized and augmented channels. Companion to `lookupBindingsAt`
+ * for callers that need to iterate every name at a scope (e.g.
+ * `propagateImportedReturnTypes`). Order is not guaranteed; callers
+ * that need stable iteration should sort externally.
+ *
+ * Fast paths (zero allocation) when at most one channel is populated:
+ * returns the underlying `Map.keys()` iterator directly. Only when both
+ * channels carry names do we materialize a `Set` for deduplication.
+ */
+export declare function namesAtScope(scopeId: ScopeId, scopes: ScopeResolutionIndexes): Iterable<string>;
 /**
  * True when a def's `type` names a class-like declaration — every kind
  * that collapses to `@scope.class` in the scope-extractor query contract.
@@ -48,8 +83,10 @@ export declare function findReceiverTypeBinding(startScope: ScopeId, receiverNam
  * Walks the scope chain upward and consults TWO sources at each step:
  *   1. `scope.bindings` — populated during scope-extraction Pass 2 with
  *      local declarations (`origin: 'local'`).
- *   2. `indexes.bindings` — populated by the cross-file finalize pass
- *      with import/namespace/wildcard/reexport origins.
+ *   2. The cross-file finalized + augmented bindings, via
+ *      `lookupBindingsAt` (per I8: finalized = canonical immutable
+ *      output; augmented = post-finalize hooks like
+ *      `populateNamespaceSiblings`).
  *
  * Without (2) we'd miss every cross-file class-receiver call.
  */
@@ -57,8 +94,9 @@ export declare function findClassBindingInScope(startScope: ScopeId, receiverNam
 /**
  * Look up a callable (Function/Method/Constructor) by name in the
  * given scope's chain. Uses the dual-source pattern (scope.bindings +
- * indexes.bindings) so cross-file imports are visible — without it
- * free calls to imported functions never resolve via the post-pass.
+ * `lookupBindingsAt` for finalized + augmented) so cross-file
+ * imports are visible — without it free calls to imported functions
+ * never resolve via the post-pass.
  *
  * Mirrors `findClassBindingInScope` exactly; only the accepted
  * def-type predicate differs.
@@ -122,6 +160,11 @@ export declare function findOwnedMember(ownerDefId: string, memberName: string,
  * excluded.
  *
  * Reads from `WorkspaceResolutionIndex.moduleScopeByFile` (scope-tied
- * lookup that doesn't live on `SemanticModel`).
+ * lookup that doesn't live on `SemanticModel`). This intentionally
+ * does NOT call `lookupBindingsAt`: `findExportedDef` answers "what
+ * did the target file declare locally at module scope?", while
+ * `bindingAugmentations` models importer-side visibility created by
+ * post-finalize hooks. Callers that need importer-visible exports use
+ * `findExportedDefByName`, which is dual-channel aware.
  */
 export declare function findExportedDef(targetFile: string, memberName: string, index: WorkspaceResolutionIndex): SymbolDefinition | undefined;

package/dist/core/ingestion/scope-resolution/scope/walkers.js

@@ -1,13 +1,14 @@
 /**
  * Scope-chain lookup primitives shared across language providers.
  *
- * Four functions:
+ * Five functions:
  *   - `findReceiverTypeBinding` — walk scope.typeBindings up the chain
  *     for a receiver name.
- *   - `findClassBindingInScope` — walk scope.bindings + indexes.bindings
- *     (pre-finalize + post-finalize) for a class-kind binding. Dual-
- *     source is required because the cross-file finalize pass produces
- *     a separate bindings map that is not merged back into scope.bindings.
+ *   - `lookupBindingsAt` — read finalized + augmented binding refs at
+ *     one scope, deduped by `def.nodeId`. The dual-source-aware
+ *     primitive every other binding lookup composes with.
+ *   - `findClassBindingInScope` — walk scope.bindings + the indexes via
+ *     `lookupBindingsAt` for a class-kind binding.
  *   - `findOwnedMember` — find a method/field owned by a class def
  *     across all parsed files by (ownerId, simpleName).
  *   - `findExportedDef` — find a file-level exported def (top-of-module
@@ -18,6 +19,80 @@
  * "resolve member on owner with MRO" pattern. All four are reusable
  * as-is for TypeScript, Java, Kotlin, Ruby, etc.
  */
+const EMPTY_BINDINGS = Object.freeze([]);
+/**
+ * Look up binding refs at `scopeId` for `name`, consulting both the
+ * finalize-owned `bindings` channel and the post-finalize
+ * `bindingAugmentations` channel (see invariant I8 in
+ * `contract/scope-resolver.ts`). Finalized refs come first; augmented
+ * refs append, deduped by `def.nodeId` so a sibling that's also
+ * explicitly imported doesn't double-emit.
+ *
+ * Returns a shared frozen empty array when neither channel has the
+ * name — callers can compare against `=== EMPTY_BINDINGS` if they
+ * want a fast-path miss check. The bucket arrays are returned by
+ * reference when only one channel populates them; the merged path
+ * allocates a fresh array.
+ *
+ * Walker primitives (`findClassBindingInScope`,
+ * `findCallableBindingInScope`, `findExportedDefByName`) and
+ * post-finalize passes that read finalized bindings (e.g.
+ * `propagateImportedReturnTypes`, `namespace-targets`) MUST go
+ * through this helper instead of `scopes.bindings.get(...)` directly,
+ * so the augmentation channel is always visible.
+ */
+export function lookupBindingsAt(scopeId, name, scopes) {
+    const finalized = scopes.bindings.get(scopeId)?.get(name);
+    const augmented = scopes.bindingAugmentations.get(scopeId)?.get(name);
+    const fLen = finalized?.length ?? 0;
+    const aLen = augmented?.length ?? 0;
+    if (fLen === 0 && aLen === 0)
+        return EMPTY_BINDINGS;
+    if (aLen === 0)
+        return finalized;
+    if (fLen === 0)
+        return augmented;
+    const seen = new Set();
+    const out = [];
+    for (const r of finalized) {
+        seen.add(r.def.nodeId);
+        out.push(r);
+    }
+    for (const r of augmented) {
+        if (seen.has(r.def.nodeId))
+            continue;
+        out.push(r);
+    }
+    return out;
+}
+const EMPTY_NAMES = Object.freeze([]);
+/**
+ * Return the union of bound names at `scopeId` across both the
+ * finalized and augmented channels. Companion to `lookupBindingsAt`
+ * for callers that need to iterate every name at a scope (e.g.
+ * `propagateImportedReturnTypes`). Order is not guaranteed; callers
+ * that need stable iteration should sort externally.
+ *
+ * Fast paths (zero allocation) when at most one channel is populated:
+ * returns the underlying `Map.keys()` iterator directly. Only when both
+ * channels carry names do we materialize a `Set` for deduplication.
+ */
+export function namesAtScope(scopeId, scopes) {
+    const finalized = scopes.bindings.get(scopeId);
+    const augmented = scopes.bindingAugmentations.get(scopeId);
+    const fSize = finalized?.size ?? 0;
+    const aSize = augmented?.size ?? 0;
+    if (fSize === 0 && aSize === 0)
+        return EMPTY_NAMES;
+    if (aSize === 0)
+        return finalized.keys();
+    if (fSize === 0)
+        return augmented.keys();
+    const out = new Set(finalized.keys());
+    for (const name of augmented.keys())
+        out.add(name);
+    return out;
+}
 /**
  * True when a def's `type` names a class-like declaration — every kind
  * that collapses to `@scope.class` in the scope-extractor query contract.
@@ -67,8 +142,10 @@ export function findReceiverTypeBinding(startScope, receiverName, scopes) {
  * Walks the scope chain upward and consults TWO sources at each step:
  *   1. `scope.bindings` — populated during scope-extraction Pass 2 with
  *      local declarations (`origin: 'local'`).
- *   2. `indexes.bindings` — populated by the cross-file finalize pass
- *      with import/namespace/wildcard/reexport origins.
+ *   2. The cross-file finalized + augmented bindings, via
+ *      `lookupBindingsAt` (per I8: finalized = canonical immutable
+ *      output; augmented = post-finalize hooks like
+ *      `populateNamespaceSiblings`).
  *
  * Without (2) we'd miss every cross-file class-receiver call.
  */
@@ -89,13 +166,10 @@ export function findClassBindingInScope(startScope, receiverName, scopes) {
                     return b.def;
             }
         }
-        const finalizedScopeBindings = scopes.bindings.get(currentId);
-        const importedBindings = finalizedScopeBindings?.get(receiverName);
-        if (importedBindings !== undefined) {
-            for (const b of importedBindings) {
-                if (isClassLike(b.def.type))
-                    return b.def;
-            }
+        const importedBindings = lookupBindingsAt(currentId, receiverName, scopes);
+        for (const b of importedBindings) {
+            if (isClassLike(b.def.type))
+                return b.def;
         }
         currentId = scope.parent;
     }
@@ -104,8 +178,9 @@ export function findClassBindingInScope(startScope, receiverName, scopes) {
 /**
  * Look up a callable (Function/Method/Constructor) by name in the
  * given scope's chain. Uses the dual-source pattern (scope.bindings +
- * indexes.bindings) so cross-file imports are visible — without it
- * free calls to imported functions never resolve via the post-pass.
+ * `lookupBindingsAt` for finalized + augmented) so cross-file
+ * imports are visible — without it free calls to imported functions
+ * never resolve via the post-pass.
  *
  * Mirrors `findClassBindingInScope` exactly; only the accepted
  * def-type predicate differs.
@@ -128,13 +203,10 @@ export function findCallableBindingInScope(startScope, callableName, scopes) {
                 }
             }
         }
-        const finalizedScopeBindings = scopes.bindings.get(currentId);
-        const importedBindings = finalizedScopeBindings?.get(callableName);
-        if (importedBindings !== undefined) {
-            for (const b of importedBindings) {
-                if (b.def.type === 'Function' || b.def.type === 'Method' || b.def.type === 'Constructor') {
-                    return b.def;
-                }
+        const importedBindings = lookupBindingsAt(currentId, callableName, scopes);
+        for (const b of importedBindings) {
+            if (b.def.type === 'Function' || b.def.type === 'Method' || b.def.type === 'Constructor') {
+                return b.def;
             }
         }
         currentId = scope.parent;
@@ -272,12 +344,10 @@ export function findExportedDefByName(name, inScope, scopes, index) {
                     return b.def;
             }
         }
-        const finalized = scopes.bindings.get(currentId)?.get(name);
-        if (finalized !== undefined) {
-            for (const b of finalized) {
-                if (b.def.type === 'Function' || b.def.type === 'Method')
-                    return b.def;
-            }
+        const finalized = lookupBindingsAt(currentId, name, scopes);
+        for (const b of finalized) {
+            if (b.def.type === 'Function' || b.def.type === 'Method')
+                return b.def;
         }
         currentId = scope.parent;
     }
@@ -332,7 +402,12 @@ export function findOwnedMember(ownerDefId, memberName, model) {
  * excluded.
  *
  * Reads from `WorkspaceResolutionIndex.moduleScopeByFile` (scope-tied
- * lookup that doesn't live on `SemanticModel`).
+ * lookup that doesn't live on `SemanticModel`). This intentionally
+ * does NOT call `lookupBindingsAt`: `findExportedDef` answers "what
+ * did the target file declare locally at module scope?", while
+ * `bindingAugmentations` models importer-side visibility created by
+ * post-finalize hooks. Callers that need importer-visible exports use
+ * `findExportedDefByName`, which is dual-channel aware.
  */
 export function findExportedDef(targetFile, memberName, index) {
     const moduleScope = index.moduleScopeByFile.get(targetFile);

package/dist/core/ingestion/utils/env.d.ts

@@ -8,3 +8,13 @@
  */
 /** Whether we're running in development mode (enables verbose console logging). */
 export declare const isDev: boolean;
+/**
+ * Whether scope-resolution dev validators (e.g. `validateBindingsImmutability`)
+ * should run AND emit warnings. Off by default in CLI runs to avoid silent
+ * O(n) scans on large repos; on in `NODE_ENV=development` or when explicitly
+ * opted-in via `VALIDATE_SEMANTIC_MODEL=1`. `VALIDATE_SEMANTIC_MODEL=0` is the
+ * explicit off switch and wins over both.
+ *
+ * Read every call (not memoized) so test setups using `vi.stubEnv` work.
+ */
+export declare const isSemanticModelValidatorEnabled: () => boolean;

package/dist/core/ingestion/utils/env.js

@@ -8,3 +8,17 @@
  */
 /** Whether we're running in development mode (enables verbose console logging). */
 export const isDev = process.env.NODE_ENV === 'development';
+/**
+ * Whether scope-resolution dev validators (e.g. `validateBindingsImmutability`)
+ * should run AND emit warnings. Off by default in CLI runs to avoid silent
+ * O(n) scans on large repos; on in `NODE_ENV=development` or when explicitly
+ * opted-in via `VALIDATE_SEMANTIC_MODEL=1`. `VALIDATE_SEMANTIC_MODEL=0` is the
+ * explicit off switch and wins over both.
+ *
+ * Read every call (not memoized) so test setups using `vi.stubEnv` work.
+ */
+export const isSemanticModelValidatorEnabled = () => {
+    if (process.env.VALIDATE_SEMANTIC_MODEL === '0')
+        return false;
+    return process.env.NODE_ENV === 'development' || process.env.VALIDATE_SEMANTIC_MODEL === '1';
+};

package/dist/core/ingestion/workers/parse-worker.js

@@ -15,7 +15,7 @@ import Ruby from 'tree-sitter-ruby';
 import { createRequire } from 'node:module';
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { getProvider } from '../languages/index.js';
-import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from '../constants.js';
+import { getTreeSitterBufferSize, getTreeSitterContentByteLength, TREE_SITTER_MAX_BUFFER, } from '../constants.js';
 // tree-sitter-swift is an optionalDependency — may not be installed
 const _require = createRequire(import.meta.url);
 let Swift = null;
@@ -1001,7 +1001,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
     }
     for (const file of files) {
         // Skip files larger than the max tree-sitter buffer (32 MB)
-        if (file.content.length > TREE_SITTER_MAX_BUFFER)
+        if (getTreeSitterContentByteLength(file.content) > TREE_SITTER_MAX_BUFFER)
             continue;
         // Vue SFC preprocessing: extract <script> block content
         let parseContent = file.content;
@@ -1019,7 +1019,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         let tree;
         try {
             tree = parser.parse(parseContent, undefined, {
-                bufferSize: getTreeSitterBufferSize(parseContent.length),
+                bufferSize: getTreeSitterBufferSize(parseContent),
             });
         }
         catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.3",
+  "version": "1.6.4-rc.4",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",