gitnexus 1.6.3-rc.1 → 1.6.3-rc.2

package/dist/_shared/index.d.ts

@@ -5,4 +5,11 @@ export { SupportedLanguages } from './languages.js';
 export { getLanguageFromFilename, getSyntaxLanguageFromFilename } from './language-detection.js';
 export type { MroStrategy } from './mro-strategy.js';
 export type { PipelinePhase, PipelineProgress } from './pipeline.js';
+export type { SymbolDefinition } from './scope-resolution/symbol-definition.js';
+export type { ScopeId, DefId, ScopeKind, Range, Capture, BindingRef, ImportEdge, TypeRef, Scope, ResolutionEvidence, Resolution, Reference, ReferenceIndex, LookupParams, RegistryContributor, } from './scope-resolution/types.js';
+export { EvidenceWeights, typeBindingWeightAtDepth } from './scope-resolution/evidence-weights.js';
+export { ORIGIN_PRIORITY } from './scope-resolution/origin-priority.js';
+export type { OriginForTieBreak } from './scope-resolution/origin-priority.js';
+export { LanguageClassifications, isProductionLanguage, } from './scope-resolution/language-classification.js';
+export type { LanguageClassification } from './scope-resolution/language-classification.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/_shared/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,SAAS,EACT,cAAc,EACd,gBAAgB,EAChB,SAAS,EACT,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,WAAW,EACX,cAAc,EACd,SAAS,EACT,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAGzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AACjG,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,SAAS,EACT,cAAc,EACd,gBAAgB,EAChB,SAAS,EACT,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,WAAW,EACX,cAAc,EACd,SAAS,EACT,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAGzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AACjG,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAIrE,YAAY,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAChF,YAAY,EACV,OAAO,EACP,KAAK,EACL,SAAS,EACT,KAAK,EACL,OAAO,EACP,UAAU,EACV,UAAU,EACV,OAAO,EACP,KAAK,EACL,kBAAkB,EAClB,UAAU,EACV,SAAS,EACT,cAAc,EACd,YAAY,EACZ,mBAAmB,GACpB,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AACnG,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AACxE,YAAY,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAG/E,OAAO,EACL,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,+CAA+C,CAAC;AACvD,YAAY,EAAE,sBAAsB,EAAE,MAAM,+CAA+C,CAAC"}

package/dist/_shared/index.js

@@ -3,4 +3,9 @@ export { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME, } from '.
 // Language support
 export { SupportedLanguages } from './languages.js';
 export { getLanguageFromFilename, getSyntaxLanguageFromFilename } from './language-detection.js';
+// Evidence + tie-break constants (RFC Appendix A, Appendix B)
+export { EvidenceWeights, typeBindingWeightAtDepth } from './scope-resolution/evidence-weights.js';
+export { ORIGIN_PRIORITY } from './scope-resolution/origin-priority.js';
+// Language classification (RFC §6.1 Ring 3/4 governance)
+export { LanguageClassifications, isProductionLanguage, } from './scope-resolution/language-classification.js';
 //# sourceMappingURL=index.js.map

package/dist/_shared/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,mBAAmB;AACnB,OAAO,EACL,WAAW,EACX,cAAc,EACd,SAAS,EACT,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AAGpC,mBAAmB;AACnB,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,mBAAmB;AACnB,OAAO,EACL,WAAW,EACX,cAAc,EACd,SAAS,EACT,oBAAoB,GACrB,MAAM,4BAA4B,CAAC;AAGpC,mBAAmB;AACnB,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AA2BjG,8DAA8D;AAC9D,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AACnG,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAGxE,yDAAyD;AACzD,OAAO,EACL,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,+CAA+C,CAAC"}

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

