/**
 * Unit tests for `scope-extractor.extract` — the 5-pass driver
 * (RFC §5.3; Ring 2 PKG #919).
 *
 * Tests are organized by pass so a regression localizes to the pass it
 * broke. A `MockProvider` emits synthetic `CaptureMatch[]` with no real
 * AST; the extractor is pure given those captures.
 */

import { describe, it, expect } from 'vitest';
import type {
  Capture,
  CaptureMatch,
  ParsedImport,
  ParsedTypeBinding,
  ReferenceKind,
  Scope,
  ScopeKind,
  SymbolDefinition,
} from 'gitnexus-shared';
import {
  extract,
  selectNodeBearingDef,
  type ScopeExtractorHooks,
} from '../../../src/core/ingestion/scope-extractor.js';

// ─── Synthetic-capture helpers ──────────────────────────────────────────────

const cap = (
  name: string,
  startLine: number,
  startCol: number,
  endLine: number,
  endCol: number,
  text = '',
): Capture => ({
  name,
  range: { startLine, startCol, endLine, endCol },
  text,
});

const scopeMatch = (
  kind: Lowercase<ScopeKind>,
  startLine: number,
  startCol: number,
  endLine: number,
  endCol: number,
): CaptureMatch => ({
  [`@scope.${kind}`]: cap(`@scope.${kind}`, startLine, startCol, endLine, endCol),
});

const declMatch = (
  kindStr: string,
  name: string,
  startLine: number,
  startCol: number,
  endLine: number,
  endCol: number,
  extras: Record<string, Capture> = {},
): CaptureMatch => ({
  [`@declaration.${kindStr}`]: cap(`@declaration.${kindStr}`, startLine, startCol, endLine, endCol),
  '@declaration.name': cap('@declaration.name', startLine, startCol, endLine, endCol, name),
  ...extras,
});

const importMatch = (
  startLine: number,
  startCol: number,
  endLine: number,
  endCol: number,
): CaptureMatch => ({
  '@import.statement': cap('@import.statement', startLine, startCol, endLine, endCol),
});

const typeBindingMatch = (
  startLine: number,
  startCol: number,
  endLine: number,
  endCol: number,
): CaptureMatch => ({
  '@type-binding.parameter': cap('@type-binding.parameter', startLine, startCol, endLine, endCol),
});

const refMatch = (
  suffix: string,
  name: string,
  startLine: number,
  startCol: number,
  endLine: number,
  endCol: number,
  extras: Record<string, Capture> = {},
): CaptureMatch => ({
  [`@reference.${suffix}`]: cap(`@reference.${suffix}`, startLine, startCol, endLine, endCol),
  '@reference.name': cap('@reference.name', startLine, startCol, endLine, endCol, name),
  ...extras,
});

// ─── MockProvider ───────────────────────────────────────────────────────────
//
// The extractor declares its dependency on a narrow `ScopeExtractorHooks`
// surface — not the full `LanguageProvider`. Tests implement exactly that
// surface, so adding a new hook to `extract()` that's not in
// `ScopeExtractorHooks` is a compile error, not a silent test pass.

function mockProvider(hooks: Partial<ScopeExtractorHooks> = {}): ScopeExtractorHooks {
  return hooks;
}

// ─── §Pass 1: scope tree construction ──────────────────────────────────────

