gitnexus 1.6.4-rc.2 → 1.6.4-rc.21

package/dist/core/ingestion/languages/typescript/receiver-binding.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Synthesize `@type-binding.this` captures for TypeScript instance-like
+ * methods.
+ *
+ * Tree-sitter can't cleanly express "the implicit `this` receiver of a
+ * non-static member of a class / interface / abstract class" via a
+ * static `.scm` pattern, so we walk up the AST in code — mirrors
+ * Python's `self` / `cls` and C#'s `this` / `base` synthesis.
+ *
+ * Scope coverage:
+ *
+ *   - `method_definition` inside `class_declaration`,
+ *     `abstract_class_declaration`, or `class_expression` → synthesize
+ *     `this` → enclosing class name.
+ *   - `method_signature` / `abstract_method_signature` inside
+ *     `interface_declaration` or `abstract_class_declaration` →
+ *     synthesize `this` → enclosing type's name (so interface method
+ *     bodies' `this.x` chains resolve via the interface's field
+ *     annotations).
+ *   - `arrow_function` / `function_expression` that is a direct value
+ *     of a `public_field_definition` (class field) — `m = () => {}` —
+ *     synthesize `this` → enclosing class name. These capture `this`
+ *     lexically; without synthesis, their body's `this.foo` wouldn't
+ *     resolve.
+ *
+ * Not synthesized (intentionally):
+ *
+ *   - `static` methods / static fields. `this` in a static context
+ *     refers to the class constructor, not an instance; we leave the
+ *     binding empty and let chain resolution fall through to the
+ *     class's static members lookup.
+ *   - Regular `function_declaration` / `function_expression` at
+ *     module level or in a non-class context. No enclosing type, no
+ *     `this` semantics.
+ *   - Arrow functions nested inside a method body. The scope-chain
+ *     walk in `tsReceiverBinding` finds the outer method's `this`
+ *     naturally, matching TS's lexical-this rule for arrow functions.
+ *
+ * Each synthesized match emits the anchor captures needed by
+ * `interpretTsTypeBinding`:
+ *
+ *   `@type-binding.this`  (source discriminator — interpret maps to 'self')
+ *   `@type-binding.name`  (the literal `'this'`)
+ *   `@type-binding.type`  (the enclosing type's name)
+ */
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/**
+ * Produce zero or one `CaptureMatch` synthesizing `this` for `fnNode`.
+ *
+ *   - `null` — function has no synthetic `this` (free / static /
+ *     not-in-class / no name on enclosing type).
+ *   - One match — anchor on the function body so the synthetic binding
+ *     attaches to the function's scope (not the outer class scope).
+ *
+ * The caller is responsible for passing a `fnNode` whose type is one
+ * of the scope function nodes the scope query emits.
+ */
+export declare function synthesizeTsReceiverBinding(fnNode: SyntaxNode): CaptureMatch | null;

package/dist/core/ingestion/languages/typescript/receiver-binding.js

@@ -0,0 +1,171 @@
+/**
+ * Synthesize `@type-binding.this` captures for TypeScript instance-like
+ * methods.
+ *
+ * Tree-sitter can't cleanly express "the implicit `this` receiver of a
+ * non-static member of a class / interface / abstract class" via a
+ * static `.scm` pattern, so we walk up the AST in code — mirrors
+ * Python's `self` / `cls` and C#'s `this` / `base` synthesis.
+ *
+ * Scope coverage:
+ *
+ *   - `method_definition` inside `class_declaration`,
+ *     `abstract_class_declaration`, or `class_expression` → synthesize
+ *     `this` → enclosing class name.
+ *   - `method_signature` / `abstract_method_signature` inside
+ *     `interface_declaration` or `abstract_class_declaration` →
+ *     synthesize `this` → enclosing type's name (so interface method
+ *     bodies' `this.x` chains resolve via the interface's field
+ *     annotations).
+ *   - `arrow_function` / `function_expression` that is a direct value
+ *     of a `public_field_definition` (class field) — `m = () => {}` —
+ *     synthesize `this` → enclosing class name. These capture `this`
+ *     lexically; without synthesis, their body's `this.foo` wouldn't
+ *     resolve.
+ *
+ * Not synthesized (intentionally):
+ *
+ *   - `static` methods / static fields. `this` in a static context
+ *     refers to the class constructor, not an instance; we leave the
+ *     binding empty and let chain resolution fall through to the
+ *     class's static members lookup.
+ *   - Regular `function_declaration` / `function_expression` at
+ *     module level or in a non-class context. No enclosing type, no
+ *     `this` semantics.
+ *   - Arrow functions nested inside a method body. The scope-chain
+ *     walk in `tsReceiverBinding` finds the outer method's `this`
+ *     naturally, matching TS's lexical-this rule for arrow functions.
+ *
+ * Each synthesized match emits the anchor captures needed by
+ * `interpretTsTypeBinding`:
+ *
+ *   `@type-binding.this`  (source discriminator — interpret maps to 'self')
+ *   `@type-binding.name`  (the literal `'this'`)
+ *   `@type-binding.type`  (the enclosing type's name)
+ */
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+/** Node types that define a TypeScript "type with instance members". */
+const TYPE_DECL_NODE_TYPES = new Set([
+    'class_declaration',
+    'abstract_class_declaration',
+    'class',
+    'class_expression',
+    'interface_declaration',
+]);
+/** Scope function nodes that could be a class method body. */
+const CLASS_MEMBER_FUNCTION_TYPES = new Set([
+    'method_definition',
+    'method_signature',
+    'abstract_method_signature',
+]);
+/** Function-like values that can back a class field (`m = () => {}`). */
+const CLASS_FIELD_FUNCTION_TYPES = new Set(['arrow_function', 'function_expression']);
+/**
+ * Produce zero or one `CaptureMatch` synthesizing `this` for `fnNode`.
+ *
+ *   - `null` — function has no synthetic `this` (free / static /
+ *     not-in-class / no name on enclosing type).
+ *   - One match — anchor on the function body so the synthetic binding
+ *     attaches to the function's scope (not the outer class scope).
+ *
+ * The caller is responsible for passing a `fnNode` whose type is one
+ * of the scope function nodes the scope query emits.
+ */
+export function synthesizeTsReceiverBinding(fnNode) {
+    // Classify the function's role.
+    const role = classifyFunctionRole(fnNode);
+    if (role === null)
+        return null;
+    // Static methods / static fields don't have an instance `this`.
+    if (isStaticMember(role.memberNode))
+        return null;
+    // Find enclosing type declaration. Walking past function-like
+    // boundaries is fine — nested local functions inside a method can
+    // still reference outer `this` through the lexical chain, but we
+    // only synthesize on the immediate function body. The resolver's
+    // scope-chain walk reaches ancestor synthesized bindings for nested
+    // arrow functions.
+    const enclosingType = findEnclosingType(role.memberNode);
+    if (enclosingType === null)
+        return null;
+    const typeName = getTypeDeclName(enclosingType);
+    if (typeName === null)
+        return null;
+    // Anchor the synthetic capture on the function body so the binding
+    // lands in the method's scope, not its parent type scope. Method
+    // signatures in interfaces / abstract classes have no body — use
+    // the method node itself as the anchor; scope-extractor attaches
+    // it to the function scope created by the `@scope.function`
+    // anchor at the same range.
+    const anchorNode = fnNode.childForFieldName('body') ?? fnNode;
+    return buildThisBinding(anchorNode, typeName);
+}
+/**
+ * Decide whether `fnNode` participates as a class member. Returns
+ * `null` when the function is not structurally "a class instance
+ * member" — e.g. a free function, a non-method arrow expression, an
+ * arrow inside a method body (those inherit `this` via scope chain
+ * lookup, no synthesis needed).
+ */
+function classifyFunctionRole(fnNode) {
+    if (CLASS_MEMBER_FUNCTION_TYPES.has(fnNode.type)) {
+        return { memberNode: fnNode };
+    }
+    if (CLASS_FIELD_FUNCTION_TYPES.has(fnNode.type)) {
+        // `public_field_definition` represents a class field. Only when
+        // the arrow/function-expression is a DIRECT value of a field do
+        // we treat it as a class method with synthesized `this`.
+        const parent = fnNode.parent;
+        if (parent !== null && parent.type === 'public_field_definition') {
+            const valueField = parent.childForFieldName('value');
+            if (valueField !== null && valueField.startIndex === fnNode.startIndex) {
+                return { memberNode: parent };
+            }
+        }
+    }
+    return null;
+}
+/** Class-body definitions carry an optional `accessibility_modifier` and
+ *  optional `static` keyword as named children. The `static` token is
+ *  usually a plain child of the member node — not a named field — so
+ *  we scan children for a token whose text is exactly `static`. */
+function isStaticMember(memberNode) {
+    for (let i = 0; i < memberNode.childCount; i++) {
+        const c = memberNode.child(i);
+        if (c === null)
+            continue;
+        // `static` can appear as an unnamed token or as a `readonly` /
+        // `static` keyword node depending on grammar version; check text.
+        if (c.text === 'static')
+            return true;
+    }
+    return false;
+}
+function findEnclosingType(node) {
+    let cur = node.parent;
+    while (cur !== null) {
+        if (TYPE_DECL_NODE_TYPES.has(cur.type))
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
+}
+/** Return the declared name of a class / interface / abstract-class.
+ *  `class_expression` ( `const X = class { … }` ) may lack a name —
+ *  in that case we return `null` and the caller skips synthesis (the
+ *  outer variable's name is the usable handle, but wiring it would
+ *  require a separate walk; defer to a follow-up). */
+function getTypeDeclName(typeNode) {
+    const nameField = typeNode.childForFieldName('name');
+    if (nameField === null)
+        return null;
+    return nameField.text;
+}
+function buildThisBinding(anchorNode, typeText) {
+    const m = {
+        '@type-binding.this': nodeToCapture('@type-binding.this', anchorNode),
+        '@type-binding.name': syntheticCapture('@type-binding.name', anchorNode, 'this'),
+        '@type-binding.type': syntheticCapture('@type-binding.type', anchorNode, typeText),
+    };
+    return m;
+}

package/dist/core/ingestion/languages/typescript/scope-resolver.d.ts

@@ -0,0 +1,16 @@
+/**
+ * TypeScript `ScopeResolver` registered in `SCOPE_RESOLVERS` and
+ * consumed by the generic `runScopeResolution` orchestrator
+ * (RFC #909 Ring 3).
+ *
+ * Third migration after Python and C#. Follows the same minimal
+ * wiring-only pattern — per-hook logic lives in the sibling modules
+ * (`arity.ts`, `merge-bindings.ts`, `import-target.ts`, etc.).
+ *
+ * See ./index.ts for the per-module rationale and the full list of
+ * known limitations. The canonical capture vocabulary is pinned in
+ * ./query.ts (TYPESCRIPT_SCOPE_QUERY constant).
+ */
+import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
+declare const typescriptScopeResolver: ScopeResolver;
+export { typescriptScopeResolver };

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

@@ -0,0 +1,113 @@
+/**
+ * TypeScript `ScopeResolver` registered in `SCOPE_RESOLVERS` and
+ * consumed by the generic `runScopeResolution` orchestrator
+ * (RFC #909 Ring 3).
+ *
+ * Third migration after Python and C#. Follows the same minimal
+ * wiring-only pattern — per-hook logic lives in the sibling modules
+ * (`arity.ts`, `merge-bindings.ts`, `import-target.ts`, etc.).
+ *
+ * See ./index.ts for the per-module rationale and the full list of
+ * known limitations. The canonical capture vocabulary is pinned in
+ * ./query.ts (TYPESCRIPT_SCOPE_QUERY constant).
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { typescriptProvider } from '../typescript.js';
+import { loadTsconfigPaths } from '../../language-config.js';
+import { typescriptArityCompatibility, typescriptMergeBindings, resolveTsTarget, } from './index.js';
+/**
+ * Build a `resolveImportTarget` adapter that memoizes the workspace
+ * file list, the lower-cased file list, and the per-pass `resolveCache`
+ * across every import lookup in a single workspace pass. The
+ * orchestrator passes the same `ReadonlySet` reference for every call
+ * within a pass — we use that identity to detect when the workspace
+ * changes and recompute the derived state lazily.
+ *
+ * Without this memoization, `resolveTsTarget` re-derived
+ * `allFileList` and `normalizedFileList` (both O(N_files)) and threw
+ * away the `resolveCache` on every import — O(N_files × N_imports)
+ * total work for what should be O(N_files + N_imports).
+ */
+function makeTsResolveImportTarget() {
+    let cached = null;
+    return (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
+        if (cached === null || cached.key !== allFilePaths) {
+            const allFileList = Array.from(allFilePaths);
+            cached = {
+                key: allFilePaths,
+                allFilePaths: new Set(allFilePaths),
+                allFileList,
+                normalizedFileList: allFileList.map((f) => f.toLowerCase()),
+                resolveCache: new Map(),
+            };
+        }
+        const cfg = resolutionConfig;
+        const ws = {
+            fromFile,
+            allFilePaths: cached.allFilePaths,
+            allFileList: cached.allFileList,
+            normalizedFileList: cached.normalizedFileList,
+            resolveCache: cached.resolveCache,
+            tsconfigPaths: cfg?.tsconfigPaths ?? null,
+        };
+        return resolveTsTarget(targetRaw, ws);
+    };
+}
+const typescriptScopeResolver = {
+    language: SupportedLanguages.TypeScript,
+    languageProvider: typescriptProvider,
+    importEdgeReason: 'typescript-scope: import',
+    resolveImportTarget: makeTsResolveImportTarget(),
+    // Threaded into `resolveImportTarget` so tsconfig path aliases
+    // (`@/services/user`, `~/x`, …) resolve through the same standard
+    // resolver branch the legacy DAG uses. One I/O round-trip per
+    // workspace pass; the orchestrator awaits this once.
+    loadResolutionConfig: async (repoPath) => ({
+        tsconfigPaths: await loadTsconfigPaths(repoPath),
+    }),
+    // TypeScript declaration merging + LEGB: local > import > wildcard,
+    // separated by declaration space (value / type / namespace). The
+    // per-scope id is unused (shadowing is computed from origin + def.type),
+    // so we don't need to synthesize a Scope here.
+    mergeBindings: (existing, incoming) => [...typescriptMergeBindings([...existing, ...incoming])],
+    // Adapter: typescriptArityCompatibility uses (def, callsite); the
+    // ScopeResolver contract is (callsite, def).
+    arityCompatibility: (callsite, def) => typescriptArityCompatibility(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    // TypeScript uses `super` for super-class dispatch as a plain
+    // identifier or as `super()` in constructors. Match both — `super`
+    // on its own (`super.foo`, `super[x]`) and `super(...)` (constructor
+    // chain). This also correctly rejects identifiers that merely
+    // contain the substring `super` (e.g. `superman`).
+    isSuperReceiver: (text) => /^super(\s*\(|\s*\.|\s*\[|\s*$)/.test(text.trim()),
+    // TypeScript is statically typed — field-fallback heuristic off
+    // (the type-binding layer produces precise owner types). Return-
+    // type propagation across imports on (matches the legacy DAG's
+    // behavior: explicit return-type annotations flow across `export`
+    // boundaries and resolve chained member calls).
+    fieldFallbackOnMethodLookup: false,
+    propagatesReturnTypesAcrossImports: true,
+    // TypeScript uses `.values()` / `.keys()` method-call syntax for
+    // collection views — no property-style accessors like C#'s
+    // `Dictionary<K,V>.Values`. Leave `unwrapCollectionAccessor`
+    // undefined and let the regular member-call branch handle them.
+    //
+    // `collapseMemberCallsByCallerTarget` left undefined (= false) —
+    // TypeScript legacy DAG emits one edge per call site, so
+    // per-site dedup is the parity target.
+    //
+    // `populateNamespaceSiblings` left undefined — TypeScript requires
+    // an explicit `import` / namespace augmentation for cross-file
+    // visibility; there's no implicit same-namespace sibling rule
+    // like C#'s.
+    //
+    // `hoistTypeBindingsToModule` — `tsBindingScopeFor` DOES hoist
+    // method return-type bindings to the enclosing Module scope
+    // (mirrors C#), so enable the walk-up that lets the compound-
+    // receiver resolver find them.
+    hoistTypeBindingsToModule: true,
+};
+export { typescriptScopeResolver };

package/dist/core/ingestion/languages/typescript/simple-hooks.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Trivial / no-op-ish hooks for the TypeScript provider. Kept together
+ * because each is a few lines and they share a common theme: making
+ * the provider's choice explicit rather than relying on "absence ==
+ * default" so reviewers don't have to re-derive the analysis.
+ */
+import type { CaptureMatch, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } from '../../../../_shared/index.js';
+/**
+ * TypeScript/JavaScript has block-scoped `let`/`const` (the innermost
+ * default covers these) but function-scoped `var` — which hoists to
+ * the enclosing **function or module** scope, bypassing intermediate
+ * blocks. JS also function-hoists `function_declaration` to the same
+ * level.
+ *
+ * We distinguish var from let/const by sniffing the `@declaration.variable`
+ * capture's leading keyword. The capture's text begins with the
+ * source-literal keyword (`var ` / `let ` / `const `) because the
+ * anchor is the outer `lexical_declaration` / `variable_declaration`
+ * node — there's no whitespace before the keyword in any well-formed
+ * TS/JS source.
+ *
+ * Additionally hoists **method return-type bindings**
+ * (`@type-binding.return`) all the way to the Module scope, matching
+ * C#: the compound-receiver walker and `propagateImportedReturnTypes`
+ * both read from module-level typeBindings for cross-file chain
+ * propagation.
+ */
+export declare function tsBindingScopeFor(decl: CaptureMatch, innermost: Scope, tree: ScopeTree): ScopeId | null;
+/**
+ * TypeScript imports are syntactically top-level: `import_statement` is
+ * legal only inside `program` (the module root). `namespace X { … }`
+ * bodies CAN contain imports (`internal_module`), in which case the
+ * import scopes to the namespace. Dynamic `import()` calls appear
+ * inside any scope but their runtime effect is still a module-level
+ * resolution — we attach the `ParsedImport` to the innermost Module /
+ * Namespace scope so the binding is visible through the full subtree.
+ *
+ * Returning `null` delegates to the central default, which walks to
+ * the nearest enclosing `Module`/`Namespace`. That matches our rule,
+ * so we only override when we explicitly need a non-default scope
+ * (we don't).
+ */
+export declare function tsImportOwningScope(_imp: ParsedImport, _innermost: Scope, _tree: ScopeTree): ScopeId | null;
+/**
+ * Look up `this` on the function scope's type bindings.
+ *
+ * `this` is synthesized as a type binding on instance-method function
+ * scopes during capture emission (`receiver-binding.ts`). Arrow
+ * functions and nested functions that reference `this` naturally
+ * resolve it via the scope-chain walk — if the arrow function is a
+ * class method (`m = () => {}`), it gets a synthesized `this`; if it
+ * is nested inside a class method, the scope-chain lookup finds the
+ * outer method's `this`. This mirrors TypeScript's lexical-this
+ * semantics for arrow functions.
+ *
+ * Returns `null` for:
+ *   - static methods (no `this` synthesized)
+ *   - free functions / module-level code (no enclosing class-like)
+ *   - non-Function scopes
+ *
+ * Caveat: a non-arrow `function` declaration nested inside a method
+ * DOES see the outer `this` via our scope-chain lookup, even though at
+ * runtime its `this` is independently bound (strict-mode `undefined`,
+ * sloppy `globalThis`). We accept this false-positive — the real-world
+ * pattern that relies on independent `this` inside a nested regular
+ * function inside a class method is extremely rare, and catching it
+ * would require injecting a `this: undefined` shadow on every non-
+ * arrow function scope. Documented as a known limitation in
+ * `index.ts`.
+ */
+export declare function tsReceiverBinding(functionScope: Scope): TypeRef | null;

package/dist/core/ingestion/languages/typescript/simple-hooks.js

@@ -0,0 +1,131 @@
+/**
+ * Trivial / no-op-ish hooks for the TypeScript provider. Kept together
+ * because each is a few lines and they share a common theme: making
+ * the provider's choice explicit rather than relying on "absence ==
+ * default" so reviewers don't have to re-derive the analysis.
+ */
+// ─── bindingScopeFor ──────────────────────────────────────────────────────
+/**
+ * TypeScript/JavaScript has block-scoped `let`/`const` (the innermost
+ * default covers these) but function-scoped `var` — which hoists to
+ * the enclosing **function or module** scope, bypassing intermediate
+ * blocks. JS also function-hoists `function_declaration` to the same
+ * level.
+ *
+ * We distinguish var from let/const by sniffing the `@declaration.variable`
+ * capture's leading keyword. The capture's text begins with the
+ * source-literal keyword (`var ` / `let ` / `const `) because the
+ * anchor is the outer `lexical_declaration` / `variable_declaration`
+ * node — there's no whitespace before the keyword in any well-formed
+ * TS/JS source.
+ *
+ * Additionally hoists **method return-type bindings**
+ * (`@type-binding.return`) all the way to the Module scope, matching
+ * C#: the compound-receiver walker and `propagateImportedReturnTypes`
+ * both read from module-level typeBindings for cross-file chain
+ * propagation.
+ */
+export function tsBindingScopeFor(decl, innermost, tree) {
+    // Method return type: hoist to Module (mirrors csharpBindingScopeFor).
+    if (decl['@type-binding.return'] !== undefined) {
+        return walkToScope(innermost, tree, 'Module');
+    }
+    // Parameter property (`constructor(public address: Address)`): hoist
+    // to the enclosing Class scope so `user.address` field access
+    // resolves through the class's typeBindings. The regular
+    // @type-binding.parameter binding still fires for the constructor
+    // scope; this one adds a second binding on the class.
+    if (decl['@type-binding.parameter-property'] !== undefined) {
+        return walkToScope(innermost, tree, 'Class');
+    }
+    // `var` declarations: hoist to nearest enclosing Function or Module.
+    const variable = decl['@declaration.variable'];
+    if (variable !== undefined && isVarDeclaration(variable.text)) {
+        return walkToScope(innermost, tree, 'Function', 'Module');
+    }
+    // Function declarations are already anchored at their definition
+    // site via `@scope.function`; hoisting is a no-op for them (JS
+    // function hoisting is about visibility before the definition, not
+    // about placing the binding in a different scope). The scope tree
+    // already attaches their name to the enclosing scope. No override
+    // needed.
+    return null;
+}
+/**
+ * Walk up the scope chain to find the first scope whose `kind` matches
+ * any of `kinds`. Returns the matching scope's id or `null` when no
+ * ancestor matches (e.g., a return type binding emitted outside any
+ * Module scope — shouldn't happen in well-formed input).
+ */
+function walkToScope(from, tree, ...kinds) {
+    let cur = from;
+    const kindSet = new Set(kinds);
+    while (cur !== undefined) {
+        if (kindSet.has(cur.kind))
+            return cur.id;
+        const parentId = cur.parent ?? null;
+        if (parentId === null)
+            break;
+        cur = tree.getScope(parentId);
+    }
+    return null;
+}
+/** `var x = 1;` vs `let x = 1;` / `const x = 1;`. The capture's text
+ *  starts at the outer declaration's `startIndex` in source, which is
+ *  the keyword's first character — no leading whitespace possible. */
+function isVarDeclaration(captureText) {
+    return (captureText.startsWith('var ') ||
+        captureText.startsWith('var\t') ||
+        captureText.startsWith('var\n'));
+}
+// ─── importOwningScope ────────────────────────────────────────────────────
+/**
+ * TypeScript imports are syntactically top-level: `import_statement` is
+ * legal only inside `program` (the module root). `namespace X { … }`
+ * bodies CAN contain imports (`internal_module`), in which case the
+ * import scopes to the namespace. Dynamic `import()` calls appear
+ * inside any scope but their runtime effect is still a module-level
+ * resolution — we attach the `ParsedImport` to the innermost Module /
+ * Namespace scope so the binding is visible through the full subtree.
+ *
+ * Returning `null` delegates to the central default, which walks to
+ * the nearest enclosing `Module`/`Namespace`. That matches our rule,
+ * so we only override when we explicitly need a non-default scope
+ * (we don't).
+ */
+export function tsImportOwningScope(_imp, _innermost, _tree) {
+    return null;
+}
+// ─── receiverBinding ──────────────────────────────────────────────────────
+/**
+ * Look up `this` on the function scope's type bindings.
+ *
+ * `this` is synthesized as a type binding on instance-method function
+ * scopes during capture emission (`receiver-binding.ts`). Arrow
+ * functions and nested functions that reference `this` naturally
+ * resolve it via the scope-chain walk — if the arrow function is a
+ * class method (`m = () => {}`), it gets a synthesized `this`; if it
+ * is nested inside a class method, the scope-chain lookup finds the
+ * outer method's `this`. This mirrors TypeScript's lexical-this
+ * semantics for arrow functions.
+ *
+ * Returns `null` for:
+ *   - static methods (no `this` synthesized)
+ *   - free functions / module-level code (no enclosing class-like)
+ *   - non-Function scopes
+ *
+ * Caveat: a non-arrow `function` declaration nested inside a method
+ * DOES see the outer `this` via our scope-chain lookup, even though at
+ * runtime its `this` is independently bound (strict-mode `undefined`,
+ * sloppy `globalThis`). We accept this false-positive — the real-world
+ * pattern that relies on independent `this` inside a nested regular
+ * function inside a class method is extremely rare, and catching it
+ * would require injecting a `this: undefined` shadow on every non-
+ * arrow function scope. Documented as a known limitation in
+ * `index.ts`.
+ */
+export function tsReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('this') ?? null;
+}

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

@@ -26,6 +26,7 @@ import { typescriptVariableConfig, javascriptVariableConfig, } from '../variable
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { typescriptCallConfig, javascriptCallConfig, } from '../call-extractors/configs/typescript-javascript.js';
 import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { emitTsScopeCaptures, interpretTsImport, interpretTsTypeBinding, tsBindingScopeFor, tsImportOwningScope, tsReceiverBinding, typescriptMergeBindings, typescriptArityCompatibility, resolveTsImportTarget, } from './typescript/index.js';
 /**
  * TypeScript/JavaScript: arrow_function and function_expression get their name
  * from the parent variable_declarator (e.g. `const foo = () => {}`).
@@ -162,6 +163,24 @@ export const typescriptProvider = defineLanguage({
     classExtractor: createClassExtractor(typescriptClassConfig),
     heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
     builtInNames: BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    // TypeScript is the third migration after Python and C#. See
+    // ./typescript/index.ts for the full per-hook rationale and the
+    // canonical capture vocabulary in ./typescript/query.ts
+    // (TYPESCRIPT_SCOPE_QUERY constant).
+    emitScopeCaptures: emitTsScopeCaptures,
+    interpretImport: interpretTsImport,
+    interpretTypeBinding: interpretTsTypeBinding,
+    bindingScopeFor: tsBindingScopeFor,
+    importOwningScope: tsImportOwningScope,
+    // Merge precedence is decided from BindingRef origin + declaration
+    // space only. The central finalizer already calls this per (scope,
+    // name), so the Scope object itself intentionally does not affect
+    // TypeScript declaration merging.
+    mergeBindings: (_scope, bindings) => typescriptMergeBindings(bindings),
+    receiverBinding: tsReceiverBinding,
+    arityCompatibility: typescriptArityCompatibility,
+    resolveImportTarget: resolveTsImportTarget,
 });
 export const javascriptProvider = defineLanguage({
     id: SupportedLanguages.JavaScript,

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

@@ -1,5 +1,5 @@
 // gitnexus/src/core/ingestion/method-extractors/configs/swift.ts
-// Verified against tree-sitter-swift 0.6.0
+// Verified against tree-sitter-swift 0.7.x
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { findVisibility, hasKeyword, hasModifier } from '../../field-extractors/configs/helpers.js';
 import { extractSimpleTypeName } from '../../type-extractors/shared.js';
@@ -97,7 +97,7 @@ function extractSwiftReturnType(node) {
  */
 function extractSwiftParameters(node) {
     const params = [];
-    // In tree-sitter-swift 0.6.0, parameters are direct children of function_declaration.
+    // In tree-sitter-swift, parameters are direct children of function_declaration.
     // Default value tokens ('=', literal) are siblings of the parameter node at the
     // function_declaration level, not children of the parameter node.
     for (let i = 0; i < node.childCount; i++) {
@@ -242,8 +242,7 @@ function extractSwiftAnnotations(node) {
 // ---------------------------------------------------------------------------
 export const swiftMethodConfig = {
     language: SupportedLanguages.Swift,
-    // tree-sitter-swift 0.6.0 may use class_declaration for classes, structs, enums, extensions,
-    // and actors — but this cannot be verified until the grammar installs on Node 22+.
+    // Keep this conservative until Swift type-shape coverage is expanded.
     // TODO: Verify struct_declaration, enum_declaration, extension_declaration, actor_declaration
     // node types once tree-sitter-swift loads on Node 22, and add them here if they are distinct.
     // protocol_declaration is a separate, confirmed node type.

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