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

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

@@ -71,7 +71,7 @@ const TSX_GRAMMAR = TS.tsx;
 function isTsxFile(filePath) {
     return filePath.endsWith('.tsx');
 }
-const TYPESCRIPT_SCOPE_QUERY = `
+export const TYPESCRIPT_SCOPE_QUERY = `
 ;; Scopes — module / namespace / class-likes / function-likes
 (program) @scope.module
 
@@ -87,14 +87,53 @@ const TYPESCRIPT_SCOPE_QUERY = `
 ;; class expressions omit it); ScopeExtractor tolerates missing names.
 (class) @scope.class
 
-(function_declaration) @scope.function
-(generator_function_declaration) @scope.function
-(function_signature) @scope.function
-(method_definition) @scope.function
-(method_signature) @scope.function
-(abstract_method_signature) @scope.function
+;; \`@receiver-owner.this\` marks a scope that BINDS its own \`this\` rather
+;; than inheriting one (#2701) — see \`Scope.ownsReceivers\`. Every function
+;; form except \`arrow_function\` carries it: ECMA-262 gives an arrow
+;; \`[[ThisMode]] = lexical\` (no \`this\` in its environment record, so the
+;; lookup passes through), while every other form binds \`this\` at call time.
+;; \`method_definition\` is marked too and is unaffected — it also carries a
+;; synthesized \`this\` typeBinding, which the walk consults first.
+;; The marker rides on the same node as \`@scope.function\`; it is outside the
+;; \`@scope.\` namespace so \`anchorCaptureFor\` cannot mistake it for the anchor.
+(function_declaration) @scope.function @receiver-owner.this
+(generator_function_declaration) @scope.function @receiver-owner.this
+(function_signature) @scope.function @receiver-owner.this
+(method_definition) @scope.function @receiver-owner.this
+(method_signature) @scope.function @receiver-owner.this
+(abstract_method_signature) @scope.function @receiver-owner.this
 (arrow_function) @scope.function
-(function_expression) @scope.function
+(function_expression) @scope.function @receiver-owner.this
+;; \`function*(){}\` as an EXPRESSION. Absent from this list before #2701, so it
+;; was not a scope at all and \`this\` inside one read as the enclosing method's.
+(generator_function) @scope.function @receiver-owner.this
+
+;; Object literals (the { ... } value expression, NOT object_type or
+;; object_pattern) get their own scope boundary. Without it, a
+;; method_definition/property-arrow's auto-hoist (scope-extractor.ts)
+;; has nowhere to stop and leaks the name past the literal into whatever
+;; lexically encloses it -- e.g. 'export default { async fetch(req) {} }'
+;; would bind fetch at Module scope, letting an unrelated same-file
+;; fetch(...) call (the platform global) incorrectly resolve to it
+;; (#2545). Object (not Block or Class): object-literal members are
+;; reachable only via property access, never as bare identifiers -- not
+;; even by a SIBLING property's function body, unlike a real Block
+;; (if/for/while, where a nested closure legitimately sees a sibling
+;; let/const) or a Class (implicit-this sibling dispatch). Scope-chain
+;; walkers (scope-resolution/scope/walkers.ts) skip an Object scope's
+;; own bindings entirely while still treating it as a hoist boundary
+;; (#2551).
+(object) @scope.object
+
+;; Statement blocks are BINDING scopes (#2699). ECMAScript gives every block its
+;; own environment record, so \`let\`/\`const\`/\`class\`/\`function\` declared in
+;; sibling blocks of one function are DIFFERENT bindings — without this the
+;; resolver sees both as function-level and a call in one branch resolves to
+;; both. \`tsBindingScopeFor\` already implements the other half of the rule:
+;; \`var\` hoists past blocks to the enclosing Function/Module, \`let\`/\`const\`
+;; take the innermost scope, which is now the block.
+(statement_block) @scope.block
+
 
 ;; Type aliases that contain an object_type are structurally class-like —
 ;; they define a shape with named members. Emit @scope.class so the
@@ -104,30 +143,45 @@ const TYPESCRIPT_SCOPE_QUERY = `
   value: (object_type)) @scope.class
 
 ;; Declarations — types