describe('Pass 1: scope tree', () => {
  it('creates a single Module scope from one @scope.module match', () => {
    const result = extract([scopeMatch('module', 1, 0, 100, 0)], 'a.ts', mockProvider());
    expect(result.scopes).toHaveLength(1);
    expect(result.scopes[0]!.kind).toBe('Module');
    expect(result.scopes[0]!.parent).toBeNull();
    expect(result.moduleScope).toBe(result.scopes[0]!.id);
  });

  it('synthesizes a single empty Module scope when the provider emits no captures', () => {
    const result = extract([], 'empty.py', mockProvider());
    expect(result.scopes).toHaveLength(1);
    expect(result.scopes[0]!).toMatchObject({
      kind: 'Module',
      parent: null,
      range: { startLine: 0, startCol: 0, endLine: 0, endCol: 0 },
    });
    expect(result.moduleScope).toBe(result.scopes[0]!.id);
  });

  it('nests Class under Module when the class range is contained in the module range', () => {
    const result = extract(
      [scopeMatch('module', 1, 0, 100, 0), scopeMatch('class', 5, 0, 50, 0)],
      'a.ts',
      mockProvider(),
    );
    expect(result.scopes).toHaveLength(2);
    const cls = result.scopes.find((s) => s.kind === 'Class')!;
    const mod = result.scopes.find((s) => s.kind === 'Module')!;
    expect(cls.parent).toBe(mod.id);
  });

  it('nests Method under Class, Class under Module — deep nesting', () => {
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        scopeMatch('class', 5, 0, 50, 0),
        scopeMatch('function', 10, 2, 30, 2),
      ],
      'a.ts',
      mockProvider(),
    );
    const mod = result.scopes.find((s) => s.kind === 'Module')!;
    const cls = result.scopes.find((s) => s.kind === 'Class')!;
    const fn = result.scopes.find((s) => s.kind === 'Function')!;
    expect(cls.parent).toBe(mod.id);
    expect(fn.parent).toBe(cls.id);
  });

  it('places non-nested siblings at the same level under the module', () => {
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        scopeMatch('function', 10, 0, 20, 0),
        scopeMatch('function', 30, 0, 40, 0),
      ],
      'a.ts',
      mockProvider(),
    );
    const mod = result.scopes.find((s) => s.kind === 'Module')!;
    const fns = result.scopes.filter((s) => s.kind === 'Function');
    expect(fns).toHaveLength(2);
    for (const fn of fns) expect(fn.parent).toBe(mod.id);
  });

  it('uses `provider.resolveScopeKind` to override the default kind from the suffix', () => {
    // Provider upgrades a `@scope.block` to `Expression` for a comprehension-
    // style use case.
    const result = extract(
      [scopeMatch('module', 1, 0, 100, 0), scopeMatch('block', 10, 0, 15, 0)],
      'a.ts',
      mockProvider({
        resolveScopeKind: (match) => (match['@scope.block'] !== undefined ? 'Expression' : null),
      }),
    );
    expect(result.scopes.find((s) => s.kind === 'Expression')).toBeDefined();
  });

  it('throws ScopeTreeInvariantError when siblings overlap (provider bug)', () => {
    expect(() =>
      extract(
        [
          scopeMatch('module', 1, 0, 100, 0),
          scopeMatch('function', 10, 0, 20, 0),
          scopeMatch('function', 15, 0, 25, 0), // overlaps
        ],
        'a.ts',
        mockProvider(),
      ),
    ).toThrow(/overlap/i);
  });

  it('synthesizes a Module scope and re-parents orphan Function when no Module is present', () => {
    const result = extract([scopeMatch('function', 1, 0, 10, 0)], 'a.ts', mockProvider());
    const moduleScope = result.scopes.find((s) => s.kind === 'Module');
    expect(moduleScope).toBeDefined();
    const fnScope = result.scopes.find((s) => s.kind === 'Function');
    expect(fnScope).toBeDefined();
    expect(fnScope!.parent).toBe(moduleScope!.id);
  });
});

// ─── §Pass 2: declarations + local bindings ────────────────────────────────

describe('Pass 2: declarations + local bindings', () => {
  it('routes one multi-topic match through both scope and declaration passes', () => {
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        {
          '@scope.function': cap('@scope.function', 5, 0, 20, 0, 'render'),
          '@declaration.function': cap('@declaration.function', 5, 0, 20, 0, 'render'),
          '@declaration.name': cap('@declaration.name', 5, 0, 5, 6, 'render'),
        },
      ],
      'a.ts',
      mockProvider(),
    );

    expect(result.scopes.some((scope) => scope.kind === 'Function')).toBe(true);
    expect(result.localDefs).toHaveLength(1);
    expect(result.localDefs[0]!.qualifiedName).toBe('render');
  });

  it('attaches a Class declaration to its enclosing Module scope', () => {
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        scopeMatch('class', 5, 0, 50, 0),
        declMatch('class', 'User', 5, 6, 5, 10),
      ],
      'a.ts',
      mockProvider(),
    );
    // The declaration sits at line 5 → innermost scope is Class (at 5:0..50:0).
    const cls = result.scopes.find((s) => s.kind === 'Class')!;
    expect(cls.ownedDefs).toHaveLength(1);
    expect(cls.ownedDefs[0]!.type).toBe('Class');
    expect(cls.ownedDefs[0]!.qualifiedName).toBe('User');
    expect(cls.bindings.get('User')).toBeDefined();
    expect(cls.bindings.get('User')![0]!.origin).toBe('local');
  });

  it('records the declaration in `localDefs` as well', () => {
    const result = extract(
      [scopeMatch('module', 1, 0, 100, 0), declMatch('function', 'render', 5, 0, 5, 6)],
      'a.ts',
      mockProvider(),
    );
    expect(result.localDefs).toHaveLength(1);
    expect(result.localDefs[0]!.type).toBe('Function');
  });

  it('preserves a synthetic declaration marker on the definition', () => {
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        declMatch('class', 'Worker$1', 5, 0, 10, 0, {
          '@declaration.is-synthetic': cap('@declaration.is-synthetic', 5, 0, 10, 0, 'true'),
        }),
      ],
      'a.ts',
      mockProvider(),
    );

    expect(result.localDefs).toHaveLength(1);
    expect(result.localDefs[0]!.isSynthetic).toBe(true);
  });

  it('honors `provider.bindingScopeFor` to hoist a binding to an outer scope', () => {
    // Treat every declaration as hoisted to the module scope.
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        scopeMatch('function', 10, 0, 30, 0),
        declMatch('variable', 'x', 15, 4, 15, 5),
      ],
      'a.ts',
      mockProvider({
        bindingScopeFor: (_match, _innermost, scopeTree) => {
          for (const s of scopeTree.byId.values()) if (s.kind === 'Module') return s.id;
          return null;
        },
      }),
    );
    const mod = result.scopes.find((s) => s.kind === 'Module')!;
    const fn = result.scopes.find((s) => s.kind === 'Function')!;
    // Binding hoisted to module; function scope's bindings empty for 'x'.
    expect(mod.bindings.get('x')).toBeDefined();
    expect(fn.bindings.get('x')).toBeUndefined();
    // `ownedDefs` stays structural (innermost = function).
    expect(fn.ownedDefs).toHaveLength(1);
  });

  it('ignores declarations with unknown kind suffixes', () => {
    const result = extract(
      [scopeMatch('module', 1, 0, 100, 0), declMatch('mystery', 'x', 5, 0, 5, 1)],
      'a.ts',
      mockProvider(),
    );
    expect(result.localDefs).toHaveLength(0);
  });
});