@@ -0,0 +1,69 @@
+/**
+ * `EvidenceWeights` — RFC Appendix A (authoritative values).
+ *
+ * Starting calibration for scope-based resolution. Shadow-first rollout
+ * tunes these against legacy DAG parity. Every `ResolutionEvidence.weight`
+ * value in the codebase MUST reference this map; inline magic numbers are a
+ * lint violation. Extends issue #429 (centralize hardcoded confidence values).
+ *
+ * Evidence composes additively inside `composeEvidence`; the sum is capped
+ * at 1.0 in `Resolution.confidence`.
+ */
+/**
+ * Authoritative weight map. Keys are a mix of `ResolutionEvidence.kind`
+ * values and special modifiers (scope-chain depth, MRO depth decay,
+ * unlinked-import multiplicative cap).
+ */
+export declare const EvidenceWeights: {
+    /** `BindingRef.origin === 'local'` */
+    readonly local: 0.55;
+    /** `BindingRef.origin === 'import'` */
+    readonly import: 0.45;
+    /** `BindingRef.origin === 'reexport'` */
+    readonly reexport: 0.4;
+    /** `BindingRef.origin === 'namespace'` */
+    readonly namespace: 0.4;
+    /** `BindingRef.origin === 'wildcard'` */
+    readonly wildcard: 0.3;
+    /** Deducted per parent-hop taken (depth-0 = 0, depth-1 = −0.02, …). */
+    readonly scopeChainPerDepth: -0.02;
+    /**
+     * Weight applied when the receiver's type binding resolves to a class that
+     * declares the candidate as a method/field. Decays by MRO depth: direct
+     * class = index 0; 1 parent hop = index 1; etc. Falls back to the last
+     * value for depths beyond the table.
+     */
+    readonly typeBindingByMroDepth: readonly [0.5, 0.42, 0.36, 0.32, 0.3];
+    /** `def.ownerId === resolvedReceiver.def.id` (exact owner match). */
+    readonly ownerMatch: 0.2;
+    /** Explanatory only — retained for debuggability. Never discriminates
+     *  because surviving candidates already passed `acceptedKinds`. */
+    readonly kindMatch: 0;
+    /** `provider.arityCompatibility(...) === 'compatible'` */
+    readonly arityMatchCompatible: 0.1;
+    /** `provider.arityCompatibility(...) === 'unknown'` */
+    readonly arityMatchUnknown: 0;
+    /** `provider.arityCompatibility(...) === 'incompatible'` — penalizes;
+     *  candidates filtered only when a compatible candidate exists. */
+    readonly arityMatchIncompatible: -0.15;
+    /** Hit via `QualifiedNameIndex.byQualifiedName`. */
+    readonly globalQualified: 0.35;
+    /** Fallback hit in a `byName` index (and nothing was lexically visible). */
+    readonly globalName: 0.1;
+    /** Call/reference flowing through a `dynamic-unresolved` edge. */
+    readonly dynamicImportUnresolved: 0.02;
+    /**
+     * Multiplicative cap on the edge-derived evidence signal
+     * (`import`/`wildcard`/`reexport`/`namespace`) when
+     * `ImportEdge.linkStatus === 'unresolved'`. Independent corroborating
+     * signals on the same candidate (`owner-match`, `arity-match`,
+     * `type-binding`) are NOT penalized.
+     */
+    readonly unlinkedImportMultiplier: 0.5;
+};
+/**
+ * Look up the `type-binding` signal weight for a given MRO depth, falling
+ * back to the last tabulated value for depths beyond the table.
+ */
+export declare function typeBindingWeightAtDepth(mroDepth: number): number;
+//# sourceMappingURL=evidence-weights.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-weights.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/evidence-weights.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AACH,eAAO,MAAM,eAAe;IAE1B,sCAAsC;;IAEtC,uCAAuC;;IAEvC,yCAAyC;;IAEzC,0CAA0C;;IAE1C,yCAAyC;;IAIzC,uEAAuE;;IAIvE;;;;;OAKG;;IAIH,qEAAqE;;IAErE;uEACmE;;IAInE,0DAA0D;;IAE1D,uDAAuD;;IAEvD;uEACmE;;IAInE,oDAAoD;;IAEpD,4EAA4E;;IAI5E,kEAAkE;;IAIlE;;;;;;OAMG;;CAEK,CAAC;AAEX;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKjE"}

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

