@codragraph/cli 1.6.2

package/dist/_shared/language-detection.js

@@ -0,0 +1,139 @@
+/**
+ * Language Detection — maps file paths to SupportedLanguages enum values.
+ *
+ * Shared between CLI (ingestion pipeline) and web (syntax highlighting).
+ *
+ * ADDING A NEW LANGUAGE:
+ * 1. Add enum member to SupportedLanguages in languages.ts
+ * 2. Add file extensions to EXTENSION_MAP below
+ * 3. TypeScript will error if you miss either step (exhaustive Record)
+ */
+import { SupportedLanguages } from './languages.js';
+/** Ruby extensionless filenames recognised as Ruby source */
+const RUBY_EXTENSIONLESS_FILES = new Set([
+    'Rakefile',
+    'Gemfile',
+    'Guardfile',
+    'Vagrantfile',
+    'Brewfile',
+]);
+/**
+ * Exhaustive map: every SupportedLanguages member → its file extensions.
+ *
+ * If a new language is added to the enum without adding an entry here,
+ * TypeScript emits a compile error: "Property 'NewLang' is missing in type..."
+ */
+const EXTENSION_MAP = {
+    [SupportedLanguages.JavaScript]: ['.js', '.jsx', '.mjs', '.cjs'],
+    [SupportedLanguages.TypeScript]: ['.ts', '.tsx', '.mts', '.cts'],
+    [SupportedLanguages.Python]: ['.py'],
+    [SupportedLanguages.Java]: ['.java'],
+    [SupportedLanguages.C]: ['.c'],
+    [SupportedLanguages.CPlusPlus]: ['.cpp', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.hh'],
+    [SupportedLanguages.CSharp]: ['.cs'],
+    [SupportedLanguages.Go]: ['.go'],
+    [SupportedLanguages.Ruby]: ['.rb', '.rake', '.gemspec'],
+    [SupportedLanguages.Rust]: ['.rs'],
+    [SupportedLanguages.PHP]: ['.php', '.phtml', '.php3', '.php4', '.php5', '.php8'],
+    [SupportedLanguages.Kotlin]: ['.kt', '.kts'],
+    [SupportedLanguages.Swift]: ['.swift'],
+    [SupportedLanguages.Dart]: ['.dart'],
+    [SupportedLanguages.Vue]: ['.vue'],
+    [SupportedLanguages.Cobol]: ['.cbl', '.cob', '.cpy', '.cobol'],
+}; // Ensure exhaustiveness
+/** Pre-built reverse lookup: extension → language (built once at module load). */
+const extToLang = new Map();
+for (const [lang, exts] of Object.entries(EXTENSION_MAP)) {
+    for (const ext of exts) {
+        extToLang.set(ext, lang);
+    }
+}
+/**
+ * Map file extension to SupportedLanguage enum.
+ * Returns null if the file extension is not recognized.
+ */
+export const getLanguageFromFilename = (filename) => {
+    // Fast path: check the extension map
+    const lastDot = filename.lastIndexOf('.');
+    if (lastDot >= 0) {
+        const ext = filename.slice(lastDot).toLowerCase();
+        const lang = extToLang.get(ext);
+        if (lang !== undefined)
+            return lang;
+    }
+    // Ruby extensionless files (Rakefile, Gemfile, etc.)
+    const basename = filename.split('/').pop() || filename;
+    if (RUBY_EXTENSIONLESS_FILES.has(basename)) {
+        return SupportedLanguages.Ruby;
+    }
+    return null;
+};
+/**
+ * Exhaustive map: every SupportedLanguages member → Prism syntax identifier.
+ *
+ * If a new language is added to the enum without adding an entry here,
+ * TypeScript emits a compile error.
+ */
+const SYNTAX_MAP = {
+    [SupportedLanguages.JavaScript]: 'javascript',
+    [SupportedLanguages.TypeScript]: 'typescript',
+    [SupportedLanguages.Python]: 'python',
+    [SupportedLanguages.Java]: 'java',
+    [SupportedLanguages.C]: 'c',
+    [SupportedLanguages.CPlusPlus]: 'cpp',
+    [SupportedLanguages.CSharp]: 'csharp',
+    [SupportedLanguages.Go]: 'go',
+    [SupportedLanguages.Ruby]: 'ruby',
+    [SupportedLanguages.Rust]: 'rust',
+    [SupportedLanguages.PHP]: 'php',
+    [SupportedLanguages.Kotlin]: 'kotlin',
+    [SupportedLanguages.Swift]: 'swift',
+    [SupportedLanguages.Dart]: 'dart',
+    [SupportedLanguages.Vue]: 'typescript',
+    [SupportedLanguages.Cobol]: 'cobol',
+}; // Ensure exhaustiveness
+/** Non-code file extensions → Prism-compatible syntax identifiers */
+const AUXILIARY_SYNTAX_MAP = {
+    json: 'json',
+    yaml: 'yaml',
+    yml: 'yaml',
+    md: 'markdown',
+    mdx: 'markdown',
+    html: 'markup',
+    htm: 'markup',
+    erb: 'markup',
+    xml: 'markup',
+    css: 'css',
+    scss: 'css',
+    sass: 'css',
+    sh: 'bash',
+    bash: 'bash',
+    zsh: 'bash',
+    sql: 'sql',
+    toml: 'toml',
+    ini: 'ini',
+    dockerfile: 'docker',
+};
+/** Extensionless filenames → Prism-compatible syntax identifiers */
+const AUXILIARY_BASENAME_MAP = {
+    Makefile: 'makefile',
+    Dockerfile: 'docker',
+};
+/**
+ * Map file path to a Prism-compatible syntax highlight language string.
+ * Covers all SupportedLanguages (code files) plus common non-code formats.
+ * Returns 'text' for unrecognised files.
+ */
+export const getSyntaxLanguageFromFilename = (filePath) => {
+    const lang = getLanguageFromFilename(filePath);
+    if (lang)
+        return SYNTAX_MAP[lang];
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    if (ext && ext in AUXILIARY_SYNTAX_MAP)
+        return AUXILIARY_SYNTAX_MAP[ext];
+    const basename = filePath.split('/').pop() || '';
+    if (basename in AUXILIARY_BASENAME_MAP)
+        return AUXILIARY_BASENAME_MAP[basename];
+    return 'text';
+};
+//# sourceMappingURL=language-detection.js.map

package/dist/_shared/language-detection.js.map

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

package/dist/_shared/languages.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Supported language enum — single source of truth.
+ *
+ * Both CLI and web use this to identify which language a file/node belongs to.
+ * The CLI uses it throughout the ingestion pipeline; the web uses it for display.
+ */
+export declare enum SupportedLanguages {
+    JavaScript = "javascript",
+    TypeScript = "typescript",
+    Python = "python",
+    Java = "java",
+    C = "c",
+    CPlusPlus = "cpp",
+    CSharp = "csharp",
+    Go = "go",
+    Ruby = "ruby",
+    Rust = "rust",
+    PHP = "php",
+    Kotlin = "kotlin",
+    Swift = "swift",
+    Dart = "dart",
+    Vue = "vue",
+    /** Standalone regex processor — no tree-sitter, no LanguageProvider. */
+    Cobol = "cobol"
+}
+//# sourceMappingURL=languages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"languages.d.ts","sourceRoot":"","sources":["../src/languages.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oBAAY,kBAAkB;IAC5B,UAAU,eAAe;IACzB,UAAU,eAAe;IACzB,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,CAAC,MAAM;IACP,SAAS,QAAQ;IACjB,MAAM,WAAW;IACjB,EAAE,OAAO;IACT,IAAI,SAAS;IACb,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,wEAAwE;IACxE,KAAK,UAAU;CAChB"}

package/dist/_shared/languages.js

@@ -0,0 +1,27 @@
+/**
+ * Supported language enum — single source of truth.
+ *
+ * Both CLI and web use this to identify which language a file/node belongs to.
+ * The CLI uses it throughout the ingestion pipeline; the web uses it for display.
+ */
+export var SupportedLanguages;
+(function (SupportedLanguages) {
+    SupportedLanguages["JavaScript"] = "javascript";
+    SupportedLanguages["TypeScript"] = "typescript";
+    SupportedLanguages["Python"] = "python";
+    SupportedLanguages["Java"] = "java";
+    SupportedLanguages["C"] = "c";
+    SupportedLanguages["CPlusPlus"] = "cpp";
+    SupportedLanguages["CSharp"] = "csharp";
+    SupportedLanguages["Go"] = "go";
+    SupportedLanguages["Ruby"] = "ruby";
+    SupportedLanguages["Rust"] = "rust";
+    SupportedLanguages["PHP"] = "php";
+    SupportedLanguages["Kotlin"] = "kotlin";
+    SupportedLanguages["Swift"] = "swift";
+    SupportedLanguages["Dart"] = "dart";
+    SupportedLanguages["Vue"] = "vue";
+    /** Standalone regex processor — no tree-sitter, no LanguageProvider. */
+    SupportedLanguages["Cobol"] = "cobol";
+})(SupportedLanguages || (SupportedLanguages = {}));
+//# sourceMappingURL=languages.js.map

package/dist/_shared/languages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"languages.js","sourceRoot":"","sources":["../src/languages.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAN,IAAY,kBAkBX;AAlBD,WAAY,kBAAkB;IAC5B,+CAAyB,CAAA;IACzB,+CAAyB,CAAA;IACzB,uCAAiB,CAAA;IACjB,mCAAa,CAAA;IACb,6BAAO,CAAA;IACP,uCAAiB,CAAA;IACjB,uCAAiB,CAAA;IACjB,+BAAS,CAAA;IACT,mCAAa,CAAA;IACb,mCAAa,CAAA;IACb,iCAAW,CAAA;IACX,uCAAiB,CAAA;IACjB,qCAAe,CAAA;IACf,mCAAa,CAAA;IACb,iCAAW,CAAA;IACX,wEAAwE;IACxE,qCAAe,CAAA;AACjB,CAAC,EAlBW,kBAAkB,KAAlB,kBAAkB,QAkB7B"}

package/dist/_shared/lbug/schema-constants.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LadybugDB schema constants — single source of truth.
+ *
+ * NODE_TABLES and REL_TYPES define what the knowledge graph can contain.
+ * Both CLI and web must agree on these for data compatibility.
+ *
+ * Full DDL schemas remain in each package's own schema.ts because
+ * the CLI uses native LadybugDB and the web uses WASM.
+ */
+export declare const NODE_TABLES: readonly ["File", "Folder", "Function", "Class", "Interface", "Method", "CodeElement", "Community", "Process", "Section", "Struct", "Enum", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Variable", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module", "Route", "Tool"];
+export type NodeTableName = (typeof NODE_TABLES)[number];
+export declare const REL_TABLE_NAME = "CodeRelation";
+export declare const REL_TYPES: readonly ["CONTAINS", "DEFINES", "IMPORTS", "CALLS", "EXTENDS", "IMPLEMENTS", "HAS_METHOD", "HAS_PROPERTY", "ACCESSES", "METHOD_OVERRIDES", "OVERRIDES", "METHOD_IMPLEMENTS", "MEMBER_OF", "STEP_IN_PROCESS", "HANDLES_ROUTE", "FETCHES", "HANDLES_TOOL", "ENTRY_POINT_OF", "WRAPS", "QUERIES"];
+export type RelType = (typeof REL_TYPES)[number];
+export declare const EMBEDDING_TABLE_NAME = "CodeEmbedding";
+//# sourceMappingURL=schema-constants.d.ts.map

package/dist/_shared/lbug/schema-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-constants.d.ts","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,0VAgCd,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,SAAS,iSAqBZ,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC"}

package/dist/_shared/lbug/schema-constants.js

@@ -0,0 +1,67 @@
+/**
+ * LadybugDB schema constants — single source of truth.
+ *
+ * NODE_TABLES and REL_TYPES define what the knowledge graph can contain.
+ * Both CLI and web must agree on these for data compatibility.
+ *
+ * Full DDL schemas remain in each package's own schema.ts because
+ * the CLI uses native LadybugDB and the web uses WASM.
+ */
+export const NODE_TABLES = [
+    'File',
+    'Folder',
+    'Function',
+    'Class',
+    'Interface',
+    'Method',
+    'CodeElement',
+    'Community',
+    'Process',
+    'Section',
+    'Struct',
+    'Enum',
+    'Macro',
+    'Typedef',
+    'Union',
+    'Namespace',
+    'Trait',
+    'Impl',
+    'TypeAlias',
+    'Const',
+    'Static',
+    'Variable',
+    'Property',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Constructor',
+    'Template',
+    'Module',
+    'Route',
+    'Tool',
+];
+export const REL_TABLE_NAME = 'CodeRelation';
+export const REL_TYPES = [
+    'CONTAINS',
+    'DEFINES',
+    'IMPORTS',
+    'CALLS',
+    'EXTENDS',
+    'IMPLEMENTS',
+    'HAS_METHOD',
+    'HAS_PROPERTY',
+    'ACCESSES',
+    'METHOD_OVERRIDES',
+    'OVERRIDES', // Legacy compat alias — kept until all stored indexes are migrated
+    'METHOD_IMPLEMENTS',
+    'MEMBER_OF',
+    'STEP_IN_PROCESS',
+    'HANDLES_ROUTE',
+    'FETCHES',
+    'HANDLES_TOOL',
+    'ENTRY_POINT_OF',
+    'WRAPS',
+    'QUERIES',
+];
+export const EMBEDDING_TABLE_NAME = 'CodeEmbedding';
+//# sourceMappingURL=schema-constants.js.map

package/dist/_shared/lbug/schema-constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-constants.js","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,WAAW;IACX,QAAQ;IACR,aAAa;IACb,WAAW;IACX,SAAS;IACT,SAAS;IACT,QAAQ;IACR,MAAM;IACN,OAAO;IACP,SAAS;IACT,OAAO;IACP,WAAW;IACX,OAAO;IACP,MAAM;IACN,WAAW;IACX,OAAO;IACP,QAAQ;IACR,UAAU;IACV,UAAU;IACV,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,aAAa;IACb,UAAU;IACV,QAAQ;IACR,OAAO;IACP,MAAM;CACE,CAAC;AAIX,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC;AAE7C,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,UAAU;IACV,SAAS;IACT,SAAS;IACT,OAAO;IACP,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,UAAU;IACV,kBAAkB;IAClB,WAAW,EAAE,mEAAmE;IAChF,mBAAmB;IACnB,WAAW;IACX,iBAAiB;IACjB,eAAe;IACf,SAAS;IACT,cAAc;IACd,gBAAgB;IAChB,OAAO;IACP,SAAS;CACD,CAAC;AAIX,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC"}

package/dist/_shared/mro-strategy.d.ts

@@ -0,0 +1,41 @@
+/**
+ * MRO (Method Resolution Order) strategy — shared canonical definition.
+ *
+ * Lives in `@codragraph/shared` so `model/resolve.ts` and `mro-processor.ts` share
+ * the type without importing the language registry (avoids circular coupling).
+ *
+ * `first-wins` (default, Java/C#/Kotlin/Go/Swift/Dart):
+ *   BFS ancestor walk in declaration order; first match wins.
+ *
+ * `leftmost-base` (C++):
+ *   BFS walk; HeritageMap preserves source insertion order, so BFS naturally
+ *   picks the leftmost base in diamond inheritance.
+ *
+ * `c3` (Python):
+ *   C3-linearization; falls back to BFS on cyclic/inconsistent hierarchy.
+ *   See model/resolve.ts § c3Linearize.
+ *
+ * `implements-split` (Java/C#/Kotlin):
+ *   Low-level lookup is BFS; graph-level mro-processor detects and warns on
+ *   interface-default method ambiguity.
+ *
+ * `qualified-syntax` (Rust):
+ *   No auto-resolution — `lookupMethodByOwnerWithMRO` returns undefined immediately.
+ *   Rust requires explicit `<Type as Trait>::method` syntax.
+ *
+ * `ruby-mixin` (Ruby):
+ *   Kind-aware walk that does NOT short-circuit on direct owner first (`prepend`
+ *   must beat the class's own method). Walk order:
+ *     1. Prepend providers (reverse declaration — last-prepended wins)
+ *     2. Direct owner's own methods
+ *     3. Include providers (reverse declaration)
+ *     4. Transitive ancestors (BFS fallback)
+ *   Singleton dispatch: caller passes `ancestryOverride` (extend providers only);
+ *   becomes a simple left-to-right scan. Miss NEVER falls through to file-scoped
+ *   lookup — null-routes or honors `fallback`.
+ *
+ * @see model/resolve.ts § lookupMethodByOwnerWithMRO
+ * @see languages/ruby.ts § selectDispatch
+ */
+export type MroStrategy = 'first-wins' | 'c3' | 'leftmost-base' | 'implements-split' | 'qualified-syntax' | 'ruby-mixin';
+//# sourceMappingURL=mro-strategy.d.ts.map

package/dist/_shared/mro-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mro-strategy.d.ts","sourceRoot":"","sources":["../src/mro-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,MAAM,WAAW,GACnB,YAAY,GACZ,IAAI,GACJ,eAAe,GACf,kBAAkB,GAClB,kBAAkB,GAClB,YAAY,CAAC"}

package/dist/_shared/mro-strategy.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mro-strategy.js.map

package/dist/_shared/mro-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mro-strategy.js","sourceRoot":"","sources":["../src/mro-strategy.ts"],"names":[],"mappings":""}

package/dist/_shared/pipeline.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pipeline progress types — shared between CLI and web.
+ */
+export type PipelinePhase = 'idle' | 'extracting' | 'structure' | 'parsing' | 'imports' | 'calls' | 'heritage' | 'communities' | 'processes' | 'enriching' | 'complete' | 'error';
+export interface PipelineProgress {
+    phase: PipelinePhase;
+    percent: number;
+    message: string;
+    detail?: string;
+    stats?: {
+        filesProcessed: number;
+        totalFiles: number;
+        nodesCreated: number;
+    };
+}
+//# sourceMappingURL=pipeline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../src/pipeline.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,YAAY,GACZ,WAAW,GACX,SAAS,GACT,SAAS,GACT,OAAO,GACP,UAAU,GACV,aAAa,GACb,WAAW,GACX,WAAW,GACX,UAAU,GACV,OAAO,CAAC;AAEZ,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE;QACN,cAAc,EAAE,MAAM,CAAC;QACvB,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;CACH"}

package/dist/_shared/pipeline.js

@@ -0,0 +1,5 @@
+/**
+ * Pipeline progress types — shared between CLI and web.
+ */
+export {};
+//# sourceMappingURL=pipeline.js.map

package/dist/_shared/pipeline.js.map

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

package/dist/_shared/scope-resolution/def-index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `DefIndex` — O(1) `DefId → SymbolDefinition` materialization.
+ *
+ * The global "what is this id?" lookup. Every per-kind registry (ClassRegistry,
+ * MethodRegistry, FieldRegistry) returns `DefId[]` and resolves them back to
+ * full `SymbolDefinition` records through this index — one central hash map,
+ * one allocation per def.
+ *
+ * Part of RFC #909 Ring 2 SHARED — #913.
+ *
+ * Consumed by: #917 (`Registry.lookup` implementations), #915 (SCC finalize).
+ */
+import type { SymbolDefinition } from './symbol-definition.js';
+import type { DefId } from './types.js';
+export interface DefIndex {
+    readonly byId: ReadonlyMap<DefId, SymbolDefinition>;
+    readonly size: number;
+    get(id: DefId): SymbolDefinition | undefined;
+    has(id: DefId): boolean;
+}
+/**
+ * Build a `DefIndex` from a flat list of `SymbolDefinition` records.
+ *
+ * **Collision policy: first-write-wins.** `DefId` is meant to be unique
+ * (`nodeId` is the stable graph identifier), so a collision indicates an
+ * upstream bug — most likely the same symbol parsed twice or a duplicate
+ * commit into the pipeline. Rather than silently overwriting with a later
+ * definition that may be partial or wrong, the first record wins and
+ * subsequent records for the same id are dropped. Pipeline bugs surface
+ * later as `has(id) === true` but the def looking older than expected,
+ * which is easier to debug than a silent overwrite.
+ *
+ * Pure function — safe to call repeatedly; no side effects.
+ */
+export declare function buildDefIndex(defs: readonly SymbolDefinition[]): DefIndex;
+//# sourceMappingURL=def-index.d.ts.map

package/dist/_shared/scope-resolution/def-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"def-index.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/def-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,GAAG,CAAC,EAAE,EAAE,KAAK,GAAG,gBAAgB,GAAG,SAAS,CAAC;IAC7C,GAAG,CAAC,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,gBAAgB,EAAE,GAAG,QAAQ,CAOzE"}