// ─── §Pass 3: imports ──────────────────────────────────────────────────────

describe('Pass 3: raw imports', () => {
  it('collects imports via `provider.interpretImport`', () => {
    const named: ParsedImport = {
      kind: 'named',
      localName: 'User',
      importedName: 'User',
      targetRaw: './models',
    };
    const result = extract(
      [scopeMatch('module', 1, 0, 100, 0), importMatch(3, 0, 3, 30)],
      'a.ts',
      mockProvider({
        interpretImport: () => named,
      }),
    );
    expect(result.parsedImports).toEqual([named]);
  });

  it('drops imports when `interpretImport` returns null', () => {
    const result = extract(
      [scopeMatch('module', 1, 0, 100, 0), importMatch(3, 0, 3, 30)],
      'a.ts',
      mockProvider({
        interpretImport: () => null,
      }),
    );
    expect(result.parsedImports).toEqual([]);
  });

  it('emits no imports when the provider does not implement `interpretImport`', () => {
    const result = extract(
      [scopeMatch('module', 1, 0, 100, 0), importMatch(3, 0, 3, 30)],
      'a.ts',
      mockProvider(),
    );
    expect(result.parsedImports).toEqual([]);
  });
});

// ─── §Pass 3: `runsOnlyWhenCalled` ────────────────────────────────────────
//
// The one scope fact Pass 3 reads before flattening the imports into a
// per-file list. It has to be decided here: `FinalizeFile.parsedImports` is
// flat, and finalize publishes a file's edges under `file.moduleScope`, so no
// later stage can tell where a statement sat (see
// `ParsedImport.runsOnlyWhenCalled`). Posed captures rather than a language,
// because the rule is language-agnostic and every scope kind has to be covered
// — no single grammar produces them all.

