gitnexus 1.6.10-rc.99 → 1.6.10

package/dist/core/ingestion/type-env.js

@@ -67,10 +67,10 @@ const fastStripNullable = (typeName) => {
         : stripNullable(typeName);
 };
 /** Implementation of the lookup logic backing TypeEnvironment.lookup. */
-const lookupInEnv = (env, varName, callNode, patternOverrides, enclosingFunctionFinder, extractFunctionNameHook, filePath) => {
+const lookupInEnv = (env, varName, callNode, patternOverrides, enclosingFunctionFinder, extractFunctionNameHook, filePath, thisBoundaryNodeTypes) => {
     // Self/this receiver: resolve to enclosing class name via AST walk
     if (varName === 'self' || varName === 'this' || varName === '$this') {
-        return findEnclosingClassName(callNode);
+        return findEnclosingClassName(callNode, thisBoundaryNodeTypes);
     }
     // Super/base/parent receiver: resolve to the parent class name via AST walk.
     // Walks up to the enclosing class, then extracts the superclass from its heritage node.
@@ -115,11 +115,15 @@ const enclosingParentClassNameCache = new Map();
  * Used to resolve `self`/`this` receivers to their containing type.
  * Memoized per-file: cache is cleared at buildTypeEnv entry.
  */
-const findEnclosingClassName = (node) => {
+const findEnclosingClassName = (node, thisBoundaryNodeTypes) => {
     if (enclosingClassNameCache.has(node))
         return enclosingClassNameCache.get(node);
     let current = node.parent;
     while (current) {
+        if (thisBoundaryNodeTypes?.has(current.type) === true) {
+            enclosingClassNameCache.set(node, undefined);
+            return undefined;
+        }
         if (CLASS_CONTAINER_TYPES.has(current.type)) {
             const nameNode = current.childForFieldName('name') ?? findTypeIdentifierChild(current);
             if (nameNode) {
@@ -140,12 +144,12 @@ const THIS_RECEIVERS = new Set(['this', 'self', '$this', 'Me']);
  * or when the receiver is not a this-keyword. Properties are readonly in the
  * discriminated union, so a new object is returned when substitution occurs.
  */
-const substituteThisReceiver = (item, node) => {
+const substituteThisReceiver = (item, node, thisBoundaryNodeTypes) => {
     if (item.kind !== 'fieldAccess' && item.kind !== 'methodCallResult')
         return item;
     if (!THIS_RECEIVERS.has(item.receiver))
         return item;
-    const className = findEnclosingClassName(node);
+    const className = findEnclosingClassName(node, thisBoundaryNodeTypes);
     if (!className)
         return item;
     return { ...item, receiver: className };
@@ -1016,7 +1020,7 @@ export const buildTypeEnv = (tree, language, options) => {
                     const items = Array.isArray(pending) ? pending : [pending];
                     for (const item of items) {
                         // Substitute this/self/$this/Me receivers with enclosing class name
-                        const resolved = substituteThisReceiver(item, node);
+                        const resolved = substituteThisReceiver(item, node, config.thisBoundaryNodeTypes);
                         pendingItems.push({ scope, ...resolved });
                     }
                 }
@@ -1082,7 +1086,7 @@ export const buildTypeEnv = (tree, language, options) => {
         }
     }
     return {
-        lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides, options?.enclosingFunctionFinder, extractFuncNameHook, options?.filePath),
+        lookup: (varName, callNode) => lookupInEnv(env, varName, callNode, patternOverrides, options?.enclosingFunctionFinder, extractFuncNameHook, options?.filePath, config.thisBoundaryNodeTypes),
         constructorBindings: bindings,
         fileScope: () => env.get(FILE_SCOPE) ?? emptyFileScope(),
         allScopes: () => env,

package/dist/core/ingestion/type-extractors/shared.d.ts

@@ -1,3 +1,4 @@
+import type { ElementAccessRoute } from '../scope-resolution/contract/scope-resolver.js';
 import type { SyntaxNode } from '../utils/ast-helpers.js';
 /** Which type argument to extract from a multi-arg generic container.
  *  - 'first': key type (e.g., K from Map<K,V>) — used for .keys(), .keySet()
@@ -127,5 +128,21 @@ export declare const extractCalleeName: (callNode: SyntaxNode) => string | undef
  * Returns undefined when the extracted type is not a simple word.
  */
 export declare function extractElementTypeFromString(typeStr: string, pos?: TypeArgPosition): string | undefined;
+/**
+ * `elementTypeOf` for a language with no property-style collection view:
+ * answer the subscript route from the written spelling, decline the accessor
+ * route.
+ *
+ * Languages whose collection views are spelled as method calls (`.values()`,
+ * `.iter()`) never reach the accessor route — the compound resolver's
+ * call-expression branch handles those — so the whole hook is this one
+ * decision. Declining (returning `undefined`) is the answer "this spelling is
+ * not a container", which is what stops an index-overloading class from
+ * folding `x[k].m()` onto its own members.
+ *
+ * Languages that DO expose a collection view as a property (C#'s `.Values`)
+ * need a bespoke body instead.
+ */
+export declare const indexOnlyElementType: (containerType: string, via: ElementAccessRoute) => string | undefined;
 export declare const extractReturnTypeName: (raw: string, depth?: number) => string | undefined;
 export {};

package/dist/core/ingestion/type-extractors/shared.js

@@ -631,6 +631,22 @@ export function extractElementTypeFromString(typeStr, pos = 'last') {
     }
     return undefined;
 }
+/**
+ * `elementTypeOf` for a language with no property-style collection view:
+ * answer the subscript route from the written spelling, decline the accessor
+ * route.
+ *
+ * Languages whose collection views are spelled as method calls (`.values()`,
+ * `.iter()`) never reach the accessor route — the compound resolver's
+ * call-expression branch handles those — so the whole hook is this one
+ * decision. Declining (returning `undefined`) is the answer "this spelling is
+ * not a container", which is what stops an index-overloading class from
+ * folding `x[k].m()` onto its own members.
+ *
+ * Languages that DO expose a collection view as a property (C#'s `.Values`)
+ * need a bespoke body instead.
+ */
+export const indexOnlyElementType = (containerType, via) => via.kind === 'index' ? extractElementTypeFromString(containerType) : undefined;
 // ── Return type text helpers ─────────────────────────────────────────────
 // extractReturnTypeName works on raw return-type text already stored in
 // SymbolDefinition (e.g. "User", "Promise<User>", "User | null", "*User").

package/dist/core/ingestion/type-extractors/types.d.ts

@@ -130,6 +130,18 @@ export interface LanguageTypeConfig {
     readonly allowPatternBindingOverwrite?: boolean;
     /** Node types that represent typed declarations for this language */
     declarationNodeTypes: ReadonlySet<string>;
+    /** Function node types that OWN their `this` receiver, terminating the
+     *  upward AST walk that resolves `this`/`self`/`$this` to an enclosing
+     *  class. The type-env twin of `Scope.ownsReceivers` (#2701): the scope
+     *  layer gates receiver-type LOOKUP, this gates receiver-type INFERENCE
+     *  during capture, and a call is only suppressed when both agree.
+     *
+     *  Most languages leave it unset — their closures capture the enclosing
+     *  `this` lexically (Kotlin lambdas, Go func literals, C# lambdas, Dart
+     *  function expressions, PHP closures auto-bound since 5.4, Python's
+     *  `self` closed over by a nested `def`) — so the walk is unchanged
+     *  there. JavaScript/TypeScript are the exception. */
+    thisBoundaryNodeTypes?: ReadonlySet<string>;
     /** Optional: language-specific way to find a declaration's type-annotation node.
      * Prefer providing this for grammars where the type is wrapped (e.g., C#, Kotlin, Swift). */
     getDeclarationTypeNode?: DeclarationTypeNodeLocator;

package/dist/core/ingestion/type-extractors/typescript.d.ts

@@ -1,2 +1,22 @@
 import type { LanguageTypeConfig } from './types.js';
+/**
+ * Ordinary functions own their `this`; arrows do not (#2701).
+ *
+ * ECMA-262 gives an arrow `[[ThisMode]] = lexical` — it has no `this` binding
+ * in its environment record, so the lookup passes through to the enclosing
+ * environment. Every other function form binds `this` at call time, so
+ * `this.m()` inside one does NOT reach the enclosing class. That is exactly
+ * the distinction `tsc` draws by resolving `this` through `getThisContainer`
+ * with `includeArrowFunctions = false`.
+ *
+ * `method_definition` is deliberately absent: it is the construct that binds
+ * `this` TO the enclosing class, so the walk must pass through it and stop at
+ * the class. (Unlike the scope-layer marker in `typescript/query.ts`, which
+ * can list it because a method's own `this` typeBinding is consulted first.)
+ *
+ * Kept in sync with `@receiver-owner.this` in `languages/typescript/query.ts`
+ * and `languages/javascript/query.ts` — the two layers must agree or a call
+ * suppressed by one is re-introduced by the other.
+ */
+export declare const THIS_BOUNDARY_NODE_TYPES: ReadonlySet<string>;
 export declare const typeConfig: LanguageTypeConfig;

package/dist/core/ingestion/type-extractors/typescript.js

@@ -646,9 +646,35 @@ const inferTsLiteralType = (node) => {
             return undefined;
     }
 };
+/**
+ * Ordinary functions own their `this`; arrows do not (#2701).
+ *
+ * ECMA-262 gives an arrow `[[ThisMode]] = lexical` — it has no `this` binding
+ * in its environment record, so the lookup passes through to the enclosing
+ * environment. Every other function form binds `this` at call time, so
+ * `this.m()` inside one does NOT reach the enclosing class. That is exactly
+ * the distinction `tsc` draws by resolving `this` through `getThisContainer`
+ * with `includeArrowFunctions = false`.
+ *
+ * `method_definition` is deliberately absent: it is the construct that binds
+ * `this` TO the enclosing class, so the walk must pass through it and stop at
+ * the class. (Unlike the scope-layer marker in `typescript/query.ts`, which
+ * can list it because a method's own `this` typeBinding is consulted first.)
+ *
+ * Kept in sync with `@receiver-owner.this` in `languages/typescript/query.ts`
+ * and `languages/javascript/query.ts` — the two layers must agree or a call
+ * suppressed by one is re-introduced by the other.
+ */
+export const THIS_BOUNDARY_NODE_TYPES = new Set([
+    'function_declaration',
+    'function_expression',
+    'generator_function',
+    'generator_function_declaration',
+]);
 export const typeConfig = {
     declarationNodeTypes: DECLARATION_NODE_TYPES,
     forLoopNodeTypes: FOR_LOOP_NODE_TYPES,
+    thisBoundaryNodeTypes: THIS_BOUNDARY_NODE_TYPES,
     patternBindingNodeTypes: new Set(['binary_expression']),
     extractDeclaration,
     extractParameter,

package/dist/core/ingestion/utils/ast-helpers.d.ts

@@ -4,19 +4,39 @@ import type { LanguageProvider } from '../language-provider.js';
 /** Tree-sitter AST node. Re-exported for use across ingestion modules. */
 export type SyntaxNode = Parser.SyntaxNode;
 /**
- * Qualify a Rust inherent-impl target (`impl Inner { ... }`) by its enclosing
- * `mod_item` scope, so a bare same-tail target nested under different modules
- * resolves to a DISTINCT path (`outer.Inner` vs `other.Inner`) — the #1982
- * follow-up to #1975. Walks `mod_item` ancestors (outermost → innermost) and
- * joins them with the normalized raw target via the shared `splitQualifiedName`.
- * A top-level `impl Inner` (no enclosing mod) returns the bare target unchanged.
- * Keyed purely on tree-sitter node types (no language name), matching the
- * inherent-impl branch in `findEnclosingClassInfo`; the caller restricts this to
- * UNSCOPED targets (`type_identifier`) so a SCOPED `impl a::Inner` keeps its full
- * raw text (#1975). The Impl-node materialization in parsing-processor /
- * parse-worker mirrors this so the owner edge and node id agree byte-for-byte.
- */
-export declare const qualifyRustImplTargetByModScope: (implNode: SyntaxNode, rawTargetText: string) => string;
+ * Qualify a name by its enclosing `mod_item` scope, so two same-tail items nested
+ * under different modules get DISTINCT paths (`outer.Inner` vs `other.Inner`).
+ * Walks `mod_item` ancestors (outermost → innermost) and joins them with the
+ * normalized raw text via the shared `splitQualifiedName`. Keyed purely on
+ * tree-sitter node types (no language name), so it is a no-op for every grammar
+ * without such a node.
+ *
+ * TWO callers, with different contracts — read both before widening either:
+ *
+ *  1. The inherent-impl target (`impl Inner { … }`) — the #1982 follow-up to
+ *     #1975, reachable through the {@link qualifyRustImplTargetByModScope} alias
+ *     and mirrored by the inherent-impl branch in `findEnclosingClassInfo` so the
+ *     owner edge and the node id agree byte-for-byte. That caller gates on an
+ *     UNSCOPED `type_identifier`, which is what keeps a SCOPED `impl a::Inner` on
+ *     its full raw text.
+ *
+ *  2. Free items, for module node identity (#2742). That caller gates on the node
+ *     being on neither side of an owner edge (`MEMBER_OWNER_NODE_TYPES`,
+ *     `enclosingClassInfo`) and not inside a callable, because only the id moves
+ *     here — every owner-edge anchor is minted separately and does not follow.
+ *
+ * A name with NO enclosing `mod` is returned verbatim, never normalized: rewriting
+ * a scoped target's separator (`a::Inner` → `a.Inner`) would move its node id away
+ * from the id its owner edge emits, which is how caller 2 first broke caller 1's
+ * #1975 contract. Splitting an unscoped name has always been the identity, so
+ * caller 1 is unaffected either way.
+ */
+export declare const qualifyByEnclosingModScope: (node: SyntaxNode, rawText: string) => string;
+/**
+ * Impl-target alias of {@link qualifyByEnclosingModScope}, kept as its own name
+ * because the caller gates it on UNSCOPED targets (see the contract above).
+ */
+export declare const qualifyRustImplTargetByModScope: (node: SyntaxNode, rawText: string) => string;
 /**
  * #1991: scope-label predicate that single-sources the `nodeLabel === 'Trait'`
  * checks in parsing-processor.ts / parse-worker.ts. A Ruby `module` maps to the
@@ -41,8 +61,72 @@ type QueryMatchLike = {
         node: SyntaxNode;
     }>;
 };
-export declare const buildConcreteTypedefDefinitionRanges: (matches: readonly QueryMatchLike[]) => Set<string>;
 export declare const isSuppressedConcreteTypedefDuplicate: (captureMap: Record<string, SyntaxNode>, concreteTypedefRanges: ReadonlySet<string>) => boolean;
+/** True when `label` is the kind of node a value capture emits. */
+export declare const isValueDefinitionLabel: (label: NodeLabel) => boolean;
+/**
+ * One pass over a file's matches: definition-name claims by rank, plus the
+ * concrete-typedef ranges the loop's separate typedef guard consumes.
+ */
+export interface DefinitionPreScan {
+    /**
+     * Keys claimed by any non-value capture — consulted by `Const`/`Static`/
+     * `Variable`. Includes `Property`, so an annotated Python attribute still
+     * beats the bare-assignment `Variable` capture on the same statement.
+     */
+    readonly nonValue: ReadonlySet<string>;
+    /**
+     * Keys claimed by a *callable* capture (`Function`/`Method`/`Constructor`) —
+     * consulted by `Property`. Narrower than `nonValue` on purpose: a `Property`
+     * must be collapsible by a callable (Kotlin `val f = { … }`, Swift
+     * `let f = { … }`) without being collapsible by its own claim.
+     */
+    readonly callable: ReadonlySet<string>;
+    /** Ranges of `type_definition` nodes that already emit a concrete struct/enum. */
+    readonly concreteTypedefRanges: ReadonlySet<string>;
+}
+/**
+ * Pre-scan `matches` for the `${definitionNode.startIndex}:${name}` keys already
+ * claimed by a higher-ranked definition capture, so the parse-worker's duplicate
+ * suppression is order-independent.
+ *
+ * Rank, highest first: callable (`Function`/`Method`/`Constructor`) → `Property`
+ * → value (`Const`/`Static`/`Variable`). A capture is dropped only when a
+ * STRICTLY higher rank claimed the same declaration node and name, so no capture
+ * can suppress itself and no rank can suppress a peer.
+ *
+ * ## Why this exists (#2687)
+ *
+ * `const X = () => {}` matches BOTH `@definition.function` and
+ * `@definition.const` on the same `lexical_declaration`. Only one graph node
+ * should survive — the `Function`, because that is what `CALLS` edges target.
+ * The parse-worker's in-loop dedup intends exactly that, but only the value
+ * branch consults its `processedDefinitionNodes` set, so suppression worked only
+ * if the function match happened to be processed first. It is not: tree-sitter
+ * completes the const pattern at `@name`, while the function pattern must also
+ * match the trailing `(arrow_function)` / `(function_expression)` value, so the
+ * const match is yielded FIRST and the edgeless `Const:` twin escaped.
+ *
+ * Consulting this set makes the outcome independent of match order.
+ *
+ * ## Keying
+ *
+ * Keys are `startIndex:name`, never `startIndex` alone — a multi-name
+ * declaration (`const a = 1, b = () => {}`) shares ONE definition node, and a
+ * bare-index key would wrongly suppress `a`'s legitimate `Const` node.
+ *
+ * Labels come from {@link getLabelFromCaptures}, the same function the main loop
+ * uses, so the pre-scan and the loop can never disagree about what counts as a
+ * value capture — including when a provider's `labelOverride` reclassifies one.
+ * A match that resolves to a value label registers nothing, so a match can never
+ * suppress itself.
+ *
+ * Language-agnostic: keyed off capture names and labels only.
+ *
+ * Also collects the concrete-typedef ranges that suppress the analogous
+ * typedef/struct duplicate, so both suppression sets come from one traversal.
+ */
+export declare const buildDefinitionPreScan: (matches: readonly QueryMatchLike[], provider: LanguageProvider) => DefinitionPreScan;
 /**
  * Node types that represent function/method definitions across languages.
  * Used by parent-walk in call-processor, parse-worker, and type-env to detect
@@ -63,6 +147,26 @@ export declare const FUNCTION_NODE_TYPES: Set<string>;
  * orphaned HAS_METHOD edges or incorrect labels.
  */
 export declare const CLASS_CONTAINER_TYPES: Set<string>;
+/**
+ * Node types whose OWN node id must not be re-keyed by an enclosing-scope
+ * qualifier (see {@link qualifyByEnclosingModScope}) unless the owner-edge
+ * anchor moves in the same change.
+ *
+ * These are the containers a member can be declared inside. Their members'
+ * `HAS_METHOD` / `HAS_PROPERTY` edges anchor on `findEnclosingClassInfo().classId`,
+ * which is minted from the container's bare `nameNode.text` further down this
+ * file and only follows a qualified shape when the provider opts in via
+ * `classExtractor.qualifiedNodeId`. So qualifying a container's id alone points
+ * every one of its member edges at a node that does not exist — the edges are
+ * dropped at COPY time and the container silently loses all its members.
+ *
+ * Derived from `CLASS_CONTAINER_TYPES` on purpose: that set is already the
+ * single source of "this node type owns member edges", carries the INVARIANT
+ * note above binding it to `CONTAINER_TYPE_TO_LABEL`, and so a language adding
+ * a container cannot gain a mismatched id shape here without also failing that
+ * invariant. Keyed purely on tree-sitter node types — no language names.
+ */
+export declare const MEMBER_OWNER_NODE_TYPES: ReadonlySet<string>;
 export declare const CONTAINER_TYPE_TO_LABEL: Record<string, string>;
 /**
  * Pre-order walk over a node and all its named descendants, invoking `cb` on
@@ -81,6 +185,38 @@ export declare const CONTAINER_TYPE_TO_LABEL: Record<string, string>;
 export declare function walkNamedTree(node: SyntaxNode, cb: (node: SyntaxNode) => void): void;
 /** Return the first matching ancestor unless a boundary ancestor is reached first. */
 export declare function findAncestorBeforeBoundary(node: SyntaxNode, targetTypes: ReadonlySet<string>, boundaryTypes: ReadonlySet<string>): SyntaxNode | null;
+/**
+ * Enclosing callable for grammars that split a callable into a SIGNATURE node
+ * and a SIBLING body, where the callable is therefore never an ancestor of the
+ * code inside it.
+ *
+ * Dart is the case that forced this: `int outer() { … }` parses as
+ * `function_signature` followed by `function_body` as SIBLINGS, so an ancestor
+ * walk from a closure inside the body can never reach `outer`. No membership
+ * set fixes that — the walk is looking in the wrong direction (#2699).
+ *
+ * Deliberately a FALLBACK, used only when the ancestor walk found nothing.
+ *
+ * The sibling must be a BARE SIGNATURE, and that restriction is load-bearing —
+ * "any preceding callable sibling" is WRONG and was caught regressing PHP. In
+ * `<?php function target($x) {…} $handler = function ($x) {…};` the closure is
+ * at FILE level, so the primary ancestor walk correctly finds nothing and this
+ * fallback runs; an unrestricted version then grabs the preceding
+ * `function_definition` and mis-qualifies the file-level `$handler` as
+ * `target.$handler`. A preceding sibling is only an ENCLOSING callable when it
+ * cannot hold its own body — i.e. when the grammar split the body off.
+ *
+ * `SPLIT_SIGNATURE_NODE_TYPES` is exactly that set, and it is derived rather
+ * than listed: `LOCAL_SCOPE_BODY_NODE_TYPES` already filters the bare-signature
+ * types out of `FUNCTION_NODE_TYPES`, so the difference between them IS the
+ * split-signature set. PHP's `function_definition` carries a body and is in
+ * both, so it is excluded; Dart's `function_signature` is in only the former,
+ * so it qualifies.
+ *
+ * Language-neutral by construction — it names no grammar, and any future
+ * signature/body-split language is covered for free.
+ */
+export declare function findSplitBodyCallableAncestor(node: SyntaxNode, signatureOnlyTypes: ReadonlySet<string>, boundaryTypes: ReadonlySet<string>): SyntaxNode | null;
 /**
  * Determine the graph node label from a tree-sitter capture map.
  * Handles language-specific reclassification via the provider's labelOverride hook
@@ -141,7 +277,33 @@ getQualifiedOwnerName?: (node: SyntaxNode, simpleName: string) => string | null)
 /** Object literal binding info for TS/JS shorthand methods. */
 export interface ObjectLiteralBindingInfo {
     ownerId: string;
+    /**
+     * Owner name, when the owner is also the member's qualifier.
+     *
+     * Set by {@link findMemberAssignmentOwnerInfo} so a prototype method keys as
+     * `Foo.bar` — without it two constructors in one file that each define
+     * `bar` collapse onto a single `Method:<file>:bar` id.
+     *
+     * {@link findObjectLiteralBindingInfo} sets it ONLY when the caller opts in
+     * via `includeOwnerName`. Its `Method` ids must stay exactly as they were —
+     * qualifying them would rewrite every object-literal method id in every
+     * indexed repo — but object-literal KEYS (indexed since A1/A5) genuinely
+     * need it: two config objects in one file sharing a key name otherwise
+     * collapse onto a single `Property:<file>:<key>` id, merging two distinct
+     * settings into one symbol.
+     */
+    ownerName?: string;
 }
+/**
+ * True when an object-literal member is contained by an array before reaching
+ * another callable or class boundary.
+ *
+ * An array does not provide a stable named owner for its elements, so members
+ * below one cannot use `<binding>.<member>` identity or ownership. They still
+ * need distinct graph identities, however; callers use this predicate to opt
+ * into source-position qualification while keeping ownership suppressed.
+ */
+export declare const isArrayContainedObjectLiteralMember: (node: SyntaxNode) => boolean;
 /**
  * Find the file-scope variable that owns an object literal method definition.
  *
@@ -167,7 +329,109 @@ export interface ObjectLiteralBindingInfo {
  *     ancestor also returns null (catches block-scoped declarations inside
  *     top-level `if`/`for`/`try`/etc., which cannot be imported).
  */
-export declare const findObjectLiteralBindingInfo: (node: SyntaxNode, filePath: string) => ObjectLiteralBindingInfo | null;
+/**
+ * Owner for the keys of an ANONYMOUS object literal in return position (R3-4).
+ *
+ * `return { symbol, score, wickRatio, … }` binds to nothing, so its keys had no
+ * anchor and could not be qualified — which on the reporting repo left the
+ * central payload of the signal pipeline, ~25 fields, entirely unqueryable.
+ * There are 437 such sites in one backend directory, so this is the dominant
+ * shape, not an edge case.
+ *
+ * The enclosing FUNCTION is the honest owner: the literal is that function's
+ * return shape, which is a contract its callers consume. Qualifying by it keeps
+ * two functions returning the same key name as two distinct nodes, exactly as
+ * `ownerName` does for variable-bound literals.
+ *
+ * Returns null when the literal is not DIRECTLY returned (a nested literal, or
+ * one inside a callback several frames down), because then the enclosing
+ * function is not what the object describes.
+ */
+/**
+ * True when this definition node is a key of a literal in RETURN position.
+ *
+ * Deliberately independent of whether an OWNER NAME could be derived. The two
+ * are different questions, and conflating them mislabels the anonymous case:
+ * `[function (row) { return { k: row.x }; }]` yields no name to qualify by, so
+ * the owner lookup returns null — but the key is still a return shape, and
+ * flagging it by owner-presence would leave it looking like a DECLARED anchor
+ * and let it outrank a real declaration during narrowing.
+ */
+export declare const isReturnShapeProperty: (node: SyntaxNode) => boolean;
+export declare const findReturnShapeOwnerInfo: (node: SyntaxNode, filePath: string) => {
+    readonly ownerId?: string;
+    readonly ownerName: string;
+} | null;
+export declare const findObjectLiteralBindingInfo: (node: SyntaxNode, filePath: string, options?: {
+    /**
+     * Also return `ownerName` so the member qualifies as `<owner>.<member>`.
+     * Opt-in because turning it on for `Method` would rewrite existing ids.
+     */
+    readonly includeOwnerName?: boolean;
+}) => ObjectLiteralBindingInfo | null;
+/**
+ * Find the owner of a member assigned by `<Owner>.prototype.<member> = fn`
+ * (#2723 follow-up).
+ *
+ * Sibling of {@link findObjectLiteralBindingInfo}: same seam, same return
+ * shape, different syntax. There the owner is the variable the literal is
+ * bound to; here it is the identifier to the left of `.prototype`.
+ *
+ * The owner label is read from the file's own module-scope declaration, so the
+ * edge points at the node that actually exists — `function Foo() {}` is a
+ * `Function` node, `class Foo {}` is a `Class` node. When the file declares no
+ * such name (the constructor lives in another module) no owner is claimed:
+ * a HAS_METHOD edge to a fabricated node is worse than a top-level Method.
+ */
+export declare const findMemberAssignmentOwnerInfo: (node: SyntaxNode, filePath: string) => ObjectLiteralBindingInfo | null;
+/**
+ * The receiver name of a `<Owner>.prototype.<member> = <function>` assignment,
+ * or null when `assignment` is not that shape.
+ *
+ * Only a bare identifier owner is accepted. `a.b.prototype.c = …` and
+ * `getClass().prototype.c = …` name an owner this layer cannot resolve to a
+ * definition, so they are left alone rather than attributed to a guess.
+ */
+export declare const prototypeAssignmentOwnerName: (assignment: SyntaxNode) => string | null;
+/**
+ * The constructor function that owns a `this.member = <function>` assignment,
+ * or null when there is none (module top level, or an owner this layer cannot
+ * name).
+ *
+ * Only a `function_declaration` counts. An `arrow_function` does NOT bind its
+ * own `this` (ECMA-262 gives it `[[ThisMode]] = lexical`), so the walk passes
+ * through arrows to the function that actually binds the receiver — the same
+ * rule `@receiver-owner.this` encodes in the scope queries (#2701). A class
+ * method never reaches here: parse-worker resolves its owner from the
+ * enclosing class container first.
+ */
+export declare const thisAssignmentOwnerName: (assignment: SyntaxNode) => string | null;
+/**
+ * True when `node` is a `X.prototype.Y = <function>` or `this.Y = <function>`
+ * assignment — i.e. a callable MEMBER rather than a free function.
+ *
+ * Takes the ASSIGNMENT node, because that is what the `@definition.function`
+ * capture is anchored on and therefore what `provider.labelOverride` receives.
+ */
+export declare const isPrototypeMemberAssignmentNode: (node: SyntaxNode) => boolean;
+/**
+ * True when `node` is `module.exports = <anonymous function>` (#2723).
+ *
+ * The whole module IS the callable, so there is no property to take a name
+ * from and the caller supplies a file-derived one. A NAMED function expression
+ * is excluded — its own name is captured directly and is more informative.
+ */
+/**
+ * True when `node` is `module.exports = <function>`, named or anonymous — the
+ * CommonJS default export, where the whole module IS the callable.
+ *
+ * `exports = fn` is deliberately NOT this shape: reassigning the `exports`
+ * binding does not export anything in CommonJS, it only breaks the alias to
+ * `module.exports`.
+ */
+export declare const isCjsDefaultExportAssignment: (node: SyntaxNode) => boolean;
+/** True when `node` is a `this.Y = <function>` assignment, at any nesting. */
+export declare const isThisMemberAssignmentNode: (node: SyntaxNode) => boolean;
 /** Convenience wrapper: returns just the class ID string (backward compat). */
 export declare const findEnclosingClassId: (node: SyntaxNode, filePath: string) => string | null;
 /**
@@ -234,12 +498,30 @@ export declare const PARAMETER_LIST_NODE_TYPES: Set<string>;
  * and accessor bodies must not.
  */
 export declare const LOCAL_SCOPE_BODY_NODE_TYPES: ReadonlySet<string>;
+/**
+ * Callable node types whose grammar splits the body off into a SIBLING node, so
+ * the callable is never an ancestor of the code inside it (Dart
+ * `function_signature` / `method_signature`).
+ *
+ * Derived, not listed, so it cannot drift from the two sets that define it:
+ * `LOCAL_SCOPE_BODY_NODE_TYPES` is `FUNCTION_NODE_TYPES` minus exactly the bare
+ * signature types, so the difference IS the split-signature set.
+ *
+ * Must stay BELOW `LOCAL_SCOPE_BODY_NODE_TYPES` — reading it earlier hits the
+ * temporal dead zone and throws at module load.
+ */
+export declare const SPLIT_SIGNATURE_NODE_TYPES: ReadonlySet<string>;
 /** Walk an AST node depth-first, returning the first descendant with the given type. */
 export declare function findDescendant(root: SyntaxNode, type: string): SyntaxNode | null;
 /** Extract the text content from a string or encapsed_string AST node. */
 export declare function extractStringContent(node: SyntaxNode | null | undefined): string | null;
 /** Find the first direct named child of a tree-sitter node matching the given type. */
 export declare function findChild(node: SyntaxNode, type: string): SyntaxNode | null;
+/** Remove bidi-override and zero-width control characters from attacker-
+ *  influenced repository text before it is exposed through graph descriptions
+ *  or MCP output (#2286). Global `sanitizeUTF8` intentionally remains focused
+ *  on encoding/control-character validity. */
+export declare const stripBidiAndZeroWidth: (text: string) => string;
 /**
  * Extract the normalized text of a leading doc comment immediately preceding a
  * definition node — covering both block doc comments (Javadoc / KDoc / JSDoc /