gitnexus 1.6.3-rc.8 → 1.6.3

package/dist/_shared/scope-resolution/reference-site.js

@@ -0,0 +1,24 @@
+/**
+ * `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`).
+ */
+export {};
+//# sourceMappingURL=reference-site.js.map

package/dist/_shared/scope-resolution/reference-site.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-site.js","sourceRoot":"","sources":["../../src/scope-resolution/reference-site.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG"}

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

@@ -0,0 +1,27 @@
+/**
+ * `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).
+ */
+import type { Resolution, ScopeId } from '../types.js';
+import { type RegistryContext } from './context.js';
+export interface ClassRegistry {
+    /**
+     * Look up a class-like symbol by simple or dotted name anchored at
+     * `scope`. Returns a confidence-ranked `Resolution[]`; consume `[0]`
+     * for the best answer.
+     */
+    lookup(name: string, scope: ScopeId): readonly Resolution[];
+}
+export declare function buildClassRegistry(ctx: RegistryContext): ClassRegistry;
+//# sourceMappingURL=class-registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"class-registry.d.ts","sourceRoot":"","sources":["../../../src/scope-resolution/registries/class-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAEjE,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,SAAS,UAAU,EAAE,CAAC;CAC7D;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa,CAWtE"}

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

@@ -0,0 +1,30 @@
+/**
+ * `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).
+ */
+import { lookupCore } from './lookup-core.js';
+import { CLASS_KINDS } from './context.js';
+export function buildClassRegistry(ctx) {
+    const params = {
+        acceptedKinds: CLASS_KINDS,
+        useReceiverTypeBinding: false,
+        ownerScopedContributor: null,
+    };
+    return {
+        lookup(name, scope) {
+            return lookupCore(name, scope, params, ctx);
+        },
+    };
+}
+//# sourceMappingURL=class-registry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"class-registry.js","sourceRoot":"","sources":["../../../src/scope-resolution/registries/class-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,UAAU,EAAyB,MAAM,kBAAkB,CAAC;AACrE,OAAO,EAAE,WAAW,EAAwB,MAAM,cAAc,CAAC;AAWjE,MAAM,UAAU,kBAAkB,CAAC,GAAoB;IACrD,MAAM,MAAM,GAAqB;QAC/B,aAAa,EAAE,WAAW;QAC1B,sBAAsB,EAAE,KAAK;QAC7B,sBAAsB,EAAE,IAAI;KAC7B,CAAC;IACF,OAAO;QACL,MAAM,CAAC,IAAY,EAAE,KAAc;YACjC,OAAO,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QAC9C,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/_shared/scope-resolution/registries/context.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `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 `gitnexus-shared`, data + hooks
+ * supplied by the caller**. Nothing here loads files, parses AST, or
+ * reaches into the CLI package.
+ */
+import type { NodeLabel } from '../../graph/types.js';
+import type { SymbolDefinition } from '../symbol-definition.js';
+import type { Callsite, DefId } from '../types.js';
+import type { DefIndex } from '../def-index.js';
+import type { QualifiedNameIndex } from '../qualified-name-index.js';
+import type { ModuleScopeIndex } from '../module-scope-index.js';
+import type { ScopeTree } from '../scope-tree.js';
+import type { MethodDispatchIndex } from '../method-dispatch-index.js';
+export interface RegistryProviders {
+    /**
+     * Language-specific arity compatibility between a callsite and a candidate
+     * `def`. Mirrors `LanguageProvider.arityCompatibility` from #911. Optional:
+     * when absent, every candidate receives `'unknown'` (neutral signal).
+     */
+    arityCompatibility?(callsite: Callsite, def: SymbolDefinition): ArityVerdict;
+}
+export type ArityVerdict = 'compatible' | 'unknown' | 'incompatible';
+/**
+ * Per-owner membership view plugged into `LookupParams.ownerScopedContributor`.
+ *
+ * When the caller knows a receiver is of type `Owner` (e.g., after
+ * resolving an explicit receiver or via `self`), it can supply the
+ * `Owner`'s own member bucket here. `lookupCore` treats hits from this
+ * contributor as `origin: 'local'` inside the owner's body scope —
+ * strongest-visibility evidence, unaffected by the scope-chain hop
+ * deduction that punishes outer-scope hits.
+ *
+ * Ring 1's `RegistryContributor = unknown` opaque placeholder is narrowed
+ * to this concrete shape here in Ring 2 SHARED (#917).
+ */
+export interface OwnerScopedContributor {
+    /** The owner (class/struct/trait/interface) that bounds this view. */
+    readonly ownerDefId: DefId;
+    /**
+     * Methods / fields directly declared on the owner, keyed by simple name.
+     * Return empty array on miss; implementations should NOT walk the MRO —
+     * that's `MethodDispatchIndex`'s job, handled in the type-binding step.
+     */
+    byName(name: string): readonly SymbolDefinition[];
+}
+export interface RegistryContext {
+    readonly scopes: ScopeTree;
+    readonly defs: DefIndex;
+    readonly qualifiedNames: QualifiedNameIndex;
+    readonly moduleScopes: ModuleScopeIndex;
+    /**
+     * Method-dispatch index; required for method/field registries that
+     * honor `useReceiverTypeBinding`. Omit for class-only lookups.
+     */
+    readonly methodDispatch?: MethodDispatchIndex;
+    readonly providers: RegistryProviders;
+}
+export declare const CLASS_KINDS: readonly NodeLabel[];
+export declare const METHOD_KINDS: readonly NodeLabel[];
+export declare const FIELD_KINDS: readonly NodeLabel[];
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/scope-resolution/registries/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAIvE,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,kBAAkB,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,gBAAgB,GAAG,YAAY,CAAC;CAC9E;AAED,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,cAAc,CAAC;AAIrE;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,sBAAsB;IACrC,sEAAsE;IACtE,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;IAC3B;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,gBAAgB,EAAE,CAAC;CACnD;AAID,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,cAAc,EAAE,kBAAkB,CAAC;IAC5C,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,mBAAmB,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC;CACvC;AAOD,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAc1C,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,SAAS,SAAS,EAI3C,CAAC;AAEH,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAK1C,CAAC"}

