gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/languages/typescript/array-callback.d.ts

@@ -23,32 +23,6 @@
  * Pure given the input node. No I/O, no globals.
  */
 import type { SyntaxNode } from '../../utils/ast-helpers.js';
-/**
- * Array prototype higher-order methods whose result is a value, not a
- * function. A callback passed to one of these is an anonymous callback,
- * never a top-level function definition. Identifier-callee HOCs
- * (`forwardRef(...)`, `useCallback(...)`, custom factories) are
- * deliberately NOT listed — they keep their `Function` classification.
- *
- * Trade-off (unchanged from before #1876): a custom *fluent-API* member
- * call with a callback whose method name is not in this set
- * (`qb.where(x => …)`) still classifies as `Function`. There is no clean
- * syntactic line beyond the well-known Array surface, so the set is
- * intentionally closed and easy to extend.
- *
- * Receiver-blind, by design: the match keys on the method NAME only, never
- * the receiver type (tree-sitter has no type information here). So an in-set
- * name on a NON-array receiver — `Map`/`Set` `.forEach`, an RxJS
- * `observable.map(…)`, a query builder `.sort(…)`, a lodash chain
- * `.filter(…)` — is ALSO treated as a callback and has its
- * `@declaration.function` dropped. This is an accepted limitation, not a
- * regression: those bindings hold the call's *result value*, not a callable,
- * so a value def is the correct classification anyway. The only genuine loss
- * is a bespoke DSL whose in-set-named method returns something callable —
- * rare enough to accept rather than guard with type inference. Pinned by the
- * "in-set method on a non-array receiver" case in `*-captures.test.ts`.
- */
-export declare const ARRAY_CALLBACK_METHODS: ReadonlySet<string>;
 /**
  * True when `node` (an `arrow_function` / `function_expression`) is the
  * callback argument of an array higher-order-method call, i.e. the
@@ -60,8 +34,8 @@ export declare const ARRAY_CALLBACK_METHODS: ReadonlySet<string>;
  * (`forwardRef(() => …)` — callee is an `identifier`, not a
  * `member_expression`), so neither is ever suppressed.
  *
- * Intentional non-suppressing gaps (preserve current behavior, no
- * regression): parenthesized callee `(arr.map)(cb)` (`parenthesized_expression`)
- * and computed callee `arr['map'](cb)` (`subscript_expression`).
+ * The helper itself only handles direct `member_expression` callees. Broader
+ * shapes like `(arr.map)(cb)` and `arr['map'](cb)` are now filtered at the
+ * query layer, so this emit-side check stays focused on the direct fallback.
  */
 export declare function isArrayMethodCallbackArrow(node: SyntaxNode): boolean;

package/dist/core/ingestion/languages/typescript/array-callback.js

@@ -22,46 +22,7 @@
  *
  * Pure given the input node. No I/O, no globals.
  */