describe('Pass 3: runsOnlyWhenCalled', () => {
  const named: ParsedImport = {
    kind: 'named',
    localName: 'User',
    importedName: 'User',
    targetRaw: './models',
  };

  /**
   * Mark an import sitting at line 12 against a scope tree posed as nested
   * `@scope.*` captures, and report whether it came out deferred.
   */
  const deferredUnder = (...kinds: readonly Lowercase<ScopeKind>[]): boolean => {
    // Each scope nests inside the previous one and all of them contain line 12.
    const scopes = kinds.map((kind, depth) => scopeMatch(kind, 1 + depth, 0, 100 - depth, 0));
    const result = extract(
      [...scopes, importMatch(12, 0, 12, 30)],
      'a.ts',
      mockProvider({ interpretImport: () => named }),
    );
    expect(result.parsedImports).toHaveLength(1);
    return result.parsedImports[0]!.runsOnlyWhenCalled === true;
  };

  it('a module-level import is not marked', () => {
    expect(deferredUnder('module')).toBe(false);
  });

  it('an import inside a Function IS marked', () => {
    expect(deferredUnder('module', 'function')).toBe(true);
  });

  it('the walk climbs past every non-Function kind to reach the Function', () => {
    // A `Block` inside a function does not run at initialization even though
    // `Block` on its own does. Reading only the immediate scope kind fails
    // every one of these.
    expect(deferredUnder('module', 'function', 'block')).toBe(true);
    expect(deferredUnder('module', 'function', 'block', 'block')).toBe(true);
    expect(deferredUnder('module', 'function', 'class')).toBe(true);
    expect(deferredUnder('module', 'function', 'expression')).toBe(true);
    expect(deferredUnder('module', 'function', 'object')).toBe(true);
    expect(deferredUnder('module', 'class', 'function', 'block')).toBe(true);
  });

  it('kinds that execute where they are defined are NOT marked', () => {
    // `if (FLAG) { require('./x'); }` at module top level really does force an
    // initialization order, and so do class, namespace, object-literal and
    // comprehension bodies. Only a `Function` defers.
    expect(deferredUnder('module', 'block')).toBe(false);
    expect(deferredUnder('module', 'namespace')).toBe(false);
    expect(deferredUnder('module', 'class')).toBe(false);
    expect(deferredUnder('module', 'namespace', 'class')).toBe(false);
    expect(deferredUnder('module', 'expression')).toBe(false);
    expect(deferredUnder('module', 'object')).toBe(false);
    expect(deferredUnder('module', 'class', 'block')).toBe(false);
  });

  it('a sibling function does not mark an import outside it', () => {
    // Containment decides, not "the file has a function somewhere".
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        scopeMatch('function', 20, 0, 40, 0),
        importMatch(3, 0, 3, 30),
      ],
      'a.ts',
      mockProvider({ interpretImport: () => named }),
    );
    expect(result.parsedImports[0]!.runsOnlyWhenCalled).toBeUndefined();
  });

  it('the property is absent, not false, when the import initializes', () => {
    // Absence is the fail-safe reading, and it keeps an un-deferred
    // `ParsedImport` byte-identical to what it was before the field existed —
    // which is what the fixture suites across fourteen languages assert.
    const result = extract(
      [scopeMatch('module', 1, 0, 100, 0), importMatch(3, 0, 3, 30)],
      'a.ts',
      mockProvider({ interpretImport: () => named }),
    );
    expect(result.parsedImports).toEqual([named]);
  });

  // ─── The provider capability that opts out of the position rule ──────────
  //
  // The walk answers "does this run only when the enclosing function is
  // called?", which presupposes the import is a statement that RUNS. C/C++
  // `#include` is not — the preprocessor splices the header in before the
  // program starts, wherever the directive sits — and neither is a Rust `use`,
  // a compile-time path alias. Both are legal inside a function body.
  // Deferring one would make `check --cycles` drop a cycle that is entirely
  // real, and suppressing a true cycle is the failure direction that matters.
  //
  // The opt-out is a capability on the provider, checked here, rather than a
  // language test inside the walk: shared `core/ingestion/` pipeline code must
  // not name languages (AGENTS.md). These cases pin the CONTRACT — that the
  // flag is read at all, that its default is unchanged, and which of its two
  // values is the opt-out — with no language in sight.
  // `function-local-import-chain.test.ts` pins the C and Rust provider ends of
  // it against real source.

  it('a provider whose imports do not execute where written is never marked', () => {
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        scopeMatch('function', 2, 0, 99, 0),
        importMatch(12, 0, 12, 30),
      ],
      'a.c',
      mockProvider({ interpretImport: () => named, importsExecuteWhereWritten: false }),
    );
    // Byte-identical to the un-deferred shape, not merely `!== true`.
    expect(result.parsedImports).toEqual([named]);
  });

  it('the identical captures ARE marked for a provider that does not declare it', () => {
    // The control that makes the case above mean something: same scopes, same
    // import position, only the capability differs.
    const captures = [
      scopeMatch('module', 1, 0, 100, 0),
      scopeMatch('function', 2, 0, 99, 0),
      importMatch(12, 0, 12, 30),
    ];
    expect(
      extract(captures, 'a.ts', mockProvider({ interpretImport: () => named })).parsedImports,
    ).toEqual([{ ...named, runsOnlyWhenCalled: true }]);
    // Absent must mean `true`, not merely "not false" — the default is the
    // safe direction (position defers), and only an explicit `false` withholds
    // deferral. Spelling `true` therefore has to behave exactly like absent.
    expect(
      extract(
        captures,
        'a.ts',
        mockProvider({ interpretImport: () => named, importsExecuteWhereWritten: true }),
      ).parsedImports,
    ).toEqual([{ ...named, runsOnlyWhenCalled: true }]);
  });
});

// ─── §Pass 4: type bindings ───────────────────────────────────────────────