package/dist/_shared/scope-resolution/registries/context.js

@@ -0,0 +1,44 @@
+/**
+ * `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 `gitnexus-shared`, data + hooks
+ * supplied by the caller**. Nothing here loads files, parses AST, or
+ * reaches into the CLI package.
+ */
+// ─── 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`).
+export const CLASS_KINDS = Object.freeze([
+    'Class',
+    'Interface',
+    'Enum',
+    'Struct',
+    'Union',
+    'Trait',
+    'TypeAlias',
+    'Typedef',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Template',
+    'Namespace',
+]);
+export const METHOD_KINDS = Object.freeze([
+    'Method',
+    'Function',
+    'Constructor',
+]);
+export const FIELD_KINDS = Object.freeze([
+    'Variable',
+    'Property',
+    'Const',
+    'Static',
+]);
+//# sourceMappingURL=context.js.map

package/dist/_shared/scope-resolution/registries/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/scope-resolution/registries/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAiEH,8EAA8E;AAC9E,EAAE;AACF,0EAA0E;AAC1E,6DAA6D;AAE7D,MAAM,CAAC,MAAM,WAAW,GAAyB,MAAM,CAAC,MAAM,CAAC;IAC7D,OAAO;IACP,WAAW;IACX,MAAM;IACN,QAAQ;IACR,OAAO;IACP,OAAO;IACP,WAAW;IACX,SAAS;IACT,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,UAAU;IACV,WAAW;CACZ,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,YAAY,GAAyB,MAAM,CAAC,MAAM,CAAC;IAC9D,QAAQ;IACR,UAAU;IACV,aAAa;CACd,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,WAAW,GAAyB,MAAM,CAAC,MAAM,CAAC;IAC7D,UAAU;IACV,UAAU;IACV,OAAO;IACP,QAAQ;CACT,CAAC,CAAC"}