+;; The type-parameter list is captured with \`?\` rather than as a second
+;; pattern: a separate rule would make a GENERIC declaration match twice, and
+;; both matches mint the same def id (filePath+range+type+name), so which one
+;; survived — the one carrying the parameters or the one without — would be
+;; decided by match order. An optional child keeps it at one match either way.
 (class_declaration
-  name: (type_identifier) @declaration.name) @declaration.class
+  name: (type_identifier) @declaration.name
+  type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.class
 
 (abstract_class_declaration
-  name: (type_identifier) @declaration.name) @declaration.class
+  name: (type_identifier) @declaration.name
+  type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.class
 
 (interface_declaration
-  name: (type_identifier) @declaration.name) @declaration.interface
+  name: (type_identifier) @declaration.name
+  type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.interface
 
 (enum_declaration
   name: (identifier) @declaration.name) @declaration.enum
 
+;; Tagged @declaration.type_alias, NOT @declaration.type: normalizeNodeLabel
+;; accepts typealias / type_alias and has no "type" case, so the old tag mapped
+;; to no label and TypeScript aliases produced NO scope-resolution def at all.
+;; Kotlin and Dart already spell it this way.
 (type_alias_declaration
-  name: (type_identifier) @declaration.name) @declaration.type
+  name: (type_identifier) @declaration.name
+  type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.type_alias
 
 (internal_module
   name: (identifier) @declaration.name) @declaration.namespace
 
 ;; Declarations — methods / functions / constructors
 (function_declaration
-  name: (identifier) @declaration.name) @declaration.function
+  name: (identifier) @declaration.name
+  type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.function
 
 (generator_function_declaration
-  name: (identifier) @declaration.name) @declaration.function
+  name: (identifier) @declaration.name
+  type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.function
 
 ;; Function overload signatures (declaration-only; body in a separate
 ;; function_declaration). Extractors dedup by (name, parameterTypes).
@@ -169,6 +223,51 @@ const TYPESCRIPT_SCOPE_QUERY = `
     name: (identifier) @declaration.name
     value: (function_expression) @declaration.function))
 
