import { describe, it, expect } from 'vitest';
import { resolve, ResolverIO } from '@beehexa/hexasync-template-compose';
import {
  mergeKey,
  overrideVariables,
} from '@beehexa/hexasync-template-compose';
import { reconcile, createTracer } from '@beehexa/hexasync-template-compose';
import { renderReport } from '@beehexa/hexasync-template-report-render';
import { renderReportHtml } from '@beehexa/hexasync-template-report-render';
import { makeVirtualIO } from './fixtures';
import { TracerEvent } from '@beehexa/hexasync-template-compose';

const read = (io: ResolverIO, p: string): Promise<string> =>
  io.readFileIfExists(p) as Promise<string>;

describe('CR fix: CAP-5 diamond dedupe is replacement-aware', () => {
  it('same base referenced twice with different replacements yields two instances', async () => {
    const io = makeVirtualIO({
      '/vfs/int/partials/main.yaml': `externals:\n  - type: project\n    path: ../../misa\n  - type: project\n    path: ../../sapo\n`,
      '/vfs/misa/partials/main.yaml': `externals:\n  - type: project\n    path: ../../base\n    replacements:\n      - fromKey: '**GEN**'\n        toKey: '**MISA**'\n`,
      '/vfs/sapo/partials/main.yaml': `externals:\n  - type: project\n    path: ../../base\n    replacements:\n      - fromKey: '**GEN**'\n        toKey: '**SAPO**'\n`,
      '/vfs/base/partials/main.yaml': `externals: []\n`,
      '/vfs/base/partials/B.yaml': `pushers:\n  - id: '**GEN**'\n`,
    });
    const r = await resolve(
      '/vfs/int/partials',
      await read(io, '/vfs/int/partials/main.yaml'),
      io,
    );
    const baseItems = r.worklist.filter((w) =>
      w.path.includes('base/partials/B.yaml'),
    );
    expect(baseItems).toHaveLength(2);
    const toKeys = baseItems
      .flatMap((i) => i.replacements.map((x) => x.toKey))
      .sort();
    expect(toKeys).toEqual(['**MISA**', '**SAPO**']);
  });

  it('true diamond (identical replacements) still dedupes to one', async () => {
    const io = makeVirtualIO({
      '/vfs/int/partials/main.yaml': `externals:\n  - type: project\n    path: ../../misa\n  - type: project\n    path: ../../sapo\n`,
      '/vfs/misa/partials/main.yaml': `externals:\n  - type: project\n    path: ../../base\n`,
      '/vfs/sapo/partials/main.yaml': `externals:\n  - type: project\n    path: ../../base\n`,
      '/vfs/base/partials/main.yaml': `externals: []\n`,
      '/vfs/base/partials/B.yaml': `pushers:\n  - id: BASE\n`,
    });
    const r = await resolve(
      '/vfs/int/partials',
      await read(io, '/vfs/int/partials/main.yaml'),
      io,
    );
    expect(
      r.worklist.filter((w) => w.path.includes('base/partials/B.yaml')),
    ).toHaveLength(1);
  });
});

describe('CR fix: override:true merges last (wins)', () => {
  it('override local sorts after non-override peers', async () => {
    const io = makeVirtualIO({
      '/vfs/p/partials/main.yaml': `externals:\n  - type: local\n    path: ./A.yaml\n    index: 0\n  - type: local\n    path: ./B.yaml\n    override: true\n`,
      '/vfs/p/partials/A.yaml': `pushers:\n  - id: A\n`,
      '/vfs/p/partials/B.yaml': `pushers:\n  - id: B\n`,
    });
    const r = await resolve(
      '/vfs/p/partials',
      await read(io, '/vfs/p/partials/main.yaml'),
      io,
    );
    const ia = r.worklist.findIndex((w) => w.path.includes('A.yaml'));
    const ib = r.worklist.findIndex((w) => w.path.includes('B.yaml'));
    expect(ib).toBeGreaterThan(ia); // override B merged after A
  });
});