package/dist/_shared/scope-resolution/registries/evidence.d.ts

@@ -0,0 +1,56 @@
+/**
+ * `composeEvidence` — translate accumulated raw signals per candidate
+ * into a `ResolutionEvidence[]` using the authoritative `EvidenceWeights`
+ * map (RFC §4.3 + Appendix A; Ring 2 SHARED #917).
+ *
+ * Each `RawSignals` record describes what was observed about a candidate
+ * during the 7-step walk: where it was found, at what depth, whether
+ * anything corroborates it. This module turns those raw facts into the
+ * typed evidence list attached to the outgoing `Resolution`.
+ *
+ * **Every weight comes from `EvidenceWeights`.** No inline magic numbers.
+ * Extends issue #429 (centralize hardcoded confidence values).
+ *
+ * **Confidence compose rule.** Signals add; the sum is capped at 1.0 at
+ * the call site (inside `lookupCore`). This module only emits the list;
+ * it does NOT compute the capped sum so callers can inspect per-signal
+ * contributions for debugging.
+ */
+import type { BindingRef, ResolutionEvidence } from '../types.js';
+/**
+ * Raw signals observed for a single candidate during the 7-step walk.
+ * Optional fields encode "this signal did not fire"; presence encodes
+ * "emit an evidence record".
+ */
+export interface RawSignals {
+    /** Visibility origin of the binding that produced this candidate. */
+    readonly origin?: BindingRef['origin'] | 'global-qualified' | 'global-name';
+    /** Depth at which the binding was found (hops up from start scope). */
+    readonly scopeChainDepth?: number;
+    /** `ImportEdge` that brought the name in; present when origin is a non-local. */
+    readonly viaUnlinkedImport?: boolean;
+    /** Set when the candidate came via the receiver's type-binding MRO walk. */
+    readonly typeBindingMroDepth?: number;
+    /** `def.ownerId === resolvedReceiver.def.nodeId`. */
+    readonly ownerMatch?: boolean;
+    /** Always fires for candidates that pass `acceptedKinds`; weight 0. */
+    readonly kindMatch: true;
+    readonly arityVerdict?: 'compatible' | 'unknown' | 'incompatible';
+    /** Candidate flows through a `kind: 'dynamic-unresolved'` ImportEdge. */
+    readonly dynamicUnresolved?: boolean;
+}
+/**
+ * Compose the raw signals into a stable `ResolutionEvidence[]` list.
+ *
+ * Emission order mirrors the `EvidenceWeights` layout: where-found →
+ * type-binding → corroborators → arity → degraded. Stable order makes
+ * the per-signal contributions easy to reason about in tests and in the
+ * shadow-mode parity dashboard.
+ */
+export declare function composeEvidence(signals: RawSignals): readonly ResolutionEvidence[];
+/**
+ * Sum evidence weights and clamp to `[0, 1]`. Separate from `composeEvidence`
+ * so tests and the parity dashboard can inspect the raw evidence list.
+ */
+export declare function confidenceFromEvidence(evidence: readonly ResolutionEvidence[]): number;
+//# sourceMappingURL=evidence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../../../src/scope-resolution/registries/evidence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGlE;;;;GAIG;AACH,MAAM,WAAW,UAAU;IAEzB,qEAAqE;IACrE,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,kBAAkB,GAAG,aAAa,CAAC;IAC5E,uEAAuE;IACvE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,iFAAiF;IACjF,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAGrC,4EAA4E;IAC5E,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAGtC,qDAAqD;IACrD,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IAGzB,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,GAAG,SAAS,GAAG,cAAc,CAAC;IAGlE,yEAAyE;IACzE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS,kBAAkB,EAAE,CA6ElF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,GAAG,MAAM,CAMtF"}