@@ -0,0 +1,84 @@
+/**
+ * `EvidenceWeights` — RFC Appendix A (authoritative values).
+ *
+ * Starting calibration for scope-based resolution. Shadow-first rollout
+ * tunes these against legacy DAG parity. Every `ResolutionEvidence.weight`
+ * value in the codebase MUST reference this map; inline magic numbers are a
+ * lint violation. Extends issue #429 (centralize hardcoded confidence values).
+ *
+ * Evidence composes additively inside `composeEvidence`; the sum is capped
+ * at 1.0 in `Resolution.confidence`.
+ */
+/**
+ * Authoritative weight map. Keys are a mix of `ResolutionEvidence.kind`
+ * values and special modifiers (scope-chain depth, MRO depth decay,
+ * unlinked-import multiplicative cap).
+ */
+export const EvidenceWeights = {
+    // ─── Where-found signals (visibility) ─────────────────────────────────────
+    /** `BindingRef.origin === 'local'` */
+    local: 0.55,
+    /** `BindingRef.origin === 'import'` */
+    import: 0.45,
+    /** `BindingRef.origin === 'reexport'` */
+    reexport: 0.4,
+    /** `BindingRef.origin === 'namespace'` */
+    namespace: 0.4,
+    /** `BindingRef.origin === 'wildcard'` */
+    wildcard: 0.3,
+    // ─── Scope-chain deduction (per-hop) ──────────────────────────────────────
+    /** Deducted per parent-hop taken (depth-0 = 0, depth-1 = −0.02, …). */
+    scopeChainPerDepth: -0.02,
+    // ─── Receiver-type-binding signal (decays by MRO depth) ───────────────────
+    /**
+     * Weight applied when the receiver's type binding resolves to a class that
+     * declares the candidate as a method/field. Decays by MRO depth: direct
+     * class = index 0; 1 parent hop = index 1; etc. Falls back to the last
+     * value for depths beyond the table.
+     */
+    typeBindingByMroDepth: [0.5, 0.42, 0.36, 0.32, 0.3],
+    // ─── Corroborating signals ────────────────────────────────────────────────
+    /** `def.ownerId === resolvedReceiver.def.id` (exact owner match). */
+    ownerMatch: 0.2,
+    /** Explanatory only — retained for debuggability. Never discriminates
+     *  because surviving candidates already passed `acceptedKinds`. */
+    kindMatch: 0.0,
+    // ─── Arity compatibility (from `provider.arityCompatibility`) ─────────────
+    /** `provider.arityCompatibility(...) === 'compatible'` */
+    arityMatchCompatible: 0.1,
+    /** `provider.arityCompatibility(...) === 'unknown'` */
+    arityMatchUnknown: 0.0,
+    /** `provider.arityCompatibility(...) === 'incompatible'` — penalizes;
+     *  candidates filtered only when a compatible candidate exists. */
+    arityMatchIncompatible: -0.15,
+    // ─── Global fallback (only when nothing lexically visible) ────────────────
+    /** Hit via `QualifiedNameIndex.byQualifiedName`. */
+    globalQualified: 0.35,
+    /** Fallback hit in a `byName` index (and nothing was lexically visible). */
+    globalName: 0.1,
+    // ─── Degraded signals ─────────────────────────────────────────────────────
+    /** Call/reference flowing through a `dynamic-unresolved` edge. */
+    dynamicImportUnresolved: 0.02,
+    // ─── Unresolved-import cap (multiplicative, applied per-signal) ───────────
+    /**
+     * Multiplicative cap on the edge-derived evidence signal
+     * (`import`/`wildcard`/`reexport`/`namespace`) when
+     * `ImportEdge.linkStatus === 'unresolved'`. Independent corroborating
+     * signals on the same candidate (`owner-match`, `arity-match`,
+     * `type-binding`) are NOT penalized.
+     */
+    unlinkedImportMultiplier: 0.5,
+};
+/**
+ * Look up the `type-binding` signal weight for a given MRO depth, falling
+ * back to the last tabulated value for depths beyond the table.
+ */
+export function typeBindingWeightAtDepth(mroDepth) {
+    const table = EvidenceWeights.typeBindingByMroDepth;
+    if (mroDepth < 0)
+        return table[0];
+    if (mroDepth >= table.length)
+        return table[table.length - 1];
+    return table[mroDepth];
+}
+//# sourceMappingURL=evidence-weights.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-weights.js","sourceRoot":"","sources":["../../src/scope-resolution/evidence-weights.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,6EAA6E;IAC7E,sCAAsC;IACtC,KAAK,EAAE,IAAI;IACX,uCAAuC;IACvC,MAAM,EAAE,IAAI;IACZ,yCAAyC;IACzC,QAAQ,EAAE,GAAG;IACb,0CAA0C;IAC1C,SAAS,EAAE,GAAG;IACd,yCAAyC;IACzC,QAAQ,EAAE,GAAG;IAEb,6EAA6E;IAC7E,uEAAuE;IACvE,kBAAkB,EAAE,CAAC,IAAI;IAEzB,6EAA6E;IAC7E;;;;;OAKG;IACH,qBAAqB,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAU;IAE5D,6EAA6E;IAC7E,qEAAqE;IACrE,UAAU,EAAE,GAAG;IACf;uEACmE;IACnE,SAAS,EAAE,GAAG;IAEd,6EAA6E;IAC7E,0DAA0D;IAC1D,oBAAoB,EAAE,GAAG;IACzB,uDAAuD;IACvD,iBAAiB,EAAE,GAAG;IACtB;uEACmE;IACnE,sBAAsB,EAAE,CAAC,IAAI;IAE7B,6EAA6E;IAC7E,oDAAoD;IACpD,eAAe,EAAE,IAAI;IACrB,4EAA4E;IAC5E,UAAU,EAAE,GAAG;IAEf,6EAA6E;IAC7E,kEAAkE;IAClE,uBAAuB,EAAE,IAAI;IAE7B,6EAA6E;IAC7E;;;;;;OAMG;IACH,wBAAwB,EAAE,GAAG;CACrB,CAAC;AAEX;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CAAC,QAAgB;IACvD,MAAM,KAAK,GAAG,eAAe,CAAC,qBAAqB,CAAC;IACpD,IAAI,QAAQ,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClC,IAAI,QAAQ,IAAI,KAAK,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC7D,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAC;AACzB,CAAC"}