describe('CR fix: deterministic tiebreaks', () => {
  it('equal-weight siblings keep declaration/BFS order', async () => {
    const io = makeVirtualIO({
      '/vfs/int/partials/main.yaml': `externals:\n  - type: project\n    path: ../../misa\n    weight: 5\n  - type: project\n    path: ../../sapo\n    weight: 5\n`,
      '/vfs/misa/partials/main.yaml': `externals: []\n`,
      '/vfs/misa/partials/M.yaml': `pushers:\n  - id: M\n`,
      '/vfs/sapo/partials/main.yaml': `externals: []\n`,
      '/vfs/sapo/partials/S.yaml': `pushers:\n  - id: S\n`,
    });
    const r = await resolve(
      '/vfs/int/partials',
      await read(io, '/vfs/int/partials/main.yaml'),
      io,
    );
    const order = r.worklist.map((w) => w.project);
    expect(order.indexOf('misa')).toBeLessThan(order.indexOf('sapo'));
  });

  it('equal-index globbed files break ties by filename (glob sorted)', async () => {
    const io = makeVirtualIO({
      '/vfs/p/partials/main.yaml': `externals: []\n`,
      '/vfs/p/partials/B.yaml': `pushers:\n  - id: B\n`,
      '/vfs/p/partials/A.yaml': `pushers:\n  - id: A\n`,
    });
    const r = await resolve(
      '/vfs/p/partials',
      await read(io, '/vfs/p/partials/main.yaml'),
      io,
    );
    const ia = r.worklist.findIndex((w) => w.path.endsWith('A.yaml'));
    const ib = r.worklist.findIndex((w) => w.path.endsWith('B.yaml'));
    expect(ia).toBeLessThan(ib); // filename order deterministic
  });
});

describe('CR fix: externals non-array is tolerated', () => {
  it('does not crash when externals is a mapping', async () => {
    const io = makeVirtualIO({
      '/vfs/p/partials/main.yaml': `externals:\n  oops: not-a-list\npushers:\n  - id: X\n`,
    });
    await expect(
      resolve(
        '/vfs/p/partials',
        await read(io, '/vfs/p/partials/main.yaml'),
        io,
      ),
    ).resolves.toBeDefined();
  });
});

describe('CR fix: mergeKey depth for arrays nested under a map', () => {
  it('emits nested id/key items at depth > 0', async () => {
    const tracer = createTracer();
    const from = { notification: { channels: [{ id: 'C1' }] } };
    const override = { notification: { channels: [{ id: 'C2' }] } };
    mergeKey(
      'f',
      'notification',
      from.notification,
      override.notification,
      tracer,
      0,
    );
    const chanEvent = tracer.events().find((e) => e.idOrKey === 'C2')!;
    expect(chanEvent.depth).toBeGreaterThan(0); // not a top-level component
  });
});

describe('CR fix: overrideVariables substitutes longest key first', () => {
  it('a substring token does not corrupt the longer token', async () => {
    const out = overrideVariables(`k: "**ProductId**"`, {
      '**Id**': 'AAA',
      '**ProductId**': 'BBB',
    });
    expect(out.k).toBe('BBB');
  });
});

describe('CR fix: reconcile token-form (no false LOST) + no directive noise', () => {
  it('a component present in the (token-form) output is not LOST', async () => {
    const events: TracerEvent[] = [
      {
        idOrKey: '**BaseId**',
        parentKey: 'pushers',
        operation: 'added',
        depth: 0,
        sourceFile: 'f',
        project: 'base',
        generation: 1,
        weight: 10,
      },
    ];
    // token-form output (pre-substitution) — matches tracer ids
    const finalOutput = { pushers: [{ id: '**BaseId**' }] };
    const model = reconcile(
      events,
      [],
      finalOutput,
      [{ project: 'base', generation: 1, weight: 10 }],
      'demo',
    );
    expect(model.counts.lost).toBe(0);
    expect(model.counts.inherited).toBe(1);
  });

  it('finalComponentIndex tolerates a mixed collection (one id-less element)', async () => {
    const events: TracerEvent[] = [
      {
        idOrKey: 'P',
        parentKey: 'pushers',
        operation: 'added',
        depth: 0,
        sourceFile: 'f',
        project: 'base',
        generation: 1,
        weight: 1,
      },
    ];
    const finalOutput = { pushers: [{ id: 'P' }, { note: 'no-id-here' }] };
    const model = reconcile(
      events,
      [],
      finalOutput,
      [{ project: 'base', generation: 1, weight: 1 }],
      'demo',
    );
    expect(model.counts.lost).toBe(0);
  });
});