package/dist/_shared/scope-resolution/registries/evidence.js

@@ -0,0 +1,150 @@
+/**
+ * `composeEvidence` — translate accumulated raw signals per candidate
+ * into a `ResolutionEvidence[]` using the authoritative `EvidenceWeights`
+ * map (RFC §4.3 + Appendix A; Ring 2 SHARED #917).
+ *
+ * Each `RawSignals` record describes what was observed about a candidate
+ * during the 7-step walk: where it was found, at what depth, whether
+ * anything corroborates it. This module turns those raw facts into the
+ * typed evidence list attached to the outgoing `Resolution`.
+ *
+ * **Every weight comes from `EvidenceWeights`.** No inline magic numbers.
+ * Extends issue #429 (centralize hardcoded confidence values).
+ *
+ * **Confidence compose rule.** Signals add; the sum is capped at 1.0 at
+ * the call site (inside `lookupCore`). This module only emits the list;
+ * it does NOT compute the capped sum so callers can inspect per-signal
+ * contributions for debugging.
+ */
+import { EvidenceWeights, typeBindingWeightAtDepth } from '../evidence-weights.js';
+/**
+ * Compose the raw signals into a stable `ResolutionEvidence[]` list.
+ *
+ * Emission order mirrors the `EvidenceWeights` layout: where-found →
+ * type-binding → corroborators → arity → degraded. Stable order makes
+ * the per-signal contributions easy to reason about in tests and in the
+ * shadow-mode parity dashboard.
+ */
+export function composeEvidence(signals) {
+    const out = [];
+    // ── Where-found visibility ─────────────────────────────────────────────
+    if (signals.origin !== undefined) {
+        const baseWeight = getOriginWeight(signals.origin);
+        const capped = signals.viaUnlinkedImport
+            ? baseWeight * EvidenceWeights.unlinkedImportMultiplier
+            : baseWeight;
+        const evidenceKind = whereFoundEvidenceKind(signals.origin);
+        out.push({
+            kind: evidenceKind,
+            weight: capped,
+            ...(signals.viaUnlinkedImport
+                ? { note: `via unresolved import (${EvidenceWeights.unlinkedImportMultiplier}× cap)` }
+                : {}),
+        });
+    }
+    // ── Scope-chain depth deduction (per-hop, only meaningful for lexical
+    // hits where scopeChainDepth ≥ 1). Depth 0 = no deduction; depth N ≥ 1
+    // emits a single `scope-chain` evidence with the accumulated penalty.
+    if (signals.scopeChainDepth !== undefined && signals.scopeChainDepth > 0) {
+        out.push({
+            kind: 'scope-chain',
+            weight: EvidenceWeights.scopeChainPerDepth * signals.scopeChainDepth,
+            note: `depth=${signals.scopeChainDepth}`,
+        });
+    }
+    // ── Type-binding / MRO path ────────────────────────────────────────────
+    if (signals.typeBindingMroDepth !== undefined) {
+        out.push({
+            kind: 'type-binding',
+            weight: typeBindingWeightAtDepth(signals.typeBindingMroDepth),
+            note: `mroDepth=${signals.typeBindingMroDepth}`,
+        });
+    }
+    // ── Owner match (explanatory for debug) ────────────────────────────────
+    if (signals.ownerMatch === true) {
+        out.push({
+            kind: 'owner-match',
+            weight: EvidenceWeights.ownerMatch,
+        });
+    }
+    // ── Kind match (always present; weight 0; retained for debuggability) ──
+    out.push({
+        kind: 'kind-match',
+        weight: EvidenceWeights.kindMatch,
+    });
+    // ── Arity ──────────────────────────────────────────────────────────────
+    if (signals.arityVerdict !== undefined) {
+        const weight = signals.arityVerdict === 'compatible'
+            ? EvidenceWeights.arityMatchCompatible
+            : signals.arityVerdict === 'incompatible'
+                ? EvidenceWeights.arityMatchIncompatible
+                : EvidenceWeights.arityMatchUnknown;
+        out.push({
+            kind: 'arity-match',
+            weight,
+            note: signals.arityVerdict,
+        });
+    }
+    // ── Dynamic-unresolved (degraded signal) ───────────────────────────────
+    if (signals.dynamicUnresolved === true) {
+        out.push({
+            kind: 'dynamic-import-unresolved',
+            weight: EvidenceWeights.dynamicImportUnresolved,
+        });
+    }
+    return out;
+}
+/**
+ * Sum evidence weights and clamp to `[0, 1]`. Separate from `composeEvidence`
+ * so tests and the parity dashboard can inspect the raw evidence list.
+ */
+export function confidenceFromEvidence(evidence) {
+    let sum = 0;
+    for (const e of evidence)
+        sum += e.weight;
+    if (sum < 0)
+        return 0;
+    if (sum > 1)
+        return 1;
+    return sum;
+}
+// ─── Internal ───────────────────────────────────────────────────────────────
+function getOriginWeight(origin) {
+    switch (origin) {
+        case 'local':
+            return EvidenceWeights.local;
+        case 'import':
+            return EvidenceWeights.import;
+        case 'reexport':
+            return EvidenceWeights.reexport;
+        case 'namespace':
+            return EvidenceWeights.namespace;
+        case 'wildcard':
+            return EvidenceWeights.wildcard;
+        case 'global-qualified':
+            return EvidenceWeights.globalQualified;
+        case 'global-name':
+            // Reserved for Ring 3 byName global index. `lookupCore` today only
+            // emits `'global-qualified'` (via `lookupQualified`, dotted-name
+            // fallback); no code path constructs `origin: 'global-name'` yet.
+            // Kept here so the Appendix A weight stays live and `composeEvidence`
+            // remains exhaustive over the origin union.
+            return EvidenceWeights.globalName;
+    }
+}
+function whereFoundEvidenceKind(origin) {
+    switch (origin) {
+        case 'local':
+            return 'local';
+        case 'import':
+        case 'reexport':
+        case 'namespace':
+        case 'wildcard':
+            return 'import';
+        case 'global-qualified':
+            return 'global-qualified';
+        case 'global-name':
+            return 'global-name';
+    }
+}
+//# sourceMappingURL=evidence.js.map