package/dist/_shared/scope-resolution/language-classification.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `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)
+ */
+import { SupportedLanguages } from '../languages.js';
+export type LanguageClassification = 'production' | 'experimental' | 'quarantined';
+/**
+ * The canonical classification for each supported language. Governance
+ * changes (promote `experimental` → `production`, quarantine a language, …)
+ * update this map in a dedicated PR.
+ */
+export declare const LanguageClassifications: Readonly<Record<SupportedLanguages, LanguageClassification>>;
+/** Convenience predicate: is this language gating Ring 4 retirement? */
+export declare function isProductionLanguage(lang: SupportedLanguages): boolean;
+//# sourceMappingURL=language-classification.d.ts.map

package/dist/_shared/scope-resolution/language-classification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-classification.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/language-classification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,MAAM,sBAAsB,GAAG,YAAY,GAAG,cAAc,GAAG,aAAa,CAAC;AAEnF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,kBAAkB,EAAE,sBAAsB,CAAC,CAkB9F,CAAC;AAEJ,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAEtE"}

package/dist/_shared/scope-resolution/language-classification.js

@@ -0,0 +1,44 @@
+/**
+ * `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)
+ */
+import { SupportedLanguages } from '../languages.js';
+/**
+ * The canonical classification for each supported language. Governance
+ * changes (promote `experimental` → `production`, quarantine a language, …)
+ * update this map in a dedicated PR.
+ */
+export const LanguageClassifications = {
+    [SupportedLanguages.JavaScript]: 'production',
+    [SupportedLanguages.TypeScript]: 'production',
+    [SupportedLanguages.Python]: 'production',
+    [SupportedLanguages.Java]: 'production',
+    [SupportedLanguages.C]: 'production',
+    [SupportedLanguages.CPlusPlus]: 'production',
+    [SupportedLanguages.CSharp]: 'production',
+    [SupportedLanguages.Go]: 'production',
+    [SupportedLanguages.Ruby]: 'production',
+    [SupportedLanguages.Rust]: 'production',
+    [SupportedLanguages.PHP]: 'production',
+    [SupportedLanguages.Kotlin]: 'production',
+    [SupportedLanguages.Swift]: 'production',
+    [SupportedLanguages.Dart]: 'production',
+    [SupportedLanguages.Vue]: 'experimental',
+    [SupportedLanguages.Cobol]: 'experimental',
+};
+/** Convenience predicate: is this language gating Ring 4 retirement? */
+export function isProductionLanguage(lang) {
+    return LanguageClassifications[lang] === 'production';
+}
+//# sourceMappingURL=language-classification.js.map

package/dist/_shared/scope-resolution/language-classification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-classification.js","sourceRoot":"","sources":["../../src/scope-resolution/language-classification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAIrD;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAClC;IACE,CAAC,kBAAkB,CAAC,UAAU,CAAC,EAAE,YAAY;IAC7C,CAAC,kBAAkB,CAAC,UAAU,CAAC,EAAE,YAAY;IAC7C,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,YAAY;IACzC,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,YAAY;IACvC,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,YAAY;IACpC,CAAC,kBAAkB,CAAC,SAAS,CAAC,EAAE,YAAY;IAC5C,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,YAAY;IACzC,CAAC,kBAAkB,CAAC,EAAE,CAAC,EAAE,YAAY;IACrC,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,YAAY;IACvC,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,YAAY;IACvC,CAAC,kBAAkB,CAAC,GAAG,CAAC,EAAE,YAAY;IACtC,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,YAAY;IACzC,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,YAAY;IACxC,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,YAAY;IACvC,CAAC,kBAAkB,CAAC,GAAG,CAAC,EAAE,cAAc;IACxC,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,cAAc;CAC3C,CAAC;AAEJ,wEAAwE;AACxE,MAAM,UAAU,oBAAoB,CAAC,IAAwB;IAC3D,OAAO,uBAAuB,CAAC,IAAI,CAAC,KAAK,YAAY,CAAC;AACxD,CAAC"}

