cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/utils/method-props.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arityForIdFromInfo = arityForIdFromInfo;
+exports.buildCollisionGroups = buildCollisionGroups;
+exports.typeTagForId = typeTagForId;
+exports.constTagForId = constTagForId;
+exports.parameterShapeIdTag = parameterShapeIdTag;
+exports.buildMethodProps = buildMethodProps;
+const index_js_1 = require("../../../../shared/index.js");
+/** Languages where class overload signatures are declaration-only contracts
+ *  that should collapse to the implementation body's node ID. */
+const SKIP_TYPE_HASH_LANGUAGES = new Set([
+    index_js_1.SupportedLanguages.TypeScript,
+    index_js_1.SupportedLanguages.JavaScript,
+]);
+/**
+ * Compute arity for ID-generation purposes.
+ * Returns `undefined` when any parameter is variadic (arity is indeterminate).
+ */
+function arityForIdFromInfo(info) {
+    return info.parameters.some((p) => p.isVariadic) ? undefined : info.parameters.length;
+}
+/**
+ * Compute a type-based discriminator suffix for same-arity overloads.
+ * Returns `~type1,type2` when the current method collides with another method
+ * in the same class that has the same name and arity but different parameter types.
+ * Returns `''` when there is no collision or types are unavailable.
+ */
+/**
+ * Build collision groups from a method map — groups methods by `name#arity`.
+ * Call once per class, then pass to typeTagForId/constTagForId to avoid O(N²) scans.
+ */
+function buildCollisionGroups(methodMap) {
+    const groups = new Map();
+    for (const info of methodMap.values()) {
+        if (info.parameters.some((p) => p.isVariadic))
+            continue;
+        const key = `${info.name}#${info.parameters.length}`;
+        let group = groups.get(key);
+        if (!group) {
+            group = [];
+            groups.set(key, group);
+        }
+        group.push(info);
+    }
+    return groups;
+}
+function typeTagForId(methodMap, methodName, arity, currentInfo, language, 
+/** Pre-built collision groups from buildCollisionGroups(). Avoids O(N) scan per call. */
+collisionGroups) {
+    if (arity === undefined)
+        return '';
+    // Zero-arity methods have no parameter types to disambiguate.
+    if (arity === 0)
+        return '';
+    // TS/JS class overload signatures are declaration-only contracts that should
+    // collapse to the implementation body's node ID, not be disambiguated.
+    if (language && SKIP_TYPE_HASH_LANGUAGES.has(language))
+        return '';
+    // Check if all parameters of this method have types (rawType or type)
+    if (currentInfo.parameters.length > 0 &&
+        currentInfo.parameters.some((p) => (p.rawType ?? p.type) === null)) {
+        return '';
+    }
+    // Use pre-built collision group if available, otherwise scan (backward compat)
+    const groupKey = `${methodName}#${arity}`;
+    const sameArityGroup = collisionGroups?.get(groupKey) ?? _buildGroup(methodMap, methodName, arity);
+    // No collision — single method with this name+arity
+    if (sameArityGroup.length < 2)
+        return '';
+    // Check that ALL methods in the collision group have full type info
+    for (const info of sameArityGroup) {
+        if (info.parameters.length > 0 && info.parameters.some((p) => (p.rawType ?? p.type) === null)) {
+            return '';
+        }
+    }
+    // Build type tag from current method's parameter types.
+    // Prefer rawType (preserves generic/template args like vector<int>) over
+    // type (simplified by extractSimpleTypeName which strips generics).
+    const types = currentInfo.parameters.map((p) => (p.rawType ?? p.type));
+    return `~${types.join(',')}`;
+}
+/** Fallback: build a same-arity group by scanning the full map (O(N)). */
+function _buildGroup(methodMap, methodName, arity) {
+    const group = [];
+    for (const info of methodMap.values()) {
+        if (info.name !== methodName)
+            continue;
+        if (info.parameters.some((p) => p.isVariadic))
+            continue;
+        if (info.parameters.length !== arity)
+            continue;
+        group.push(info);
+    }
+    return group;
+}
+/**
+ * Compute a const-qualifier suffix for C++ const/non-const method collisions.
+ * Returns `$const` when the current method is const-qualified and a non-const
+ * method with the same name and arity exists in the same class.
+ * Returns `''` when there is no collision or the method is not const-qualified.
+ */
+function constTagForId(methodMap, methodName, arity, currentInfo, 
+/** Pre-built collision groups from buildCollisionGroups(). Avoids O(N) scan per call. */
+collisionGroups) {
+    if (!currentInfo.isConst)
+        return '';
+    if (arity === undefined)
+        return '';
+    // Use pre-built group if available
+    const groupKey = `${methodName}#${arity}`;
+    const group = collisionGroups?.get(groupKey);
+    const candidates = group ?? _buildGroup(methodMap, methodName, arity);
+    // Check if a non-const method exists in the collision group
+    for (const info of candidates) {
+        if (info === currentInfo)
+            continue;
+        if (info.isConst)
+            continue;
+        return '$const';
+    }
+    return '';
+}
+/**
+ * Disambiguate function-template overloads whose normalized parameter types
+ * intentionally collapse to the same placeholder token (`T`, `U`, ...), but
+ * whose C++ sidecar shape is semantically different (`T` vs `T*` / `T&`).
+ *
+ * Kept intentionally narrow: concrete types already use the existing raw-type
+ * overload tag, and non-template languages should not acquire sidecar-shaped
+ * IDs.
+ */
+function parameterShapeIdTag(parameterTypes, parameterTypeClasses) {
+    if (parameterTypes === undefined ||
+        parameterTypeClasses === undefined ||
+        parameterTypes.length === 0) {
+        return '';
+    }
+    let hasTemplatePlaceholder = false;
+    let hasDisambiguatingShape = false;
+    const parts = [];
+    for (let i = 0; i < parameterTypes.length; i++) {
+        const type = parameterTypes[i];
+        const typeClass = parameterTypeClasses[i];
+        if (typeClass === undefined)
+            return '';
+        if (/^[A-Z]\w*$/.test(type))
+            hasTemplatePlaceholder = true;
+        if (typeClass.indirection !== 'value' ||
+            typeClass.pointerDepth > 0 ||
+            (typeClass.cv !== 'none' && typeClass.cv !== 'unknown')) {
+            hasDisambiguatingShape = true;
+        }
+        parts.push(`${type}:${typeClass.cv}:${typeClass.indirection}:${typeClass.pointerDepth.toString()}`);
+    }
+    if (!hasTemplatePlaceholder || !hasDisambiguatingShape)
+        return '';
+    return `~shape:${parts.join('|')}`;
+}
+/** Convert MethodInfo from methodExtractor into flat properties for a graph node. */
+function buildMethodProps(info) {
+    const types = [];
+    const typeClasses = [];
+    let optionalCount = 0;
+    let hasVariadic = false;
+    for (const p of info.parameters) {
+        if (p.type !== null)
+            types.push(p.type);
+        if (p.typeClass !== undefined)
+            typeClasses.push(p.typeClass);
+        if (p.isOptional)
+            optionalCount++;
+        if (p.isVariadic)
+            hasVariadic = true;
+    }
+    return {
+        parameterCount: hasVariadic ? undefined : info.parameters.length,
+        ...(!hasVariadic && optionalCount > 0
+            ? { requiredParameterCount: info.parameters.length - optionalCount }
+            : {}),
+        ...(types.length > 0 ? { parameterTypes: types } : {}),
+        ...(typeClasses.length === info.parameters.length && typeClasses.length > 0
+            ? { parameterTypeClasses: typeClasses }
+            : {}),
+        returnType: info.returnType ?? undefined,
+        visibility: info.visibility,
+        isStatic: info.isStatic,
+        isAbstract: info.isAbstract,
+        isFinal: info.isFinal,
+        ...(info.isVirtual ? { isVirtual: info.isVirtual } : {}),
+        ...(info.isOverride ? { isOverride: info.isOverride } : {}),
+        ...(info.isAsync ? { isAsync: info.isAsync } : {}),
+        ...(info.isPartial ? { isPartial: info.isPartial } : {}),
+        ...(info.isConst ? { isConst: info.isConst } : {}),
+        ...(info.isDeleted ? { isDeleted: info.isDeleted } : {}),
+        ...(info.annotations.length > 0 ? { annotations: info.annotations } : {}),
+    };
+}