-/**
- * Array prototype higher-order methods whose result is a value, not a
- * function. A callback passed to one of these is an anonymous callback,
- * never a top-level function definition. Identifier-callee HOCs
- * (`forwardRef(...)`, `useCallback(...)`, custom factories) are
- * deliberately NOT listed — they keep their `Function` classification.
- *
- * Trade-off (unchanged from before #1876): a custom *fluent-API* member
- * call with a callback whose method name is not in this set
- * (`qb.where(x => …)`) still classifies as `Function`. There is no clean
- * syntactic line beyond the well-known Array surface, so the set is
- * intentionally closed and easy to extend.
- *
- * Receiver-blind, by design: the match keys on the method NAME only, never
- * the receiver type (tree-sitter has no type information here). So an in-set
- * name on a NON-array receiver — `Map`/`Set` `.forEach`, an RxJS
- * `observable.map(…)`, a query builder `.sort(…)`, a lodash chain
- * `.filter(…)` — is ALSO treated as a callback and has its
- * `@declaration.function` dropped. This is an accepted limitation, not a
- * regression: those bindings hold the call's *result value*, not a callable,
- * so a value def is the correct classification anyway. The only genuine loss
- * is a bespoke DSL whose in-set-named method returns something callable —
- * rare enough to accept rather than guard with type inference. Pinned by the
- * "in-set method on a non-array receiver" case in `*-captures.test.ts`.
- */
-export const ARRAY_CALLBACK_METHODS = new Set([
-    'map',
-    'filter',
-    'find',
-    'findIndex',
-    'findLast',
-    'findLastIndex',
-    'forEach',
-    'reduce',
-    'reduceRight',
-    'some',
-    'every',
-    'flatMap',
-    'sort',
-]);
+import { ARRAY_CALLBACK_METHODS } from '../../ts-js-hoc-utils.js';
 /**
  * True when `node` (an `arrow_function` / `function_expression`) is the
  * callback argument of an array higher-order-method call, i.e. the
@@ -73,9 +34,9 @@ export const ARRAY_CALLBACK_METHODS = new Set([
  * (`forwardRef(() => …)` — callee is an `identifier`, not a
  * `member_expression`), so neither is ever suppressed.
  *
- * Intentional non-suppressing gaps (preserve current behavior, no
- * regression): parenthesized callee `(arr.map)(cb)` (`parenthesized_expression`)
- * and computed callee `arr['map'](cb)` (`subscript_expression`).
+ * The helper itself only handles direct `member_expression` callees. Broader
+ * shapes like `(arr.map)(cb)` and `arr['map'](cb)` are now filtered at the
+ * query layer, so this emit-side check stays focused on the direct fallback.
  */
 export function isArrayMethodCallbackArrow(node) {
     const args = node.parent;

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

@@ -33,6 +33,7 @@ import { computeTsArityMetadata } from './arity-metadata.js';
 import { isArrayMethodCallbackArrow } from './array-callback.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { deriveDefaultExportHocName, isBlockedDefaultExportHoc, isDefaultExportHocFunctionNode, } from '../../ts-js-hoc-utils.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`. */
@@ -139,10 +140,11 @@ function findSelfOrAncestorOfTypes(node, types) {
     return null;
 }
 export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
-    // Skip the parse when the caller (parse phase's scopeTreeCache) already
-    // produced a Tree for this source. Cache miss = re-parse, same as before.
-    // The cachedTree parameter is typed as `unknown` at the LanguageProvider
-    // contract layer; cast here at the use site.
+    // Reuse a pre-parsed Tree when the caller passes one via `cachedTree`; a
+    // miss re-parses. (The cache is currently always empty — its only producer,
+    // the sequential parser, was removed — so this re-parses in practice.) The
+    // cachedTree parameter is typed `unknown` at the LanguageProvider contract
+    // layer; cast here at the use site.
     //
     // Grammar selection: `.tsx` files are parsed with the TSX grammar,
     // `.ts` files with the TypeScript grammar. The two grammars have
@@ -242,6 +244,15 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
             if (arrowNode !== null && isArrayMethodCallbackArrow(arrowNode)) {
                 continue;
             }
+            if (arrowNode !== null && isBlockedDefaultExportHoc(arrowNode)) {
+                continue;
+            }
+        }
+        if (fnDeclAnchor !== undefined) {
+            const fnNode = findFunctionNode(tree.rootNode, fnDeclAnchor.range, groupedNodes['@declaration.function']);
+            if (fnNode !== null && isDefaultExportHocFunctionNode(fnNode)) {
+                grouped['@declaration.name'] = syntheticCapture('@declaration.name', fnNode, deriveDefaultExportHocName(filePath));
+            }
         }
         // Synthesize arity metadata on function-like declaration anchors
         // before pushing the match. The registry uses these to narrow
@@ -271,21 +282,26 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
         // calls use `new_expression`; regular calls use `call_expression`.
         //
         // JSX call anchors (`jsx_self_closing_element` / `jsx_opening_element`
-        // captured by the TSX-only suffix in `query.ts`) intentionally do
-        // NOT carry arity metadata. The lookup below would resolve `callNode`
-        // to `null` for a JSX anchor (the anchor is neither a call_expression
-        // nor a new_expression), so the synthesis branch silently no-ops and
-        // the JSX call enters the registry with name-only resolution. This
-        // is acceptable for React: components are virtually never
-        // overloaded in the current GitNexus graph model, so name-only
-        // dispatch matches the single component definition. If a future
-        // codebase introduces overloaded React components AND needs JSX
-        // calls to disambiguate by props-arity, a JSX-aware arity
-        // synthesizer would need to count `jsx_attribute` children of the
-        // opening tag instead of `arguments`.
+        // captured by the TSX-only suffix in `query.ts`) intentionally do NOT carry
+        // arity metadata. A JSX component used as a call argument (e.g.
+        // `render(<Foo .../>)`) is itself a @reference.call.* anchor; without a guard
+        // the ascent below would climb from it into the enclosing call_expression and
+        // mis-attribute that call's arity to the component. The early guard skips
+        // arity synthesis for JSX anchors — restoring the pre-#1951 range-based
+        // behavior (the old findNodeAtRange found no call_expression at the JSX
+        // element's range). The guard lives here, not inside findSelfOrAncestorOfTypes
+        // (shared with the import-statement and function-scope ascents). This is
+        // acceptable for React: components are virtually never overloaded in the
+        // current GitNexus graph model, so name-only dispatch matches the single
+        // component definition. A future props-arity-aware synthesizer would count
+        // `jsx_attribute` children of the opening tag instead of `arguments`.
         const callAnchor = pickFirstCapture(grouped, CALL_TAGS);
         const callAnchorNode = pickFirstNode(groupedNodes, CALL_TAGS);
-        if (callAnchor !== undefined && grouped['@reference.arity'] === undefined) {
+        const anchorIsJsxElement = callAnchorNode?.type === 'jsx_self_closing_element' ||
+            callAnchorNode?.type === 'jsx_opening_element';
+        if (callAnchor !== undefined &&
+            grouped['@reference.arity'] === undefined &&
+            !anchorIsJsxElement) {
             const callNode = findSelfOrAncestorOfTypes(callAnchorNode, ['call_expression', 'new_expression']) ??
                 findNodeAtRange(tree.rootNode, callAnchor.range, 'call_expression') ??
                 findNodeAtRange(tree.rootNode, callAnchor.range, 'new_expression');
@@ -327,8 +343,122 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
     synthesizeDestructuringBindings(tree.rootNode, out);
     synthesizeForOfMapTupleBindings(tree.rootNode, out);
     synthesizeInstanceofNarrowings(tree.rootNode, out);
+    synthesizeTsInheritanceReferences(tree.rootNode, out);
     return out;
 }
+/**
+ * Synthesize `@reference.inherits` captures from TypeScript class heritage so
+ * the registry-primary scope-resolution path emits EXTENDS / IMPLEMENTS edges
+ * (mirrors C# `synthesizeCsharpInheritanceReferences` / JS
+ * `synthesizeJsInheritanceReferences`). Without this, TS inheritance edges came
+ * only from the legacy heritage-capture leg (removed in #942), which the worker
+ * pipeline drops for registry-primary languages — yielding 0 inheritance edges
+ * in worker mode (issue #1951).
+ *
+ * Scope is intentionally limited to a `class_declaration`'s `class_heritage`
+ * `extends_clause` value + `implements_clause` types, matching the legacy
+ * TypeScript heritage query's class scope (TYPESCRIPT_QUERIES). Generic
+ * bases agree across both paths: `extends Base<T>` is captured by the legacy
+ * `extends_clause value: (identifier)` already (the `type_arguments` are a
+ * sibling field), and `implements IFoo<T>` is captured by a legacy clause
+ * widened to read the `generic_type`'s `name:` identifier — so the registry
+ * path keeps parity on SIMPLE (unqualified) generic bases too (#1951).
+ * Qualified bases (`ns.Base`, `ns.Base<T>`, `ns.IFoo<T>`) are ALSO now at parity
+ * (#1956 tri-review U2): the synth resolves them by their member_expression /
+ * nested_type_identifier tail, and the legacy heritage query was widened with
+ * matching arms (member_expression for extends, nested_type_identifier plain +
+ * generic-wrapped for implements).
+ *
+ * `interface_declaration` / `abstract_class_declaration` heritage is NOT emitted
+ * by the synth. The EXTENDS-vs-IMPLEMENTS split is decided downstream from the
+ * resolved target's symbol kind in `preEmitInheritanceEdges` (class-extends →
+ * EXTENDS, implements-interface / interface-target → IMPLEMENTS), so all bases
+ * are emitted with the same `inherits` kind here. The base lookup name is
+ * normalized to its bare simple identifier (`BaseModel<string>` → `BaseModel`,
+ * `models.Base` → `Base`) so `findClassBindingInScope` resolves it.
+ */
+function synthesizeTsInheritanceReferences(root, out) {
+    const stack = [root];
+    for (;;) {
+        const node = stack.pop();
+        if (node === undefined)
+            break;
+        for (const child of node.namedChildren) {
+            if (child !== null)
+                stack.push(child);
+        }
+        if (node.type !== 'class_declaration')
+            continue;
+        // Find the `class_heritage` child (holds extends / implements clauses).
+        let heritage = null;
+        for (const child of node.namedChildren) {
+            if (child !== null && child.type === 'class_heritage') {
+                heritage = child;
+                break;
+            }
+        }
+        if (heritage === null)
+            continue;
+        for (const clause of heritage.namedChildren) {
+            if (clause === null)
+                continue;
+            if (clause.type === 'extends_clause') {
+                // `extends Foo` / `extends Foo<T>` — the base is the `value:` field
+                // (an identifier; generics live in a sibling `type_arguments`).
+                const value = clause.childForFieldName('value') ?? clause.firstNamedChild;
+                emitTsInheritanceBase(value, out);
+            }
+            else if (clause.type === 'implements_clause') {
+                // `implements IFoo, IBar<T>` — each base type is a direct named child.
+                for (const base of clause.namedChildren) {
+                    emitTsInheritanceBase(base, out);
+                }
+            }
+        }
+    }
+}
+/** Emit one `@reference.inherits` match for a TS heritage base, normalizing
+ *  the lookup name to its bare simple identifier. No-ops on null / non-type
+ *  nodes or when the bare name can't be derived. */
+function emitTsInheritanceBase(base, out) {
+    if (base === null)
+        return;
+    const nameNode = terminalTsTypeNameNode(base);
+    if (nameNode === null)
+        return;
+    out.push({
+        '@reference.inherits': nodeToCapture('@reference.inherits', base),
+        '@reference.name': nodeToCapture('@reference.name', nameNode),
+    });
+}
+/** Resolve a TypeScript heritage base node to its bare simple-identifier node.
+ *  `Foo` → `Foo`, `Foo<T>` (generic_type) → `Foo`, `models.Base`
+ *  (nested_type_identifier / member_expression) → `Base`. Mirrors C#'s
+ *  `terminalTypeNameNode`; returns null when no leaf identifier is reachable. */
+function terminalTsTypeNameNode(node) {
+    switch (node.type) {
+        case 'identifier':
+        case 'type_identifier':
+        // `extends ns.Base` parses as a member_expression whose tail is a
+        // `property_identifier` (not a type_identifier) — treat it as a leaf name.
+        case 'property_identifier':
+            return node;
+        case 'generic_type': {
+            // generic_type has a `name:` field (type_identifier / nested_type_identifier);
+            // recurse to strip the type_arguments and reach the bare base identifier.
+            const name = node.childForFieldName('name') ?? node.firstNamedChild;
+            return name === null ? null : terminalTsTypeNameNode(name);
+        }
+        case 'nested_type_identifier':
+        case 'member_expression': {
+            // Qualified `A.B.Base` → tail identifier `Base`.
+            const tail = node.lastNamedChild;
+            return tail === null ? null : terminalTsTypeNameNode(tail);
+        }
+        default:
+            return null;
+    }
+}
 /**
  * Walk the AST and synthesize type-binding captures for object
  * destructuring of the form `const { field } = rhs` or

package/dist/core/ingestion/languages/typescript/index.d.ts

@@ -80,10 +80,9 @@
  *      identifiers are narrowed (`user instanceof User`). Member paths
  *      such as `user.address instanceof Address` remain unresolved.
  *
- * Shadow-harness corpus parity on `test/integration/resolvers/
- * typescript.test.ts` is the authoritative signal for which of these
- * matter in practice. The CI parity gate blocks any PR that regresses
- * either the legacy or registry-primary run.
+ * The `test/integration/resolvers/typescript.test.ts` resolver suite is
+ * the authoritative signal for which of these matter in practice; it runs
+ * in the standard CI test workflow, so a regression blocks the merge.
  */
 export { emitTsScopeCaptures } from './captures.js';
 export { getTypescriptCaptureCacheStats, resetTypescriptCaptureCacheStats } from './cache-stats.js';

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

@@ -80,10 +80,9 @@
  *      identifiers are narrowed (`user instanceof User`). Member paths
  *      such as `user.address instanceof Address` remain unresolved.
  *
- * Shadow-harness corpus parity on `test/integration/resolvers/
- * typescript.test.ts` is the authoritative signal for which of these
- * matter in practice. The CI parity gate blocks any PR that regresses
- * either the legacy or registry-primary run.
+ * The `test/integration/resolvers/typescript.test.ts` resolver suite is
+ * the authoritative signal for which of these matter in practice; it runs
+ * in the standard CI test workflow, so a regression blocks the merge.
  */
 export { emitTsScopeCaptures } from './captures.js';
 export { getTypescriptCaptureCacheStats, resetTypescriptCaptureCacheStats } from './cache-stats.js';

package/dist/core/ingestion/languages/typescript/query.d.ts

@@ -33,9 +33,8 @@
  *     same identifier also binds as a parameter in the constructor scope
  *     via the normal `required_parameter` → `@type-binding.parameter` path.
  *   - **Enum** — dual type+value. Emits `@scope.class` (enum body contains
- *     member declarations) + `@declaration.enum`. Members are captured as
- *     `@declaration.property` via the generic property_identifier pattern
- *     inside enum_body.
+ *     member declarations) + `@declaration.enum`. Enum member names
+ *     are captured via `enum_assignment` (see below).
  *
  * Node types pinned via `scripts/_probe_typescript_grammar.ts`:
  *   internal_module, namespace_export, namespace_import, import_specifier,

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

@@ -33,9 +33,8 @@
  *     same identifier also binds as a parameter in the constructor scope
  *     via the normal `required_parameter` → `@type-binding.parameter` path.
  *   - **Enum** — dual type+value. Emits `@scope.class` (enum body contains
- *     member declarations) + `@declaration.enum`. Members are captured as
- *     `@declaration.property` via the generic property_identifier pattern
- *     inside enum_body.
+ *     member declarations) + `@declaration.enum`. Enum member names
+ *     are captured via `enum_assignment` (see below).
  *
  * Node types pinned via `scripts/_probe_typescript_grammar.ts`:
  *   internal_module, namespace_export, namespace_import, import_specifier,
@@ -52,6 +51,7 @@
  */
 import Parser from 'tree-sitter';
 import TS from 'tree-sitter-typescript';
+import { ARRAY_METHOD_NOT_ANY_OF_PREDICATE, DEFAULT_EXPORT_IDENTIFIER_NOT_ANY_OF_PREDICATE, } from '../../ts-js-hoc-utils.js';
 // tree-sitter-typescript exports both `typescript` and `tsx` grammars on
 // the default export. The package's `.d.ts` types the default export
 // loosely; we narrow at the use site. The two grammars are NOT
@@ -81,6 +81,11 @@ const TYPESCRIPT_SCOPE_QUERY = `
 (abstract_class_declaration) @scope.class
 (interface_declaration) @scope.class
 (enum_declaration) @scope.class
+;; Class expressions: const Foo = class { ... } / const Foo = class Named { ... }.
+;; tree-sitter-typescript uses (class) (NOT class_expression) -- same node
+;; name as tree-sitter-javascript. The name field is optional (anonymous
+;; class expressions omit it); ScopeExtractor tolerates missing names.
+(class) @scope.class
 
 (function_declaration) @scope.function
 (generator_function_declaration) @scope.function
@@ -273,10 +278,16 @@ const TYPESCRIPT_SCOPE_QUERY = `
 ;; via \`(filePath, type, qualifiedName)\` — second wins. Acceptable;
 ;; multi-arrow-callback APIs are rare (\`new Promise(executor)\` is the
 ;; main one and takes a single executor).
+;;
+;; NOTE: Split into identifier vs member_expression patterns. Member
+;; expressions are filtered with a blocklist of common array methods
+;; (map, filter, reduce, etc.) to avoid false positives like
+;; \`const x = arr.map(a => ...)\` being classified as Function.
 (lexical_declaration
   (variable_declarator
     name: (identifier) @declaration.name
     value: (call_expression
+      function: (identifier)
       arguments: (arguments
         (arrow_function) @declaration.function))))
 
@@ -284,13 +295,35 @@ const TYPESCRIPT_SCOPE_QUERY = `
   (variable_declarator
     name: (identifier) @declaration.name
     value: (call_expression
+      function: (identifier)
       arguments: (arguments
         (function_expression) @declaration.function))))
 
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      function: (member_expression
+        property: (property_identifier) @callee)
+      arguments: (arguments
+        (arrow_function) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      function: (member_expression
+        property: (property_identifier) @callee)
+      arguments: (arguments
+        (function_expression) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
 (variable_declaration
   (variable_declarator
     name: (identifier) @declaration.name
     value: (call_expression
+      function: (identifier)
       arguments: (arguments
         (arrow_function) @declaration.function))))
 
@@ -298,10 +331,68 @@ const TYPESCRIPT_SCOPE_QUERY = `
   (variable_declarator
     name: (identifier) @declaration.name
     value: (call_expression
+      function: (identifier)
       arguments: (arguments
         (function_expression) @declaration.function))))
 
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      function: (member_expression
+        property: (property_identifier) @callee)
+      arguments: (arguments
+        (arrow_function) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      function: (member_expression
+        property: (property_identifier) @callee)
+      arguments: (arguments
+        (function_expression) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
+;; HOC-wrapped default exports: \`export default defineEventHandler(async (e) => { ... })\`.
+;; The emit phase rewrites @declaration.name to a file-derived name so
+;; wrappers like \`defineEventHandler\` / \`React.memo\` do not collapse
+;; unrelated modules onto the same symbol name.
+((export_statement
+  value: (call_expression
+    function: (identifier) @hoc
+    arguments: (arguments
+      (arrow_function) @declaration.function)))
+  ${DEFAULT_EXPORT_IDENTIFIER_NOT_ANY_OF_PREDICATE})
+
+((export_statement
+  value: (call_expression
+    function: (identifier) @hoc
+    arguments: (arguments
+      (function_expression) @declaration.function)))
+  ${DEFAULT_EXPORT_IDENTIFIER_NOT_ANY_OF_PREDICATE})
+
+((export_statement
+  value: (call_expression
+    function: (member_expression
+      property: (property_identifier) @callee)
+    arguments: (arguments
+      (arrow_function) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
+((export_statement
+  value: (call_expression
+    function: (member_expression
+      property: (property_identifier) @callee)
+    arguments: (arguments
+      (function_expression) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
 ;; Method definitions — regular + private (#field) methods.
+;; These match inside both class_declaration and class (class expression)
+;; bodies. The @scope.class for class expressions (see (class) above)
+;; ensures methods inside class expressions get the correct Class scope parent.
 (method_definition
   name: (property_identifier) @declaration.name) @declaration.method
 
@@ -323,6 +414,15 @@ const TYPESCRIPT_SCOPE_QUERY = `
 (public_field_definition
   name: (private_property_identifier) @declaration.name) @declaration.property
 
+;; Enum members: enum Color { Red, Green = 1, Blue }.
+;; Bare members (no value): Red, Blue — property_identifier inside enum_body.
+;; Members with value: Green = 1 — enum_assignment with name field.
+(enum_body
+  (property_identifier) @declaration.name) @declaration.property
+
+(enum_assignment
+  name: (_) @declaration.name) @declaration.property
+
 ;; Declarations — parameter properties: \`constructor(public name: string)\`.
 ;; The accessibility_modifier presence distinguishes these from regular
 ;; parameters. The identifier is also bound as a parameter in the
@@ -444,6 +544,26 @@ const TYPESCRIPT_SCOPE_QUERY = `
   type: (type_annotation
     (generic_type) @type-binding.type)) @type-binding.parameter
 
+(optional_parameter
+  pattern: (identifier) @type-binding.name
+  type: (type_annotation
+    (predefined_type) @type-binding.type)) @type-binding.parameter
+
+(optional_parameter
+  pattern: (identifier) @type-binding.name
+  type: (type_annotation
+    (union_type) @type-binding.type)) @type-binding.parameter
+
+(optional_parameter
+  pattern: (identifier) @type-binding.name
+  type: (type_annotation
+    (array_type) @type-binding.type)) @type-binding.parameter
+
+(optional_parameter
+  pattern: (identifier) @type-binding.name
+  type: (type_annotation
+    (readonly_type) @type-binding.type)) @type-binding.parameter
+
 ;; Type bindings — variable annotations: \`let u: User = ...\` / \`const u: User\`.
 (variable_declarator
   name: (identifier) @type-binding.name
@@ -843,7 +963,8 @@ const TYPESCRIPT_SCOPE_QUERY = `
   constructor: (identifier) @reference.name) @reference.call.constructor
 
 (new_expression
-  constructor: (member_expression) @reference.call.constructor.qualified) @reference.call.constructor
+  constructor: (member_expression
+    property: (property_identifier) @reference.name) @reference.call.constructor.qualified) @reference.call.constructor
 
 ;; References — write access: \`obj.field = value\`.
 (assignment_expression

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

@@ -49,7 +49,6 @@ 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. */

package/dist/core/ingestion/languages/typescript.d.ts

@@ -1,9 +1,8 @@
 /**
  * TypeScript and JavaScript language providers.
  *
- * Both languages share the same type extraction config (typescriptConfig),
- * export checker (tsExportChecker), and named binding extractor
- * (extractTsNamedBindings). They differ in file extensions, tree-sitter
+ * Both languages share the same type extraction config (typescriptConfig)
+ * and export checker (tsExportChecker). They differ in file extensions, tree-sitter
  * queries (TypeScript grammar has interface/type nodes), and language ID.
  */
 export declare const BUILT_INS: ReadonlySet<string>;