package/dist/_shared/scope-resolution/def-index.js

@@ -0,0 +1,51 @@
+/**
+ * `DefIndex` — O(1) `DefId → SymbolDefinition` materialization.
+ *
+ * The global "what is this id?" lookup. Every per-kind registry (ClassRegistry,
+ * MethodRegistry, FieldRegistry) returns `DefId[]` and resolves them back to
+ * full `SymbolDefinition` records through this index — one central hash map,
+ * one allocation per def.
+ *
+ * Part of RFC #909 Ring 2 SHARED — #913.
+ *
+ * Consumed by: #917 (`Registry.lookup` implementations), #915 (SCC finalize).
+ */
+/**
+ * Build a `DefIndex` from a flat list of `SymbolDefinition` records.
+ *
+ * **Collision policy: first-write-wins.** `DefId` is meant to be unique
+ * (`nodeId` is the stable graph identifier), so a collision indicates an
+ * upstream bug — most likely the same symbol parsed twice or a duplicate
+ * commit into the pipeline. Rather than silently overwriting with a later
+ * definition that may be partial or wrong, the first record wins and
+ * subsequent records for the same id are dropped. Pipeline bugs surface
+ * later as `has(id) === true` but the def looking older than expected,
+ * which is easier to debug than a silent overwrite.
+ *
+ * Pure function — safe to call repeatedly; no side effects.
+ */
+export function buildDefIndex(defs) {
+    const byId = new Map();
+    for (const def of defs) {
+        if (byId.has(def.nodeId))
+            continue; // first-write-wins
+        byId.set(def.nodeId, def);
+    }
+    return wrapIndex(byId);
+}
+// ─── Internal ───────────────────────────────────────────────────────────────
+function wrapIndex(byId) {
+    return {
+        byId,
+        get size() {
+            return byId.size;
+        },
+        get(id) {
+            return byId.get(id);
+        },
+        has(id) {
+            return byId.has(id);
+        },
+    };
+}
+//# sourceMappingURL=def-index.js.map

package/dist/_shared/scope-resolution/def-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"def-index.js","sourceRoot":"","sources":["../../src/scope-resolution/def-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAYH;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,aAAa,CAAC,IAAiC;IAC7D,MAAM,IAAI,GAAG,IAAI,GAAG,EAA2B,CAAC;IAChD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,SAAS,CAAC,mBAAmB;QACvD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC;AACzB,CAAC;AAED,+EAA+E;AAE/E,SAAS,SAAS,CAAC,IAAkC;IACnD,OAAO;QACL,IAAI;QACJ,IAAI,IAAI;YACN,OAAO,IAAI,CAAC,IAAI,CAAC;QACnB,CAAC;QACD,GAAG,CAAC,EAAS;YACX,OAAO,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACtB,CAAC;QACD,GAAG,CAAC,EAAS;YACX,OAAO,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACtB,CAAC;KACF,CAAC;AACJ,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"}