cgraphx 2.0.2 → 2.0.6

package/dist/core/code/shared/scope-resolution/language-classification.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * `LanguageClassification` — RFC §6.1 Ring 3 / Ring 4 governance.
+ *
+ * Classifies each `SupportedLanguages` member for the rollout. Ring 4 (DAG
+ * retirement) is gated on *all production languages* being registry-primary
+ * and stable for one release cycle; `experimental` and `quarantined`
+ * languages do not block.
+ *
+ * Initial classification (locked in Ring 1 #910):
+ *   - production: javascript, typescript, python, java, c, cpp, csharp, go,
+ *                 ruby, rust, php, kotlin, swift, dart
+ *   - experimental: vue (embedded-language / SFC complexity),
+ *                   cobol (regex-provider path)
+ *   - quarantined: (none)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageClassifications = void 0;
+exports.isProductionLanguage = isProductionLanguage;
+const languages_js_1 = require("../languages.js");
+/**
+ * The canonical classification for each supported language. Governance
+ * changes (promote `experimental` → `production`, quarantine a language, …)
+ * update this map in a dedicated PR.
+ */
+exports.LanguageClassifications = {
+    [languages_js_1.SupportedLanguages.JavaScript]: 'production',
+    [languages_js_1.SupportedLanguages.TypeScript]: 'production',
+    [languages_js_1.SupportedLanguages.Python]: 'production',
+    [languages_js_1.SupportedLanguages.Java]: 'production',
+    [languages_js_1.SupportedLanguages.C]: 'production',
+    [languages_js_1.SupportedLanguages.CPlusPlus]: 'production',
+    [languages_js_1.SupportedLanguages.CSharp]: 'production',
+    [languages_js_1.SupportedLanguages.Go]: 'production',
+    [languages_js_1.SupportedLanguages.Ruby]: 'production',
+    [languages_js_1.SupportedLanguages.Rust]: 'production',
+    [languages_js_1.SupportedLanguages.PHP]: 'production',
+    [languages_js_1.SupportedLanguages.Kotlin]: 'production',
+    [languages_js_1.SupportedLanguages.Swift]: 'production',
+    [languages_js_1.SupportedLanguages.Dart]: 'production',
+    [languages_js_1.SupportedLanguages.Vue]: 'experimental',
+};
+/** Convenience predicate: is this language gating Ring 4 retirement? */
+function isProductionLanguage(lang) {
+    return exports.LanguageClassifications[lang] === 'production';
+}

package/dist/core/code/shared/scope-resolution/method-dispatch-index.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * `MethodDispatchIndex` — materialized view of class hierarchies keyed by
+ * `DefId` (RFC §3.1; Ring 2 SHARED #914).
+ *
+ * Two O(1)-access maps used by `Registry.lookupMethod` and interface-
+ * dispatch callers:
+ *
+ *   - `mroByOwnerDefId`       : owner class → full MRO ancestor chain
+ *                               (excludes the owner itself, in per-language
+ *                               strategy order).
+ *   - `implsByInterfaceDefId` : interface/trait → classes that implement it.
+ *
+ * **Not an MRO implementation.** The build function is a pure aggregator: it
+ * asks the caller (via `computeMro` and `implementsOf` callbacks) for the
+ * per-language answers and materializes the two-way index. MRO strategies
+ * live where they already do today (`model/resolve.ts § c3Linearize`,
+ * `languages/ruby.ts § selectDispatch`, etc.) — this index does not
+ * reimplement them.
+ *
+ * Why callbacks and not a shared strategy registry: the five strategies
+ * (Python C3, Ruby kind-aware, Java/Kotlin linear, Rust qualified-syntax,
+ * COBOL none) already exist in the CLI package and depend on the CLI's
+ * `HeritageMap` + `SemanticModel`. Pulling them into `cgraph-shared` would
+ * require migrating both — out of scope for #914. Callbacks let the shared
+ * build stay pure while honoring existing strategies verbatim.
+ *
+ * Consumed by: #917 (`Registry.lookupMethod` MRO fast path, interface
+ * dispatch resolver).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMethodDispatchIndex = buildMethodDispatchIndex;
+// ─── Builder ────────────────────────────────────────────────────────────────
+function buildMethodDispatchIndex(input) {
+    const mroByOwnerDefId = new Map();
+    const extendsOnlyByOwnerDefId = input.computeExtendsOnlyMro
+        ? new Map()
+        : undefined;
+    const implsBuilding = new Map();
+    const implsSeen = new Map();
+    for (const ownerId of input.owners) {
+        // First-write-wins on duplicate owner ids: a stable policy consistent
+        // with sibling indexes (#913 DefIndex / ModuleScopeIndex).
+        if (!mroByOwnerDefId.has(ownerId)) {
+            const chain = input.computeMro(ownerId);
+            mroByOwnerDefId.set(ownerId, Object.freeze(chain.slice()));
+        }
+        if (input.computeExtendsOnlyMro !== undefined &&
+            extendsOnlyByOwnerDefId !== undefined &&
+            !extendsOnlyByOwnerDefId.has(ownerId)) {
+            const extOnly = input.computeExtendsOnlyMro(ownerId);
+            extendsOnlyByOwnerDefId.set(ownerId, Object.freeze(extOnly.slice()));
+        }
+        for (const ifaceId of input.implementsOf(ownerId)) {
+            let seen = implsSeen.get(ifaceId);
+            if (seen === undefined) {
+                seen = new Set();
+                implsSeen.set(ifaceId, seen);
+            }
+            if (seen.has(ownerId))
+                continue;
+            seen.add(ownerId);
+            let bucket = implsBuilding.get(ifaceId);
+            if (bucket === undefined) {
+                bucket = [];
+                implsBuilding.set(ifaceId, bucket);
+            }
+            bucket.push(ownerId);
+        }
+    }
+    const implsByInterfaceDefId = new Map();
+    for (const [ifaceId, owners] of implsBuilding) {
+        implsByInterfaceDefId.set(ifaceId, Object.freeze(owners.slice()));
+    }
+    return wrapIndex(mroByOwnerDefId, implsByInterfaceDefId, extendsOnlyByOwnerDefId);
+}
+// ─── Internal ───────────────────────────────────────────────────────────────
+const EMPTY = Object.freeze([]);
+function wrapIndex(mroByOwnerDefId, implsByInterfaceDefId, extendsOnlyMroByOwnerDefId) {
+    const base = {
+        mroByOwnerDefId,
+        implsByInterfaceDefId,
+        mroFor(ownerDefId) {
+            return mroByOwnerDefId.get(ownerDefId) ?? EMPTY;
+        },
+        implementorsOf(interfaceDefId) {
+            return implsByInterfaceDefId.get(interfaceDefId) ?? EMPTY;
+        },
+    };
+    if (extendsOnlyMroByOwnerDefId !== undefined) {
+        return {
+            ...base,
+            extendsOnlyMroByOwnerDefId,
+            extendsOnlyMroFor(ownerDefId) {
+                return extendsOnlyMroByOwnerDefId.get(ownerDefId) ?? EMPTY;
+            },
+        };
+    }
+    return base;
+}

package/dist/core/code/shared/scope-resolution/module-scope-index.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * `ModuleScopeIndex` — O(1) `filePath → moduleScopeId` lookup.
+ *
+ * Every file parsed produces exactly one `Module` scope at its root. The
+ * finalize algorithm needs to resolve `ImportEdge.targetFile` to a concrete
+ * module scope id in constant time during the link pass; this index is that
+ * mapping.
+ *
+ * Part of RFC #909 Ring 2 SHARED — #913.
+ *
+ * Consumed by: #915 (SCC finalize link pass).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildModuleScopeIndex = buildModuleScopeIndex;
+/**
+ * Build a `ModuleScopeIndex` from a flat list of `{ filePath, moduleScopeId }`
+ * pairs.
+ *
+ * **Collision policy: first-write-wins.** A file should appear exactly once
+ * in a single ingestion run; collisions indicate the same file was parsed
+ * twice or a `filePath` normalization bug upstream. Dropping the later
+ * entry preserves the first-stable id the rest of the pipeline may already
+ * have registered against.
+ *
+ * **Caller contract: filePath keys must be pre-normalized.** This index
+ * keys on the raw `filePath` string and does NOT canonicalize separators,
+ * case, or trailing slashes. Callers upstream of this function must agree
+ * on a canonical form (typically repo-root-relative, POSIX separators,
+ * no trailing slash) before constructing entries — otherwise `C:\foo\bar.ts`,
+ * `C:/foo/bar.ts`, and `foo/bar.ts` will all hash to distinct buckets and
+ * `get()` will miss.
+ *
+ * Pure function — safe to call repeatedly; no side effects.
+ */
+function buildModuleScopeIndex(entries) {
+    const byFilePath = new Map();
+    for (const { filePath, moduleScopeId } of entries) {
+        if (byFilePath.has(filePath))
+            continue; // first-write-wins
+        byFilePath.set(filePath, moduleScopeId);
+    }
+    return wrapIndex(byFilePath);
+}
+// ─── Internal ───────────────────────────────────────────────────────────────
+function wrapIndex(byFilePath) {
+    return {
+        byFilePath,
+        get size() {
+            return byFilePath.size;
+        },
+        get(filePath) {
+            return byFilePath.get(filePath);
+        },
+        has(filePath) {
+            return byFilePath.has(filePath);
+        },
+    };
+}

package/dist/core/code/shared/scope-resolution/origin-priority.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * `ORIGIN_PRIORITY` — RFC Appendix B (authoritative values).
+ *
+ * Tie-break ordering applied inside `Registry.lookup` Step 7 when
+ * `|Δconfidence| < 0.001` between two `Resolution` candidates. Lower number
+ * = stronger (wins the tie).
+ *
+ * Full tie-break order (§4.2 Step 7):
+ *   confidence DESC → scope depth ASC → MRO depth ASC → ORIGIN_PRIORITY ASC
+ *   → DefId.localeCompare
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORIGIN_PRIORITY = void 0;
+exports.ORIGIN_PRIORITY = {
+    local: 0,
+    import: 1,
+    reexport: 2,
+    namespace: 3,
+    wildcard: 4,
+    'global-qualified': 5,
+    'global-name': 6,
+};

package/dist/core/code/shared/scope-resolution/parsed-file.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * `ParsedFile` — the per-file artifact produced by `ScopeExtractor`
+ * (RFC §3.2 Phase 1; Ring 2 PKG #919).
+ *
+ * The boundary between Phase 1 (extraction, per-file, parallelizable) and
+ * Phase 2 (finalize, cross-file). One `ParsedFile` is emitted per source
+ * file; the finalize orchestrator (#921) collects them into a workspace-
+ * wide set and feeds them to the shared `finalize` algorithm (#915).
+ *
+ * ## Shape
+ *
+ *   - `scopes`           — every `Scope` created for this file, in tree-
+ *                          topological order (module first, then children).
+ *                          `Scope.bindings` carry **local-only** bindings at
+ *                          this stage; finalize merges imports/wildcards on top.
+ *   - `parsedImports`    — raw `ParsedImport[]` for this file; finalize
+ *                          resolves each to a concrete `ImportEdge`.
+ *   - `localDefs`        — defs structurally declared in this file. A
+ *                          superset of every `Scope.ownedDefs` union.
+ *                          Listed separately so `finalize` can dedup-index
+ *                          without re-walking scopes.
+ *   - `referenceSites`   — pre-resolution usage facts; populated by the
+ *                          resolution phase into `ReferenceIndex`.
+ *
+ * ## What `ParsedFile` deliberately does NOT carry
+ *
+ *   - Linked `ImportEdge`s. Those are finalize output.
+ *   - A `ScopeTree` instance. Callers build one from `scopes` (cheap —
+ *     `buildScopeTree(parsedFile.scopes)`). Keeping the ParsedFile flat
+ *     makes IPC serialization from worker threads straightforward.
+ *   - Merged module-scope bindings. Finalize owns that materialization.
+ *
+ * ## Compatibility with `FinalizeFile`
+ *
+ * `FinalizeFile` (defined in `./finalize-algorithm.ts`) is a structural
+ * subset of `ParsedFile` — `filePath`, `moduleScope`, `parsedImports`,
+ * `localDefs`. A `ParsedFile` is trivially convertible to a `FinalizeFile`
+ * by picking those four fields, so the finalize orchestrator threads
+ * ParsedFile through to the shared algorithm without shape-shifting.
+ *
+ * ## Source-of-truth invariant
+ *
+ * `ParsedFile` is the single semantic model consumed by both the legacy
+ * DAG (`cgraph/src/core/ingestion/` outside `scope-resolution/`) and
+ * the scope-resolution pipeline (`cgraph/src/core/ingestion/scope-resolution/`).
+ * Downstream passes MUST NOT build a parallel parse representation; if
+ * a pass needs AST-level facts that `ParsedFile` doesn't expose, it
+ * should reuse the orchestrator's `treeCache` rather than re-invoke
+ * `parser.parse(...)` on its own. See the
+ * `ScopeResolver` contract (`cgraph/src/core/ingestion/scope-resolution/contract/scope-resolver.ts`)
+ * for the full list of invariants downstream consumers rely on.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/code/shared/scope-resolution/position-index.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * `PositionIndex` — O(log N_file) scope-at-position lookup
+ * (RFC §3.1; Ring 2 SHARED #912).
+ *
+ * Per-file sorted array of `(range, scopeId)` entries, sorted by start
+ * position ASC (`startLine`, then `startCol`). `atPosition(filePath, line,
+ * col)` binary-searches for the last entry whose start ≤ (line, col), then
+ * scans backward through the sorted prefix and returns the first entry
+ * whose range contains the query position.
+ *
+ * **Why this works.** `ScopeTree`'s invariants (parent strictly contains
+ * child; siblings don't overlap) guarantee that the scopes containing a
+ * given point form an **ancestor chain**. When scanning backward through
+ * entries sorted by start position ASC, the first scope we find that
+ * contains the query is the innermost one — any deeper-starting scope
+ * that also contained the query would appear *later* in the sorted array,
+ * but we're only scanning entries with start ≤ query, so anything later
+ * necessarily starts after the query and can't contain it.
+ *
+ * Expected complexity: `O(log N_file + D)` where `D` is the lexical depth
+ * at the query position (typically ≤ 10). Worst-case degrades to `O(N_file)`
+ * only under pathological inputs (many scopes starting at the same line).
+ *
+ * **Line/column conventions.** Matches `Range` in `types.ts`: lines are
+ * 1-based, columns are 0-based. Ranges are **inclusive on both ends** —
+ * a scope whose `endLine:endCol` equals the query position still contains
+ * it. That matches how tree-sitter captures bodies (closing brace
+ * included) and how closed PR #902's `enclosingFunctions` behaved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPositionIndex = buildPositionIndex;
+/**
+ * Build a `PositionIndex` from a flat list of `Scope` records.
+ *
+ * Duplicate `id`s are tolerated and deduplicated — the caller's
+ * `ScopeTree.buildScopeTree` is the authoritative validator of scope
+ * identity, and the position index does not need to re-check that
+ * invariant.
+ */
+function buildPositionIndex(scopes) {
+    const entriesByFile = new Map();
+    const seen = new Set();
+    for (const scope of scopes) {
+        if (seen.has(scope.id))
+            continue;
+        seen.add(scope.id);
+        let bucket = entriesByFile.get(scope.filePath);
+        if (bucket === undefined) {
+            bucket = [];
+            entriesByFile.set(scope.filePath, bucket);
+        }
+        bucket.push({ id: scope.id, range: scope.range });
+    }
+    for (const bucket of entriesByFile.values()) {
+        bucket.sort(compareEntry);
+    }
+    return wrapIndex(entriesByFile, seen.size);
+}
+/**
+ * Sort by start position ASC, breaking ties by end position DESC so that
+ * larger (outer) scopes appear before their smaller (inner) co-starting
+ * siblings in the array. Makes the backward-scan contract crisp: the
+ * first containing hit from the end of the scanned prefix is the
+ * innermost scope.
+ */
+function compareEntry(a, b) {
+    if (a.range.startLine !== b.range.startLine)
+        return a.range.startLine - b.range.startLine;
+    if (a.range.startCol !== b.range.startCol)
+        return a.range.startCol - b.range.startCol;
+    if (a.range.endLine !== b.range.endLine)
+        return b.range.endLine - a.range.endLine;
+    return b.range.endCol - a.range.endCol;
+}
+/** Whether `(line, col)` is at or after `range`'s start. */
+function startIsAtOrBefore(range, line, col) {
+    if (range.startLine < line)
+        return true;
+    if (range.startLine > line)
+        return false;
+    return range.startCol <= col;
+}
+/** Whether `(line, col)` is at or before `range`'s end (inclusive). */
+function endIsAtOrAfter(range, line, col) {
+    if (range.endLine > line)
+        return true;
+    if (range.endLine < line)
+        return false;
+    return range.endCol >= col;
+}
+/**
+ * Return the largest index `i` in `arr` where `arr[i].range` starts at or
+ * before `(line, col)`. Returns `-1` if no entry starts ≤ the query.
+ *
+ * Classic "upper bound - 1" binary search: find the first entry that
+ * starts *after* the query, then step back one.
+ */
+function findLastStartLteIndex(arr, line, col) {
+    let lo = 0;
+    let hi = arr.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (startIsAtOrBefore(arr[mid].range, line, col)) {
+            lo = mid + 1;
+        }
+        else {
+            hi = mid;
+        }
+    }
+    return lo - 1;
+}
+function wrapIndex(entriesByFile, size) {
+    return {
+        get size() {
+            return size;
+        },
+        atPosition(filePath, line, col) {
+            const bucket = entriesByFile.get(filePath);
+            if (bucket === undefined || bucket.length === 0)
+                return undefined;
+            const endIdx = findLastStartLteIndex(bucket, line, col);
+            if (endIdx < 0)
+                return undefined;
+            // Scan backward; first containing hit is innermost (see file header).
+            for (let i = endIdx; i >= 0; i--) {
+                const entry = bucket[i];
+                if (endIsAtOrAfter(entry.range, line, col)) {
+                    // `startIsAtOrBefore` is guaranteed true by the binary search.
+                    return entry.id;
+                }
+            }
+            return undefined;
+        },
+    };
+}

package/dist/core/code/shared/scope-resolution/qualified-name-index.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * `QualifiedNameIndex` — O(1) `qualifiedName → DefId[]` lookup across all kinds.
+ *
+ * Cross-kind fast path for qualified-name resolution
+ * (`lookupQualified(qname, scope, params)` in RFC §4.5). Class, method,
+ * field, and namespace defs all contribute to a single index here; consumers
+ * filter the returned `DefId[]` by `p.acceptedKinds` at the call site.
+ *
+ * Returns `DefId[]` (not a single `DefId`) because multiple defs can legally
+ * share a qualified name — partial classes in C#, method overloads, or
+ * accidental cross-kind collisions. The lookup caller filters to the expected
+ * kind(s) and ranks the survivors.
+ *
+ * Part of RFC #909 Ring 2 SHARED — #913.
+ *
+ * Consumed by: #917 (`Registry.lookup` qualified fast path, `resolveTypeRef`
+ * dotted fallback via #916).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQualifiedNameIndex = buildQualifiedNameIndex;
+/**
+ * Build a `QualifiedNameIndex` from a flat list of `SymbolDefinition` records.
+ *
+ * Only defs with a non-empty `qualifiedName` contribute; defs without one are
+ * silently skipped (not every kind carries a qualified name — anonymous or
+ * top-level symbols, dynamic-unresolved imports, etc.).
+ *
+ * **Duplicate policy: appended in input order.** Each unique `(qname, DefId)`
+ * pair contributes at most once — repeated entries for the same pair are
+ * deduplicated. Distinct `DefId`s sharing a `qname` accumulate in insertion
+ * order (stable output for deterministic lookup ranking at the call site).
+ *
+ * Pure function — safe to call repeatedly; no side effects.
+ */
+function buildQualifiedNameIndex(defs) {
+    const byQualifiedName = new Map();
+    const seenPairs = new Set();
+    for (const def of defs) {
+        const qname = def.qualifiedName;
+        if (qname === undefined || qname.length === 0)
+            continue;
+        const pairKey = `${qname}\0${def.nodeId}`;
+        if (seenPairs.has(pairKey))
+            continue;
+        seenPairs.add(pairKey);
+        const bucket = byQualifiedName.get(qname);
+        if (bucket === undefined) {
+            byQualifiedName.set(qname, [def.nodeId]);
+        }
+        else {
+            bucket.push(def.nodeId);
+        }
+    }
+    // Freeze bucket arrays so consumers can't mutate the index.
+    const frozen = new Map();
+    for (const [k, v] of byQualifiedName) {
+        frozen.set(k, Object.freeze(v.slice()));
+    }
+    return wrapIndex(frozen);
+}
+// ─── Internal ───────────────────────────────────────────────────────────────
+const EMPTY = Object.freeze([]);
+function wrapIndex(byQualifiedName) {
+    return {
+        byQualifiedName,
+        get size() {
+            return byQualifiedName.size;
+        },
+        get(qualifiedName) {
+            return byQualifiedName.get(qualifiedName) ?? EMPTY;
+        },
+        has(qualifiedName) {
+            return byQualifiedName.has(qualifiedName);
+        },
+    };
+}

package/dist/core/code/shared/scope-resolution/reference-site.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * `ReferenceSite` — a pre-resolution usage fact collected by `ScopeExtractor`
+ * (RFC §3.2 Phase 1; Ring 2 PKG #919).
+ *
+ * One record per `@reference.*` capture. The extractor records:
+ *   - the name being referenced (method/field/class name),
+ *   - the source range,
+ *   - the innermost lexical scope containing the reference,
+ *   - the reference kind (call, read, write, inherits, etc.),
+ *   - optional call-form classification from `provider.classifyCallForm`,
+ *   - optional explicit-receiver hint for dotted calls (`user.save()`),
+ *   - optional arity for call sites.
+ *
+ * Reference sites are consumed by the resolution phase (RFC §3.2 Phase 4)
+ * which routes each through `Registry.lookup` / `resolveTypeRef` and
+ * emits the final `Reference` record into `ReferenceIndex`.
+ *
+ * **Pre-resolution only.** `ReferenceSite` intentionally carries no
+ * `toDef`, `confidence`, or `evidence`. Those are populated by the
+ * resolution step that reads this record and produces a `Reference`
+ * (defined in `./types.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/code/shared/scope-resolution/registries/class-registry.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * `ClassRegistry` — scope-aware lookup for class-like symbols
+ * (RFC §4.4; Ring 2 SHARED #917).
+ *
+ * Thin wrapper over `lookupCore`, specialized for class kinds:
+ *
+ *   - `acceptedKinds` = Class / Interface / Enum / Struct / Union /
+ *     Trait / TypeAlias / Typedef / Record / Delegate / Annotation /
+ *     Template / Namespace.
+ *   - `useReceiverTypeBinding` is **false** — classes are resolved by
+ *     name through the lexical chain + global qualified fallback, not
+ *     via a receiver type.
+ *   - Arity filter is not applicable (classes are not called with
+ *     argument counts at lookup time).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClassRegistry = buildClassRegistry;
+const lookup_core_js_1 = require("./lookup-core.js");
+const context_js_1 = require("./context.js");
+function buildClassRegistry(ctx) {
+    const params = {
+        acceptedKinds: context_js_1.CLASS_KINDS,
+        useReceiverTypeBinding: false,
+        ownerScopedContributor: null,
+    };
+    return {
+        lookup(name, scope) {
+            return (0, lookup_core_js_1.lookupCore)(name, scope, params, ctx);
+        },
+    };
+}

package/dist/core/code/shared/scope-resolution/registries/context.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * `RegistryContext` — the injected state required by the scope-aware
+ * registry lookups (RFC §4; Ring 2 SHARED #917).
+ *
+ * Bundles every Ring 2 index + every provider hook the 7-step algorithm
+ * might consult. Threaded through `lookupCore` and the three public
+ * registries unchanged; construction is the caller's responsibility
+ * (typically once per workspace-indexing pass in Ring 2 PKG).
+ *
+ * The design intent is **pure-logic in `cgraph-shared`, data + hooks
+ * supplied by the caller**. Nothing here loads files, parses AST, or
+ * reaches into the CLI package.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MACRO_KINDS = exports.FIELD_KINDS = exports.METHOD_KINDS = exports.CLASS_KINDS = void 0;
+// ─── Per-kind default `acceptedKinds` sets ─────────────────────────────────
+//
+// Exported so the three public registries stay declarative (each one just
+// points at the right constant + passes it to `lookupCore`).
+exports.CLASS_KINDS = Object.freeze([
+    'Class',
+    'Interface',
+    'Enum',
+    'Struct',
+    'Union',
+    'Trait',
+    'TypeAlias',
+    'Typedef',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Template',
+    'Namespace',
+]);
+exports.METHOD_KINDS = Object.freeze([
+    'Method',
+    'Function',
+    'Constructor',
+]);
+exports.FIELD_KINDS = Object.freeze([
+    'Variable',
+    'Property',
+    'Const',
+    'Static',
+]);
+// Macros occupy a namespace disjoint from functions/methods: a `log!`
+// invocation must resolve ONLY to a `macro_rules! log` definition, never
+// to a same-named `fn log`. `MACRO_KINDS` is therefore a singleton
+// (`['Macro']`) and is NOT merged into METHOD_KINDS — keeping the two
+// keyspaces separate is what prevents the cross-namespace false-edge.
+exports.MACRO_KINDS = Object.freeze(['Macro']);