+;; CJS property-assignment exports (#2723) — see the matching block in
+;; \`languages/javascript/query.ts\` for the rationale. Mirrored here because
+;; \`.ts\` files in a CommonJS package use the same form, and because the JS
+;; provider delegates several hooks to these TypeScript counterparts.
+;; One pattern per receiver form, RHS forms folded into an inner LEAF
+;; alternation — see the matching note in \`languages/javascript/query.ts\` for
+;; why that shape is safe under the tree-sitter 0.21.1 alternation hazard.
+(assignment_expression
+  left: (member_expression
+    object: (identifier) @_cjs.receiver
+    property: (property_identifier) @declaration.name)
+  right: [
+    (arrow_function)
+    (function_expression)
+    (generator_function)
+  ] @declaration.function)
+
+;; \`this.X = fn\` at MODULE level of a CommonJS file — there \`this\` IS
+;; \`module.exports\`, so this declares an export. Pruned emit-side for ESM
+;; files (where top-level \`this\` is undefined) and for a \`this\` inside a
+;; function, which is an instance member rather than an export.
+(assignment_expression
+  left: (member_expression
+    object: (this)
+    property: (property_identifier) @declaration.name)
+  right: [
+    (arrow_function)
+    (function_expression)
+    (generator_function)
+  ] @declaration.function)
+
+(assignment_expression
+  left: (member_expression
+    object: (member_expression
+      object: (identifier) @_cjs.module
+      property: (property_identifier) @_cjs.exports)
+    property: (property_identifier) @declaration.name)
+  right: [
+    (arrow_function)
+    (function_expression)
+    (generator_function)
+  ] @declaration.function
+  (#eq? @_cjs.module "module")
+  (#eq? @_cjs.exports "exports"))
+
 ;; Object-property arrows / function expressions named by their pair key:
 ;; \`{ addItem: (item) => ..., removeItem: (item) => ... }\`. The legacy
 ;; TYPESCRIPT_QUERIES emits the same shape; mirroring it here keeps
@@ -407,6 +506,48 @@ const TYPESCRIPT_SCOPE_QUERY = `
 (method_signature
   name: (property_identifier) @declaration.name) @declaration.method
 
+;; Members of a declared SHAPE — interface bodies and object-type aliases both
+;; spell them as property_signature (A4). The sibling method_signature rule
+;; above declared interface METHODS, so only properties were missing: a typed
+;; receiver resolved to the shape's scope and then found no member there, and
+;; the field's consumers were unreachable. TypeScript sets
+;; fieldFallbackOnMethodLookup:false, so there is no name-based safety net
+;; here — the precise path is the only one, and it needs the declaration.
+;; ANCHORED to declared shapes — see the matching rule in TYPESCRIPT_QUERIES
+;; for why. Unanchored this matched inline parameter and return types and
+;; nested object types, whose members then collided onto the enclosing
+;; class/interface/alias.
+(interface_body
+  (property_signature
+    name: (property_identifier) @declaration.name) @declaration.property)
+
+;; Object-literal keys of a NAMED object — the scope-resolution half of the
+;; matching rule in TYPESCRIPT_QUERIES. The parse query mints the Property NODE;
+;; this mints the DEF a precise read can resolve to.
+(variable_declarator
+  name: (identifier)
+  value: (object
+    (pair
+      key: (property_identifier) @declaration.name) @declaration.property))
+
+(variable_declarator
+  name: (identifier)
+  value: (call_expression
+    function: (member_expression
+      object: (identifier) @_ts.identity.obj
+      property: (property_identifier) @_ts.identity.fn)
+    arguments: (arguments
+      (object
+        (pair
+          key: (property_identifier) @declaration.name) @declaration.property)))
+  (#eq? @_ts.identity.obj "Object")
+  (#match? @_ts.identity.fn "^(freeze|seal|preventExtensions)$"))
+
+(type_alias_declaration
+  value: (object_type
+    (property_signature
+      name: (property_identifier) @declaration.name) @declaration.property))
+
 ;; Declarations — class fields
 (public_field_definition
   name: (property_identifier) @declaration.name) @declaration.property
@@ -791,6 +932,40 @@ const TYPESCRIPT_SCOPE_QUERY = `
   type: (type_annotation
     (type_identifier) @type-binding.type)) @type-binding.annotation
 
+;; Type bindings — class field constructor-inferred: \`private p = new Outer()\`.
+;; The annotation patterns above cover a field that DECLARES its type; a field
+;; whose type must be inferred from its initializer matched nothing, so it had
+;; no typeBinding, so \`this.p\` could not be typed and the receiver fold declined
+;; the whole chain — losing even the first, ordinary named link (#2807).
+;;
+;; Anchored on \`public_field_definition\` exactly like the annotation patterns,
+;; so the binding lands in the same (class body) scope with no bindingScopeFor
+;; override. \`annotation\` outranks \`constructor-inferred\` in
+;; typeBindingStrength, so \`private p: Outer = new Outer()\` still resolves
+;; through its annotation regardless of which pattern matches first.
+;;
+;; Kotlin and Swift express both a local and a stored property with ONE grammar
+;; node (property_declaration) and so needed no separate field pattern; the
+;; TypeScript grammar splits them (variable_declarator vs
+;; public_field_definition), which is why only the local form was ever covered.
+(public_field_definition
+  name: (property_identifier) @type-binding.name
+  value: (new_expression
+    constructor: (identifier) @type-binding.type)) @type-binding.constructor
+
+;; Qualified: \`private p = new models.Outer()\` — mirrors the local form above;
+;; the member_expression's text is resolved via QualifiedNameIndex.
+(public_field_definition
+  name: (property_identifier) @type-binding.name
+  value: (new_expression
+    constructor: (member_expression) @type-binding.type)) @type-binding.constructor
+
+;; Private-name field: \`#p = new Outer()\`.
+(public_field_definition
+  name: (private_property_identifier) @type-binding.name
+  value: (new_expression
+    constructor: (identifier) @type-binding.type)) @type-binding.constructor
+
 ;; Type bindings — method return type: \`save(): User { … }\` / \`function f(): User { … }\`.
 ;; Function/method return-type is the type_annotation that is a direct
 ;; child of the function node (not the parameter's annotation). Anchor on
@@ -919,6 +1094,78 @@ const TYPESCRIPT_SCOPE_QUERY = `
   right: (new_expression
     constructor: (identifier) @type-binding.type)) @type-binding.constructor
 
+;; Type bindings — field assigned through \`this\`: \`this.p = new Outer()\` on a
+;; field that declares no type (#2807). The rebind pattern above only matches a
+;; bare identifier LHS, so an unannotated field assigned in the constructor had
+;; no typeBinding at all. (An ANNOTATED field does not need this — its
+;; annotation already types it, which is why \`private p: Outer;\` + the same
+;; assignment always resolved.)
+;;
+;; The nesting is the whole safety property. \`this.x = new Y()\` is a legal
+;; statement ANYWHERE, and the binding it produces is hoisted onto the nearest
+;; enclosing Class — so a context-free version of this pattern typed a class's
+;; field from an assignment whose \`this\` was some OTHER object, overwriting the
+;; field's real type (pass4CollectTypeBindings resolves a same-source tie in
+;; favour of the LATER match). Requiring the chain
+;; \`class_body → method_definition → statement_block → expression_statement\`
+;; makes the marker fire only where \`this\` provably IS an instance of the class
+;; the binding lands on. It rejects, in order of how easily each was hit:
+;; a non-arrow callback inside a method (\`function () { this.x = new Y(); }\` —
+;; \`this\` is the call's receiver), an object-literal method (also a
+;; \`method_definition\`, but under \`object\`, not \`class_body\`), and module top
+;; level (no enclosing Class at all, where the hoist used to fall back to the
+;; innermost scope and could overwrite a module local of the same name).
+;;
+;; This mirrors \`synthesizeConstructorFieldBindings\` in
+;; \`languages/javascript/captures.ts\`, which walks only \`method_definition\`
+;; bodies and only their DIRECT \`expression_statement\` children — the two
+;; languages must not read the same source differently. TypeScript accepts any
+;; method rather than only \`constructor\` (a later \`setUp()\` assignment types
+;; the field just as well), which is the one intended divergence.
+;;
+;; Two shapes are deliberately NOT matched, both erring toward no binding:
+;; an assignment nested in a block (\`if (…) { this.p = new Outer(); }\`) and one
+;; inside an arrow (\`() => { this.p = new Outer(); }\`, where \`this\` IS the
+;; instance). Both are only ever a MISSING binding, never a wrong one, and JS
+;; declines them too.
+;;
+;; \`@type-binding.this-field\` is a MARKER, not the anchor: it sits on the narrow
+;; \`(this)\` node, so anchorCaptureFor's broadest-range rule keeps the whole
+;; assignment_expression (@type-binding.constructor) as the anchor and the
+;; source stays \`constructor-inferred\`. tsBindingScopeFor reads the marker to
+;; hoist the binding onto the enclosing Class scope — without that hoist the
+;; binding would land on the method's own Function scope, where
+;; typeOfMemberOnClass never looks. The marker must stay specific to THIS
+;; pattern: hoisting every constructor-inferred binding would move method-local
+;; \`const o = new Outer()\` out of its own scope.
+;;
+;; One constraint the grammar cannot carry: \`static\` is an ANONYMOUS token on
+;; \`method_definition\` with no field name, and tree-sitter patterns cannot
+;; negate one. \`this\` in a static method is the class object, so that last
+;; wrong receiver is dropped by \`emitTsScopeCaptures\` instead.
+(class_body
+  (method_definition
+    body: (statement_block
+      (expression_statement
+        (assignment_expression
+          left: (member_expression
+            object: (this) @type-binding.this-field
+            property: (property_identifier) @type-binding.name)
+          right: (new_expression
+            constructor: (identifier) @type-binding.type)) @type-binding.constructor))))
+
+;; Qualified form: \`this.p = new models.Outer()\`.
+(class_body
+  (method_definition
+    body: (statement_block
+      (expression_statement
+        (assignment_expression
+          left: (member_expression
+            object: (this) @type-binding.this-field
+            property: (property_identifier) @type-binding.name)
+          right: (new_expression
+            constructor: (member_expression) @type-binding.type)) @type-binding.constructor))))
+
 (assignment_expression
   left: (identifier) @type-binding.name
   right: (call_expression
@@ -987,6 +1234,85 @@ const TYPESCRIPT_SCOPE_QUERY = `
 (member_expression
   object: (_) @reference.receiver
   property: (property_identifier) @reference.name) @reference.read.member
+
+;; References — value position (#2437): a function identifier assigned as an
+;; object-literal property value (\`{ emitScopeCaptures: emitCppScopeCaptures }\`)
+;; or shorthand (\`{ emitHook }\`). Resolution keeps only callable targets
+;; (MethodRegistry), so plain-value pairs (\`{ port: DEFAULT_PORT }\`) emit
+;; nothing; the emitted edge is a reference-class USES (registration ≠
+;; invocation). \`@reference.property-key\` records the key so the
+;; property-dispatch pass can synthesize CALLS at \`x.<key>()\` sites; for
+;; shorthand the key IS the name (both tags on one node). Two separate
+;; patterns — never combined in \`[...]\` (tree-sitter 0.21 drops alternation
+;; siblings around predicates). Destructuring shorthand is a different node
+;; (\`shorthand_property_identifier_pattern\`), so \`const { a } = o\` cannot
+;; match; string/computed keys carry no \`property_identifier\` and register
+;; without a dispatch key.
+(pair
+  key: (property_identifier) @reference.property-key
+  value: (identifier) @reference.name @reference.value-ref)
+
+(object
+  (shorthand_property_identifier) @reference.name @reference.property-key @reference.value-ref)
+
+;; Bare-identifier reads (A2), VALUE POSITIONS ONLY — a blanket \`(identifier)\`
+;; rule would mint a site for every token in the file.
+;;
+;; These existed only in the JavaScript query, so A2 did not work for
+;; TypeScript AT ALL: a \`.ts\` module reading its own \`const\` by bare name
+;; produced no reference site, and "who uses this constant?" answered a
+;; confident zero for an entire language. Found by writing the namespace
+;; fixture below and watching it fail for the wrong reason.
+(arguments
+  (identifier) @reference.name @reference.read.identifier)
+
+(assignment_pattern
+  right: (identifier) @reference.name @reference.read.identifier)
+
+(return_statement
+  (identifier) @reference.name @reference.read.identifier)
+
+;; \`const next = LIMIT\` and \`n > LIMIT\` — both plainly value reads, and both
+;; named in review as gaps between what A2 claimed and what it matched.
+(variable_declarator
+  value: (identifier) @reference.name @reference.read.identifier)
+
+(binary_expression
+  left: (identifier) @reference.name @reference.read.identifier)
+
+(binary_expression
+  right: (identifier) @reference.name @reference.read.identifier)
+
+;; References — TYPE POSITION (R2-2). An annotation naming a declared type is
+;; the only thing that makes that type's declaration reachable from the code
+;; that depends on it, and TypeScript captured none: only cpp and csharp emitted
+;; type references at all. So an exported API-contract type owned its members
+;; (round 1) but had \`incoming: {}\`, and "what breaks if I remove this field?"
+;; — the question a contract type exists to answer — had no edge to walk.
+;;
+;; The resolution path was already complete on the other side:
+;; \`type-reference\` routes to the ClassRegistry, whose CLASS_KINDS already
+;; lists TypeAlias, Interface and Enum, and \`edges.ts\` already maps the kind to
+;; USES. Only the capture was missing.
+;;
+;; Anchored to the CONTEXTS a type is used in — annotations, type arguments,
+;; and heritage \`implements\` — never a bare \`(type_identifier)\`. A blanket rule
+;; would also match the identifier in \`type X = …\` and \`interface X\`, making
+;; every declaration a consumer of itself.
+(type_annotation
+  (type_identifier) @reference.name @reference.type_reference)
+
+(type_annotation
+  (generic_type
+    name: (type_identifier) @reference.name @reference.type_reference))
+
+(type_arguments
+  (type_identifier) @reference.name @reference.type_reference)
+
+;; \`x as SomeType\` / \`satisfies SomeType\` — an assertion is a claim ABOUT a
+;; declared type, so the code making it depends on that declaration.
+(as_expression
+  (type_identifier) @reference.name @reference.type_reference)
 `;
 /**
  * JSX-only query suffix. Appended to the base query when compiling

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

@@ -57,3 +57,20 @@ import { type SyntaxNode } from '../../utils/ast-helpers.js';
  * of the scope function nodes the scope query emits.
  */
 export declare function synthesizeTsReceiverBinding(fnNode: SyntaxNode): CaptureMatch | null;
+/**
+ * Nodes that REBIND `this`, so the walk for an enclosing type must stop at them.
+ *
+ * Without these the walk ran to the top of the file and happily synthesized a binding
+ * from a type that does not own the member. An object-literal method nested in a class
+ * bound `this` to the CLASS:
+ *
+ *     class A { outer() { const o = { inner() { return this.x; } }; return o; } }
+ *
+ * `this` inside `o.inner` is `o`, never `A` — so every `this.…` in such a method
+ * resolved against the wrong type. Only the module-level object literal escaped, because
+ * there was no enclosing class to reach.
+ *
+ * An arrow is deliberately absent: it inherits `this` lexically, so the walk SHOULD pass
+ * through it (that is what makes a class-field arrow `m = () => this.x` resolve).
+ */
+export declare const THIS_REBINDING_BOUNDARY_TYPES: ReadonlySet<string>;

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

@@ -140,9 +140,36 @@ function isStaticMember(memberNode) {
     }
     return false;
 }
+/**
+ * Nodes that REBIND `this`, so the walk for an enclosing type must stop at them.
+ *
+ * Without these the walk ran to the top of the file and happily synthesized a binding
+ * from a type that does not own the member. An object-literal method nested in a class
+ * bound `this` to the CLASS:
+ *
+ *     class A { outer() { const o = { inner() { return this.x; } }; return o; } }
+ *
+ * `this` inside `o.inner` is `o`, never `A` — so every `this.…` in such a method
+ * resolved against the wrong type. Only the module-level object literal escaped, because
+ * there was no enclosing class to reach.
+ *
+ * An arrow is deliberately absent: it inherits `this` lexically, so the walk SHOULD pass
+ * through it (that is what makes a class-field arrow `m = () => this.x` resolve).
+ */
+export const THIS_REBINDING_BOUNDARY_TYPES = new Set([
+    'object', // object literal — `this` is the literal, not any enclosing type
+    'function_declaration',
+    'function_expression',
+    'generator_function',
+    'generator_function_declaration',
+]);
 function findEnclosingType(node) {
     let cur = node.parent;
     while (cur !== null) {
+        // Boundary before the type check: a rebinding node between the member and a type
+        // means the type does not own this `this`.
+        if (THIS_REBINDING_BOUNDARY_TYPES.has(cur.type))
+            return null;
         if (TYPE_DECL_NODE_TYPES.has(cur.type))
             return cur;
         cur = cur.parent;

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

@@ -17,9 +17,10 @@ import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js
 import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
 import { simpleKey } from '../../scope-resolution/graph-bridge/node-lookup.js';
 import { typescriptProvider } from '../typescript.js';
-import { loadTsconfigPaths } from '../../language-config.js';
-import { buildSuffixIndex } from '../../import-resolvers/utils.js';
-import { typescriptArityCompatibility, typescriptMergeBindings, resolveTsTarget, } from './index.js';
+import { loadTsconfigIndex } from './tsconfig.js';
+import { loadNodeWorkspacePackages, } from '../../import-resolvers/node-workspace-packages.js';
+import { indexOnlyElementType } from '../../type-extractors/shared.js';
+import { typescriptArityCompatibility, typescriptMergeBindings, resolveTsTarget } from './index.js';
 import { getNuxtAutoImportEntry, hasNuxtAutoImports, loadNuxtAutoImports, } from './nuxt-auto-imports.js';
 const TYPESCRIPT_TYPE_ONLY_BINDING_TYPES = new Set([
     'Interface',
@@ -31,47 +32,32 @@ const TYPESCRIPT_TYPE_ONLY_BINDING_TYPES = new Set([
     'Decorator',
 ]);
 /**
- * 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.
+ * Build the `resolveImportTarget` adapter.
  *
- * 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).
+ * No per-file-set memo any more: the suffix index it existed to amortize is
+ * gone with #2953. Real resolution derives nothing from the file list — every
+ * candidate comes from a config the repo declares, and checking one is a
+ * `Set.has` — so there is nothing left to cache per pass.
  */
 function makeTsResolveImportTarget() {
-    let cached = null;
     return (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
-        if (cached === null || cached.key !== allFilePaths) {
-            const allFileList = Array.from(allFilePaths);
-            const normalizedFileList = allFileList.map((f) => f.toLowerCase());
-            cached = {
-                key: allFilePaths,
-                allFilePaths: new Set(allFilePaths),
-                allFileList,
-                normalizedFileList,
-                index: buildSuffixIndex(normalizedFileList, allFileList),
-                resolveCache: new Map(),
-            };
-        }
         const cfg = resolutionConfig;
-        const ws = {
+        return resolveTsTarget(targetRaw, {
             fromFile,
-            allFilePaths: cached.allFilePaths,
-            allFileList: cached.allFileList,
-            normalizedFileList: cached.normalizedFileList,
-            index: cached.index,
-            resolveCache: cached.resolveCache,
-            tsconfigPaths: cfg?.tsconfigPaths ?? null,
-        };
-        return resolveTsTarget(targetRaw, ws);
+            allFilePaths,
+            tsconfigs: cfg?.tsconfigs ?? null,
+            nodeWorkspacePackages: cfg?.nodeWorkspacePackages ?? null,
+        });
     };
 }
 const typescriptScopeResolver = {
+    // One hook, both routes. TypeScript exposes collection views as METHOD calls
+    // (`.values()`), which the call-expression branch already handles, so the
+    // accessor route yields nothing here — but it is now the same hook rather
+    // than a second one left undefined.
+    elementTypeOf: indexOnlyElementType,
+    // Construction is keyword-prefixed: `new Service(db).doWork()` (#2708).
+    constructionSyntax: { keyword: 'new' },
     language: SupportedLanguages.TypeScript,
     languageProvider: typescriptProvider,
     importEdgeReason: 'typescript-scope: import',
@@ -83,7 +69,8 @@ const typescriptScopeResolver = {
     // `nuxtAutoImports` is null for non-Nuxt projects (no .nuxt/imports.d.ts),
     // so this adds zero overhead to ordinary TypeScript repos.
     loadResolutionConfig: async (repoPath) => ({
-        tsconfigPaths: await loadTsconfigPaths(repoPath),
+        tsconfigs: await loadTsconfigIndex(repoPath),
+        nodeWorkspacePackages: await loadNodeWorkspacePackages(repoPath),
         nuxtAutoImports: await loadNuxtAutoImports(repoPath),
     }),
     // TypeScript declaration merging + LEGB: local > import > wildcard,
@@ -109,10 +96,10 @@ const typescriptScopeResolver = {
     // 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.
+    // TypeScript uses `.values()` / `.keys()` method-call syntax for collection
+    // views -- no property-style accessors like C#'s `Dictionary<K,V>.Values` --
+    // so `elementTypeOf` answers only the `index` route and lets the regular
+    // member-call branch handle the rest.
     //
     // `collapseMemberCallsByCallerTarget` left undefined (= false) --
     // TypeScript legacy DAG emits one edge per call site, so

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

@@ -26,16 +26,6 @@ import type { CaptureMatch, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } f
  * propagation.
  */
 export declare function tsBindingScopeFor(decl: CaptureMatch, innermost: Scope, tree: ScopeTree): ScopeId | 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).
- *
- * Exported so language-specific hook wrappers (e.g. `jsBindingScopeFor`)
- * can reuse it without duplicating the traversal logic.
- */
-export declare function walkToScope(from: Scope, tree: ScopeTree, ...kinds: readonly Scope['kind'][]): ScopeId | null;
 /**
  * TypeScript imports are syntactically top-level: `import_statement` is
  * legal only inside `program` (the module root). `namespace X { … }`