describe('CR fix: report escapes markdown-breaking ids', () => {
  it('escapes pipe characters in component ids', async () => {
    const events: TracerEvent[] = [
      {
        idOrKey: 'a|b',
        parentKey: 'pushers',
        operation: 'added',
        depth: 0,
        sourceFile: 'f',
        project: 'THIS',
        generation: 0,
        weight: NaN,
      },
    ];
    const model = reconcile(
      events,
      [],
      { pushers: [{ id: 'a|b' }] },
      [{ project: 'THIS', generation: 0, weight: NaN }],
      'demo',
    );
    const md = renderReport(model);
    // Provenance/per-project are HTML tables now → pipes HTML-escaped, not \|.
    expect(md).toContain('a&#124;b');
    expect(md).not.toContain('<td><code>a|b'); // raw pipe never leaks into a cell
  });
});

describe('CR round-2: wholesale overwrites are recorded (kept, with detail)', () => {
  it('id-less scalar array overwrite is recorded (hadComponents=false, no excluded)', async () => {
    const tracer = createTracer();
    mergeKey('f', 'indexGroups', [1, 2], [3], tracer, 0);
    expect(tracer.overwrites()).toHaveLength(1);
    expect(tracer.overwrites()[0].hadComponents).toBe(false);
    expect(
      tracer.events().filter((e) => e.operation === 'excluded'),
    ).toHaveLength(0);
  });

  it('overwriting a component array records hadComponents + depth, and emits NO excluded events', async () => {
    const tracer = createTracer();
    mergeKey(
      'f',
      'pushers',
      [{ id: 'A' }, { id: 'B' }],
      [{ noId: true }],
      tracer,
      0,
    );
    expect(tracer.overwrites()).toHaveLength(1);
    expect(tracer.overwrites()[0].hadComponents).toBe(true);
    expect(tracer.overwrites()[0].depth).toBe(0);
    // A wholesale clobber is NOT an explicit `!` removal — it must not emit excluded
    // events (they'd mislabel the drop). The reporter handles it via the record.
    expect(
      tracer.events().filter((e) => e.operation === 'excluded'),
    ).toHaveLength(0);
  });
});

describe('CR round-2: report gates on any externals (local OR project)', () => {
  const read = (io: ResolverIO, p: string): Promise<string> =>
    io.readFileIfExists(p) as Promise<string>;
  it('type: local externals set hasExternals (report will be written) but not hasInheritance', async () => {
    const io = makeVirtualIO({
      '/vfs/p/partials/main.yaml': `externals:\n  - type: local\n    path: ./A.yaml\n`,
      '/vfs/p/partials/A.yaml': `pushers:\n  - id: A\n`,
    });
    const r = await resolve(
      '/vfs/p/partials',
      await read(io, '/vfs/p/partials/main.yaml'),
      io,
    );
    expect(r.hasExternals).toBe(true);
    expect(r.hasInheritance).toBe(false);
  });
  it('no externals (globbed-only) => hasExternals false (no report)', async () => {
    const io = makeVirtualIO({
      '/vfs/q/partials/main.yaml': `externals: []\n`,
      '/vfs/q/partials/A.yaml': `pushers:\n  - id: A\n`,
    });
    const r = await resolve(
      '/vfs/q/partials',
      await read(io, '/vfs/q/partials/main.yaml'),
      io,
    );
    expect(r.hasExternals).toBe(false);
  });
});

describe('CR round-2: root main.yaml excluded from worklist (no self-merge)', () => {
  const read = (io: ResolverIO, p: string): Promise<string> =>
    io.readFileIfExists(p) as Promise<string>;
  it('the current project main.yaml is not re-listed as a component', async () => {
    const io = makeVirtualIO({
      '/vfs/int/partials/main.yaml': `externals:\n  - type: project\n    path: ../../base\npushers:\n  - id: ROOT\n`,
      '/vfs/base/partials/main.yaml': `externals: []\n`,
      '/vfs/base/partials/B.yaml': `pushers:\n  - id: BASE\n`,
    });
    const r = await resolve(
      '/vfs/int/partials',
      await read(io, '/vfs/int/partials/main.yaml'),
      io,
    );
    expect(
      r.worklist.some((w) => w.path.endsWith('int/partials/main.yaml')),
    ).toBe(false);
  });
});