describe('Pass 4: type bindings', () => {
  it('attaches a parameter-annotation TypeRef to the innermost scope', () => {
    const parsed: ParsedTypeBinding = {
      boundName: 'user',
      rawTypeName: 'User',
      source: 'parameter-annotation',
    };
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        scopeMatch('function', 5, 0, 20, 0),
        typeBindingMatch(6, 4, 6, 14),
      ],
      'a.ts',
      mockProvider({
        interpretTypeBinding: () => parsed,
      }),
    );
    const fn = result.scopes.find((s) => s.kind === 'Function')!;
    const tb = fn.typeBindings.get('user');
    expect(tb).toBeDefined();
    expect(tb!.rawName).toBe('User');
    expect(tb!.source).toBe('parameter-annotation');
    expect(tb!.declaredAtScope).toBe(fn.id);
  });

  it('skips type-binding matches when the provider returns null', () => {
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        scopeMatch('function', 5, 0, 20, 0),
        typeBindingMatch(6, 4, 6, 14),
      ],
      'a.ts',
      mockProvider({
        interpretTypeBinding: () => null,
      }),
    );
    const fn = result.scopes.find((s) => s.kind === 'Function')!;
    expect(fn.typeBindings.size).toBe(0);
  });
});

// ─── §Pass 5: reference sites ─────────────────────────────────────────────

describe('Pass 5: reference sites', () => {
  it('emits a call reference with the innermost scope anchor', () => {
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        scopeMatch('function', 5, 0, 20, 0),
        refMatch('call.free', 'print', 10, 4, 10, 9),
      ],
      'a.ts',
      mockProvider(),
    );
    const fn = result.scopes.find((s) => s.kind === 'Function')!;
    expect(result.referenceSites).toHaveLength(1);
    expect(result.referenceSites[0]!.name).toBe('print');
    expect(result.referenceSites[0]!.kind).toBe('call');
    expect(result.referenceSites[0]!.callForm).toBe('free');
    expect(result.referenceSites[0]!.inScope).toBe(fn.id);
  });

  it('classifies member calls via the `@reference.call.member` sub-tag', () => {
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        refMatch('call.member', 'save', 3, 4, 3, 8, {
          '@reference.receiver': cap('@reference.receiver', 3, 0, 3, 4, 'user'),
        }),
      ],
      'a.ts',
      mockProvider(),
    );
    expect(result.referenceSites[0]!.callForm).toBe('member');
    expect(result.referenceSites[0]!.explicitReceiver).toEqual({ name: 'user' });
  });

  it('falls back to `provider.classifyCallForm` when the anchor has no sub-tag', () => {
    const result = extract(
      [scopeMatch('module', 1, 0, 100, 0), refMatch('call', 'foo', 3, 0, 3, 3)],
      'a.ts',
      mockProvider({
        classifyCallForm: () => 'member',
      }),
    );
    expect(result.referenceSites[0]!.callForm).toBe('member');
  });

  it('recognizes all reference kinds (call, read, write, inherits, type, import_use)', () => {
    const kindsToEmit: Array<[string, ReferenceKind]> = [
      ['call.free', 'call'],
      ['read', 'read'],
      ['write', 'write'],
      ['inherits', 'inherits'],
      ['type', 'type-reference'],
      ['import_use', 'import-use'],
    ];
    const matches = [
      scopeMatch('module', 1, 0, 100, 0),
      ...kindsToEmit.map(([suffix], i) => refMatch(suffix, `ref${i}`, 10 + i, 0, 10 + i, 5)),
    ];
    const result = extract(matches, 'a.ts', mockProvider());
    expect(result.referenceSites.map((s) => s.kind)).toEqual(kindsToEmit.map(([, kind]) => kind));
  });

  it('picks the call anchor over a wider-ranged @reference.receiver (regression for KNOWN_SUB_TAGS exclusion)', () => {
    // Regression for the bug fixed before commit: a member call like
    // `user.save()` where the receiver capture (`user`) spans MORE source
    // than the call anchor (`save`). The broadest-range anchor heuristic
    // would have picked the receiver — `anchorCaptureFor` must exclude
    // known sub-tags (`@reference.receiver`, `@reference.name`, etc.) to
    // route the match as a `call` reference.
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        {
          // Receiver spans columns 0-10 (wider).
          '@reference.receiver': cap('@reference.receiver', 3, 0, 3, 10, 'longUserName'),
          // Call name spans columns 11-15 (narrower).
          '@reference.name': cap('@reference.name', 3, 11, 3, 15, 'save'),
          // The anchor — call.member — spans 0-17 (full expression). In the
          // buggy behavior the receiver would have tied-or-won. Even here,
          // the fix guarantees we pick the call anchor, never the sub-tag.
          '@reference.call.member': cap('@reference.call.member', 3, 0, 3, 17),
        },
      ],
      'a.ts',
      mockProvider(),
    );
    expect(result.referenceSites).toHaveLength(1);
    expect(result.referenceSites[0]!.name).toBe('save'); // NOT 'longUserName'
    expect(result.referenceSites[0]!.kind).toBe('call');
    expect(result.referenceSites[0]!.callForm).toBe('member');
    expect(result.referenceSites[0]!.explicitReceiver).toEqual({ name: 'longUserName' });
  });

  it('parses arity from @reference.arity when present', () => {
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        refMatch('call.free', 'foo', 3, 0, 3, 3, {
          '@reference.arity': cap('@reference.arity', 3, 0, 3, 0, '2'),
        }),
      ],
      'a.ts',
      mockProvider(),
    );
    expect(result.referenceSites[0]!.arity).toBe(2);
  });

  // #2782: languages whose member-read pattern also matches the callee of a
  // member call mark that site rather than dropping it — the phantom-vs-genuine
  // decision needs the resolved tail's kind and so belongs at edge emission.
  it('records @reference.callee-position as inCalleePosition without becoming the anchor', () => {
    const result = extract(
      [
        scopeMatch('module', 1, 0, 100, 0),
        refMatch('read', 'Work', 3, 0, 3, 10, {
          // Widest capture in the match: if it were not a known sub-tag it
          // would win `anchorCaptureFor` and route the site to an unknown kind.
          '@reference.callee-position': cap(
            '@reference.callee-position',
            3,
            0,
            3,
            20,
            'h.dep.Work',
          ),
        }),
      ],
      'a.ts',
      mockProvider(),
    );
    expect(result.referenceSites).toHaveLength(1);
    expect(result.referenceSites[0]).toMatchObject({
      name: 'Work',
      kind: 'read',
      inCalleePosition: true,
    });
  });

  it('leaves inCalleePosition unset on an ordinary read', () => {
    const result = extract(
      [scopeMatch('module', 1, 0, 100, 0), refMatch('read', 'Label', 3, 0, 3, 10)],
      'a.ts',
      mockProvider(),
    );
    expect(result.referenceSites[0]!.inCalleePosition).toBeUndefined();
  });
});

