gitnexus 1.6.3-rc.1 → 1.6.3-rc.3

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, CaptureMatch, BindingRef, ImportEdge, TypeRef, Scope, ResolutionEvidence, Resolution, Reference, ReferenceIndex, LookupParams, RegistryContributor, ParsedImport, ParsedTypeBinding, WorkspaceIndex, ScopeTree, Callsite, } 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,YAAY,EACZ,UAAU,EACV,UAAU,EACV,OAAO,EACP,KAAK,EACL,kBAAkB,EAClB,UAAU,EACV,SAAS,EACT,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,SAAS,EACT,QAAQ,GACT,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;AAiCjG,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"}