package/dist/_shared/scope-resolution/origin-priority.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `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
+ */
+export type OriginForTieBreak = 'local' | 'import' | 'reexport' | 'namespace' | 'wildcard' | 'global-qualified' | 'global-name';
+export declare const ORIGIN_PRIORITY: Readonly<Record<OriginForTieBreak, number>>;
+//# sourceMappingURL=origin-priority.d.ts.map

package/dist/_shared/scope-resolution/origin-priority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"origin-priority.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/origin-priority.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,iBAAiB,GACzB,OAAO,GACP,QAAQ,GACR,UAAU,GACV,WAAW,GACX,UAAU,GACV,kBAAkB,GAClB,aAAa,CAAC;AAElB,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAQvE,CAAC"}

package/dist/_shared/scope-resolution/origin-priority.js

@@ -0,0 +1,21 @@
+/**
+ * `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
+ */
+export const ORIGIN_PRIORITY = {
+    local: 0,
+    import: 1,
+    reexport: 2,
+    namespace: 3,
+    wildcard: 4,
+    'global-qualified': 5,
+    'global-name': 6,
+};
+//# sourceMappingURL=origin-priority.js.map

package/dist/_shared/scope-resolution/origin-priority.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"origin-priority.js","sourceRoot":"","sources":["../../src/scope-resolution/origin-priority.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAWH,MAAM,CAAC,MAAM,eAAe,GAAgD;IAC1E,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC;IACT,QAAQ,EAAE,CAAC;IACX,SAAS,EAAE,CAAC;IACZ,QAAQ,EAAE,CAAC;IACX,kBAAkB,EAAE,CAAC;IACrB,aAAa,EAAE,CAAC;CACjB,CAAC"}

package/dist/_shared/scope-resolution/symbol-definition.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `SymbolDefinition` — the canonical shape of an indexed symbol record.
+ *
+ * Historically defined in `gitnexus/src/core/ingestion/model/symbol-table.ts`;
+ * moved into `gitnexus-shared` as part of RFC #909 Ring 1 (#910) so the
+ * scope-resolution types that reference it can live in the shared package
+ * alongside their consumers (`gitnexus/` and `gitnexus-web/`).
+ *
+ * Shape is unchanged from the prior local definition.
+ */
+import type { NodeLabel } from '../graph/types.js';
+export interface SymbolDefinition {
+    nodeId: string;
+    filePath: string;
+    type: NodeLabel;
+    /** Canonical dot-separated qualified type name for class-like symbols
+     *  (e.g. `App.Models.User`). Falls back to the simple symbol name when no
+     *  package/namespace/module scope exists or no explicit qualified metadata is provided. */
+    qualifiedName?: string;
+    parameterCount?: number;
+    /** Number of required (non-optional, non-default) parameters.
+     *  Enables range-based arity filtering: argCount >= requiredParameterCount && argCount <= parameterCount. */
+    requiredParameterCount?: number;
+    /** Per-parameter type names for overload disambiguation (e.g. ['int', 'String']).
+     *  Populated when parameter types are resolvable from AST (any typed language). */
+    parameterTypes?: string[];
+    /** Raw return type text extracted from AST (e.g. 'User', 'Promise<User>') */
+    returnType?: string;
+    /** Declared type for non-callable symbols — fields/properties (e.g. 'Address', 'List<User>') */
+    declaredType?: string;
+    /** Links Method/Constructor/Property to owning Class/Struct/Trait nodeId */
+    ownerId?: string;
+}
+//# sourceMappingURL=symbol-definition.d.ts.map

package/dist/_shared/scope-resolution/symbol-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-definition.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/symbol-definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;IAChB;;+FAE2F;IAC3F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;iHAC6G;IAC7G,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;uFACmF;IACnF,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

package/dist/_shared/scope-resolution/symbol-definition.js

@@ -0,0 +1,12 @@
+/**
+ * `SymbolDefinition` — the canonical shape of an indexed symbol record.
+ *
+ * Historically defined in `gitnexus/src/core/ingestion/model/symbol-table.ts`;
+ * moved into `gitnexus-shared` as part of RFC #909 Ring 1 (#910) so the
+ * scope-resolution types that reference it can live in the shared package
+ * alongside their consumers (`gitnexus/` and `gitnexus-web/`).
+ *
+ * Shape is unchanged from the prior local definition.
+ */
+export {};
+//# sourceMappingURL=symbol-definition.js.map

package/dist/_shared/scope-resolution/symbol-definition.js.map

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