describe('CR round-2: weight null/blank is rejected', () => {
  const read = (io: ResolverIO, p: string): Promise<string> =>
    io.readFileIfExists(p) as Promise<string>;
  it('weight: null throws (not silently coerced to 0)', async () => {
    const io = makeVirtualIO({
      '/vfs/p/partials/main.yaml': `externals:\n  - type: project\n    path: ../../b\n    weight: null\n`,
      '/vfs/b/partials/main.yaml': `externals: []\n`,
    });
    await expect(
      resolve(
        '/vfs/p/partials',
        await read(io, '/vfs/p/partials/main.yaml'),
        io,
      ),
    ).rejects.toThrow(/invalid weight/);
  });
});

describe('CR round-2: report highlighting', () => {
  it('status badges are colored and last-wins is highlighted', async () => {
    const events: TracerEvent[] = [
      {
        idOrKey: 'P',
        parentKey: 'pushers',
        operation: 'added',
        depth: 0,
        sourceFile: 'f',
        project: 'base',
        generation: 1,
        weight: 10,
      },
    ];
    const model = reconcile(
      events,
      [],
      { pushers: [{ id: 'P' }] },
      [
        { project: 'base', generation: 1, weight: 10 },
        { project: 'THIS', generation: 0, weight: NaN },
      ],
      'demo',
    );
    const md = renderReport(model);
    expect(md).toContain('color:'); // colored status badges
    expect(md).toMatch(/<strong>last \(wins\)<\/strong>/); // last-wins highlighted
  });
});

