arceus-s 1.6.4

package/dist/_shared/scope-resolution/registries/lookup-core.js

@@ -0,0 +1,349 @@
+/**
+ * `lookupCore` — the shared 7-step canonical resolution algorithm
+ * (RFC §4.2; Ring 2 SHARED #917).
+ *
+ * Pure function. Given a name, a starting scope, and per-kind parameters,
+ * walks lexical scopes + optional type-binding MRO + optional owner
+ * contributor + global qualified-name fallback, and returns a ranked
+ * `Resolution[]` with per-candidate evidence.
+ *
+ * All three public registries (`ClassRegistry` / `MethodRegistry` /
+ * `FieldRegistry`) dispatch into this function, differing only in the
+ * parameters they pass. The CHOICE of which steps fire is expressed
+ * through `LookupParams`, not through different algorithms per kind.
+ *
+ * ## Algorithm (RFC §4.2, verbatim names)
+ *
+ * **Step 1 — Lexical scope-chain walk.** From `startScope`, walk
+ *   parent-ward. At each scope, consult `scope.bindings.get(name)`:
+ *     - Filter candidates whose `def.type ∈ acceptedKinds`.
+ *     - For each surviving candidate, record a raw signal with the
+ *       binding's origin + the current scope-chain depth.
+ *     - **Hard shadow.** If `bindings.get(name)` is non-empty (including
+ *       non-kind-matching candidates), stop walking. The name is
+ *       lexically bound here; outer scopes are not consulted.
+ *
+ * **Step 2 — Type-binding resolution.** When `useReceiverTypeBinding`
+ *   is true, resolve the receiver's type at `startScope` (from
+ *   `scope.typeBindings`), then walk the MRO via
+ *   `MethodDispatchIndex.mroFor(ownerDefId)`. Membership per owner comes
+ *   through `RegistryContext.methodDispatch` + owner lookups into
+ *   `scope.ownedDefs`; each hit records a raw signal with the owner's
+ *   MRO depth.
+ *
+ * **Step 3 — Owner-scoped contributor.** When
+ *   `params.ownerScopedContributor` is present, merge its `byName(name)`
+ *   hits with `origin: 'local'` (they are declared directly on the
+ *   receiver). Distinct from Step 2 — Step 2 walks the MRO; Step 3 only
+ *   looks at the directly-declared owner members.
+ *
+ * **Step 4 — Kind filter (emit `kind-match` evidence).** Already
+ *   applied during Steps 1-3; this step just adds a `kind-match` signal
+ *   at weight 0 to every candidate for debuggability (so the evidence
+ *   array is self-describing).
+ *
+ * **Step 5 — Arity filter.** Call `providers.arityCompatibility(callsite,
+ *   def)` per surviving candidate. Verdicts: `compatible` / `unknown` /
+ *   `incompatible`. If at least one candidate is `compatible`, drop
+ *   `incompatible` ones. Otherwise keep all (the penalty weight alone
+ *   will rank them lower but they remain in the result).
+ *
+ * **Step 6 — Global fallback.** When Steps 1-3 produced **no**
+ *   candidates and the name contains a `.`, consult the
+ *   `QualifiedNameIndex` via `lookupQualified` — see §4.5. The `scope`
+ *   argument is NOT passed here because global lookup is scope-agnostic.
+ *
+ * **Step 7 — Rank + tie-break.** Compose evidence, compute confidence
+ *   (sum capped at 1.0), sort by the RFC Appendix B cascade.
+ *
+ * ## What this module does NOT do
+ *
+ *   - No AST reads (pure data in, pure data out).
+ *   - No `arc/` imports.
+ *   - No language switches. Language-specific behavior flows exclusively
+ *     through `providers.*` and the `params` object.
+ *   - No caching. Callers that want memoization can wrap this function.
+ */
+import { composeEvidence, confidenceFromEvidence } from './evidence.js';
+import { compareByConfidenceWithTiebreaks } from './tie-breaks.js';
+import { lookupQualified } from './lookup-qualified.js';
+/**
+ * Run the 7-step lookup. Returns a non-empty `Resolution[]` when any
+ * candidate was found; an empty array otherwise. Callers consume `[0]`
+ * for the best answer and optionally inspect the rest for alternates.
+ */
+export function lookupCore(name, startScope, params, ctx) {
+    const acceptedKinds = new Set(params.acceptedKinds);
+    const perCandidate = new Map();
+    // ── Step 1: lexical scope-chain walk ──────────────────────────────────
+    const lexicalShadowed = walkLexicalChain(name, startScope, acceptedKinds, ctx, perCandidate);
+    // ── Step 2: type-binding / MRO walk (methods/fields) ──────────────────
+    if (params.useReceiverTypeBinding && ctx.methodDispatch !== undefined) {
+        walkReceiverTypeBinding(name, startScope, acceptedKinds, params, ctx, perCandidate);
+    }
+    // ── Step 3: owner-scoped contributor ──────────────────────────────────
+    if (params.ownerScopedContributor !== null) {
+        seedFromOwnerScopedContributor(name, params.ownerScopedContributor, acceptedKinds, perCandidate);
+    }
+    // ── Step 4: kind-match evidence (emitted by composeEvidence directly) ──
+    // Handled inside `composeEvidence`.
+    // ── Step 5: arity filter ──────────────────────────────────────────────
+    if (params.callsite !== undefined) {
+        applyArityFilter(params.callsite, perCandidate, ctx);
+    }
+    // ── Step 6: global fallback (only when Steps 1-3 produced nothing) ──
+    if (perCandidate.size === 0 && !lexicalShadowed && name.includes('.')) {
+        const globals = lookupQualified(name, { acceptedKinds: params.acceptedKinds }, ctx);
+        if (globals.length > 0)
+            return globals;
+    }
+    if (perCandidate.size === 0)
+        return EMPTY;
+    // ── Step 7: compose evidence + rank ──────────────────────────────────
+    return rankCandidates(perCandidate);
+}
+function ensureCandidate(perCandidate, def) {
+    const existing = perCandidate.get(def.nodeId);
+    if (existing !== undefined)
+        return existing;
+    const fresh = {
+        def,
+        signals: { kindMatch: true },
+        tieBreakKey: { scopeDepth: 0, mroDepth: 0, origin: 'local' },
+    };
+    perCandidate.set(def.nodeId, fresh);
+    return fresh;
+}
+// ─── Step 1 implementation ─────────────────────────────────────────────────
+/**
+ * Walk the lexical scope chain from `startScope` upward. Returns `true`
+ * iff a scope with any `bindings.get(name)` entries was found — the
+ * caller uses this to decide whether to run the global fallback.
+ */
+function walkLexicalChain(name, startScope, acceptedKinds, ctx, perCandidate) {
+    let currentId = startScope;
+    let depth = 0;
+    const visited = new Set();
+    while (currentId !== null) {
+        if (visited.has(currentId))
+            return false;
+        visited.add(currentId);
+        const scope = ctx.scopes.getScope(currentId);
+        if (scope === undefined)
+            return false;
+        const bindings = scope.bindings.get(name);
+        if (bindings !== undefined && bindings.length > 0) {
+            for (const binding of bindings) {
+                if (!acceptedKinds.has(binding.def.type))
+                    continue;
+                recordLexicalHit(perCandidate, binding, depth);
+            }
+            return true; // hard shadow regardless of kind-filter survivorship
+        }
+        currentId = scope.parent;
+        depth++;
+    }
+    return false;
+}
+function recordLexicalHit(perCandidate, binding, scopeChainDepth) {
+    const state = ensureCandidate(perCandidate, binding.def);
+    state.signals.origin = binding.origin;
+    state.signals.scopeChainDepth = scopeChainDepth;
+    if (binding.via?.linkStatus === 'unresolved') {
+        state.signals.viaUnlinkedImport = true;
+    }
+    if (binding.via?.kind === 'dynamic-unresolved') {
+        state.signals.dynamicUnresolved = true;
+    }
+    state.tieBreakKey.scopeDepth = scopeChainDepth;
+    state.tieBreakKey.origin = binding.origin;
+}
+// ─── Step 2 implementation ─────────────────────────────────────────────────
+function walkReceiverTypeBinding(name, startScope, acceptedKinds, params, ctx, perCandidate) {
+    const ownerDefId = resolveReceiverOwner(startScope, params, ctx);
+    if (ownerDefId === undefined)
+        return;
+    if (ctx.methodDispatch === undefined)
+        return;
+    const ownerDef = ctx.defs.get(ownerDefId);
+    if (ownerDef === undefined)
+        return;
+    // Walk the owner itself at depth 0, then its MRO chain.
+    const walk = [ownerDefId, ...ctx.methodDispatch.mroFor(ownerDefId)];
+    for (let mroDepth = 0; mroDepth < walk.length; mroDepth++) {
+        const currentOwnerId = walk[mroDepth];
+        const members = collectOwnedMembers(currentOwnerId, name, ctx);
+        for (const def of members) {
+            if (!acceptedKinds.has(def.type))
+                continue;
+            recordTypeBindingHit(perCandidate, def, mroDepth, ownerDefId);
+        }
+    }
+}
+function resolveReceiverOwner(startScope, params, ctx) {
+    // Explicit receiver: consult the callsite scope's typeBindings for the
+    // named receiver; the attached TypeRef identifies the owner. Without a
+    // ready resolveTypeRef call (that module is separate), we do a direct
+    // lookup and trust the caller to have populated the binding.
+    if (params.explicitReceiver !== undefined) {
+        return lookupReceiverType(startScope, params.explicitReceiver.name, ctx);
+    }
+    // Implicit `self` / `this` — the scope's typeBindings should carry it.
+    for (const implicitName of IMPLICIT_RECEIVERS) {
+        const owner = lookupReceiverType(startScope, implicitName, ctx);
+        if (owner !== undefined)
+            return owner;
+    }
+    return undefined;
+}
+const IMPLICIT_RECEIVERS = Object.freeze(['self', 'this']);
+function lookupReceiverType(startScope, receiverName, ctx) {
+    let currentId = startScope;
+    const visited = new Set();
+    while (currentId !== null) {
+        if (visited.has(currentId))
+            return undefined;
+        visited.add(currentId);
+        const scope = ctx.scopes.getScope(currentId);
+        if (scope === undefined)
+            return undefined;
+        const typeRef = scope.typeBindings.get(receiverName);
+        if (typeRef !== undefined) {
+            // rawName must resolve to a def via qualifiedNames; if it doesn't, we
+            // can't claim the receiver type. No fallback — that's what
+            // `resolveTypeRef` would do, but we keep this path lean and let
+            // callers pre-resolve if they want the richer semantics.
+            const candidateIds = ctx.qualifiedNames.get(typeRef.rawName);
+            if (candidateIds.length === 1)
+                return candidateIds[0];
+            // Ambiguous (≥ 2) or missing (0) — caller must pre-resolve via
+            // `resolveTypeRef` (#916) if they want the richer semantics. We
+            // intentionally do NOT re-implement a simple-name fallback here.
+            return undefined;
+        }
+        currentId = scope.parent;
+    }
+    return undefined;
+}
+function collectOwnedMembers(ownerDefId, memberName, ctx) {
+    // An owner's members are defs whose `ownerId === ownerDefId` and whose
+    // simple name matches `memberName`. We iterate `defs.byId` — O(D) per
+    // call today. A future by-owner index would make this O(K); tracked as
+    // a follow-up optimization before Ring 3 flips go production.
+    const out = [];
+    for (const def of ctx.defs.byId.values()) {
+        if (def.ownerId !== ownerDefId)
+            continue;
+        if (simpleNameOf(def) !== memberName)
+            continue;
+        out.push(def);
+    }
+    return out;
+}
+function simpleNameOf(def) {
+    if (def.qualifiedName === undefined || def.qualifiedName.length === 0)
+        return undefined;
+    const dot = def.qualifiedName.lastIndexOf('.');
+    return dot === -1 ? def.qualifiedName : def.qualifiedName.slice(dot + 1);
+}
+function recordTypeBindingHit(perCandidate, def, mroDepth, receiverOwner) {
+    const state = ensureCandidate(perCandidate, def);
+    const existingMroDepth = state.signals.typeBindingMroDepth;
+    const firstHit = existingMroDepth === undefined;
+    // Only replace if this hit is shallower (smaller MRO depth). The local
+    // const lets TS narrow to `number` in the `else` branch so no `!`
+    // assertion is needed.
+    if (firstHit || mroDepth < existingMroDepth) {
+        state.signals.typeBindingMroDepth = mroDepth;
+        state.tieBreakKey.mroDepth = mroDepth;
+    }
+    if (def.ownerId === receiverOwner) {
+        state.signals.ownerMatch = true;
+    }
+    // Pure type-binding candidates (no lexical hit) would otherwise keep the
+    // `ensureCandidate` default `tieBreakKey.origin === 'local'`, making the
+    // Appendix B cascade lump them with local-origin candidates. Demote them
+    // to `'import'` — the strongest non-local origin — only when no earlier
+    // phase set an origin for this candidate. Lexical hits from Step 1 set
+    // `signals.origin` before Step 2 runs, so the guard skips them; Step 3
+    // (`seedFromOwnerScopedContributor`) runs AFTER Step 2 and unconditionally
+    // overrides `tieBreakKey.origin` back to `'local'` for direct-owner
+    // members, so any same-def overlap still ends up ranked correctly.
+    if (firstHit && state.signals.origin === undefined) {
+        state.tieBreakKey.origin = 'import';
+    }
+}
+// ─── Step 3 implementation ─────────────────────────────────────────────────
+function seedFromOwnerScopedContributor(name, contributor, acceptedKinds, perCandidate) {
+    for (const def of contributor.byName(name)) {
+        if (!acceptedKinds.has(def.type))
+            continue;
+        const state = ensureCandidate(perCandidate, def);
+        // Treat the contributor's direct membership as `origin: 'local'` —
+        // strongest visibility, no scope-chain penalty.
+        state.signals.origin = 'local';
+        state.signals.scopeChainDepth = 0;
+        state.signals.ownerMatch = def.ownerId === contributor.ownerDefId;
+        state.tieBreakKey.origin = 'local';
+    }
+}
+// ─── Step 5 implementation ─────────────────────────────────────────────────
+function applyArityFilter(callsite, perCandidate, ctx) {
+    const arityFn = ctx.providers.arityCompatibility;
+    if (arityFn === undefined) {
+        // No provider → record 'unknown' for every candidate; keeps signal
+        // shape uniform for composeEvidence.
+        for (const state of perCandidate.values()) {
+            state.signals.arityVerdict = 'unknown';
+        }
+        return;
+    }
+    let anyCompatible = false;
+    let anyUnknown = false;
+    for (const state of perCandidate.values()) {
+        const verdict = arityFn(callsite, state.def);
+        state.signals.arityVerdict = verdict;
+        if (verdict === 'compatible')
+            anyCompatible = true;
+        else if (verdict === 'unknown')
+            anyUnknown = true;
+    }
+    // When ALL candidates are 'incompatible' (none compatible, none unknown),
+    // the call is genuinely arity-broken — drop every candidate so the
+    // registry returns no resolution. This matches the PHP variadic case
+    // f(int $req, ...$rest) called with zero args: every candidate definitively
+    // rejects, and emitting an edge to a definitively-rejected callable is
+    // a false positive. When some candidates are 'unknown' (missing metadata),
+    // keep the set so downstream evidence can break the tie — that's the
+    // original safety-fallback behavior.
+    if (!anyCompatible) {
+        if (!anyUnknown) {
+            for (const defId of perCandidate.keys()) {
+                perCandidate.delete(defId);
+            }
+        }
+        return;
+    }
+    // Filter: when at least one compatible candidate exists, drop incompatibles.
+    for (const [defId, state] of perCandidate) {
+        if (state.signals.arityVerdict === 'incompatible') {
+            perCandidate.delete(defId);
+        }
+    }
+}
+// ─── Step 7 implementation ─────────────────────────────────────────────────
+function rankCandidates(perCandidate) {
+    const resolutions = [];
+    const tieKeys = new Map();
+    for (const state of perCandidate.values()) {
+        const evidence = composeEvidence(state.signals);
+        const confidence = confidenceFromEvidence(evidence);
+        resolutions.push({ def: state.def, confidence, evidence });
+        tieKeys.set(state.def.nodeId, { ...state.tieBreakKey });
+    }
+    resolutions.sort((a, b) => compareByConfidenceWithTiebreaks(a, b, tieKeys));
+    return Object.freeze(resolutions);
+}
+// ─── Constants ──────────────────────────────────────────────────────────────
+const EMPTY = Object.freeze([]);
+//# sourceMappingURL=lookup-core.js.map