package/dist/_shared/scope-resolution/registries/evidence.js.map

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

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

@@ -0,0 +1,26 @@
+/**
+ * `FieldRegistry` — scope-aware lookup for field / property / variable
+ * access (RFC §4.4; Ring 2 SHARED #917).
+ *
+ * Thin wrapper over `lookupCore`, specialized for data-member kinds:
+ *
+ *   - `acceptedKinds` = Variable / Property / Const / Static.
+ *   - `useReceiverTypeBinding` is **true** — fields are resolved against
+ *     the receiver type's MRO first, then via the lexical chain for
+ *     free variables.
+ *   - `callsite` is not meaningful for field access (no arity), but the
+ *     `explicitReceiver` and `ownerScopedContributor` knobs are.
+ */
+import type { Resolution, ScopeId } from '../types.js';
+import type { OwnerScopedContributor, RegistryContext } from './context.js';
+export interface FieldLookupOptions {
+    readonly explicitReceiver?: {
+        readonly name: string;
+    };
+    readonly ownerScopedContributor?: OwnerScopedContributor;
+}
+export interface FieldRegistry {
+    lookup(name: string, scope: ScopeId, options?: FieldLookupOptions): readonly Resolution[];
+}
+export declare function buildFieldRegistry(ctx: RegistryContext): FieldRegistry;
+//# sourceMappingURL=field-registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"field-registry.d.ts","sourceRoot":"","sources":["../../../src/scope-resolution/registries/field-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG5E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,QAAQ,CAAC,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CAC1D;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,SAAS,UAAU,EAAE,CAAC;CAC3F;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa,CActE"}

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