describe('CR round-2: customized diff + linked hierarchy', () => {
  it('produces a unified diff (inherited → final) and clickable hierarchy links', async () => {
    const path = await import('path');
    const snapshots = new Map<string, unknown>();
    snapshots.set(JSON.stringify(['pushers', 'P']), {
      id: 'P',
      name: 'old',
      step: 'A',
    });
    const events: TracerEvent[] = [
      {
        idOrKey: 'P',
        parentKey: 'pushers',
        operation: 'added',
        depth: 0,
        sourceFile: 'f',
        project: 'base',
        generation: 1,
        weight: 10,
      },
      {
        idOrKey: 'P',
        parentKey: 'pushers',
        operation: 'customized',
        depth: 0,
        sourceFile: 'g',
        project: 'THIS',
        generation: 0,
        weight: NaN,
      },
    ];
    const model = reconcile(
      events,
      [],
      { pushers: [{ id: 'P', name: 'new', step: 'A' }] },
      [
        { project: 'base', generation: 1, weight: 10 },
        { project: 'THIS', generation: 0, weight: NaN },
      ],
      'demo',
      {
        projectPaths: new Map([
          ['base', '/vfs/base/partials'],
          ['THIS', '/vfs/int/partials'],
        ]),
        reportDir: '/vfs/int',
        snapshots,
        relative: (from, to) => path.posix.relative(from, to),
      },
    );
    const p = model.components.find((c) => c.idOrKey === 'P')!;
    expect(p.status).toBe('customized');
    expect(p.diffText).toMatch(/- name: old/);
    expect(p.diffText).toMatch(/\+ name: new/);
    expect(p.hierarchy.find((h) => h.label === 'base')?.link).toBeTruthy();

    const md = renderReport(model);
    // Full-width diff row rendered directly beneath the customized row (5 cols
    // after the Type column moved into the collapsible group header).
    expect(md).toContain('<td colspan="5"');
    expect(md).toContain('customization diff — ');
    expect(md).toMatch(/background:#e6ffec;color:#116329[^>]*>\+ name: new/); // added, green bg
    expect(md).toMatch(/background:#ffebe9;color:#b31d28[^>]*>- name: old/); // removed, red bg
    expect(md).toMatch(/<a href="[^"]*">base<\/a>/); // clickable hierarchy link
  });
});

describe('CR round-2: HTML report', () => {
  it('renders a styled self-contained HTML doc with pills and inline diff', async () => {
    const { renderReportHtml } =
      await import('@beehexa/hexasync-template-report-render');
    const snapshots = new Map<string, unknown>();
    snapshots.set(JSON.stringify(['pushers', 'P']), { id: 'P', name: 'old' });
    const events: TracerEvent[] = [
      {
        idOrKey: 'P',
        parentKey: 'pushers',
        operation: 'added',
        depth: 0,
        sourceFile: 'f',
        project: 'base',
        generation: 1,
        weight: 10,
      },
      {
        idOrKey: 'P',
        parentKey: 'pushers',
        operation: 'customized',
        depth: 0,
        sourceFile: 'g',
        project: 'THIS',
        generation: 0,
        weight: NaN,
      },
    ];
    const model = reconcile(
      events,
      [],
      { pushers: [{ id: 'P', name: 'new' }] },
      [
        { project: 'base', generation: 1, weight: 10 },
        { project: 'THIS', generation: 0, weight: NaN },
      ],
      'demo',
      { snapshots },
    );
    const html = renderReportHtml(model);
    expect(html.startsWith('<!doctype html>')).toBe(true);
    expect(html).toContain('<style>');
    expect(html).toContain('class="pill customized"');
    expect(html).toContain('class="dl add"'); // colored diff line
    expect(html).toContain('Merge Integrity Report');
  });
});

describe('CR round-3: long unchanged diff runs collapse', () => {
  it('collapseDiff keeps context around changes and folds long unchanged runs', async () => {
    const { collapseDiff } =
      await import('@beehexa/hexasync-template-report-render');
    const ctx = Array.from({ length: 10 }, (_, i) => `  line${i}`);
    const diff = [...ctx, '- old', '+ new', ...ctx].join('\n');
    const segs = collapseDiff(diff, 2);
    // A collapsed segment exists (the long leading/trailing unchanged run)...
    expect(segs.some((s) => s.collapsed)).toBe(true);
    // ...and the change lines are always shown (never collapsed).
    const shown = segs.filter((s) => !s.collapsed).flatMap((s) => s.lines);
    expect(shown).toContain('- old');
    expect(shown).toContain('+ new');
  });

  it('report renders a collapsible “unchanged lines” fold for a big customized diff', async () => {
    const snapshots = new Map<string, unknown>();
    const big: any = { id: 'P', name: 'old' };
    for (let i = 0; i < 20; i++) big[`f${i}`] = `v${i}`;
    snapshots.set(JSON.stringify(['pushers', 'P']), big);
    const events: TracerEvent[] = [
      {
        idOrKey: 'P',
        parentKey: 'pushers',
        operation: 'added',
        depth: 0,
        sourceFile: 'f',
        project: 'base',
        generation: 1,
        weight: 10,
      },
      {
        idOrKey: 'P',
        parentKey: 'pushers',
        operation: 'customized',
        depth: 0,
        sourceFile: 'g',
        project: 'THIS',
        generation: 0,
        weight: NaN,
      },
    ];
    const finalOutput = { pushers: [{ ...big, name: 'new' }] };
    const model = reconcile(
      events,
      [],
      finalOutput,
      [
        { project: 'base', generation: 1, weight: 10 },
        { project: 'THIS', generation: 0, weight: NaN },
      ],
      'demo',
      { snapshots },
    );
    const md = renderReport(model);
    expect(md).toMatch(/unchanged lines/);
  });
});

describe('CR round-3: status priority ordering (changes on top)', () => {
  it('provenance orders LOST, customized, removed, added, then inherited', async () => {
    const mk = (
      idOrKey: string,
      op: 'added' | 'customized',
      gen: number,
    ): TracerEvent[] => [
      {
        idOrKey,
        parentKey: 'pushers',
        operation: op,
        depth: 0,
        sourceFile: 'f',
        project: gen === 0 ? 'THIS' : 'anc',
        generation: gen,
        weight: gen === 0 ? NaN : 1,
      },
    ];
    // Build: an inherited (added by ancestor, unchanged), an added (gen0 new), a customized.
    const snapshots = new Map<string, unknown>();
    snapshots.set(JSON.stringify(['pushers', 'C']), { id: 'C', name: 'old' });
    const events: TracerEvent[] = [
      ...mk('INH', 'added', 1), // inherited (ancestor only)
      ...mk('ADD', 'added', 0), // added (this)
      // customized: added by ancestor + customized by this, with a real diff
      {
        idOrKey: 'C',
        parentKey: 'pushers',
        operation: 'added',
        depth: 0,
        sourceFile: 'f',
        project: 'anc',
        generation: 1,
        weight: 1,
      },
      {
        idOrKey: 'C',
        parentKey: 'pushers',
        operation: 'customized',
        depth: 0,
        sourceFile: 'g',
        project: 'THIS',
        generation: 0,
        weight: NaN,
      },
    ];
    const finalOutput = {
      pushers: [{ id: 'INH' }, { id: 'ADD' }, { id: 'C', name: 'new' }],
    };
    const model = reconcile(
      events,
      [],
      finalOutput,
      [
        { project: 'anc', generation: 1, weight: 1 },
        { project: 'THIS', generation: 0, weight: NaN },
      ],
      'demo',
      { snapshots },
    );
    const md = renderReport(model);
    // In the provenance table, customized 'C' row must appear before inherited 'INH'.
    const rowIdx = (id: string) => md.indexOf(`<code>${id}</code>`);
    expect(rowIdx('C')).toBeLessThan(rowIdx('ADD'));
    expect(rowIdx('ADD')).toBeLessThan(rowIdx('INH'));
  });
});

// ─── Code-review round-3 regression tests (BMad adversarial review) ──────────

describe('CR round-3: inherited component winner is the introducer, not THIS (P3)', () => {
  it('identically re-included component shows winner = ancestor, status inherited', async () => {
    const ev = (
      operation: 'added' | 'customized',
      generation: number,
      project: string,
    ): TracerEvent => ({
      idOrKey: 'P',
      parentKey: 'pushers',
      operation,
      depth: 0,
      sourceFile: 'f',
      project,
      generation,
      weight: generation === 0 ? NaN : 1,
    });
    // ancestor introduces P; THIS re-includes it IDENTICALLY (no snapshot diff).
    const model = reconcile(
      [ev('added', 1, 'base'), ev('customized', 0, 'THIS')],
      [],
      { pushers: [{ id: 'P', name: 'same' }] },
      [
        { project: 'base', generation: 1, weight: 1 },
        { project: 'THIS', generation: 0, weight: NaN },
      ],
      'demo',
    );
    const p = model.components.find((c) => c.idOrKey === 'P')!;
    expect(p.status).toBe('inherited');
    expect(p.winner).toBe('base'); // NOT 'THIS'
  });
});

describe('CR round-3: excluded renders "✂ excluded" per CAP-6 (P7)', () => {
  it('uses the spec token', async () => {
    const model = reconcile(
      [
        {
          idOrKey: 'X',
          parentKey: 'pushers',
          operation: 'excluded',
          depth: 0,
          sourceFile: 'f',
          project: 'THIS',
          generation: 0,
          weight: NaN,
        },
      ],
      [],
      { pushers: [{ id: 'OTHER' }] },
      [{ project: 'THIS', generation: 0, weight: NaN }],
      'demo',
    );
    const md = renderReport(model);
    expect(md).toContain('✂ excluded');
    expect(md).not.toContain('✂ removed');
  });
});

describe('CR round-3: wholesale overwrite that drops components is flagged (D1)', () => {
  it('populates wholesaleLosses + a top warning + a diff, only for hadComponents', async () => {
    const overwrites = [
      {
        parentKey: 'pushers',
        sourceFile: '/proj/partials/Clobber.yaml',
        oldValue: [
          { id: 'A', name: 'a' },
          { id: 'B', name: 'b' },
        ],
        newValue: ['scalar-config'],
        hadComponents: true,
        depth: 0,
      },
      {
        parentKey: 'indexGroups',
        sourceFile: '/proj/partials/Cfg.yaml',
        oldValue: ['x'],
        newValue: ['y'],
        hadComponents: false, // benign config array — must NOT be reported
        depth: 0,
      },
      {
        parentKey: 'headers',
        sourceFile: '/proj/partials/Nested.yaml',
        oldValue: [{ id: 'N', name: 'n' }],
        newValue: ['x'],
        hadComponents: true,
        depth: 2, // nested overwrite — NOT a top-level component loss
      },
    ];
    const model = reconcile([], [], {}, [], 'demo', {
      overwrites,
      reportDir: '/proj',
      relative: (from, to) => to.replace(from + '/', ''),
    });
    // only the depth-0 component-dropping overwrite (not benign, not nested)
    expect(model.wholesaleLosses).toHaveLength(1);
    expect(model.wholesaleLosses[0].droppedIds).toEqual(['A', 'B']);
    expect(model.wholesaleLosses[0].sourceLink).toBe('partials/Clobber.yaml');
    expect(
      model.warnings.some((w) =>
        w.includes('dropped by a wholesale array overwrite'),
      ),
    ).toBe(true);
    const md = renderReport(model);
    expect(md).toContain('Wholesale overwrites (dropped components)');
    expect(md).toMatch(/name: a/); // the old (dropped) content shows in the diff
  });

  it('a wholesale-dropped component is NOT double-reported as excluded or LOST (R2)', async () => {
    // A was introduced by an ancestor, then its whole `pushers` array was clobbered
    // wholesale (no per-component excluded event). It must appear ONLY in the
    // wholesale section — not as an excluded row and not as ⚠ LOST.
    const model = reconcile(
      [
        {
          idOrKey: 'A',
          parentKey: 'pushers',
          operation: 'added',
          depth: 0,
          sourceFile: 'anc',
          project: 'base',
          generation: 1,
          weight: 1,
        },
      ],
      [],
      { pushers: [{ id: 'KEPT' }] }, // A is absent (clobbered)
      [{ project: 'base', generation: 1, weight: 1 }],
      'demo',
      {
        overwrites: [
          {
            parentKey: 'pushers',
            sourceFile: '/p/Clobber.yaml',
            oldValue: [{ id: 'A' }],
            newValue: ['scalar'],
            hadComponents: true,
            depth: 0,
          },
        ],
      },
    );
    expect(model.counts.lost).toBe(0); // NOT flagged LOST
    expect(model.components.find((c) => c.idOrKey === 'A')).toBeUndefined(); // no row
    expect(model.wholesaleLosses[0].droppedIds).toContain('A'); // only in the section
  });
});

describe('Feature: metrics as object/task sub-components', () => {
  it('rolls metrics up to counts-only (added / removed / customized), no per-item table', async () => {
    const ev = (
      operation: 'added' | 'customized',
      generation: number,
      project: string,
    ): TracerEvent => ({
      idOrKey: 'O',
      parentKey: 'objects',
      operation,
      depth: 0,
      sourceFile: 'f',
      project,
      generation,
      weight: generation === 0 ? NaN : 1,
    });
    // ancestor object O has M1(v1), M2, M4; THIS changes M1→v2, drops M2, adds M3, keeps M4.
    const ancObj = {
      objects: [
        {
          id: 'O',
          metrics: [
            { id: 'M1', kind: 'COUNT', v: 1 },
            { id: 'M2', kind: 'REGEX' },
            { id: 'M4', kind: 'SUM', v: 9 },
          ],
        },
      ],
    };
    const finalOutput = {
      objects: [
        {
          id: 'O',
          metrics: [
            { id: 'M1', kind: 'COUNT', v: 2 },
            { id: 'M3', kind: 'AVG' },
            { id: 'M4', kind: 'SUM', v: 9 },
          ],
        },
      ],
    };
    const model = reconcile(
      [ev('added', 1, 'base'), ev('customized', 0, 'THIS')],
      [],
      finalOutput,
      [
        { project: 'base', generation: 1, weight: 1 },
        { project: 'THIS', generation: 0, weight: NaN },
      ],
      'demo',
      {
        projectCheckpoints: [
          { label: 'base', output: ancObj },
          { label: 'THIS', output: finalOutput },
        ],
      },
    );
    const o = model.components.find((c) => c.idOrKey === 'O')!;
    // metrics are a rollup (counts-only): M1 customized, M2 removed, M3 added, M4 inherited.
    expect(o.subTable).toBeUndefined();
    expect(o.subComponents).toEqual([
      { title: 'metrics', added: 1, removed: 1, customized: 1 },
    ]);
    // parent promoted to customized by the metric changes alone.
    expect(o.status).toBe('customized');
    // renders a compact rollup line, NOT a per-item metrics table.
    const md = renderReport(model);
    expect(md).not.toContain('<summary>metrics —');
    expect(md).toMatch(/metrics:.*1 customized/);
  });

  it('non-object components have no metrics sub-table', async () => {
    const model = reconcile(
      [
        {
          idOrKey: 'P',
          parentKey: 'pushers',
          operation: 'added',
          depth: 0,
          sourceFile: 'f',
          project: 'THIS',
          generation: 0,
          weight: NaN,
        },
      ],
      [],
      { pushers: [{ id: 'P' }] },
      [{ project: 'THIS', generation: 0, weight: NaN }],
      'demo',
      {
        projectCheckpoints: [
          { label: 'THIS', output: { pushers: [{ id: 'P' }] } },
        ],
      },
    );
    const p = model.components.find((c) => c.idOrKey === 'P')!;
    expect(p.subTable).toBeUndefined();
    expect(p.subComponents).toBeUndefined();
  });

  it('webhook targets reconcile as a sub-table with a pullSteps flow', async () => {
    const ev = (
      operation: 'added' | 'customized',
      generation: number,
      project: string,
    ): TracerEvent => ({
      idOrKey: 'W',
      parentKey: 'webhooks',
      operation,
      depth: 0,
      sourceFile: 'f',
      project,
      generation,
      weight: generation === 0 ? NaN : 1,
    });
    const ancWh = {
      webhooks: [
        {
          id: 'W',
          targets: {
            customer: {
              pullSteps: [{ key: 'A', name: 'Pull', next: null }],
            },
            order: { pullSteps: [] },
          },
        },
      ],
    };
    const finalOutput = {
      webhooks: [
        {
          id: 'W',
          targets: {
            customer: {
              pullSteps: [{ key: 'A', name: 'Pull v2', next: null }],
            }, // customized
            invoice: { pullSteps: [{ key: 'B', name: 'New', next: null }] }, // added by THIS
            // 'order' removed
          },
        },
      ],
    };
    const model = reconcile(
      [ev('added', 1, 'base'), ev('customized', 0, 'THIS')],
      [],
      finalOutput,
      [
        { project: 'base', generation: 1, weight: 1 },
        { project: 'THIS', generation: 0, weight: NaN },
      ],
      'demo',
      {
        projectCheckpoints: [
          { label: 'base', output: ancWh },
          { label: 'THIS', output: finalOutput },
        ],
      },
    );
    const w = model.components.find((c) => c.idOrKey === 'W')!;
    expect(w.subTable?.title).toBe('targets');
    const byKey = Object.fromEntries(
      (w.subTable?.items ?? []).map((t) => [t.idOrKey, t]),
    );
    expect(byKey['customer'].status).toBe('customized');
    expect(byKey['customer'].flow?.kind).toBe('puller'); // pullSteps → flow
    expect(byKey['invoice'].status).toBe('added');
    expect(byKey['order'].status).toBe('excluded'); // removed
    const html = renderReportHtml(model);
    expect(html).toContain('<strong class="group-type">targets</strong>');
    expect(html).toContain('puller flow —'); // target pullSteps chart
  });

  it('top-level map-of-arrays (transformations) reconciles as a group of rows', async () => {
    const ev = (
      idOrKey: string,
      operation: 'added',
      generation: number,
    ): TracerEvent => ({
      idOrKey,
      parentKey: 'pushers',
      operation,
      depth: 0,
      sourceFile: 'f',
      project: generation === 0 ? 'THIS' : 'base',
      generation,
      weight: generation === 0 ? NaN : 1,
    });
    const ancT = {
      pushers: [{ id: 'P' }],
      transformations: { T1: [{ id: 'I1', v: 1 }] },
    };
    const finalOutput = {
      pushers: [{ id: 'P' }],
      transformations: {
        T1: [{ id: 'I1', v: 2 }], // customized item
        T2: [{ id: 'I9' }], // added entry (THIS)
      },
    };
    const model = reconcile(
      [ev('P', 'added', 1)],
      [],
      finalOutput,
      [
        { project: 'base', generation: 1, weight: 1 },
        { project: 'THIS', generation: 0, weight: NaN },
      ],
      'demo',
      {
        projectCheckpoints: [
          { label: 'base', output: ancT },
          { label: 'THIS', output: finalOutput },
        ],
      },
    );
    const rows = model.components.filter(
      (c) => c.parentKey === 'transformations',
    );
    const byKey = Object.fromEntries(rows.map((r) => [r.idOrKey, r]));
    expect(byKey['T1'].status).toBe('customized');
    expect(byKey['T1'].subTable?.items[0].idOrKey).toBe('I1'); // nested item reconciled
    expect(byKey['T2'].status).toBe('added');
  });
});