package/dist/core/code/engine/core/ingestion/utils/qualified-name.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Shared qualified-name normalization.
+ *
+ * One canonical transform from a raw, language-specific qualified name
+ * (`Other::Inner`, `pkg\Sub\Type`, `  A . B `) to the `.`-joined form the
+ * graph and the `QualifiedNameIndex` are keyed by (`Other.Inner`, `pkg.Sub.Type`,
+ * `A.B`). Extracted from `class-extractors/generic.ts` so the structure-phase
+ * `buildQualifiedName`, the scope-resolution inheritance resolver, and the
+ * per-language capture emitters all key against ONE normalizer — a raw `::`
+ * qualifier must normalize to the exact key the index already holds, or the
+ * qualified lookup silently misses (issue #1982).
+ *
+ * Do NOT confuse with `heritage-extractors/supertype-alternation.ts`'s
+ * `simplifyRawName`, which collapses a qualified name to its LAST segment
+ * (`Other::Inner` → `Inner`) — that is a tail extractor, not a normalizer, and
+ * using it as a lookup key guarantees a miss.
+ *
+ * Pure string functions; no AST or tree-sitter dependency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitQualifiedName = exports.normalizeQualifiedName = void 0;
+exports.stripTrailingTypeArguments = stripTrailingTypeArguments;
+/**
+ * Normalize a raw qualified name to the `.`-joined canonical form:
+ * strips whitespace, converts `::` and `\` separators to `.`, collapses
+ * repeated dots, and trims leading/trailing dots.
+ */
+const normalizeQualifiedName = (value) => value
+    .replace(/\s+/g, '')
+    .replace(/^::/, '')
+    .replace(/::/g, '.')
+    .replace(/\\/g, '.')
+    .replace(/\.+/g, '.')
+    .replace(/^\.+|\.+$/g, '');
+exports.normalizeQualifiedName = normalizeQualifiedName;
+/**
+ * Split a raw qualified name into its normalized, non-empty segments
+ * (`Other::Inner` → `['Other', 'Inner']`). Returns `[]` for an empty or
+ * separator-only input.
+ */
+const splitQualifiedName = (value) => {
+    const normalized = (0, exports.normalizeQualifiedName)(value);
+    return normalized ? normalized.split('.').filter(Boolean) : [];
+};
+exports.splitQualifiedName = splitQualifiedName;
+/**
+ * Strip a trailing generic argument list at angle-bracket depth 0
+ * (`Models.Box<int>` → `Models.Box`). Constructor and inheritance sites
+ * often carry type arguments that are not part of the indexed def key.
+ */
+function stripTrailingTypeArguments(value) {
+    let depth = 0;
+    let ltAt0 = -1;
+    for (let i = 0; i < value.length; i++) {
+        const c = value[i];
+        if (c === '<') {
+            if (depth === 0)
+                ltAt0 = i;
+            depth++;
+        }
+        else if (c === '>') {
+            depth = Math.max(0, depth - 1);
+            if (depth === 0 && ltAt0 >= 0) {
+                const after = value.slice(i + 1).trim();
+                if (after.length === 0)
+                    return value.slice(0, ltAt0);
+                ltAt0 = -1;
+            }
+        }
+    }
+    return value;
+}

package/dist/core/code/engine/core/ingestion/utils/receiver-chain-captures.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Synthesize `@reference.receiver-chain` for a call match whose receiver is
+ * itself an expression.
+ *
+ * Shared across every language emitter, and deliberately language-free (AGENTS.md
+ * R6): the call gate reads the `@reference.call.*` tag vocabulary, which is
+ * shared by every language's `.scm` query, rather than a per-language tag list.
+ *
+ * Lives in the emitter layer rather than the query because a `.scm` pattern
+ * cannot call `extractMixedChain`, and the receiver capture originates in
+ * several patterns per language.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeReceiverChainCapture = synthesizeReceiverChainCapture;
+const ast_helpers_js_1 = require("./ast-helpers.js");
+const call_analysis_js_1 = require("./call-analysis.js");
+const receiver_chain_codec_js_1 = require("./receiver-chain-codec.js");
+/** Tag prefix marking a match as a CALL. `@reference.callable` is deliberately
+ *  excluded by the trailing dot — it marks a callable VALUE, not a call site. */
+const CALL_TAG_PREFIX = '@reference.call.';
+/** Does this match represent a call? */
+function isCallMatch(grouped) {
+    for (const tag of Object.keys(grouped)) {
+        if (tag.startsWith(CALL_TAG_PREFIX))
+            return true;
+    }
+    return false;
+}
+/**
+ * Add `@reference.receiver-chain` to `grouped` when the match is a call whose
+ * receiver decodes to a chain over a nameable base. Mutates `grouped` in place
+ * and returns nothing — mirroring how the other synthesized captures are added.
+ *
+ * Gated on the call tags: without that gate this fires on read, write and JSX
+ * receivers too, which pay the AST walk and the persisted bytes for a field no
+ * call-site resolver reads.
+ *
+ * A chain is minted ONLY when the walk reached a nameable base.
+ * `extractMixedChain` reports `baseReceiverName: undefined` whenever it stopped
+ * early — at `MAX_CHAIN_DEPTH`, or because a step could not be read — and what it
+ * collected then is a partial chain missing exactly the head that decides the
+ * final type. Encoding that would turn a receiver we cannot type into one we type
+ * WRONGLY, so those fall through to the resolver's existing text cascade.
+ */
+function synthesizeReceiverChainCapture(grouped, receiverNode) {
+    if (receiverNode === undefined || receiverNode === null)
+        return;
+    if (grouped['@reference.receiver-chain'] !== undefined)
+        return;
+    if (!isCallMatch(grouped))
+        return;
+    const extracted = (0, call_analysis_js_1.extractMixedChain)(receiverNode);
+    if (extracted === undefined || extracted.baseReceiverName === undefined)
+        return;
+    const encoded = (0, receiver_chain_codec_js_1.encodeReceiverChain)(extracted.baseReceiverName, extracted.chain);
+    if (encoded === undefined)
+        return;
+    grouped['@reference.receiver-chain'] = (0, ast_helpers_js_1.syntheticCapture)('@reference.receiver-chain', receiverNode, encoded);
+}

package/dist/core/code/engine/core/ingestion/utils/receiver-chain-codec.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * Receiver-chain codec.
+ *
+ * THE one encoder/decoder for the compact receiver chain carried on
+ * `ReferenceSite.receiverChain`: the capture emitters write it, the
+ * scope-resolution fold reads it, and the durable ParsedFile store validates
+ * it. Two hand-rolled copies of a wire format drift — every side MUST import
+ * from here. (`taint/path-codec.ts` is the in-repo precedent for both the
+ * discipline and the shape.)
+ *
+ * ## Why a string rather than `MixedChainStep[]`
+ *
+ * `makeInterningReviver` (parsedfile-store.ts) interns strings, but it
+ * re-shares OBJECTS only when they carry `nodeId` + `filePath`. A
+ * `MixedChainStep` has neither, so an object encoding leaves every step object
+ * and every chain array as a distinct allocation on every warm load, while a
+ * string collapses to one interned instance per distinct chain.
+ *
+ * ## Wire format (version `2`)
+ *
+ * ```
+ * 2|<base>|<step>|<step>…[|~]
+ * ```
+ *
+ * - One-character version prefix, then the BASE receiver name, then ordered
+ *   base-first steps.
+ * - Each step is a one-character kind sigil followed by the member name:
+ *   `c` = call (`getUser()`), `f` = field (`address`). The sigil is the first
+ *   character of the segment and the name follows immediately, so a member
+ *   whose name begins with `c` or `f` needs no escaping (`ccount` decodes as a
+ *   call to `count`).
+ * - `a` = await and `i` = index are NAME-FREE and encode as a BARE sigil: an
+ *   awaited call's name already lives on its `c` step, and a subscript's key is
+ *   a value rather than an identifier the resolver could look up. The decoder
+ *   rejects any trailing characters after `a` or `i`, which is what keeps an
+ *   accidentally empty-name `c` or `f` segment refusing instead of decoding as
+ *   one of these.
+ * - A trailing `|~` segment is the TRUNCATION MARKER. NOTE: no current producer
+ *   mints one. `extractMixedChain` signals "stopped early" by returning
+ *   `baseReceiverName: undefined`, and the encoder requires a base, so a
+ *   truncated chain is unrepresentable rather than merely unused. The marker and
+ *   the decoder/fold guards are kept as a forward-compatible contract: a future
+ *   producer that CAN report a partial chain must set it, and the fold already
+ *   refuses such chains. Read the `truncated` field as "reserved", not "live". the chain hit
+ *   `MAX_CHAIN_DEPTH` and what is encoded is a base-side PREFIX of the real
+ *   chain. A consumer MUST treat a truncated chain as unusable for typing —
+ *   the missing tail is exactly what determines the final type — but never as
+ *   an error.
+ *
+ * `|` and `~` cannot appear in an identifier in any supported language, so the
+ * format needs no escaping and a malformed payload cannot silently decode as a
+ * different valid chain.
+ *
+ * For `svc.getUser().address.save()`, the receiver of `save` encodes as
+ * `2|svc|cgetUser|faddress` — 23 bytes. For `(await svc.getUserAsync()).save()`
+ * it is `2|svc|cgetUserAsync|a`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_RECEIVER_CHAIN_BYTES = void 0;
+exports.encodeReceiverChain = encodeReceiverChain;
+exports.decodeReceiverChain = decodeReceiverChain;
+exports.isValidReceiverChain = isValidReceiverChain;
+const call_analysis_js_1 = require("./call-analysis.js");
+/** Wire version. Bumped 1 → 2 when the name-free `await` and `index` step kinds
+ *  were added: a v1 decoder reading a v2 payload must REFUSE, not decode the
+ *  prefix it happens to understand, because a chain missing its await or index
+ *  hop decodes cleanly as a different, shorter chain and would type the receiver
+ *  against the wrong member. */
+const VERSION = '2';
+const SEPARATOR = '|';
+const TRUNCATED = '~';
+/** Sigil per step kind. ONE table, and both directions derive from it — the
+ *  decoder used to hand-write `sigil === 'c' ? 'call' : 'field'` and its own
+ *  await/index comparison, which meant the decoder was exactly the side that
+ *  could drift from the table claiming to prevent drift. */
+const SIGIL_BY_KIND = {
+    call: 'c',
+    field: 'f',
+    await: 'a',
+    index: 'i',
+};
+/** Kinds that encode as a BARE sigil, because they have no member name to
+ *  carry. Derived from the step union rather than listed twice. */
+const NAME_FREE_KINDS = new Set(['await', 'index']);
+const KIND_BY_SIGIL = new Map(Object.entries(SIGIL_BY_KIND).map(([kind, sigil]) => [sigil, kind]));
+/** Hard cap on the encoded payload. `MAX_CHAIN_DEPTH` already bounds the step
+ *  COUNT; this bounds the total bytes so a pathological identifier cannot grow
+ *  a shard without limit. Generous against real identifiers — the encoding for
+ *  a full-depth chain of 30-character names is still under 130 bytes. */
+exports.MAX_RECEIVER_CHAIN_BYTES = 512;
+/** A segment is safe when it contains no structural character. Identifiers in
+ *  every supported language satisfy this; anything that does not is a payload
+ *  we refuse to mint rather than escape. */
+function isEncodableSegment(value) {
+    // `\s` does NOT match zero-width characters (U+200B ZWS, U+200C/D ZWNJ/ZWJ,
+    // U+200E/F LRM/RLM, U+FEFF BOM). An identifier carrying one is a trojan-source
+    // vector: it would encode and persist cleanly, then match no binding at
+    // resolution time — a silent, unexplained miss. Refuse to mint instead.
+    return (value.length > 0 &&
+        !value.includes(SEPARATOR) &&
+        !value.includes(TRUNCATED) &&
+        !/[\s\u200B-\u200F\u2028\u2029\uFEFF]/.test(value));
+}
+/**
+ * Encode a chain, or `undefined` when it cannot be represented — an empty
+ * chain (nothing to fold), an unencodable name, or a payload over the byte
+ * cap. Refusing to mint is deliberate: a half-encoded chain would be decoded
+ * as a complete-but-different one.
+ */
+function encodeReceiverChain(baseReceiverName, steps, options) {
+    if (steps.length === 0 || steps.length > call_analysis_js_1.MAX_CHAIN_DEPTH)
+        return undefined;
+    if (!isEncodableSegment(baseReceiverName))
+        return undefined;
+    const parts = [VERSION, baseReceiverName];
+    for (const step of steps) {
+        // Name-free kinds encode as a bare sigil. They are exempt from the
+        // non-empty-name guard because they HAVE no name to check — not because the
+        // guard is relaxed: an empty-name `call` or `field` is still refused below.
+        if (NAME_FREE_KINDS.has(step.kind)) {
+            parts.push(SIGIL_BY_KIND[step.kind]);
+            continue;
+        }
+        if (!isEncodableSegment(step.name))
+            return undefined;
+        parts.push(`${SIGIL_BY_KIND[step.kind]}${step.name}`);
+    }
+    if (options?.truncated === true)
+        parts.push(TRUNCATED);
+    const encoded = parts.join(SEPARATOR);
+    return encoded.length > exports.MAX_RECEIVER_CHAIN_BYTES ? undefined : encoded;
+}
+/**
+ * Decode a payload, or `undefined` when it is not a well-formed chain. Total
+ * function: every malformed input returns `undefined` rather than throwing,
+ * because the two callers that matter — the extractor and the untrusted store
+ * boundary — are both on paths where a throw would cost the whole file.
+ */
+function decodeReceiverChain(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    if (value.length === 0 || value.length > exports.MAX_RECEIVER_CHAIN_BYTES)
+        return undefined;
+    const parts = value.split(SEPARATOR);
+    if (parts.length < 3)
+        return undefined; // version + base + at least one step
+    if (parts[0] !== VERSION)
+        return undefined;
+    // `parts.length < 3` above already proves this element exists.
+    const baseReceiverName = parts[1];
+    if (!isEncodableSegment(baseReceiverName))
+        return undefined;
+    let stepParts = parts.slice(2);
+    const truncated = stepParts[stepParts.length - 1] === TRUNCATED;
+    if (truncated)
+        stepParts = stepParts.slice(0, -1);
+    if (stepParts.length === 0 || stepParts.length > call_analysis_js_1.MAX_CHAIN_DEPTH)
+        return undefined;
+    const steps = [];
+    for (const part of stepParts) {
+        const sigil = part[0];
+        const name = part.slice(1);
+        // Name-free kinds must be EXACTLY their sigil. Rejecting a trailing tail is
+        // what keeps an accidentally empty-name call or field from decoding as one
+        // of these: `c` alone stays malformed, it does not become an await.
+        const kind = sigil === undefined ? undefined : KIND_BY_SIGIL.get(sigil);
+        if (kind === undefined)
+            return undefined;
+        if (NAME_FREE_KINDS.has(kind)) {
+            // Must be EXACTLY the sigil. Rejecting a trailing tail is what keeps an
+            // accidentally empty-name call or field from decoding as one of these.
+            if (name.length > 0)
+                return undefined;
+            steps.push({ kind: kind });
+            continue;
+        }
+        if (!isEncodableSegment(name))
+            return undefined;
+        steps.push({ kind: kind, name });
+    }
+    return { baseReceiverName, steps, truncated };
+}
+/** Whether a persisted value is a chain this build can use. The store boundary
+ *  wants the predicate, not the decoded value. */
+function isValidReceiverChain(value) {
+    return decodeReceiverChain(value) !== undefined;
+}

package/dist/core/code/engine/core/ingestion/utils/scope-tree-walk.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Scope-tree walking primitives shared by the providers' `bindingScopeFor`
+ * hooks.
+ *
+ * Language-neutral: parameterised over `ScopeKind` — the shared scope
+ * vocabulary — and names no language, so it belongs in the core pipeline
+ * rather than in any one provider (AGENTS.md § shared pipeline code).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkToScope = walkToScope;
+/**
+ * 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).
+ *
+ * Every provider that hoists a binding out of the scope it was captured in
+ * needs exactly this walk: a field typed from a constructor call in a method
+ * body belongs on the enclosing Class, a `var` on the enclosing Function or
+ * Module, a method return type on the Module. Which `kind` to stop at is the
+ * only per-language part, and that is the parameter.
+ */
+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;
+}