// ─── §Pass 6: callable-value-flow facts ───────────────────────────────────

describe('Pass 6: callable-value-flow facts', () => {
  it('omits callableFlowSites when the provider emits no flow captures', () => {
    const result = extract([scopeMatch('module', 1, 0, 100, 0)], 'a.ts', mockProvider());
    expect(result.callableFlowSites).toBeUndefined();
  });

  it('materializes every normalized fact shape with lexical scopes and JSON-safe metadata', () => {
    const matches: CaptureMatch[] = [
      scopeMatch('module', 1, 0, 100, 0),
      scopeMatch('function', 10, 0, 60, 0),
      {
        '@callable-flow.seed': cap('@callable-flow.seed', 20, 2, 20, 20),
        '@callable-flow.destination': cap('@callable-flow.destination', 20, 2, 20, 4, 'fp'),
        '@callable-flow.target': cap('@callable-flow.target', 20, 8, 20, 14, 'target'),
        '@callable-flow.target-name': cap('@callable-flow.target-name', 20, 8, 20, 14, 'target'),
        '@callable-flow.target-qualified-name': cap(
          '@callable-flow.target-qualified-name',
          20,
          8,
          20,
          14,
          'Ns.target',
        ),
        '@callable-flow.expected-arity': cap('@callable-flow.expected-arity', 20, 2, 20, 2, '1'),
        '@callable-flow.expected-types': cap(
          '@callable-flow.expected-types',
          20,
          2,
          20,
          2,
          '["int"]',
        ),
        '@callable-flow.expected-type-classes': cap(
          '@callable-flow.expected-type-classes',
          20,
          2,
          20,
          2,
          '[{"base":"int","cv":"none","indirection":"value","pointerDepth":0}]',
        ),
      },
      {
        '@callable-flow.copy': cap('@callable-flow.copy', 21, 2, 21, 10),
        '@callable-flow.source': cap('@callable-flow.source', 21, 8, 21, 10, 'fp'),
        '@callable-flow.destination': cap('@callable-flow.destination', 21, 2, 21, 5, 'fp2'),
      },
      {
        '@callable-flow.alias': cap('@callable-flow.alias', 22, 2, 22, 10),
        '@callable-flow.source': cap('@callable-flow.source', 22, 8, 22, 10, 'fp'),
        '@callable-flow.destination': cap('@callable-flow.destination', 22, 2, 22, 5, 'ref'),
      },
      {
        '@callable-flow.address': cap('@callable-flow.address', 23, 2, 23, 12),
        '@callable-flow.source': cap('@callable-flow.source', 23, 9, 23, 11, 'fp'),
        '@callable-flow.destination': cap('@callable-flow.destination', 23, 2, 23, 6, 'slot'),
      },
      {
        '@callable-flow.store': cap('@callable-flow.store', 24, 2, 24, 14),
        '@callable-flow.source': cap('@callable-flow.source', 24, 10, 24, 14, 'next'),
        '@callable-flow.pointer': cap('@callable-flow.pointer', 24, 3, 24, 7, 'slot'),
        '@callable-flow.pointer-indirection': cap(
          '@callable-flow.pointer-indirection',
          24,
          3,
          24,
          3,
          '1',
        ),
      },
      {
        '@callable-flow.load': cap('@callable-flow.load', 25, 2, 25, 14),
        '@callable-flow.pointer': cap('@callable-flow.pointer', 25, 10, 25, 14, 'slot'),
        '@callable-flow.destination': cap('@callable-flow.destination', 25, 2, 25, 5, 'out'),
      },
      {
        '@callable-flow.formal': cap('@callable-flow.formal', 10, 0, 60, 0),
        '@callable-flow.owner': cap('@callable-flow.owner', 10, 0, 60, 0, 'invoke'),
        '@callable-flow.binding': cap('@callable-flow.binding', 10, 15, 10, 17, 'cb'),
        '@callable-flow.parameter-index': cap(
          '@callable-flow.parameter-index',
          10,
          15,
          10,
          15,
          '0',
        ),
        '@callable-flow.passing-mode': cap(
          '@callable-flow.passing-mode',
          10,
          15,
          10,
          15,
          'reference',
        ),
      },
      {
        '@callable-flow.argument': cap('@callable-flow.argument', 30, 2, 30, 12),
        '@callable-flow.source': cap('@callable-flow.source', 30, 9, 30, 11, 'fp'),
        '@callable-flow.parameter-index': cap('@callable-flow.parameter-index', 30, 9, 30, 9, '0'),
        '@callable-flow.direct-callee-name': cap(
          '@callable-flow.direct-callee-name',
          30,
          2,
          30,
          8,
          'invoke',
        ),
      },
      {
        '@callable-flow.invoke': cap('@callable-flow.invoke', 40, 2, 40, 14),
        '@callable-flow.callee': cap('@callable-flow.callee', 40, 8, 40, 10, 'cb'),
        '@callable-flow.receiver': cap('@callable-flow.receiver', 40, 3, 40, 6, 'obj'),
        '@callable-flow.invocation-kind': cap(
          '@callable-flow.invocation-kind',
          40,
          2,
          40,
          2,
          'member-pointer',
        ),
        '@callable-flow.arity': cap('@callable-flow.arity', 40, 2, 40, 2, '0'),
      },
      // Malformed facts are ignored defensively.
      { '@callable-flow.seed': cap('@callable-flow.seed', 50, 2, 50, 8) },
    ];

    const result = extract(matches, 'a.ts', mockProvider());
    const sites = result.callableFlowSites!;
    expect(sites.map((site) => site.kind)).toEqual([
      'seed',
      'copy',
      'alias',
      'address',
      'store',
      'load',
      'formal',
      'argument',
      'invoke',
    ]);
    const fnScope = result.scopes.find((scope) => scope.kind === 'Function')!;
    expect(sites[0]).toMatchObject({
      destination: { name: 'fp', inScope: fnScope.id, indirection: 0 },
      targetName: 'target',
      targetQualifiedName: 'Ns.target',
      expectedSignature: { parameterCount: 1, parameterTypes: ['int'] },
    });
    expect(sites[4]).toMatchObject({ pointer: { name: 'slot', indirection: 1 } });
    expect(sites[6]).toMatchObject({
      ownerName: 'invoke',
      parameterIndex: 0,
      passingMode: 'reference',
      binding: { name: 'cb', inScope: fnScope.id },
    });
    expect(sites[7]).toMatchObject({ directCalleeName: 'invoke' });
    expect(sites[8]).toMatchObject({
      invocationKind: 'member-pointer',
      arity: 0,
      callee: { name: 'cb' },
      receiver: { name: 'obj' },
    });
    expect(JSON.parse(JSON.stringify(sites))).toEqual(sites);
  });
});