@@ -0,0 +1,31 @@
+/**
+ * `FieldRegistry` — scope-aware lookup for field / property / variable
+ * access (RFC §4.4; Ring 2 SHARED #917).
+ *
+ * Thin wrapper over `lookupCore`, specialized for data-member kinds:
+ *
+ *   - `acceptedKinds` = Variable / Property / Const / Static.
+ *   - `useReceiverTypeBinding` is **true** — fields are resolved against
+ *     the receiver type's MRO first, then via the lexical chain for
+ *     free variables.
+ *   - `callsite` is not meaningful for field access (no arity), but the
+ *     `explicitReceiver` and `ownerScopedContributor` knobs are.
+ */
+import { lookupCore } from './lookup-core.js';
+import { FIELD_KINDS } from './context.js';
+export function buildFieldRegistry(ctx) {
+    return {
+        lookup(name, scope, options = {}) {
+            const params = {
+                acceptedKinds: FIELD_KINDS,
+                useReceiverTypeBinding: true,
+                ownerScopedContributor: options.ownerScopedContributor ?? null,
+                ...(options.explicitReceiver !== undefined
+                    ? { explicitReceiver: options.explicitReceiver }
+                    : {}),
+            };
+            return lookupCore(name, scope, params, ctx);
+        },
+    };
+}
+//# sourceMappingURL=field-registry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"field-registry.js","sourceRoot":"","sources":["../../../src/scope-resolution/registries/field-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,UAAU,EAAyB,MAAM,kBAAkB,CAAC;AAErE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAW3C,MAAM,UAAU,kBAAkB,CAAC,GAAoB;IACrD,OAAO;QACL,MAAM,CAAC,IAAY,EAAE,KAAc,EAAE,UAA8B,EAAE;YACnE,MAAM,MAAM,GAAqB;gBAC/B,aAAa,EAAE,WAAW;gBAC1B,sBAAsB,EAAE,IAAI;gBAC5B,sBAAsB,EAAE,OAAO,CAAC,sBAAsB,IAAI,IAAI;gBAC9D,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/lookup-core.d.ts

@@ -0,0 +1,81 @@
+/**
+ * `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 `gitnexus/` 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 type { Callsite, LookupParams, Resolution, ScopeId } from '../types.js';
+import type { OwnerScopedContributor, RegistryContext } from './context.js';
+/** Extended `LookupParams` narrowing `ownerScopedContributor` to the concrete shape. */
+export interface CoreLookupParams extends Omit<LookupParams, 'ownerScopedContributor'> {
+    readonly ownerScopedContributor: OwnerScopedContributor | null;
+    /** Call-site description forwarded to `arityCompatibility`. Optional — for non-call lookups. */
+    readonly callsite?: Callsite;
+}
+/**
+ * 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 declare function lookupCore(name: string, startScope: ScopeId, params: CoreLookupParams, ctx: RegistryContext): readonly Resolution[];
+//# sourceMappingURL=lookup-core.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lookup-core.d.ts","sourceRoot":"","sources":["../../../src/scope-resolution/registries/lookup-core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAIH,OAAO,KAAK,EAEV,QAAQ,EAER,YAAY,EACZ,UAAU,EAEV,OAAO,EACR,MAAM,aAAa,CAAC;AAKrB,OAAO,KAAK,EAAgB,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAI1F,wFAAwF;AACxF,MAAM,WAAW,gBAAiB,SAAQ,IAAI,CAAC,YAAY,EAAE,wBAAwB,CAAC;IACpF,QAAQ,CAAC,sBAAsB,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAC/D,gGAAgG;IAChG,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,OAAO,EACnB,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE,eAAe,GACnB,SAAS,UAAU,EAAE,CAwCvB"}