package/dist/core/code/engine/core/ingestion/utils/symbol-labels.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYMBOL_NODE_LABELS = void 0;
+/**
+ * Graph-node labels that represent a resolvable code symbol — a definition with
+ * its own source span (function, type, member, module-like container).
+ *
+ * These get EXACT source-span content in the FTS index: `csv-generator.ts`
+ * slices exactly `[startLine, endLine]` for them (no ±2 padding), while every
+ * other label keeps the context window. That exactness depends on the 0-based
+ * `startLine`/`endLine` invariant enforced by `line-base.ts` — the slice is only
+ * correct because all emitters store 0-based lines. Keep the two together.
+ *
+ * Single source of truth so the set can't silently drift the way the inline copy
+ * did in #2379.
+ *
+ * NOTE: `group/extractors/manifest-extractor.ts`'s `CUSTOM_CONTRACT_RESOLVE_QUERY`
+ * carries a near-identical hand-list that is intentionally a SUBSET — it excludes
+ * `Namespace`, `Variable`, `Module`. Unifying the two needs a contract-resolution
+ * behavior check (would widen which nodes resolve as contract symbols), so it is
+ * deliberately left separate for now.
+ */
+exports.SYMBOL_NODE_LABELS = new Set([
+    'Function',
+    'Method',
+    'Class',
+    'Interface',
+    'CodeElement',
+    'Struct',
+    'Enum',
+    'Macro',
+    'Typedef',
+    'Union',
+    'Namespace',
+    'Trait',
+    'Impl',
+    'TypeAlias',
+    'Const',
+    'Static',
+    'Variable',
+    'Property',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Constructor',
+    'Template',
+    'Module',
+]);