package/dist/_shared/scope-resolution/types.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Scope-resolution type definitions — RFC §2 data model (authoritative source).
+ *
+ * See: https://www.notion.so/346dc50b6ed281cfaacbe480bf231d50
+ *
+ * Anti-drift rule: every type, interface, and enum defined here is the single
+ * source of truth. Later code that references these names must import them
+ * from `gitnexus-shared`; it must not re-define them locally.
+ *
+ * Lifecycle contract (RFC §2.8): scopes are **constructed during extraction,
+ * linked during finalize, immutable after finalize**. All fields are
+ * `readonly` at the type level; `Object.freeze` is applied at runtime in dev
+ * builds. `ReferenceIndex` is the sole structure populated after freeze — by
+ * resolution, before emission.
+ */
+import type { NodeLabel } from '../graph/types.js';
+import type { SymbolDefinition } from './symbol-definition.js';
+/** Stable per-(file, range, kind) scope identifier; interned for identity-fast equality. */
+export type ScopeId = string;
+/** Stable symbol-definition identifier (graph nodeId). */
+export type DefId = string;
+/** Kinds of lexical scope a `Scope` node can represent. */
+export type ScopeKind = 'Module' | 'Namespace' | 'Class' | 'Function' | 'Block' | 'Expression';
+/** Source-text range. 1-based `startLine`/`endLine`; 0-based `startCol`/`endCol`. */
+export interface Range {
+    readonly startLine: number;
+    readonly startCol: number;
+    readonly endLine: number;
+    readonly endCol: number;
+}
+/**
+ * Tagged capture emitted by a LanguageProvider's `emitScopeCaptures` hook.
+ *
+ * Parser-agnostic: tree-sitter queries and COBOL's regex tagger both produce
+ * `Capture[]`. The central `ScopeExtractor` consumes captures without
+ * knowing which parser produced them.
+ */
+export interface Capture {
+    /** Capture name, including leading `@` (e.g., `'@scope.module'`, `'@declaration.class'`). */
+    readonly name: string;
+    readonly range: Range;
+    /** The captured source text. */
+    readonly text: string;
+}
+/**
+ * A cross-file import edge attached to a module/namespace scope.
+ *
+ * Raw (unlinked) edges are emitted during parse (Phase 1); `targetModuleScope`
+ * and `targetDefId` are filled in during finalize (Phase 2) via SCC-aware
+ * bounded-fixpoint linking (RFC §3.2).
+ */
+export interface ImportEdge {
+    /** How this scope sees the imported name (after alias). */
+    readonly localName: string;
+    /** Exporting file; `null` only when `kind === 'dynamic-unresolved'`. */
+    readonly targetFile: string | null;
+    /** The name under which the target exports this symbol. */
+    readonly targetExportedName: string;
+    /** Pre-resolved at finalize: the module scope of the exporting file. */
+    readonly targetModuleScope?: ScopeId;
+    /** Pre-resolved at finalize: the exported symbol's `DefId`. */
+    readonly targetDefId?: DefId;
+    readonly kind: 'named' | 'alias' | 'namespace' | 'wildcard-expanded' | 'reexport' | 'dynamic-unresolved';
+    /** Re-export chain, for provenance (e.g., `['./y']` when re-exported via `./y`). */
+    readonly transitiveVia?: readonly string[];
+    /** Set to `'unresolved'` when the SCC fixpoint could not link this edge. */
+    readonly linkStatus?: 'unresolved';
+}
+/**
+ * A name binding visible at a scope, with provenance.
+ *
+ * Provenance stays at the visibility layer — a name being visible because it
+ * is local vs imported vs wildcard-expanded vs re-exported is a property of
+ * the binding itself. This keeps evidence emission and `import-use` reference
+ * stamping first-class instead of reconstructing provenance from a side table.
+ */
+export interface BindingRef {
+    readonly def: SymbolDefinition;
+    readonly origin: 'local' | 'import' | 'namespace' | 'wildcard' | 'reexport';
+    /** Non-null for non-local origins; carries the `ImportEdge` that brought the name into this scope. */
+    readonly via?: ImportEdge;
+}
+/**
+ * A reference to a named type, anchored at its declaration site.
+ *
+ * Design choice: raw name + declaration-site scope, resolved at lookup time.
+ * Pre-resolution would invert the extraction/resolution wall. Deferred thunks
+ * add no capability. Structured type systems are months of work per language.
+ * This shape keeps V1 tractable while preserving correctness for aliases,
+ * re-exports, and nested modules. Generics deferred to V2 via `typeArgs`.
+ */
+export interface TypeRef {
+    /** The name as written in source (e.g., `'User'`, `'models.User'`, `'List'`). */
+    readonly rawName: string;
+    /** Anchor for resolving `rawName` — the scope where the annotation/inference was written. */
+    readonly declaredAtScope: ScopeId;
+    readonly source: 'annotation' | 'parameter-annotation' | 'return-annotation' | 'self' | 'assignment-inferred' | 'constructor-inferred' | 'receiver-propagated';
+    /** Reserved for V2+: generic type arguments (`List<User>` → `[TypeRef('User')]`). V1 ignores. */
+    readonly typeArgs?: readonly TypeRef[];
+}
+/**
+ * The canonical lexical-scope node. Forms the spine of the SemanticModel.
+ *
+ * ScopeId shape (RFC §2.2): `scope:{filePath}#{startLine}:{startCol}-{endLine}:{endCol}:{kind}`
+ * — deterministic, stable across reparses of the same source, interned.
+ */
+export interface Scope {
+    readonly id: ScopeId;
+    readonly parent: ScopeId | null;
+    readonly kind: ScopeKind;
+    readonly range: Range;
+    readonly filePath: string;
+    /** Names visible from this scope. Provenance preserved via `BindingRef.origin`. */
+    readonly bindings: ReadonlyMap<string, readonly BindingRef[]>;
+    /** Defs structurally owned by this scope (e.g., methods owned by a class body scope). */
+    readonly ownedDefs: readonly SymbolDefinition[];
+    /** Import edges attached to this scope. Mostly module/namespace scopes, but some
+     *  languages allow local imports (Python `def f(): from x import Y`, Rust
+     *  fn-local `use`, TS dynamic `import()`). */
+    readonly imports: readonly ImportEdge[];
+    /** Local type facts visible from this scope (parameter annotations, `self` binding, etc.). */
+    readonly typeBindings: ReadonlyMap<string, TypeRef>;
+}
+/**
+ * One piece of evidence for a `Resolution`. Multiple signals corroborate a
+ * single match; their weights compose additively to produce `confidence`.
+ *
+ * Weights come from `EvidenceWeights` (see `./evidence-weights.ts`).
+ */
+export interface ResolutionEvidence {
+    readonly kind: 'local' | 'scope-chain' | 'import' | 'type-binding' | 'owner-match' | 'kind-match' | 'arity-match' | 'global-name' | 'global-qualified' | 'dynamic-import-unresolved';
+    /** Signal weight, sourced from `EvidenceWeights`. Additive; sum capped at 1.0. */
+    readonly weight: number;
+    /** Optional debug annotation (e.g., `'matched via self: User'`). */
+    readonly note?: string;
+}
+/**
+ * A ranked resolution candidate returned by `ClassRegistry.lookup` /
+ * `MethodRegistry.lookup` / `FieldRegistry.lookup`. Evidence composes
+ * additively; callers read `[0]` for the one-shot answer or inspect the
+ * evidence trace for debugging.
+ */
+export interface Resolution {
+    readonly def: SymbolDefinition;
+    /** Σ of `evidence[].weight`, capped at 1.0. */
+    readonly confidence: number;
+    readonly evidence: readonly ResolutionEvidence[];
+    /** Optional debug trace: scopes walked to reach `def`. */
+    readonly path?: readonly ScopeId[];
+}
+/**
+ * A post-resolution usage fact: some code at `atRange` inside `fromScope`
+ * references `toDef` with the given confidence/evidence. Materialized by the
+ * resolution phase; emitted as graph edges (`CALLS`/`READS`/`WRITES`/etc.)
+ * during the emit phase.
+ */
+export interface Reference {
+    /** Innermost lexical scope containing `atRange`. */
+    readonly fromScope: ScopeId;
+    readonly toDef: DefId;
+    /** Location of the reference in source. */
+    readonly atRange: Range;
+    readonly kind: 'call' | 'read' | 'write' | 'type-reference' | 'inherits' | 'import-use';
+    readonly confidence: number;
+    readonly evidence: readonly ResolutionEvidence[];
+}
+/**
+ * Two-way index over `Reference` records, populated during the resolution
+ * phase. Scopes stay immutable after finalize; references accumulate here.
+ */
+export interface ReferenceIndex {
+    readonly bySourceScope: ReadonlyMap<ScopeId, readonly Reference[]>;
+    readonly byTargetDef: ReadonlyMap<DefId, readonly Reference[]>;
+}
+/**
+ * Opaque placeholder for the per-kind registry passed as the owner-scoped
+ * contributor. Typed concretely in Ring 2 SHARED (#917); kept as `unknown`
+ * here so Ring 1 can ship without pulling in the registry implementation.
+ */
+export type RegistryContributor = unknown;
+/**
+ * Parameters accepted by `Registry.lookup`. Three registries (Class/Method/
+ * Field) run the same 7-step algorithm with different parameter tuples; see
+ * RFC §4.4 for per-registry specializations.
+ */
+export interface LookupParams {
+    readonly acceptedKinds: readonly NodeLabel[];
+    /** Class lookups: false. Method/Field lookups: true. */
+    readonly useReceiverTypeBinding: boolean;
+    readonly ownerScopedContributor: RegistryContributor | null;
+    /** Optional arity hint fed to `provider.arityCompatibility`. */
+    readonly arityHint?: number;
+    /** Explicit receiver name (e.g., `'user'` in `user.save()`). When present,
+     *  the receiver's type binding at the callsite scope is used; otherwise
+     *  the enclosing method's implicit `self`/`this` is consulted. See §4.1. */
+    readonly explicitReceiver?: {
+        readonly name: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/_shared/scope-resolution/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI/D,4FAA4F;AAC5F,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B,0DAA0D;AAC1D,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC;AAE3B,2DAA2D;AAC3D,MAAM,MAAM,SAAS,GACjB,QAAQ,GACR,WAAW,GACX,OAAO,GACP,UAAU,GACV,OAAO,GACP,YAAY,CAAC;AAIjB,qFAAqF;AACrF,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAID;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,2DAA2D;IAC3D,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,wEAAwE;IACxE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;IAC7B,QAAQ,CAAC,IAAI,EACT,OAAO,GACP,OAAO,GACP,WAAW,GACX,mBAAmB,GACnB,UAAU,GACV,oBAAoB,CAAC;IACzB,oFAAoF;IACpF,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC;CACpC;AAID;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC;IAC5E,sGAAsG;IACtG,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B;AAID;;;;;;;;GAQG;AACH,MAAM,WAAW,OAAO;IACtB,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,6FAA6F;IAC7F,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,MAAM,EACX,YAAY,GACZ,sBAAsB,GACtB,mBAAmB,GACnB,MAAM,GACN,qBAAqB,GACrB,sBAAsB,GACtB,qBAAqB,CAAC;IAC1B,iGAAiG;IACjG,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CACxC;AAID;;;;;GAKG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,mFAAmF;IACnF,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC,CAAC;IAE9D,yFAAyF;IACzF,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAEhD;;kDAE8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IAExC,8FAA8F;IAC9F,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrD;AAID;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EACT,OAAO,GACP,aAAa,GACb,QAAQ,GACR,cAAc,GACd,aAAa,GACb,YAAY,GACZ,aAAa,GACb,aAAa,GACb,kBAAkB,GAClB,2BAA2B,CAAC;IAChC,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,EAAE,gBAAgB,CAAC;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACjD,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CACpC;AAID;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,gBAAgB,GAAG,UAAU,GAAG,YAAY,CAAC;IACxF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAClD;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC,CAAC;IACnE,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC,CAAC;CAChE;AAID;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC;AAE1C;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,aAAa,EAAE,SAAS,SAAS,EAAE,CAAC;IAC7C,wDAAwD;IACxD,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;IACzC,QAAQ,CAAC,sBAAsB,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC5D,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;gFAE4E;IAC5E,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACvD"}

package/dist/_shared/scope-resolution/types.js

@@ -0,0 +1,17 @@
+/**
+ * Scope-resolution type definitions — RFC §2 data model (authoritative source).
+ *
+ * See: https://www.notion.so/346dc50b6ed281cfaacbe480bf231d50
+ *
+ * Anti-drift rule: every type, interface, and enum defined here is the single
+ * source of truth. Later code that references these names must import them
+ * from `gitnexus-shared`; it must not re-define them locally.
+ *
+ * Lifecycle contract (RFC §2.8): scopes are **constructed during extraction,
+ * linked during finalize, immutable after finalize**. All fields are
+ * `readonly` at the type level; `Object.freeze` is applied at runtime in dev
+ * builds. `ReferenceIndex` is the sole structure populated after freeze — by
+ * resolution, before emission.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/_shared/scope-resolution/types.js.map

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

package/dist/core/ingestion/call-processor.d.ts

@@ -1,6 +1,7 @@
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
-import type { SymbolDefinition, SymbolTableReader, HeritageMap, ExtractedHeritage } from './model/index.js';
+import type { SymbolDefinition } from '../../_shared/index.js';
+import type { SymbolTableReader, HeritageMap, ExtractedHeritage } from './model/index.js';
 import type { ResolutionContext } from './model/resolution-context.js';
 import type { TieredCandidates } from './model/resolution-context.js';
 import type { TypeEnvironment } from './type-env.js';

package/dist/core/ingestion/model/field-registry.d.ts

@@ -4,7 +4,7 @@
  * Owner-scoped field/property index extracted from SymbolTable.
  * Stores Property symbols keyed by `ownerNodeId\0fieldName` for O(1) lookup.
  */
-import type { SymbolDefinition } from './symbol-table.js';
+import type { SymbolDefinition } from '../../../_shared/index.js';
 export interface FieldRegistry {
     /** Look up a field/property by its owning class nodeId and field name. */
     lookupFieldByOwner(ownerNodeId: string, fieldName: string): SymbolDefinition | undefined;