// ─── §End-to-end fixture ──────────────────────────────────────────────────

describe('end-to-end fixture (all 5 passes together)', () => {
  it('produces a well-formed ParsedFile from a representative multi-pass input', () => {
    const matches: CaptureMatch[] = [
      // Pass 1: nested scopes
      scopeMatch('module', 1, 0, 100, 0),
      scopeMatch('class', 5, 0, 50, 0),
      scopeMatch('function', 10, 2, 40, 2),
      // Pass 2: declarations
      declMatch('class', 'User', 5, 6, 5, 10),
      declMatch('method', 'save', 10, 2, 10, 6),
      declMatch('field', 'count', 7, 2, 7, 7),
      // Pass 3: import
      importMatch(3, 0, 3, 30),
      // Pass 4: type binding
      typeBindingMatch(10, 14, 10, 18),
      // Pass 5: references
      refMatch('call.member', 'log', 20, 4, 20, 7, {
        '@reference.receiver': cap('@reference.receiver', 20, 0, 20, 4, 'self'),
      }),
      refMatch('read', 'count', 25, 4, 25, 9),
    ];

    const parsedImport: ParsedImport = {
      kind: 'named',
      localName: 'Logger',
      importedName: 'Logger',
      targetRaw: './logger',
    };
    const parsedTypeBinding: ParsedTypeBinding = {
      boundName: 'name',
      rawTypeName: 'string',
      source: 'parameter-annotation',
    };

    const result = extract(
      matches,
      'user.ts',
      mockProvider({
        interpretImport: () => parsedImport,
        interpretTypeBinding: () => parsedTypeBinding,
      }),
    );

    // Three scopes, properly nested.
    expect(result.scopes).toHaveLength(3);
    const kinds = result.scopes.map((s: Scope) => s.kind);
    expect(kinds).toEqual(expect.arrayContaining(['Module', 'Class', 'Function']));

    // Declarations landed on the correct scopes.
    const cls = result.scopes.find((s) => s.kind === 'Class')!;
    const fn = result.scopes.find((s) => s.kind === 'Function')!;
    expect(cls.ownedDefs.map((d) => d.qualifiedName).sort()).toEqual(['User', 'count'].sort());
    expect(fn.ownedDefs.map((d) => d.qualifiedName)).toEqual(['save']);

    // Local bindings present.
    expect(cls.bindings.get('User')).toBeDefined();
    expect(cls.bindings.get('count')).toBeDefined();
    expect(fn.bindings.get('save')).toBeDefined();

    // Import collected.
    expect(result.parsedImports).toEqual([parsedImport]);

    // Type binding attached to function scope.
    expect(fn.typeBindings.get('name')?.rawName).toBe('string');

    // References emitted.
    expect(result.referenceSites).toHaveLength(2);
    expect(result.referenceSites.map((r) => r.kind)).toEqual(['call', 'read']);

    // `localDefs` is the union across scopes.
    expect(result.localDefs).toHaveLength(3);
    expect(result.localDefs.map((d) => d.type).sort()).toEqual(
      ['Class', 'Method', 'Property'].sort(),
    );

    // Module scope id matches the ParsedFile header.
    const mod = result.scopes.find((s) => s.kind === 'Module')!;
    expect(result.moduleScope).toBe(mod.id);
  });
});