package/dist/_shared/scope-resolution/registries/lookup-core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup-core.js","sourceRoot":"","sources":["../../../src/scope-resolution/registries/lookup-core.ts"],"names":[],"mappings":"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"}

package/dist/_shared/scope-resolution/registries/lookup-qualified.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `lookupQualified` — qualified-name fast path (RFC §4.5; Ring 2 SHARED #917).
+ *
+ * Consults `QualifiedNameIndex` directly, filters by `acceptedKinds`, and
+ * returns `Resolution[]` with `origin: 'global-qualified'` evidence. Used by:
+ *
+ *   - `resolveTypeRef` dotted fallback (#916)
+ *   - `Registry.lookup` Step 6 when no lexical candidate survived
+ *   - Explicit dotted identifiers in Cypher / MCP tools where the caller
+ *     knows the target's canonical qualified name
+ *
+ * **Strict + deterministic.** No receiver-type resolution, no scope walk.
+ * Every surviving candidate gets the same base confidence (from
+ * `EvidenceWeights.globalQualified`), then the tie-break cascade
+ * disambiguates.
+ */
+import type { NodeLabel } from '../../graph/types.js';
+import type { Resolution } from '../types.js';
+import type { RegistryContext } from './context.js';
+export interface LookupQualifiedParams {
+    readonly acceptedKinds: readonly NodeLabel[];
+}
+/**
+ * Look up a canonical qualified name (e.g., `app.models.User`) across all
+ * defs, filtered by `acceptedKinds`. Returns an empty array when the name
+ * is not indexed or no candidate matches the kind filter.
+ *
+ * Callers consume `[0]` for the strict single-return answer; the remainder
+ * carries alternate candidates (partial classes, overloads, accidental
+ * cross-kind hits) ordered by the tie-break cascade.
+ */
+export declare function lookupQualified(qualifiedName: string, params: LookupQualifiedParams, ctx: RegistryContext): readonly Resolution[];
+//# sourceMappingURL=lookup-qualified.d.ts.map

package/dist/_shared/scope-resolution/registries/lookup-qualified.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup-qualified.d.ts","sourceRoot":"","sources":["../../../src/scope-resolution/registries/lookup-qualified.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,aAAa,EAAE,SAAS,SAAS,EAAE,CAAC;CAC9C;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,qBAAqB,EAC7B,GAAG,EAAE,eAAe,GACnB,SAAS,UAAU,EAAE,CA4BvB"}

package/dist/_shared/scope-resolution/registries/lookup-qualified.js

@@ -0,0 +1,56 @@
+/**
+ * `lookupQualified` — qualified-name fast path (RFC §4.5; Ring 2 SHARED #917).
+ *
+ * Consults `QualifiedNameIndex` directly, filters by `acceptedKinds`, and
+ * returns `Resolution[]` with `origin: 'global-qualified'` evidence. Used by:
+ *
+ *   - `resolveTypeRef` dotted fallback (#916)
+ *   - `Registry.lookup` Step 6 when no lexical candidate survived
+ *   - Explicit dotted identifiers in Cypher / MCP tools where the caller
+ *     knows the target's canonical qualified name
+ *
+ * **Strict + deterministic.** No receiver-type resolution, no scope walk.
+ * Every surviving candidate gets the same base confidence (from
+ * `EvidenceWeights.globalQualified`), then the tie-break cascade
+ * disambiguates.
+ */
+import { composeEvidence, confidenceFromEvidence } from './evidence.js';
+import { compareByConfidenceWithTiebreaks } from './tie-breaks.js';
+/**
+ * Look up a canonical qualified name (e.g., `app.models.User`) across all
+ * defs, filtered by `acceptedKinds`. Returns an empty array when the name
+ * is not indexed or no candidate matches the kind filter.
+ *
+ * Callers consume `[0]` for the strict single-return answer; the remainder
+ * carries alternate candidates (partial classes, overloads, accidental
+ * cross-kind hits) ordered by the tie-break cascade.
+ */
+export function lookupQualified(qualifiedName, params, ctx) {
+    const defIds = ctx.qualifiedNames.get(qualifiedName);
+    if (defIds.length === 0)
+        return EMPTY;
+    const acceptedKinds = new Set(params.acceptedKinds);
+    const resolutions = [];
+    const tieKeys = new Map();
+    for (const defId of defIds) {
+        const def = ctx.defs.get(defId);
+        if (def === undefined)
+            continue;
+        if (!acceptedKinds.has(def.type))
+            continue;
+        const evidence = composeEvidence({ origin: 'global-qualified', kindMatch: true });
+        const confidence = confidenceFromEvidence(evidence);
+        resolutions.push({ def, confidence, evidence });
+        tieKeys.set(def.nodeId, {
+            scopeDepth: 0,
+            mroDepth: 0,
+            origin: 'global-qualified',
+        });
+    }
+    if (resolutions.length === 0)
+        return EMPTY;
+    resolutions.sort((a, b) => compareByConfidenceWithTiebreaks(a, b, tieKeys));
+    return Object.freeze(resolutions);
+}
+const EMPTY = Object.freeze([]);
+//# sourceMappingURL=lookup-qualified.js.map

package/dist/_shared/scope-resolution/registries/lookup-qualified.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup-qualified.js","sourceRoot":"","sources":["../../../src/scope-resolution/registries/lookup-qualified.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EAAE,gCAAgC,EAAoB,MAAM,iBAAiB,CAAC;AAOrF;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAC7B,aAAqB,EACrB,MAA6B,EAC7B,GAAoB;IAEpB,MAAM,MAAM,GAAG,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;IACrD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAEtC,MAAM,aAAa,GAAG,IAAI,GAAG,CAAY,MAAM,CAAC,aAAa,CAAC,CAAC;IAE/D,MAAM,WAAW,GAAiB,EAAE,CAAC;IACrC,MAAM,OAAO,GAAG,IAAI,GAAG,EAAuB,CAAC;IAE/C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,GAAG,KAAK,SAAS;YAAE,SAAS;QAChC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,SAAS;QAE3C,MAAM,QAAQ,GAAG,eAAe,CAAC,EAAE,MAAM,EAAE,kBAAkB,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAClF,MAAM,UAAU,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC;QACpD,WAAW,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,CAAC;QAChD,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE;YACtB,UAAU,EAAE,CAAC;YACb,QAAQ,EAAE,CAAC;YACX,MAAM,EAAE,kBAAkB;SAC3B,CAAC,CAAC;IACL,CAAC;IAED,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAE3C,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,gCAAgC,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5E,OAAO,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;AACpC,CAAC;AAED,MAAM,KAAK,GAA0B,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC"}

package/dist/_shared/scope-resolution/registries/method-registry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `MethodRegistry` — scope-aware lookup for method / function / constructor
+ * dispatch (RFC §4.4; Ring 2 SHARED #917).
+ *
+ * Thin wrapper over `lookupCore`, specialized for callable kinds:
+ *
+ *   - `acceptedKinds` = Method / Function / Constructor.
+ *   - `useReceiverTypeBinding` is **true** — the type-binding + MRO walk
+ *     (Step 2) is the primary evidence path for receiver-dispatched calls.
+ *   - `callsite.arity` flows through to `provider.arityCompatibility`
+ *     when provided. When the provider is absent, arity evidence is
+ *     `unknown` (neutral signal).
+ */
+import type { Callsite, Resolution, ScopeId } from '../types.js';
+import type { OwnerScopedContributor, RegistryContext } from './context.js';
+/**
+ * Extra per-call parameters that vary across call sites but NOT across
+ * registries. Kept as a separate shape so `MethodRegistry.lookup` stays
+ * concise while still exposing the explicit-receiver + owner-contributor +
+ * arity knobs the RFC algorithm needs.
+ */
+export interface MethodLookupOptions {
+    /** Call-site arity for `provider.arityCompatibility`. */
+    readonly callsite?: Callsite;
+    /** Explicit receiver (e.g., `user` in `user.save()`). See §4.1. */
+    readonly explicitReceiver?: {
+        readonly name: string;
+    };
+    /** Optional per-owner contributor (Step 3). */
+    readonly ownerScopedContributor?: OwnerScopedContributor;
+}
+export interface MethodRegistry {
+    lookup(name: string, scope: ScopeId, options?: MethodLookupOptions): readonly Resolution[];
+}
+export declare function buildMethodRegistry(ctx: RegistryContext): MethodRegistry;
+//# sourceMappingURL=method-registry.d.ts.map

package/dist/_shared/scope-resolution/registries/method-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-registry.d.ts","sourceRoot":"","sources":["../../../src/scope-resolution/registries/method-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG5E;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,+CAA+C;IAC/C,QAAQ,CAAC,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CAC1D;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,SAAS,UAAU,EAAE,CAAC;CAC5F;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,eAAe,GAAG,cAAc,CAexE"}

package/dist/_shared/scope-resolution/registries/method-registry.js

@@ -0,0 +1,32 @@
+/**
+ * `MethodRegistry` — scope-aware lookup for method / function / constructor
+ * dispatch (RFC §4.4; Ring 2 SHARED #917).
+ *
+ * Thin wrapper over `lookupCore`, specialized for callable kinds:
+ *
+ *   - `acceptedKinds` = Method / Function / Constructor.
+ *   - `useReceiverTypeBinding` is **true** — the type-binding + MRO walk
+ *     (Step 2) is the primary evidence path for receiver-dispatched calls.
+ *   - `callsite.arity` flows through to `provider.arityCompatibility`
+ *     when provided. When the provider is absent, arity evidence is
+ *     `unknown` (neutral signal).
+ */
+import { lookupCore } from './lookup-core.js';
+import { METHOD_KINDS } from './context.js';
+export function buildMethodRegistry(ctx) {
+    return {
+        lookup(name, scope, options = {}) {
+            const params = {
+                acceptedKinds: METHOD_KINDS,
+                useReceiverTypeBinding: true,
+                ownerScopedContributor: options.ownerScopedContributor ?? null,
+                ...(options.callsite !== undefined ? { callsite: options.callsite } : {}),
+                ...(options.explicitReceiver !== undefined
+                    ? { explicitReceiver: options.explicitReceiver }
+                    : {}),
+            };
+            return lookupCore(name, scope, params, ctx);
+        },
+    };
+}
+//# sourceMappingURL=method-registry.js.map

package/dist/_shared/scope-resolution/registries/method-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-registry.js","sourceRoot":"","sources":["../../../src/scope-resolution/registries/method-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,UAAU,EAAyB,MAAM,kBAAkB,CAAC;AAErE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAqB5C,MAAM,UAAU,mBAAmB,CAAC,GAAoB;IACtD,OAAO;QACL,MAAM,CAAC,IAAY,EAAE,KAAc,EAAE,UAA+B,EAAE;YACpE,MAAM,MAAM,GAAqB;gBAC/B,aAAa,EAAE,YAAY;gBAC3B,sBAAsB,EAAE,IAAI;gBAC5B,sBAAsB,EAAE,OAAO,CAAC,sBAAsB,IAAI,IAAI;gBAC9D,GAAG,CAAC,OAAO,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACzE,GAAG,CAAC,OAAO,CAAC,gBAAgB,KAAK,SAAS;oBACxC,CAAC,CAAC,EAAE,gBAAgB,EAAE,OAAO,CAAC,gBAAgB,EAAE;oBAChD,CAAC,CAAC,EAAE,CAAC;aACR,CAAC;YACF,OAAO,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QAC9C,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/_shared/scope-resolution/registries/tie-breaks.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `compareByConfidenceWithTiebreaks` — the RFC §4.2 Step 7 total order
+ * over `Resolution` candidates (Ring 2 SHARED #917).
+ *
+ * Primary key is confidence (DESC). Remaining ties within `CONFIDENCE_EPSILON`
+ * fall through a deterministic cascade so the same inputs always produce
+ * the same winner, independent of insertion order.
+ *
+ * Tie-break cascade (per RFC Appendix B):
+ *
+ *   1. confidence DESC                       (primary)
+ *   2. scope depth ASC                       (nearer lexical scope wins)
+ *   3. MRO depth ASC                         (nearer class in hierarchy wins)
+ *   4. `ORIGIN_PRIORITY` ASC                 (local > import > … > global-name)
+ *   5. DefId.localeCompare                   (final deterministic tiebreaker)
+ *
+ * The per-candidate inputs needed beyond `Resolution.confidence` —
+ * `scopeDepth`, `mroDepth`, `origin` — are supplied via a sidecar
+ * `TieBreakKey` so the comparator stays pure and `Resolution` itself
+ * doesn't need to carry book-keeping fields.
+ */
+import { type OriginForTieBreak } from '../origin-priority.js';
+import type { Resolution } from '../types.js';
+export declare const CONFIDENCE_EPSILON = 0.001;
+/** Side-information per candidate used for secondary tie-breaks. */
+export interface TieBreakKey {
+    readonly scopeDepth: number;
+    readonly mroDepth: number;
+    readonly origin: OriginForTieBreak;
+}
+/**
+ * Pure comparator suitable for `Array.prototype.sort`. Return value follows
+ * the JavaScript convention: negative → `a` wins, positive → `b` wins.
+ *
+ * **Important:** `keys` is keyed by `Resolution.def.nodeId`, not by array
+ * index — stable across reorderings. Missing keys fall back to neutral
+ * values (`scopeDepth: 0`, `mroDepth: 0`, `origin: 'local'`), which means
+ * the tie-break degrades gracefully to defId-lexicographic ordering when
+ * side-info is unavailable. That keeps the total order deterministic
+ * even on malformed inputs.
+ */
+export declare function compareByConfidenceWithTiebreaks(a: Resolution, b: Resolution, keys: ReadonlyMap<string, TieBreakKey>): number;
+//# sourceMappingURL=tie-breaks.d.ts.map

package/dist/_shared/scope-resolution/registries/tie-breaks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tie-breaks.d.ts","sourceRoot":"","sources":["../../../src/scope-resolution/registries/tie-breaks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAmB,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AAExC,oEAAoE;AACpE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;CACpC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAC9C,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,EACb,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GACrC,MAAM,CAoBR"}

package/dist/_shared/scope-resolution/registries/tie-breaks.js

@@ -0,0 +1,60 @@
+/**
+ * `compareByConfidenceWithTiebreaks` — the RFC §4.2 Step 7 total order
+ * over `Resolution` candidates (Ring 2 SHARED #917).
+ *
+ * Primary key is confidence (DESC). Remaining ties within `CONFIDENCE_EPSILON`
+ * fall through a deterministic cascade so the same inputs always produce
+ * the same winner, independent of insertion order.
+ *
+ * Tie-break cascade (per RFC Appendix B):
+ *
+ *   1. confidence DESC                       (primary)
+ *   2. scope depth ASC                       (nearer lexical scope wins)
+ *   3. MRO depth ASC                         (nearer class in hierarchy wins)
+ *   4. `ORIGIN_PRIORITY` ASC                 (local > import > … > global-name)
+ *   5. DefId.localeCompare                   (final deterministic tiebreaker)
+ *
+ * The per-candidate inputs needed beyond `Resolution.confidence` —
+ * `scopeDepth`, `mroDepth`, `origin` — are supplied via a sidecar
+ * `TieBreakKey` so the comparator stays pure and `Resolution` itself
+ * doesn't need to carry book-keeping fields.
+ */
+import { ORIGIN_PRIORITY } from '../origin-priority.js';
+export const CONFIDENCE_EPSILON = 0.001;
+/**
+ * Pure comparator suitable for `Array.prototype.sort`. Return value follows
+ * the JavaScript convention: negative → `a` wins, positive → `b` wins.
+ *
+ * **Important:** `keys` is keyed by `Resolution.def.nodeId`, not by array
+ * index — stable across reorderings. Missing keys fall back to neutral
+ * values (`scopeDepth: 0`, `mroDepth: 0`, `origin: 'local'`), which means
+ * the tie-break degrades gracefully to defId-lexicographic ordering when
+ * side-info is unavailable. That keeps the total order deterministic
+ * even on malformed inputs.
+ */
+export function compareByConfidenceWithTiebreaks(a, b, keys) {
+    // Primary: confidence DESC, treating values within epsilon as equal.
+    const delta = b.confidence - a.confidence;
+    if (Math.abs(delta) >= CONFIDENCE_EPSILON)
+        return delta < 0 ? -1 : 1;
+    const ka = keys.get(a.def.nodeId) ?? DEFAULT_KEY;
+    const kb = keys.get(b.def.nodeId) ?? DEFAULT_KEY;
+    // Secondary: scope depth ASC.
+    if (ka.scopeDepth !== kb.scopeDepth)
+        return ka.scopeDepth - kb.scopeDepth;
+    // Tertiary: MRO depth ASC.
+    if (ka.mroDepth !== kb.mroDepth)
+        return ka.mroDepth - kb.mroDepth;
+    // Quaternary: ORIGIN_PRIORITY ASC.
+    const po = ORIGIN_PRIORITY[ka.origin] - ORIGIN_PRIORITY[kb.origin];
+    if (po !== 0)
+        return po;
+    // Final: DefId lexicographic, locale-aware for deterministic cross-platform output.
+    return a.def.nodeId.localeCompare(b.def.nodeId);
+}
+const DEFAULT_KEY = Object.freeze({
+    scopeDepth: 0,
+    mroDepth: 0,
+    origin: 'local',
+});
+//# sourceMappingURL=tie-breaks.js.map