describe('selectNodeBearingDef — #1876 one-node-per-binding collapse rule', () => {
  const def = (type: SymbolDefinition['type'], name = 'x'): SymbolDefinition => ({
    nodeId: `def:test.ts#1:0:${type}:${name}`,
    filePath: 'test.ts',
    type,
    qualifiedName: name,
  });

  it('returns undefined for an empty group', () => {
    expect(selectNodeBearingDef([])).toBeUndefined();
  });

  it('returns the only def for a single-element group', () => {
    const only = def('Variable');
    expect(selectNodeBearingDef([only])).toBe(only);
  });

  it('prefers a Function over a co-bound Variable (direct arrow / HOC)', () => {
    const fn = def('Function');
    const variable = def('Variable');
    // Order-independent: function-like wins regardless of position.
    expect(selectNodeBearingDef([variable, fn])).toBe(fn);
    expect(selectNodeBearingDef([fn, variable])).toBe(fn);
  });

  it('prefers a Method over a co-bound value def', () => {
    const method = def('Method');
    const variable = def('Variable');
    expect(selectNodeBearingDef([variable, method])).toBe(method);
  });

  it('returns the value def when no function-like def is present (array-method result)', () => {
    const constDef = def('Const');
    expect(selectNodeBearingDef([constDef])).toBe(constDef);
    const variable = def('Variable');
    expect(selectNodeBearingDef([variable])).toBe(variable);
  });

  it('prefers a value def even when an unranked label appears first', () => {
    const cls = def('Class');
    const variable = def('Variable');
    expect(selectNodeBearingDef([cls, variable])).toBe(variable);
  });

  it('falls back to the first def for label sets the rule does not rank', () => {
    const cls = def('Class');
    const iface = def('Interface');
    expect(selectNodeBearingDef([cls, iface])).toBe(cls);
  });
});