accounted/lib/transactions/__tests__/ingest.test.ts

/**
 * Tests for the generic transaction ingestion pipeline.
 *
 * Covers deduplication, insert, invoice matching, auto-categorization,
 * and result aggregation.
 */
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { ingestTransactions } from '../ingest'
import type { RawTransaction } from '@/types'
import { makeJournalEntry, makeTransaction } from '@/tests/helpers'

// ---------------------------------------------------------------------------
// Mocks
// ---------------------------------------------------------------------------

const mockEvaluateMappingRules = vi.fn()
vi.mock('@/lib/bookkeeping/mapping-engine', () => ({
  evaluateMappingRules: (...args: unknown[]) => mockEvaluateMappingRules(...args),
}))

const mockCreateTransactionJournalEntry = vi.fn()
vi.mock('@/lib/bookkeeping/transaction-entries', () => ({
  createTransactionJournalEntry: (...args: unknown[]) =>
    mockCreateTransactionJournalEntry(...args),
}))

const mockGetBestInvoiceMatch = vi.fn()
vi.mock('@/lib/invoices/invoice-matching', () => ({
  getBestInvoiceMatch: (...args: unknown[]) => mockGetBestInvoiceMatch(...args),
}))

const mockFetchExchangeRate = vi.fn()
vi.mock('@/lib/currency/riksbanken', () => ({
  fetchExchangeRate: (...args: unknown[]) => mockFetchExchangeRate(...args),
}))

// Mocked so the open-begäran pool consumes no slot in the queued Supabase
// mock: every existing test enqueues results in the pre-fetch order.
const mockLoadOpenRotRutPayoutRequests = vi.fn()
vi.mock('@/lib/invoices/rot-rut-payout-candidates', () => ({
  loadOpenRotRutPayoutRequests: (...args: unknown[]) => mockLoadOpenRotRutPayoutRequests(...args),
}))
// Default: no open begäran. vi.clearAllMocks keeps implementations, so this
// survives beforeEach; tests that need a pool override it.
mockLoadOpenRotRutPayoutRequests.mockResolvedValue([])

// ---------------------------------------------------------------------------
// Queue-based Supabase mock
// ---------------------------------------------------------------------------

function createQueueMockSupabase() {
  const resultQueue: { data: unknown; error: unknown }[] = []
  // Captures .insert() payloads keyed by table, so tests can assert what was
  // written (e.g. cash_account_id stamping).
  const inserts: Record<string, unknown[]> = {}
  // Same for .update() payloads (e.g. supplier-invoice suggestion linking).
  const updates: Record<string, unknown[]> = {}

  /**
   * Push one or more results onto the queue.
   * Each awaited Supabase chain pops the next result in FIFO order.
   */
  const enqueue = (...results: { data?: unknown; error?: unknown }[]) => {
    for (const r of results) {
      resultQueue.push({ data: r.data ?? null, error: r.error ?? null })
    }
  }

  const buildChain = (table: string): unknown => {
    const handler: ProxyHandler<object> = {
      get(_target, prop) {
        if (prop === 'then') {
          // The legal form is resolved from `companies` (never defaulted) before
          // mapping rules run; it is not part of the per-test queue.
          const next =
            table === 'companies'
              ? { data: { entity_type: 'aktiebolag' }, error: null }
              : resultQueue.shift() ?? { data: null, error: null }
          return (resolve: (v: unknown) => void) => resolve(next)
        }
        if (prop === 'insert') {
          return (payload: unknown) => {
            ;(inserts[table] ??= []).push(payload)
            return buildChain(table)
          }
        }
        if (prop === 'update') {
          return (payload: unknown) => {
            ;(updates[table] ??= []).push(payload)
            return buildChain(table)
          }
        }
        return (..._args: unknown[]) => buildChain(table)
      },
    }
    return new Proxy({}, handler)
  }

  const supabase = {
    from: vi.fn().mockImplementation((table: string) => buildChain(table)),
    rpc: vi.fn().mockImplementation(() => buildChain('rpc')),
  }

  return { supabase, enqueue, inserts, updates }
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

const USER_ID = 'user-1'
const COMPANY_ID = 'company-1'

function makeRaw(overrides: Partial<RawTransaction> = {}): RawTransaction {
  return {
    date: '2024-06-15',
    description: 'Test transaction',
    amount: -250.0,
    currency: 'SEK',
    external_id: `ext-${Math.random().toString(36).slice(2, 8)}`,
    mcc_code: null,
    merchant_name: null,
    reference: null,
    bank_connection_id: null,
    import_source: 'test',
    ...overrides,
  }
}

function makeMappingResult(overrides: Record<string, unknown> = {}) {
  return {
    rule: null,
    debit_account: '5410',
    credit_account: '1930',
    risk_level: 'low',
    confidence: 0.9,
    requires_review: false,
    default_private: false,
    vat_lines: [],
    description: 'Office supplies',
    ...overrides,
  }
}

// ---------------------------------------------------------------------------
// Tests
//
// Queue order after batch dedup refactor:
// 1. Booked transaction map query (paginated via fetchAllRows: one queue entry
//    per page; a page under 1000 rows ends the loop, so the common one-entry
//    enqueue is unchanged)
// 1b. Unbooked bank-synced transaction map query (same pagination)
// 2. Supplier invoices fetch
// 3. Batch external_id dedup query (returns matching external_ids)
// 4. Per-transaction: insert, updates, etc.
// ---------------------------------------------------------------------------

describe('ingestTransactions', () => {
  beforeEach(() => {
    vi.clearAllMocks()
  })

  // -----------------------------------------------------------------------
  // 1. Successfully imports new transactions
  // -----------------------------------------------------------------------
  it('imports new transactions when no duplicate exists', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -100 })
    const inserted = makeTransaction({ id: 'tx-1', external_id: raw.external_id })

    // Booked transaction map query (no booked transactions)
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch (no unpaid invoices)
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    // Insert returns the new transaction
    enqueue({ data: inserted, error: null })
    // evaluateMappingRules will be called but we want low confidence
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
    expect(result.errors).toBe(0)
    expect(result.transaction_ids).toEqual(['tx-1'])
  })

  // -----------------------------------------------------------------------
  // 1c. Stamps cash_account_id from the settlement account
  // -----------------------------------------------------------------------
  it('stamps cash_account_id on the insert when settlementAccount resolves', async () => {
    const { supabase, enqueue, inserts } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -100 })
    const inserted = makeTransaction({ id: 'tx-1', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: { id: 'ca-1931' }, error: null }) // cash_accounts lookup
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw], {
      settlementAccount: '1931',
    })

    expect(result.imported).toBe(1)
    expect(supabase.from).toHaveBeenCalledWith('cash_accounts')
    const txInserts = inserts['transactions'] ?? []
    expect(txInserts).toHaveLength(1)
    expect((txInserts[0] as { cash_account_id?: string | null }).cash_account_id).toBe('ca-1931')
  })

  it('inserts cash_account_id null when no settlementAccount is given', async () => {
    const { supabase, enqueue, inserts } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -100 })
    const inserted = makeTransaction({ id: 'tx-1', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    // No cash_accounts lookup: settlementAccount omitted.
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(supabase.from).not.toHaveBeenCalledWith('cash_accounts')
    const txInserts = inserts['transactions'] ?? []
    expect((txInserts[0] as { cash_account_id?: string | null }).cash_account_id).toBeNull()
  })

  // -----------------------------------------------------------------------
  // 1c2. Stamps bank_file_import_id from the batch option
  // -----------------------------------------------------------------------
  it('stamps bank_file_import_id on the insert when bankFileImportId is given', async () => {
    const { supabase, enqueue, inserts } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -100 })
    const inserted = makeTransaction({ id: 'tx-1', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw], {
      bankFileImportId: 'import-1',
    })

    expect(result.imported).toBe(1)
    const txInserts = inserts['transactions'] ?? []
    expect(txInserts).toHaveLength(1)
    expect(
      (txInserts[0] as { bank_file_import_id?: string | null }).bank_file_import_id,
    ).toBe('import-1')
  })

  it('inserts bank_file_import_id null when no batch id is given (PSD2/MCP paths)', async () => {
    const { supabase, enqueue, inserts } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -100 })
    const inserted = makeTransaction({ id: 'tx-1', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    const txInserts = inserts['transactions'] ?? []
    expect(
      (txInserts[0] as { bank_file_import_id?: string | null }).bank_file_import_id,
    ).toBeNull()
  })

  // -----------------------------------------------------------------------
  // 1d. Transaction-method classification at the insert boundary
  // -----------------------------------------------------------------------
  it('classifies transaction_method, strips the channel phrase from the title, and persists the raw codes', async () => {
    const { supabase, enqueue, inserts } = createQueueMockSupabase()
    const raw = makeRaw({
      description: 'Vercel Jul Överföring via internet',
      bank_transaction_code: 'PMNT/ICDT',
      proprietary_bank_transaction_code: 'Överföring',
    })
    const inserted = makeTransaction({ id: 'tx-1', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    const payload = (inserts['transactions'] ?? [])[0] as Record<string, unknown>
    // Working title is the clean prefix; the immutable original keeps the
    // full bank string (dedup-bridge + restore-original source).
    expect(payload.description).toBe('Vercel Jul')
    expect(payload.original_description).toBe('Vercel Jul Överföring via internet')
    // The phrase beats the generic ISO family (ICDT = credit transfer).
    expect(payload.transaction_method).toBe('transfer')
    expect(payload.bank_transaction_code).toBe('PMNT/ICDT')
    expect(payload.proprietary_bank_transaction_code).toBe('Överföring')
  })

  it('treats a bank_connection_id row as a feed even without import_source', async () => {
    // The oldest PSD2 rows predate the import_source column; a live bank
    // connection is the unambiguous feed marker (isImportedTransaction).
    const { supabase, enqueue, inserts } = createQueueMockSupabase()
    const raw = makeRaw({
      description: 'Vercel Jul Överföring via internet',
      import_source: undefined,
      bank_connection_id: 'bc-1',
    })
    const inserted = makeTransaction({ id: 'tx-1', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    const feedPayload = (inserts['transactions'] ?? [])[0] as Record<string, unknown>
    expect(feedPayload.transaction_method).toBe('transfer')
    expect(feedPayload.description).toBe('Vercel Jul')
    expect(feedPayload.original_description).toBe('Vercel Jul Överföring via internet')
  })

  it('never classifies or strips user-created sources (manual/mcp)', async () => {
    const { supabase, enqueue, inserts } = createQueueMockSupabase()
    // A user-authored title that WOULD classify+strip if it came from a feed.
    const raw = makeRaw({ description: 'Egen insättning', import_source: 'manual' })
    const inserted = makeTransaction({ id: 'tx-1', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    const payload = (inserts['transactions'] ?? [])[0] as Record<string, unknown>
    expect(payload.description).toBe('Egen insättning')
    expect(payload.original_description).toBe('Egen insättning')
    expect(payload.transaction_method).toBeNull()
  })

  it('leaves the title untouched and method null when nothing classifies', async () => {
    const { supabase, enqueue, inserts } = createQueueMockSupabase()
    const raw = makeRaw({ description: 'Test transaction' })
    const inserted = makeTransaction({ id: 'tx-1', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    const payload = (inserts['transactions'] ?? [])[0] as Record<string, unknown>
    expect(payload.description).toBe('Test transaction')
    expect(payload.original_description).toBe('Test transaction')
    expect(payload.transaction_method).toBeNull()
    expect(payload.bank_transaction_code).toBeNull()
    expect(payload.proprietary_bank_transaction_code).toBeNull()
  })

  // -----------------------------------------------------------------------
  // 2. Detects duplicates
  // -----------------------------------------------------------------------
  it('detects duplicates via external_id', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw()

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: returns matching external_id
    enqueue({ data: [{ external_id: raw.external_id }], error: null })

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
    expect(result.transaction_ids).toEqual([])
  })

  // -----------------------------------------------------------------------
  // 2b. CSV row dedupes against uncategorized enable_banking row when
  //     date+amount+description prefix match (Lunar CSV vs Lunar PSD2 case).
  // -----------------------------------------------------------------------
  it('dedupes CSV row against unbooked enable_banking row with matching description', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2024-06-15',
      amount: -250.0,
      description: 'ICA Maxi Solna',
      external_id: 'lunar_csvhash123',
      import_source: 'csv_lunar',
    })

    // Booked transaction map query: none
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query: one PSD2 row with matching content
    enqueue({
      data: [{ date: '2024-06-15', amount: -250.0, description: 'ICA Maxi Solna' }],
      error: null,
    })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: external_id differs, so no match
    enqueue({ data: [], error: null })
    // No insert expected: row should be deduplicated at content layer

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
    expect(result.transaction_ids).toEqual([])
  })

  // -----------------------------------------------------------------------
  // 2b-page. Pagination regression: buildExistingTransactionMaps paginates
  //     via fetchAllRows, so a stored twin BEYOND the 1000-row PostgREST page
  //     still lands in the dedup map. The old un-paginated select silently
  //     truncated at 1000 rows, and a re-import over a wide date range in an
  //     active company inserted everything past the cap as duplicates.
  // -----------------------------------------------------------------------
  it('dedupes against a stored twin served on the second page (>1000 stored rows)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2024-06-15',
      amount: -250.0,
      description: 'ICA Maxi Solna',
      external_id: 'lunar_csvhash_page2',
      import_source: 'csv_lunar',
    })

    // Booked map page 1: exactly 1000 filler rows in OTHER (date, öre)
    // buckets. A full page forces fetchAllRows to request page 2.
    const filler = Array.from({ length: 1000 }, (_, i) => ({
      date: '2024-06-01',
      amount: -(i + 1),
      original_description: `Filler ${i}`,
      description: `Filler ${i}`,
      import_source: 'csv_lunar',
    }))
    enqueue({ data: filler, error: null })
    // Booked map page 2: the twin the old un-paginated query dropped.
    enqueue({
      data: [{ date: '2024-06-15', amount: -250.0, original_description: 'ICA Maxi Solna', description: 'ICA Maxi Solna', import_source: 'csv_lunar' }],
      error: null,
    })
    // Unbooked map
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: no match
    enqueue({ data: [], error: null })
    // No insert expected: deduped by the text bridge against the page-2 twin.

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  // -----------------------------------------------------------------------
  // 2b-edit. Edit-safety regression: a user-edited stored title must NOT
  //     reopen the duplicate-import window. The content bridge keys off the
  //     immutable original_description, so a re-import whose bank text still
  //     matches the original is deduped even though the stored (editable)
  //     description was changed.
  // -----------------------------------------------------------------------
  it('dedupes against the original bank description even after the stored title was edited', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2024-06-15',
      amount: -250.0,
      description: 'ICA Maxi Solna', // original bank text, re-imported via CSV
      external_id: 'lunar_csvhash999', // different external_id → primary dedup misses
      import_source: 'csv_lunar',
    })

    // Booked transaction map query: none
    enqueue({ data: [], error: null })
    // Unbooked bank-synced row whose TITLE was edited by the user, but whose
    // original_description still holds the bank's verbatim text.
    enqueue({
      data: [
        {
          date: '2024-06-15',
          amount: -250.0,
          original_description: 'ICA Maxi Solna',
          description: 'Mataffär (egen rubrik)',
        },
      ],
      error: null,
    })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: external_id differs, so no match
    enqueue({ data: [], error: null })

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  // -----------------------------------------------------------------------
  // 2b-unknown. Legacy 'Unknown'/empty rows must still dedup: the stored-side
  //     content key is normalized the same way as the incoming side, so an
  //     existing row whose original_description is the legacy 'Unknown'
  //     sentinel matches an incoming 'Unknown' re-import (both → 'Okänd
  //     transaktion'). Without symmetric normalization this row would
  //     re-import as a duplicate.
  // -----------------------------------------------------------------------
  it('dedupes legacy "Unknown" rows by normalizing both the stored and incoming keys', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2024-06-15',
      amount: -250.0,
      description: 'Unknown', // legacy English sentinel re-imported via CSV
      external_id: 'lunar_csvhashU',
      import_source: 'csv_lunar',
    })

    // Booked transaction map query: none
    enqueue({ data: [], error: null })
    // Unbooked bank-synced row whose original_description is the legacy sentinel.
    enqueue({
      data: [{ date: '2024-06-15', amount: -250.0, original_description: 'Unknown', description: 'Unknown' }],
      error: null,
    })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: external_id differs, so no match
    enqueue({ data: [], error: null })

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  // -----------------------------------------------------------------------
  // 2c. No false positive within ONE channel: same date+amount but a different
  //     description does NOT dedupe when the stored row is from the SAME feed
  //     (a re-import that legitimately holds two distinct same-(date,amount)
  //     transactions). Only a cross-channel mirror (2c-bis) drops the
  //     description requirement.
  // -----------------------------------------------------------------------
  it('does not dedupe a same-channel row when the description differs', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2024-06-15',
      amount: -250.0,
      description: 'Coop Stockholm',
      external_id: 'csv_lunar_456',
      import_source: 'csv_lunar',
    })
    const inserted = makeTransaction({
      id: 'tx-no-collision',
      external_id: raw.external_id,
      amount: -250.0,
    })

    // Booked transaction map query: none
    enqueue({ data: [], error: null })
    // Unbooked row from the SAME feed (csv_lunar), same date/amount, DIFFERENT
    // description → not a cross-channel mirror → must NOT dedupe.
    enqueue({
      data: [{ date: '2024-06-15', amount: -250.0, original_description: 'ICA Maxi Solna', description: 'ICA Maxi Solna', import_source: 'csv_lunar' }],
      error: null,
    })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: no match
    enqueue({ data: [], error: null })
    // Insert succeeds: the new row is not a duplicate
    enqueue({ data: inserted, error: null })

    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
    expect(result.transaction_ids).toEqual(['tx-no-collision'])
  })

  // -----------------------------------------------------------------------
  // 2c-bis. Cross-channel mirror: the SAME bank account imported via two feeds
  //     (Nordea CSV payee text vs PSD2 OCR/message): same date+amount, one row
  //     per channel, descriptions that do NOT bridge: IS deduped on
  //     (date, öre). The real-world trigger: a CSV import landing on top of
  //     existing Enable Banking rows whose descriptions share no text.
  // -----------------------------------------------------------------------
  it('dedupes a cross-channel mirror (CSV vs PSD2) even when descriptions do not bridge', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2025-10-23',
      amount: -941,
      description: 'Fortnox Finans AB', // Nordea CSV payee
      external_id: 'nordea_business_abc123',
      import_source: 'csv_nordea_business',
    })

    // Booked transaction map query: none
    enqueue({ data: [], error: null })
    // Stored unbooked PSD2 row: same date+amount, DIFFERENT text (the OCR), from
    // a DIFFERENT feed (enable_banking).
    enqueue({
      data: [{ date: '2025-10-23', amount: -941, original_description: '506401841738056', description: '506401841738056', import_source: 'enable_banking' }],
      error: null,
    })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: different namespace, no match
    enqueue({ data: [], error: null })
    // No insert: deduped by the cross-channel mirror.

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  // -----------------------------------------------------------------------
  // 2c-ter. Cross-channel but NOT a mirror (counts differ) → ambiguous, so the
  //     description requirement stands and nothing is dropped. Two incoming CSV
  //     rows + one stored PSD2 row with no bridging text → both incoming kept.
  //     Guards the rare case where the two feeds disagree on how many
  //     transactions a (date, öre) bucket holds: prefer a visible (deletable)
  //     duplicate over silently collapsing a genuinely-new row.
  // -----------------------------------------------------------------------
  it('does not text-independently dedupe an asymmetric cross-channel bucket', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const rows = [
      makeRaw({ date: '2025-10-23', amount: -500, description: 'Betalning A', external_id: 'nordea_business_a', import_source: 'csv_nordea_business' }),
      makeRaw({ date: '2025-10-23', amount: -500, description: 'Betalning B', external_id: 'nordea_business_b', import_source: 'csv_nordea_business' }),
    ]

    // Booked transaction map query: none
    enqueue({ data: [], error: null })
    // Only ONE stored PSD2 row (different text) → incoming 2 vs cross 1 = asymmetric.
    enqueue({
      data: [{ date: '2025-10-23', amount: -500, original_description: 'A107 RAMBER', description: 'A107 RAMBER', import_source: 'enable_banking' }],
      error: null,
    })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: no match
    enqueue({ data: [], error: null })
    enqueue({ data: makeTransaction({ id: 'tx-a', amount: -500 }), error: null })
    enqueue({ data: makeTransaction({ id: 'tx-b', amount: -500 }), error: null })

    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, rows)

    expect(result.imported).toBe(2)
    expect(result.duplicates).toBe(0)
  })

  // -----------------------------------------------------------------------
  // 2c-quater. The cross-channel mirror is still subject to the account guard:
  //     a mirror match on a DIFFERENT known cash account is rejected, so a
  //     multi-account company never collapses a transaction across accounts.
  // -----------------------------------------------------------------------
  it('respects the cash-account guard on the cross-channel mirror path', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2025-10-23',
      amount: -941,
      description: 'Fortnox Finans AB',
      external_id: 'nordea_business_xyz',
      import_source: 'csv_nordea_business',
    })
    const inserted = makeTransaction({ id: 'tx-acctB', amount: -941 })

    // Booked transaction map query: none
    enqueue({ data: [], error: null })
    // Stored cross-feed twin, but it settled on a DIFFERENT account (A).
    enqueue({
      data: [{ date: '2025-10-23', amount: -941, original_description: '506401841738056', description: '506401841738056', import_source: 'enable_banking', cash_account_id: 'acct-A' }],
      error: null,
    })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: no match
    enqueue({ data: [], error: null })
    // cash_accounts lookup → batch settled on account B
    enqueue({ data: { id: 'acct-B' }, error: null })
    // Insert: different account, not a duplicate
    enqueue({ data: inserted, error: null })

    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw], {
      settlementAccount: '1931',
    })

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
  })

  // -----------------------------------------------------------------------
  // 2c-currency. The content bucket keys on (date, öre) with NO currency, so a
  //     250,00 EUR row and a 250,00 SEK row on the same date share a bucket.
  //     Every match path (text bridge, cross-channel mirror, hand mirror) must
  //     refuse to consume across currencies: the swallowed row is a real
  //     affärshändelse that would never be bokförd, and only the aggregate
  //     duplicate count would hint that anything vanished.
  // -----------------------------------------------------------------------
  it('does not text-bridge-dedupe across currencies (250 EUR vs stored 250 SEK, identical titles)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // Same feed on both sides, so the cross-channel mirror cannot fire: this
    // isolates the description-bridge path, where the titles match EXACTLY.
    const raw = makeRaw({
      date: '2026-07-13',
      amount: -250.0,
      currency: 'EUR',
      description: 'STRIPE PAYMENT',
      external_id: 'eb_EU00_2026-07-13_-25000_0',
      import_source: 'enable_banking',
    })
    const inserted = makeTransaction({ id: 'tx-eur', external_id: raw.external_id, amount: -250.0 })

    enqueue({ data: [], error: null }) // booked map
    enqueue({
      data: [{
        date: '2026-07-13', amount: -250.0,
        original_description: 'STRIPE PAYMENT', description: 'STRIPE PAYMENT',
        import_source: 'enable_banking', currency: 'SEK',
      }],
      error: null,
    }) // unbooked map: same title, same date, same öre, DIFFERENT currency
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert: kept
    mockFetchExchangeRate.mockResolvedValue(null)
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
    expect(result.transaction_ids).toEqual(['tx-eur'])
  })

  it('does not cross-channel-mirror-dedupe across currencies (CSV EUR vs stored PSD2 SEK)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // Non-bridging titles + a count-symmetric bucket = the mirror WOULD fire on
    // (date, öre) alone. The currency mismatch must keep it off.
    const raw = makeRaw({
      date: '2026-07-13',
      amount: -941,
      currency: 'EUR',
      description: 'Fortnox Finans AB',
      external_id: 'nordea_business_eur1',
      import_source: 'csv_nordea_business',
    })
    const inserted = makeTransaction({ id: 'tx-eur-mirror', external_id: raw.external_id, amount: -941 })

    enqueue({ data: [], error: null }) // booked map
    enqueue({
      data: [{
        date: '2026-07-13', amount: -941,
        original_description: '506401841738056', description: '506401841738056',
        import_source: 'enable_banking', currency: 'SEK',
      }],
      error: null,
    }) // unbooked map: cross-feed twin by (date, öre), but in SEK
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert: kept
    mockFetchExchangeRate.mockResolvedValue(null)
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
  })

  it('still dedupes a genuine same-currency re-import (control for the currency guard)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // Byte-identical to the text-bridge test above except the incoming currency
    // matches the stored one: the guard must change nothing here.
    const raw = makeRaw({
      date: '2026-07-13',
      amount: -250.0,
      currency: 'SEK',
      description: 'STRIPE PAYMENT',
      external_id: 'eb_SE00_2026-07-13_-25000_0',
      import_source: 'enable_banking',
    })

    enqueue({ data: [], error: null }) // booked map
    enqueue({
      data: [{
        date: '2026-07-13', amount: -250.0,
        original_description: 'STRIPE PAYMENT', description: 'STRIPE PAYMENT',
        import_source: 'enable_banking', currency: 'SEK',
      }],
      error: null,
    }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    // No insert: deduped by the text bridge, exactly as before the guard.

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  it('still dedupes against a stored row that carries no currency (legacy rows unchanged)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // A null currency on either side carries no contradiction, so it must stay
    // bridge-allowed: rows predating the currency column dedup as they always
    // did, even against a foreign-currency import.
    const raw = makeRaw({
      date: '2026-07-13',
      amount: -250.0,
      currency: 'EUR',
      description: 'STRIPE PAYMENT',
      external_id: 'eb_EU00_2026-07-13_-25000_9',
      import_source: 'enable_banking',
    })

    enqueue({ data: [], error: null }) // booked map
    enqueue({
      data: [{
        date: '2026-07-13', amount: -250.0,
        original_description: 'STRIPE PAYMENT', description: 'STRIPE PAYMENT',
        import_source: 'enable_banking', currency: null,
      }],
      error: null,
    }) // unbooked map: legacy row, currency unknown
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    mockFetchExchangeRate.mockResolvedValue(null)

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  // -----------------------------------------------------------------------
  // 2c-hand. Booked-hand-entered mirror: the user bookkeeps by chat/MCP FIRST
  //     (free-form Swedish title, booked), then connects the bank; the feed
  //     delivers the bank's copy of the same movement with a raw provider
  //     string that shares no text. Same (date, öre), count-symmetric bucket
  //     → deduped against the BOOKED hand-entered row.
  // -----------------------------------------------------------------------
  it('dedupes an incoming feed row against a booked hand-entered (mcp) twin whose title does not bridge', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2026-06-24',
      amount: -520,
      description: 'PLAN_ORDER_CHECKOUT-invoice-11111 Account fee', // raw provider text
      external_id: 'eb_SE00_2026-06-24_-52000_0',
      import_source: 'enable_banking',
    })

    // Booked map: the hand-entered MCP row the user already booked.
    enqueue({
      data: [{
        date: '2026-06-24', amount: -520,
        original_description: 'Wise Business engångsavgift kontoöppning',
        description: 'Wise Business engångsavgift kontoöppning',
        import_source: 'mcp', bank_connection_id: null,
        cash_account_id: null, currency: 'SEK',
      }],
      error: null,
    })
    enqueue({ data: [], error: null }) // unbooked map: none
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup: different namespace, no match
    // No insert: deduped by the booked-hand-entered mirror.

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  it('never consumes an UNBOOKED hand-entered row (staged intent is not ledger evidence)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2026-06-24',
      amount: -520,
      description: 'PLAN_ORDER_CHECKOUT-invoice-11111 Account fee',
      external_id: 'eb_SE00_2026-06-24_-52000_0',
      import_source: 'enable_banking',
    })
    const inserted = makeTransaction({ id: 'tx-kept', external_id: raw.external_id, amount: -520 })

    enqueue({ data: [], error: null }) // booked map: none
    // Unbooked map: even if an mcp row leaked in here, it must not be a mirror
    // candidate (in production the query excludes manual/mcp at the DB level).
    enqueue({
      data: [{
        date: '2026-06-24', amount: -520,
        original_description: 'Wise Business engångsavgift kontoöppning',
        description: 'Wise Business engångsavgift kontoöppning',
        import_source: 'mcp', bank_connection_id: null,
        cash_account_id: null, currency: 'SEK',
      }],
      error: null,
    })
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert: NOT deduped
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
  })

  it('does not hand-entered-dedupe an asymmetric bucket (two incoming vs one booked mcp row)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const rows = [
      makeRaw({ date: '2026-06-24', amount: -520, description: 'TRANSFER-1 Payment', external_id: 'eb_a', import_source: 'enable_banking' }),
      makeRaw({ date: '2026-06-24', amount: -520, description: 'TRANSFER-2 Payment', external_id: 'eb_b', import_source: 'enable_banking' }),
    ]

    // Booked map: ONE hand-entered row → incoming 2 vs stored 1 = asymmetric.
    enqueue({
      data: [{
        date: '2026-06-24', amount: -520,
        original_description: 'Betalning till leverantör',
        description: 'Betalning till leverantör',
        import_source: 'mcp', bank_connection_id: null,
        cash_account_id: null, currency: 'SEK',
      }],
      error: null,
    })
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: makeTransaction({ id: 'tx-a', amount: -520 }), error: null })
    enqueue({ data: makeTransaction({ id: 'tx-b', amount: -520 }), error: null })
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, rows)

    expect(result.imported).toBe(2)
    expect(result.duplicates).toBe(0)
  })

  it('does not hand-entered-dedupe across currencies (SEK manual row vs USD feed row)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // Numerically equal amounts land in the same (date, öre) bucket, but the
    // currencies differ → the mirror must stay off.
    const raw = makeRaw({
      date: '2026-07-13',
      amount: 2500,
      currency: 'USD',
      description: 'TRANSFER-9 Facilitation',
      external_id: 'eb_US00_2026-07-13_250000_0',
      import_source: 'enable_banking',
    })
    const inserted = makeTransaction({ id: 'tx-usd', external_id: raw.external_id, amount: 2500 })

    enqueue({
      data: [{
        date: '2026-07-13', amount: 2500,
        original_description: 'Kundinbetalning bankgiro',
        description: 'Kundinbetalning bankgiro',
        import_source: 'mcp', bank_connection_id: null,
        cash_account_id: null, currency: 'SEK',
      }],
      error: null,
    }) // booked map: SEK hand-entered row, same date+öre
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert: kept
    mockFetchExchangeRate.mockResolvedValue(null)
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
    expect(mockGetBestInvoiceMatch).toHaveBeenCalled() // income path still runs
  })

  it('respects the cash-account guard on the booked-hand-entered mirror path', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2026-06-24',
      amount: -520,
      description: 'TRANSFER-5 Payment',
      external_id: 'eb_acctB_2026-06-24_-52000_0',
      import_source: 'enable_banking',
    })
    const inserted = makeTransaction({ id: 'tx-acctB', amount: -520 })

    // Booked hand-entered row explicitly bound to a DIFFERENT cash account.
    enqueue({
      data: [{
        date: '2026-06-24', amount: -520,
        original_description: 'Egen insättning',
        description: 'Egen insättning',
        import_source: 'mcp', bank_connection_id: null,
        cash_account_id: 'acct-A', currency: 'SEK',
      }],
      error: null,
    })
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: { id: 'acct-B' }, error: null }) // cash_accounts → batch on account B
    enqueue({ data: inserted, error: null }) // insert: kept
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw], {
      settlementAccount: '1931',
    })

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
  })

  it('stamps the batch cash account onto a consumed null-account hand row (one-consume-ever adoption)', async () => {
    const { supabase, enqueue, updates } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2026-06-24',
      amount: -520,
      description: 'TRANSFER-5 Payment', // does not bridge the hand row's title
      external_id: 'eb_acctA_2026-06-24_-52000_0',
      import_source: 'enable_banking',
    })

    // Booked MANUAL row, account-unbound (cash_account_id null).
    enqueue({
      data: [{
        id: 'tx-hand-1',
        date: '2026-06-24', amount: -520,
        original_description: 'Egen insättning',
        description: 'Egen insättning',
        import_source: 'manual', bank_connection_id: null,
        cash_account_id: null, currency: 'SEK',
      }],
      error: null,
    })
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: { id: 'acct-A' }, error: null }) // cash_accounts → batch on account A
    enqueue({ data: null, error: null }) // adoption stamp update

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw], {
      settlementAccount: '1930',
    })

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
    // The hand row is now bound to account A, so it can never consume a feed
    // row on another account in a later sync.
    const txUpdates = (updates['transactions'] ?? []) as Record<string, unknown>[]
    expect(txUpdates).toContainEqual({ cash_account_id: 'acct-A' })
  })

  it('does not let a Layer-1 duplicate inflate the hand-mirror symmetry count', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // R0 is already stored (Layer-1 kills it); R1 is genuinely new. TWO booked
    // hand rows share the bucket. Coarse counting would say 2 incoming == 2
    // stored and consume a hand row for R1; the honest unmatched count is
    // 1 vs 2 → asymmetric → R1 must insert.
    const rows = [
      makeRaw({ date: '2026-06-24', amount: -520, description: 'TRANSFER-1 Pay', external_id: 'eb_stored_0', import_source: 'enable_banking' }),
      makeRaw({ date: '2026-06-24', amount: -520, description: 'TRANSFER-2 Pay', external_id: 'eb_new_1', import_source: 'enable_banking' }),
    ]
    const inserted = makeTransaction({ id: 'tx-new', amount: -520 })

    enqueue({
      data: [
        { id: 'h1', date: '2026-06-24', amount: -520, original_description: 'Hyra lokal', description: 'Hyra lokal', import_source: 'mcp', bank_connection_id: null, cash_account_id: null, currency: 'SEK' },
        { id: 'h2', date: '2026-06-24', amount: -520, original_description: 'Egen insättning', description: 'Egen insättning', import_source: 'mcp', bank_connection_id: null, cash_account_id: null, currency: 'SEK' },
      ],
      error: null,
    }) // booked map: two hand rows
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [{ external_id: 'eb_stored_0' }], error: null }) // external_id dedup: R0 already stored
    enqueue({ data: inserted, error: null }) // insert R1: kept
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, rows)

    expect(result.duplicates).toBe(1) // R0 via Layer-1 only
    expect(result.imported).toBe(1) // R1 inserted, no hand row consumed
  })

  it('excludes account-incompatible hand rows from the symmetry count (no mirror flip)', async () => {
    const { supabase, enqueue, updates } = createQueueMockSupabase()
    // Batch settles on account B. Stored: M1 (account-unbound) and M2 (bound to
    // account A). If M2 were counted, 2 incoming == 2 stored would switch the
    // mirror on and the non-bridging R1 would wrongly consume M1. With the
    // guard applied to the COUNT, symmetry is 2 vs 1 → mirror off → R1 inserts
    // and R2 dedups via its text bridge against M1.
    const rows = [
      makeRaw({ date: '2026-06-24', amount: -10000, description: 'TRANSFER-7 Pay', external_id: 'eb_r1', import_source: 'enable_banking' }),
      makeRaw({ date: '2026-06-24', amount: -10000, description: 'Hyra avtal 12 betalning juni', external_id: 'eb_r2', import_source: 'enable_banking' }),
    ]
    const inserted = makeTransaction({ id: 'tx-r1', amount: -10000 })

    enqueue({
      data: [
        { id: 'm1', date: '2026-06-24', amount: -10000, original_description: 'Hyra avtal 12', description: 'Hyra avtal 12', import_source: 'mcp', bank_connection_id: null, cash_account_id: null, currency: 'SEK' },
        { id: 'm2', date: '2026-06-24', amount: -10000, original_description: 'Hyra avtal 12', description: 'Hyra avtal 12', import_source: 'mcp', bank_connection_id: null, cash_account_id: 'acct-A', currency: 'SEK' },
      ],
      error: null,
    }) // booked map
    enqueue({ data: [], error: null }) // unbooked map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: { id: 'acct-B' }, error: null }) // cash_accounts → account B
    enqueue({ data: inserted, error: null }) // insert R1
    enqueue({ data: null, error: null }) // adoption stamp for M1 (text-bridged by R2)
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, rows, {
      settlementAccount: '1931',
    })

    expect(result.imported).toBe(1) // R1 kept (genuinely new)
    expect(result.duplicates).toBe(1) // R2 text-bridged M1
    // The text-bridge consumption also binds M1 to account B.
    const txUpdates = (updates['transactions'] ?? []) as Record<string, unknown>[]
    expect(txUpdates).toContainEqual({ cash_account_id: 'acct-B' })
  })

  // -----------------------------------------------------------------------
  // 2c-shadow. Same-feed scope-drift (Hole A): SHADOW MODE. Enable Banking
  //     returns the same account under a drifted IBAN, so the IBAN-embedded
  //     external_id is new (Layer-1 misses) and, because both rows are the SAME
  //     feed, the cross-channel mirror does not fire. The shadow detector
  //     MEASURES how often an enforcing rule would treat this as a re-import:   //     it logs/counts but NEVER changes what is inserted. These tests pin both
  //     that it detects the real case and, crucially, that it never flags a
  //     genuine row (the only failure mode that would matter).
  // -----------------------------------------------------------------------
  it('shadow-flags a same-feed scope-drift re-import but still imports it (no behavior change)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // Same account re-fetched under a drifted IBAN → new external_id, and a
    // description that shares no prefix with the stored row (so the text bridge
    // cannot catch it either: this is purely the scope-drift signal).
    const raw = makeRaw({
      date: '2024-06-15',
      amount: -250,
      description: 'TELENOR SVERIGE',
      external_id: 'eb_SE_NEW_2024-06-15_-25000_0',
      import_source: 'enable_banking',
      bank_connection_id: 'conn-1',
    })
    const inserted = makeTransaction({ id: 'tx-new', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked map: none
    // Unbooked map: the stored twin from the SAME feed under the OLD id scope.
    enqueue({
      data: [{
        date: '2024-06-15', amount: -250,
        original_description: 'LOAN PAYMENT 19', description: 'LOAN PAYMENT 19',
        import_source: 'enable_banking', bank_connection_id: 'conn-1',
        cash_account_id: 'ca-1930', external_id: 'eb_SE_OLD_2024-06-15_-25000_0',
      }],
      error: null,
    })
    enqueue({ data: [], error: null }) // supplier invoices: none
    enqueue({ data: [], error: null }) // external_id dedup: OLD id not among incoming NEW ids
    enqueue({ data: { id: 'ca-1930' }, error: null }) // cash_accounts: same account as the stored row
    enqueue({ data: inserted, error: null }) // insert: STILL imported (shadow only logs)
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw], {
      settlementAccount: '1930',
    })

    // Detected, but NOT acted on: imports exactly as before.
    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
    expect(result.shadow_scope_drift_candidates).toBe(1)
  })

  it('does not shadow-flag an asymmetric same-feed bucket (counts differ)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // TWO incoming rows share (date, amount) but only ONE stored twin exists →
    // the channels disagree on how many transactions the bucket holds, so the
    // signal is ambiguous and we stay silent.
    const rows = [
      makeRaw({ date: '2024-06-15', amount: -250, description: 'BETALNING A', external_id: 'eb_NEW_a', import_source: 'enable_banking' }),
      makeRaw({ date: '2024-06-15', amount: -250, description: 'BETALNING B', external_id: 'eb_NEW_b', import_source: 'enable_banking' }),
    ]
    enqueue({ data: [], error: null }) // booked
    enqueue({
      data: [{ date: '2024-06-15', amount: -250, original_description: 'OCR 9988', description: 'OCR 9988', import_source: 'enable_banking', cash_account_id: null, external_id: 'eb_OLD_x' }],
      error: null,
    }) // unbooked: ONE stored twin
    enqueue({ data: [], error: null }) // supplier
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: makeTransaction({ id: 'tx-a' }), error: null }) // insert a
    enqueue({ data: makeTransaction({ id: 'tx-b' }), error: null }) // insert b
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, rows)

    expect(result.imported).toBe(2)
    expect(result.duplicates).toBe(0)
    expect(result.shadow_scope_drift_candidates).toBe(0)
  })

  it('does not shadow-flag when the stored twin is on a different known cash account', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ date: '2024-06-15', amount: -250, description: 'TELENOR', external_id: 'eb_NEW_acctB', import_source: 'enable_banking' })
    const inserted = makeTransaction({ id: 'tx-b', external_id: raw.external_id })
    enqueue({ data: [], error: null }) // booked
    enqueue({
      data: [{ date: '2024-06-15', amount: -250, original_description: 'OCR', description: 'OCR', import_source: 'enable_banking', cash_account_id: 'acct-A', external_id: 'eb_OLD_acctA' }],
      error: null,
    }) // unbooked twin on account A
    enqueue({ data: [], error: null }) // supplier
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: { id: 'acct-B' }, error: null }) // cash_accounts → batch settled on account B
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw], { settlementAccount: '1931' })

    expect(result.imported).toBe(1)
    expect(result.shadow_scope_drift_candidates).toBe(0)
  })

  it('does not shadow-flag a genuinely new row when the stored sibling id re-arrives (not drift)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // The stored row's id IS present in this batch (normal re-sync, no drift) →
    // Layer-1 dedupes it. The SECOND incoming row is a genuinely new same-day /
    // same-amount transaction with a non-bridging description: it must import
    // AND must NOT be shadow-flagged, because the stored sibling is not
    // "orphaned" by a drifted id. This is the data-loss guard.
    const rows = [
      makeRaw({ date: '2024-06-15', amount: -250, description: 'COFFEE STARBUCKS', external_id: 'eb_X_0', import_source: 'enable_banking' }),
      makeRaw({ date: '2024-06-15', amount: -250, description: 'LUNCH RESTAURANG', external_id: 'eb_X_1', import_source: 'enable_banking' }),
    ]
    enqueue({ data: [], error: null }) // booked
    enqueue({
      data: [{ date: '2024-06-15', amount: -250, original_description: 'COFFEE STARBUCKS', description: 'COFFEE STARBUCKS', import_source: 'enable_banking', cash_account_id: null, external_id: 'eb_X_0' }],
      error: null,
    }) // stored = the _0 sibling
    enqueue({ data: [], error: null }) // supplier
    enqueue({ data: [{ external_id: 'eb_X_0' }], error: null }) // external_id dedup → eb_X_0 matches stored
    enqueue({ data: makeTransaction({ id: 'tx-x1' }), error: null }) // insert eb_X_1 only
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, rows)

    expect(result.duplicates).toBe(1) // eb_X_0 deduped by Layer-1
    expect(result.imported).toBe(1)   // eb_X_1 (genuine new) imported
    expect(result.shadow_scope_drift_candidates).toBe(0) // and NOT shadow-flagged
  })

  // -----------------------------------------------------------------------
  // 2d. Description drift: PSD2 enrichment is prefix-preserving, so an
  //     enriched re-import ("TIC" → "TIC  BG … via internet") still bridges
  //     the stored original via prefix-containment. This is the June 2026
  //     incident: the external_id ALSO changed, so the bridge is the only net.
  // -----------------------------------------------------------------------
  it('dedupes an enriched re-import whose description extends the stored original', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2026-04-07',
      amount: -11231,
      description: 'KAFFE              BG 0000000000 Bg-bet. via internet', // enriched
      external_id: 'eb_SE00_2026-04-07_-1123100_0', // NEW-scheme id → external_id dedup misses
      import_source: 'enable_banking',
    })

    enqueue({ data: [], error: null }) // booked map: none
    // Unbooked enable_banking row carrying the SHORT original description.
    enqueue({
      data: [{ date: '2026-04-07', amount: -11231, original_description: 'KAFFE', description: 'KAFFE' }],
      error: null,
    })
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup: different scheme, no match

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  // -----------------------------------------------------------------------
  // 2e. Order-independence: a genuinely-new row whose description does NOT
  //     bridge an existing same-(date,amount) row is kept, and the re-import
  //     that DOES bridge is deduped, regardless of provider ordering.
  // -----------------------------------------------------------------------
  it.each([
    ['new-first', ['Lunch', 'Coffee']],
    ['dup-first', ['Coffee', 'Lunch']],
  ])('keeps the distinct row and dedupes the bridging twin (%s)', async (_label, order) => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const rows = order.map((desc, i) =>
      makeRaw({
        date: '2026-04-07',
        amount: -250,
        description: desc,
        external_id: `csv_${desc}_${i}`,
        import_source: 'csv_lunar',
      }),
    )
    const insertedDesc = 'Lunch' // the non-bridging "Lunch" is always the row that gets inserted

    enqueue({ data: [], error: null }) // booked map: none
    // One unbooked enable_banking row "Coffee": only the incoming "Coffee" bridges it.
    enqueue({
      data: [{ date: '2026-04-07', amount: -250, original_description: 'Coffee', description: 'Coffee' }],
      error: null,
    })
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup: no match
    enqueue({
      data: makeTransaction({ id: 'tx-lunch', description: insertedDesc, amount: -250 }),
      error: null,
    }) // insert for the non-bridging "Lunch"
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, rows)

    expect(result.imported).toBe(1) // "Lunch" kept
    expect(result.duplicates).toBe(1) // "Coffee" deduped
    expect(result.transaction_ids).toEqual(['tx-lunch'])
  })

  // -----------------------------------------------------------------------
  // 2f. Counting semantics: N stored twins dedup exactly N incoming bridging
  //     rows; the surplus is inserted (never silently collapsed).
  // -----------------------------------------------------------------------
  it('dedupes exactly as many incoming rows as there are stored twins (counting)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const rows = [1, 2, 3].map((n) =>
      makeRaw({
        date: '2026-04-07',
        amount: -100,
        description: `ICA Kortköp ${n}`,
        external_id: `csv_ica_${n}`,
        import_source: 'csv_lunar',
      }),
    )

    enqueue({ data: [], error: null }) // booked map: none
    // Two stored unbooked "ICA" twins → only two of the three incoming dedup.
    enqueue({
      data: [
        { date: '2026-04-07', amount: -100, original_description: 'ICA', description: 'ICA' },
        { date: '2026-04-07', amount: -100, original_description: 'ICA', description: 'ICA' },
      ],
      error: null,
    })
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup: no match
    enqueue({
      data: makeTransaction({ id: 'tx-ica-surplus', description: 'ICA Kortköp 3', amount: -100 }),
      error: null,
    }) // insert for the surplus third row
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, rows)

    expect(result.duplicates).toBe(2)
    expect(result.imported).toBe(1)
    expect(result.transaction_ids).toEqual(['tx-ica-surplus'])
  })

  // -----------------------------------------------------------------------
  // 2g. Cross-account guard: a transaction on one bank account must NOT
  //     deduplicate a genuinely-different one on ANOTHER account of the same
  //     company. The content bucket is company-wide (only external_id embeds
  //     the account), so the bridge also requires matching cash_account_id when
  //     both sides know it.
  // -----------------------------------------------------------------------
  it('does not dedupe a bridging twin that settled on a different cash account', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2026-04-07',
      amount: -250,
      description: 'Avgift',
      external_id: 'eb_acctB_2026-04-07_-25000_0',
      import_source: 'enable_banking',
    })
    const inserted = makeTransaction({ id: 'tx-acctB', amount: -250 })

    enqueue({ data: [], error: null }) // booked map: none
    // Unbooked enable_banking twin, but it settled on a DIFFERENT account (A).
    enqueue({
      data: [{ date: '2026-04-07', amount: -250, original_description: 'Avgift', description: 'Avgift', cash_account_id: 'acct-A' }],
      error: null,
    })
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup: no match
    enqueue({ data: { id: 'acct-B' }, error: null }) // cash_accounts lookup → batch settled on account B
    enqueue({ data: inserted, error: null }) // insert: not a duplicate
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw], {
      settlementAccount: '1931',
    })

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
    expect(result.transaction_ids).toEqual(['tx-acctB'])
  })

  it('dedupes a bridging twin on the SAME cash account', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2026-04-07',
      amount: -250,
      description: 'Avgift',
      external_id: 'eb_acctA_2026-04-07_-25000_99', // different id → external_id dedup misses
      import_source: 'enable_banking',
    })

    enqueue({ data: [], error: null }) // booked map: none
    enqueue({
      data: [{ date: '2026-04-07', amount: -250, original_description: 'Avgift', description: 'Avgift', cash_account_id: 'acct-A' }],
      error: null,
    })
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup: no match
    enqueue({ data: { id: 'acct-A' }, error: null }) // cash_accounts lookup → batch settled on account A (same)
    // No insert: deduped.

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw], {
      settlementAccount: '1930',
    })

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  // -----------------------------------------------------------------------
  // 2h-shadow. Date-drift (the residual gap behind the reported bank↔bank dupes).
  //     Every dedup layer buckets on EXACT (date, öre), so a twin whose booking
  //     date drifted a day is invisible to all of them. The date-drift shadow
  //     MEASURES how often a ±1-day rule would fire: it logs/counts but NEVER
  //     changes what is inserted. These pin both that it detects the real cases
  //     and, crucially, that it never flags a genuine row.
  // -----------------------------------------------------------------------
  it('shadow-flags an EB↔EB twin one day apart with a bridging description, but still imports it', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // Same hotel expense, booking date drifted 15→16 (a real date-drift case).
    const raw = makeRaw({
      date: '2024-06-16',
      amount: -1500,
      description: 'Hotel expense',
      external_id: 'eb_SE_2024-06-16_-150000_0',
      import_source: 'enable_banking',
    })
    const inserted = makeTransaction({ id: 'tx-drift', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked map: none
    // Unbooked EB twin one day earlier: same amount/desc/account, OLD-scheme id.
    enqueue({
      data: [{
        date: '2024-06-15', amount: -1500,
        original_description: 'Hotel expense', description: 'Hotel expense',
        import_source: 'enable_banking', bank_connection_id: 'conn-1',
        cash_account_id: 'ca-1930', external_id: 'eb_SE_2024-06-15_-150000_0',
      }],
      error: null,
    })
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup: different date bucket, no match
    enqueue({ data: { id: 'ca-1930' }, error: null }) // cash_accounts: same account
    enqueue({ data: inserted, error: null }) // insert: STILL imported (shadow only logs)
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw], {
      settlementAccount: '1930',
    })

    // Detected, but NOT acted on: imports exactly as before.
    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
    expect(result.shadow_date_drift_candidates).toBe(1)
    // A different (adjacent) bucket → this is date-drift, not same-bucket scope-drift.
    expect(result.shadow_scope_drift_candidates).toBe(0)
  })

  it('shadow-flags a CSV↔EB twin one day apart via cross-channel symmetry when descriptions do not bridge', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // Nordea CSV row (payee-only desc) and its PSD2 twin booked a day later
    // (OCR/message desc): descriptions share no prefix, so only the
    // cross-channel mirror DISPLACED by a day can catch it (a real date-drift case).
    const raw = makeRaw({
      date: '2024-06-15',
      amount: -2500,
      description: 'Nordea',
      external_id: 'nordea_business_csvhash',
      import_source: 'csv_nordea_business',
    })
    const inserted = makeTransaction({ id: 'tx-cross', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked map: none
    enqueue({
      data: [{
        date: '2024-06-16', amount: -2500,
        original_description: 'Reimbursement', description: 'Reimbursement',
        import_source: 'enable_banking', bank_connection_id: 'conn-1',
        cash_account_id: null, external_id: 'eb_SE_2024-06-16_-250000_0',
      }],
      error: null,
    })
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // external_id dedup: no match
    enqueue({ data: inserted, error: null }) // insert: STILL imported
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
    expect(result.shadow_date_drift_candidates).toBe(1)
  })

  it('does not shadow-flag a date-drift twin on a different known cash account', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2024-06-16', amount: -250, description: 'Hotel expense',
      external_id: 'eb_acctB_2024-06-16_-25000_0', import_source: 'enable_banking',
    })
    const inserted = makeTransaction({ id: 'tx-b', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked
    enqueue({
      data: [{
        date: '2024-06-15', amount: -250,
        original_description: 'Hotel expense', description: 'Hotel expense',
        import_source: 'enable_banking', cash_account_id: 'acct-A',
        external_id: 'eb_acctA_2024-06-15_-25000_0',
      }],
      error: null,
    }) // bridging twin one day earlier, but on account A
    enqueue({ data: [], error: null }) // supplier
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: { id: 'acct-B' }, error: null }) // cash_accounts → batch on account B
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw], {
      settlementAccount: '1931',
    })

    expect(result.imported).toBe(1)
    expect(result.shadow_date_drift_candidates).toBe(0)
  })

  it('does not shadow-flag a twin two days away (outside the ±1-day window)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2024-06-17', amount: -250, description: 'Hotel expense',
      external_id: 'eb_2024-06-17_-25000_0', import_source: 'enable_banking',
    })
    const inserted = makeTransaction({ id: 'tx-far', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked
    enqueue({
      data: [{
        date: '2024-06-15', amount: -250,
        original_description: 'Hotel expense', description: 'Hotel expense',
        import_source: 'enable_banking', cash_account_id: null,
        external_id: 'eb_2024-06-15_-25000_0',
      }],
      error: null,
    }) // bridging twin TWO days earlier
    enqueue({ data: [], error: null }) // supplier
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.shadow_date_drift_candidates).toBe(0)
  })

  it('does not shadow-flag two genuinely-distinct same-amount rows a day apart (non-bridging, same feed)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2024-06-16', amount: -250, description: 'LUNCH RESTAURANG',
      external_id: 'eb_2024-06-16_-25000_0', import_source: 'enable_banking',
    })
    const inserted = makeTransaction({ id: 'tx-lunch', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked
    enqueue({
      data: [{
        date: '2024-06-15', amount: -250,
        original_description: 'COFFEE STARBUCKS', description: 'COFFEE STARBUCKS',
        import_source: 'enable_banking', cash_account_id: null,
        external_id: 'eb_2024-06-15_-25000_0',
      }],
      error: null,
    }) // distinct same-amount neighbour, same feed, non-bridging desc
    enqueue({ data: [], error: null }) // supplier
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.shadow_date_drift_candidates).toBe(0)
  })

  it('does not double-count: an exact-date Layer-2 dedupe is not also a date-drift candidate', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2024-06-15', amount: -250, description: 'KAFFE',
      external_id: 'eb_new_2024-06-15_-25000_0', import_source: 'enable_banking',
    })

    enqueue({ data: [], error: null }) // booked
    // Two stored twins: one EXACT-date (Layer-2 dedupes it) and one a day later.
    // The row is consumed by Layer-2 and never reaches the date-drift gate.
    enqueue({
      data: [
        { date: '2024-06-15', amount: -250, original_description: 'KAFFE', description: 'KAFFE',
          import_source: 'enable_banking', cash_account_id: null, external_id: 'eb_old_0615' },
        { date: '2024-06-16', amount: -250, original_description: 'KAFFE', description: 'KAFFE',
          import_source: 'enable_banking', cash_account_id: null, external_id: 'eb_old_0616' },
      ],
      error: null,
    })
    enqueue({ data: [], error: null }) // supplier
    enqueue({ data: [], error: null }) // external_id dedup: no match
    // No insert: deduped by Layer-2.
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
    expect(result.shadow_date_drift_candidates).toBe(0)
  })

  it('never lets the date-drift measurement break an import (malformed date is fail-safe)', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    // A malformed date would make shiftIsoDate throw; the guard must skip
    // detection so the row imports exactly as before: measurement can never
    // abort a sync. (Without the guard this test throws instead of asserting.)
    const raw = makeRaw({
      date: 'not-a-date', amount: -250, description: 'Hotel expense',
      external_id: 'eb_bad_date_0', import_source: 'enable_banking',
    })
    const inserted = makeTransaction({ id: 'tx-baddate', external_id: raw.external_id })

    enqueue({ data: [], error: null }) // booked
    enqueue({ data: [], error: null }) // unbooked
    enqueue({ data: [], error: null }) // supplier
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert: still happens
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.shadow_date_drift_candidates).toBe(0)
  })

  // -----------------------------------------------------------------------
  // 3. Counts errors when insert fails
  // -----------------------------------------------------------------------
  it('counts errors when insert fails', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw()

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    // Insert fails
    enqueue({ data: null, error: { message: 'DB constraint violation' } })

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.errors).toBe(1)
    expect(result.imported).toBe(0)
    expect(result.transaction_ids).toEqual([])
  })

  // -----------------------------------------------------------------------
  // 4. Auto-matches invoices for income transactions (amount > 0)
  // -----------------------------------------------------------------------
  it('auto-matches invoices for income transactions', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: 5000, description: 'Payment received' })
    const inserted = makeTransaction({
      id: 'tx-income',
      amount: 5000,
      external_id: raw.external_id,
    })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    // Insert returns the new transaction
    enqueue({ data: inserted, error: null })
    // Invoice match update (supabase.from('transactions').update(...))
    enqueue({ data: null, error: null })
    // Mapping rules auto-categorization update (if triggered)
    enqueue({ data: null, error: null })

    mockGetBestInvoiceMatch.mockResolvedValue({
      invoice: { id: 'inv-1' },
      confidence: 0.95,
      matchReason: 'OCR reference match',
    })
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.auto_matched_invoices).toBe(1)
    expect(mockGetBestInvoiceMatch).toHaveBeenCalledWith(
      expect.anything(), // supabase client
      COMPANY_ID,
      expect.objectContaining({ id: 'tx-income' }),
      0.50
    )
  })

  // -----------------------------------------------------------------------
  // 4a. Skatteverkets ROT/RUT payout: an income row equal to an open begäran
  //     gets potential_rot_rut_payout_request_id (a suggestion, never a hard
  //     link) and skips auto-categorisation, exactly like an invoice hint.
  // -----------------------------------------------------------------------
  it('suggests the open ROT/RUT payout request for a matching Skatteverket income row', async () => {
    const { supabase, enqueue, updates } = createQueueMockSupabase()
    const raw = makeRaw({ amount: 3000, description: 'Skatteverket utbetalning' })
    const inserted = makeTransaction({
      id: 'tx-skv',
      amount: 3000,
      currency: 'SEK',
      description: 'Skatteverket utbetalning',
      external_id: raw.external_id,
    })
    mockLoadOpenRotRutPayoutRequests.mockResolvedValueOnce([
      {
        id: 'rr-1',
        name: 'ROT 2026-07',
        deduction_type: 'rot',
        status: 'submitted',
        requested_total: 3000,
        decided_total: null,
        settlement_journal_entry_id: null,
      },
    ])
    mockGetBestInvoiceMatch.mockResolvedValue(null)

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked bank-synced map
    enqueue({ data: [], error: null }) // supplier invoices pool
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert
    enqueue({ data: null, error: null }) // suggestion update

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.auto_matched_invoices).toBe(1)
    const txUpdates = (updates['transactions'] ?? []) as Record<string, unknown>[]
    expect(txUpdates).toEqual([{ potential_rot_rut_payout_request_id: 'rr-1' }])
    // The hint short-circuits the mapping engine: no auto-booked voucher.
    expect(mockEvaluateMappingRules).not.toHaveBeenCalled()
  })

  // -----------------------------------------------------------------------
  // 4a'. Skatteverket bundles the beslut it pays that day into ONE transfer
  //      (#2239): a row equal to the SUM of several open begäran gets no hint
  //      column (the inbox recomputes the set) but must still skip the mapping
  //      engine and drain the pool, exactly like a 1:1 hint.
  // -----------------------------------------------------------------------
  it('recognises a bundled ROT/RUT payout (sum of several begäran) without persisting a hint', async () => {
    const { supabase, enqueue, updates } = createQueueMockSupabase()
    const raw = makeRaw({ amount: 5250, description: 'Skatteverket utbetalning' })
    const inserted = makeTransaction({
      id: 'tx-skv-set',
      amount: 5250,
      currency: 'SEK',
      description: 'Skatteverket utbetalning',
      external_id: raw.external_id,
    })
    const request = (id: string, name: string, requestedTotal: number) => ({
      id,
      name,
      deduction_type: 'rot' as const,
      status: 'submitted',
      requested_total: requestedTotal,
      decided_total: null,
      settlement_journal_entry_id: null,
    })
    mockLoadOpenRotRutPayoutRequests.mockResolvedValueOnce([
      request('rr-1', 'ROT 2026-07', 3000),
      request('rr-2', 'ROT 2026-08', 2250),
    ])
    mockGetBestInvoiceMatch.mockResolvedValue(null)

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked bank-synced map
    enqueue({ data: [], error: null }) // supplier invoices pool
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.auto_matched_invoices).toBe(1)
    // No single begäran equals the row, so no 1:1 hint is written; the set is
    // recomputed at read time instead of persisted.
    expect(updates['transactions'] ?? []).toEqual([])
    expect(mockEvaluateMappingRules).not.toHaveBeenCalled()
  })

  // -----------------------------------------------------------------------
  // 4b. Supplier-invoice match at sync is ALWAYS a suggestion, never a hard
  //     link. Regression: a high-confidence hit used to set
  //     supplier_invoice_id directly (with no payment voucher booked) which
  //     then BLOCKED the match route (MATCH_SI_TX_ALREADY_LINKED), stranding
  //     the bank line with no path to a payment booking (June 2026 incident:
  //     RosholmDell 18299).
  // -----------------------------------------------------------------------
  it('demotes a high-confidence supplier-invoice match to potential_supplier_invoice_id', async () => {
    const { supabase, enqueue, updates } = createQueueMockSupabase()
    const raw = makeRaw({
      date: '2026-06-08',
      amount: -29890,
      description: 'RosholmDell Advo BG 0000007746514 Bg-bet. via internet',
    })
    const inserted = makeTransaction({
      id: 'tx-rd',
      amount: -29890,
      date: '2026-06-08',
      external_id: raw.external_id,
    })
    // One unpaid invoice, exact amount, tx date inside the credit window →
    // Pass-3 amount_date match at 0.85, unambiguous (previously: hard link).
    const supplierInvoice = {
      id: 'si-rd',
      status: 'registered',
      total: 29890,
      remaining_amount: 29890,
      invoice_date: '2026-06-05',
      due_date: '2026-07-05',
      payment_reference: null,
      supplier: { name: 'RosholmDell Advokatbyrå AB' },
    }

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked bank-synced map
    enqueue({ data: [supplierInvoice], error: null }) // supplier invoices pool
    enqueue({ data: [], error: null }) // external_id dedup
    enqueue({ data: inserted, error: null }) // insert
    enqueue({ data: null, error: null }) // suggestion update

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.auto_matched_invoices).toBe(1)
    const txUpdates = (updates['transactions'] ?? []) as Record<string, unknown>[]
    expect(txUpdates).toHaveLength(1)
    expect(txUpdates[0]).toEqual({ potential_supplier_invoice_id: 'si-rd' })
    // The hard link is reserved for completed matches (payment voucher booked).
    expect(txUpdates.some((u) => 'supplier_invoice_id' in u)).toBe(false)
  })

  // -----------------------------------------------------------------------
  // 5. Does not attempt invoice matching for expenses (amount < 0)
  // -----------------------------------------------------------------------
  it('does not attempt invoice matching for expenses', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -350 })
    const inserted = makeTransaction({
      id: 'tx-expense',
      amount: -350,
      external_id: raw.external_id,
    })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    // Insert
    enqueue({ data: inserted, error: null })

    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.auto_matched_invoices).toBe(0)
    expect(mockGetBestInvoiceMatch).not.toHaveBeenCalled()
  })

  // -----------------------------------------------------------------------
  // 6. Auto-categorizes when mapping confidence >= 0.8
  // -----------------------------------------------------------------------
  it('auto-categorizes when mapping confidence is at least 0.8', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -500, mcc_code: 5411, merchant_name: 'ICA' })
    const inserted = makeTransaction({
      id: 'tx-cat',
      amount: -500,
      external_id: raw.external_id,
    })
    const journalEntry = makeJournalEntry({ id: 'je-1' })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    // Insert
    enqueue({ data: inserted, error: null })
    // Update after journal entry creation
    enqueue({ data: null, error: null })

    mockEvaluateMappingRules.mockResolvedValue(
      makeMappingResult({ confidence: 0.85, requires_review: false })
    )
    mockCreateTransactionJournalEntry.mockResolvedValue(journalEntry)

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.auto_categorized).toBe(1)
    expect(mockCreateTransactionJournalEntry).toHaveBeenCalledWith(
      expect.anything(),
      COMPANY_ID,
      USER_ID,
      expect.objectContaining({ id: 'tx-cat' }),
      expect.objectContaining({ confidence: 0.85 })
    )
  })

  // -----------------------------------------------------------------------
  // 7. Skips auto-categorization when confidence < 0.8
  // -----------------------------------------------------------------------
  it('skips auto-categorization when confidence is below 0.8', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -200 })
    const inserted = makeTransaction({
      id: 'tx-lowconf',
      amount: -200,
      external_id: raw.external_id,
    })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    // Insert
    enqueue({ data: inserted, error: null })

    mockEvaluateMappingRules.mockResolvedValue(
      makeMappingResult({ confidence: 0.6 })
    )

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.auto_categorized).toBe(0)
    expect(mockCreateTransactionJournalEntry).not.toHaveBeenCalled()
  })

  // -----------------------------------------------------------------------
  // 7b. Skips auto-categorization when requires_review is true
  // -----------------------------------------------------------------------
  it('skips auto-categorization when requires_review is true even if confidence is high', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -800 })
    const inserted = makeTransaction({
      id: 'tx-review',
      amount: -800,
      external_id: raw.external_id,
    })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    // Insert
    enqueue({ data: inserted, error: null })

    mockEvaluateMappingRules.mockResolvedValue(
      makeMappingResult({ confidence: 0.95, requires_review: true })
    )

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.auto_categorized).toBe(0)
    expect(mockCreateTransactionJournalEntry).not.toHaveBeenCalled()
  })

  // -----------------------------------------------------------------------
  // 8. Returns correct IngestResult totals
  // -----------------------------------------------------------------------
  it('returns correct IngestResult totals', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw1 = makeRaw({ external_id: 'ext-a', amount: -100 })
    const raw2 = makeRaw({ external_id: 'ext-b', amount: -200 })

    const inserted1 = makeTransaction({ id: 'tx-a', amount: -100 })
    const inserted2 = makeTransaction({ id: 'tx-b', amount: -200 })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    // Transaction 1: insert OK
    enqueue({ data: inserted1, error: null })
    // Transaction 2: insert OK
    enqueue({ data: inserted2, error: null })

    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw1, raw2])

    expect(result.imported).toBe(2)
    expect(result.duplicates).toBe(0)
    expect(result.errors).toBe(0)
    expect(result.auto_categorized).toBe(0)
    expect(result.auto_matched_invoices).toBe(0)
    expect(result.transaction_ids).toEqual(['tx-a', 'tx-b'])
  })

  // -----------------------------------------------------------------------
  // 9. Handles mixed batch (new, duplicates, errors)
  // -----------------------------------------------------------------------
  it('handles a mixed batch of new transactions, duplicates, and errors', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()

    const rawNew = makeRaw({ external_id: 'ext-new', amount: 3000 })
    const rawDup = makeRaw({ external_id: 'ext-dup', amount: -150 })
    const rawErr = makeRaw({ external_id: 'ext-err', amount: -75 })

    const insertedNew = makeTransaction({
      id: 'tx-new',
      amount: 3000,
      external_id: 'ext-new',
    })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: ext-dup already exists
    enqueue({ data: [{ external_id: 'ext-dup' }], error: null })
    // Transaction rawNew: insert OK
    enqueue({ data: insertedNew, error: null })
    // Invoice match update for income transaction
    enqueue({ data: null, error: null })
    // logMatchEvent insert (fire-and-forget)
    enqueue({ data: null, error: null })
    // rawDup: skipped (in Set): no queue entry needed
    // NOTE: auto-categorization is skipped because invoice match triggers `continue`
    // Transaction rawErr: insert fails
    enqueue({ data: null, error: { message: 'Insert failed' } })

    // Income transaction gets an invoice match
    mockGetBestInvoiceMatch.mockResolvedValue({
      invoice: { id: 'inv-match' },
      confidence: 0.95,
      matchReason: 'Exact amount match',
    })

    // Auto-categorization with high confidence
    mockEvaluateMappingRules.mockResolvedValue(
      makeMappingResult({ confidence: 0.85 })
    )
    const journalEntry = makeJournalEntry({ id: 'je-mixed' })
    mockCreateTransactionJournalEntry.mockResolvedValue(journalEntry)

    const result = await ingestTransactions(
      supabase as never,
      COMPANY_ID,
      USER_ID,
      [rawNew, rawDup, rawErr]
    )

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(1)
    expect(result.errors).toBe(1)
    expect(result.auto_matched_invoices).toBe(1)
    expect(result.auto_categorized).toBe(0) // Skipped: invoice match triggers continue
    expect(result.transaction_ids).toEqual(['tx-new'])
  })

  // -----------------------------------------------------------------------
  // Edge: empty input array
  // -----------------------------------------------------------------------
  it('returns zero totals for an empty input array', async () => {
    const { supabase } = createQueueMockSupabase()

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [])

    expect(result).toEqual({
      imported: 0,
      duplicates: 0,
      reconciled: 0,
      auto_categorized: 0,
      auto_matched_invoices: 0,
      errors: 0,
      transaction_ids: [],
      shadow_scope_drift_candidates: 0,
      shadow_date_drift_candidates: 0,
    })
  })

  // -----------------------------------------------------------------------
  // Edge: invoice matching error is non-critical
  // -----------------------------------------------------------------------
  it('continues processing when invoice matching throws', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: 1000 })
    const inserted = makeTransaction({ id: 'tx-inv-err', amount: 1000 })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    enqueue({ data: inserted, error: null })

    mockGetBestInvoiceMatch.mockRejectedValue(new Error('Network error'))
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    // Should still count as imported even though invoice matching failed
    expect(result.imported).toBe(1)
    expect(result.auto_matched_invoices).toBe(0)
    expect(result.errors).toBe(0)
  })

  // -----------------------------------------------------------------------
  // Edge: auto-categorization error is non-critical
  // -----------------------------------------------------------------------
  it('continues processing when auto-categorization throws', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -400 })
    const inserted = makeTransaction({ id: 'tx-cat-err', amount: -400 })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    enqueue({ data: inserted, error: null })

    mockEvaluateMappingRules.mockRejectedValue(new Error('Mapping error'))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.auto_categorized).toBe(0)
    expect(result.errors).toBe(0)
  })

  // -----------------------------------------------------------------------
  // Imports never auto-link to existing journal entries.
  // Reconciliation must be an explicit user action (manualLink / runReconciliation).
  // Regression: viktor@frnzn.com, bank txns from 2026 were silently linked
  // to SIE-imported vouchers, surfacing them as "bokförda" without action.
  // -----------------------------------------------------------------------
  it('never auto-reconciles imported transactions to existing GL lines', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -500, external_id: 'ext-recon' })
    const inserted = makeTransaction({
      id: 'tx-recon',
      amount: -500,
      external_id: 'ext-recon',
      currency: 'SEK',
    })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    // Insert
    enqueue({ data: inserted, error: null })

    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.reconciled).toBe(0)
  })

  // -----------------------------------------------------------------------
  // rawInsertOnly: skips reconciliation, matching, and auto-categorization
  // -----------------------------------------------------------------------
  it('skips reconciliation, matching, and categorization when rawInsertOnly is set', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: 5000, description: 'Payment received' })
    const inserted = makeTransaction({
      id: 'tx-raw',
      amount: 5000,
      external_id: raw.external_id,
    })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // No supplier invoices fetch (skipped by rawInsertOnly)
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    // Insert returns the new transaction
    enqueue({ data: inserted, error: null })

    const result = await ingestTransactions(
      supabase as never, COMPANY_ID, USER_ID, [raw],
      { rawInsertOnly: true }
    )

    expect(result.imported).toBe(1)
    expect(result.reconciled).toBe(0)
    expect(result.auto_categorized).toBe(0)
    expect(result.auto_matched_invoices).toBe(0)
    // Should NOT have attempted any post-insert operations
    expect(mockGetBestInvoiceMatch).not.toHaveBeenCalled()
    expect(mockEvaluateMappingRules).not.toHaveBeenCalled()
  })

  it('still deduplicates when rawInsertOnly is set', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ external_id: 'ext-dup-raw' })

    // Booked transaction map query
    enqueue({ data: [], error: null })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: already exists
    enqueue({ data: [{ external_id: 'ext-dup-raw' }], error: null })

    const result = await ingestTransactions(
      supabase as never, COMPANY_ID, USER_ID, [raw],
      { rawInsertOnly: true }
    )

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  // -----------------------------------------------------------------------
  // Content-based dedup: cross-source duplicate detection
  // -----------------------------------------------------------------------
  it('skips transactions that match already-booked ones by date+amount+description', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      external_id: 'psd2_conn123_tx456',
      date: '2024-06-15',
      amount: -250,
    })

    // Booked transaction map returns a booked tx with same date+amount+description
    enqueue({
      data: [{ date: '2024-06-15', amount: -250, description: raw.description }],
      error: null,
    })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no match by external_id)
    enqueue({ data: [], error: null })

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  it('imports transactions when booked ones have different amounts', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      external_id: 'psd2_conn123_tx789',
      date: '2024-06-15',
      amount: -300,
    })
    const inserted = makeTransaction({ id: 'tx-new', amount: -300 })

    // Booked transaction map: same date but different amount
    enqueue({
      data: [{ date: '2024-06-15', amount: -250, description: raw.description }],
      error: null,
    })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no match)
    enqueue({ data: [], error: null })
    // Insert
    enqueue({ data: inserted, error: null })

    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
  })

  it('bridges the external_id scheme change: a booked OLD-scheme eb_ row is caught by content dedup on re-sync', async () => {
    // Transition scenario: an enable_banking row was imported+booked under the
    // OLD unstable scheme (eb_{iban}_{txid}). After deploy, the re-sync derives
    // a NEW content-based external_id that will NOT match by external_id, so
    // layer-1 misses. Layer 1b (booked content dedup) MUST catch it, otherwise
    // the user sees the exact duplicate the fix is meant to prevent.
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      external_id: 'eb_SE123_2024-06-15_-25000_0', // new scheme
      date: '2024-06-15',
      amount: -250,
      description: 'ICA Maxi Solna',
      import_source: 'enable_banking',
    })

    // Booked map: the SAME transaction still carries its OLD-scheme external_id
    // in the DB; dedup matches on content, not on external_id.
    enqueue({
      data: [{ date: '2024-06-15', amount: -250, description: 'ICA Maxi Solna' }],
      error: null,
    })
    // Unbooked enable_banking map: none
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query: DB still holds eb_SE123_{old_txid}, so the
    // new external_id finds NO match here.
    enqueue({ data: [], error: null })

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  it('dedupes against a booked row whose amount is a numeric string (PostgREST), not a number', async () => {
    // Regression: PostgREST can serialize a `numeric` column as a string
    // ("-250.00") while the incoming raw amount is a JS number (-250). Before
    // the öre-normalized dedup key these never compared equal, so content dedup
    // silently missed and the row was re-imported as a duplicate.
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({
      external_id: 'eb_acc_2024-06-15_-25000_0',
      date: '2024-06-15',
      amount: -250,
      description: 'ICA Maxi Solna',
    })

    // Booked map: same transaction, amount as a STRING with trailing zeros.
    enqueue({
      data: [{ date: '2024-06-15', amount: '-250.00', description: 'ICA Maxi Solna' }],
      error: null,
    })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no match by external_id: the id scheme changed)
    enqueue({ data: [], error: null })

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.duplicates).toBe(1)
    expect(result.imported).toBe(0)
  })

  it('handles multiple booked transactions with same date+amount correctly', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()

    // Three incoming transactions with the same date+amount
    const raw1 = makeRaw({ external_id: 'psd2_a', date: '2024-06-15', amount: -100 })
    const raw2 = makeRaw({ external_id: 'psd2_b', date: '2024-06-15', amount: -100 })
    const raw3 = makeRaw({ external_id: 'psd2_c', date: '2024-06-15', amount: -100 })

    const inserted = makeTransaction({ id: 'tx-new', amount: -100 })

    // Booked map: 2 existing booked transactions with same date+amount+description
    // So 2 of the 3 incoming should be skipped, 1 should be imported
    enqueue({
      data: [
        { date: '2024-06-15', amount: -100, description: raw1.description },
        { date: '2024-06-15', amount: -100, description: raw1.description },
      ],
      error: null,
    })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches for any)
    enqueue({ data: [], error: null })

    // raw1: not in external_id set → content dedup matches (bookedCount=2 -> 1)
    // raw2: not in external_id set → content dedup matches (bookedCount=1 -> 0)
    // raw3: not in external_id set → content dedup exhausted → insert
    enqueue({ data: inserted, error: null })

    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw1, raw2, raw3])

    expect(result.duplicates).toBe(2)
    expect(result.imported).toBe(1)
  })

  // -----------------------------------------------------------------------
  // FX rate fetching (issue #442)
  // Each non-SEK transaction must be priced at the rate of its OWN date,
  // not the import date and not a single batch-level rate.
  // -----------------------------------------------------------------------
  it('fetches an exchange rate per unique (currency, date) pair', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw1 = makeRaw({ amount: -100, currency: 'USD', date: '2026-05-07', external_id: 'usd-a' })
    const raw2 = makeRaw({ amount: -50, currency: 'USD', date: '2026-05-08', external_id: 'usd-b' })
    const raw3 = makeRaw({ amount: -200, currency: 'EUR', date: '2026-05-07', external_id: 'eur-a' })
    const raw4 = makeRaw({ amount: -300, currency: 'USD', date: '2026-05-07', external_id: 'usd-c' })

    enqueue({ data: [], error: null }) // booked map
    enqueue({ data: [], error: null }) // unbooked enable_banking map
    enqueue({ data: [], error: null }) // supplier invoices
    enqueue({ data: [], error: null }) // batch external_id dedup
    enqueue({ data: makeTransaction({ id: 'tx-1' }), error: null })
    enqueue({ data: makeTransaction({ id: 'tx-2' }), error: null })
    enqueue({ data: makeTransaction({ id: 'tx-3' }), error: null })
    enqueue({ data: makeTransaction({ id: 'tx-4' }), error: null })

    mockFetchExchangeRate.mockResolvedValue({ currency: 'USD', rate: 9.2, date: '2026-05-07' })
    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw1, raw2, raw3, raw4])

    // 3 unique pairs: USD/2026-05-07, USD/2026-05-08, EUR/2026-05-07.
    // raw4 reuses USD/2026-05-07 and must NOT trigger an extra fetch.
    expect(mockFetchExchangeRate).toHaveBeenCalledTimes(3)
    const pairs = mockFetchExchangeRate.mock.calls.map(([currency, date]) => ({
      currency,
      date: (date as Date).toISOString().split('T')[0],
    }))
    expect(pairs).toContainEqual({ currency: 'USD', date: '2026-05-07' })
    expect(pairs).toContainEqual({ currency: 'USD', date: '2026-05-08' })
    expect(pairs).toContainEqual({ currency: 'EUR', date: '2026-05-07' })
  })

  it('does not fetch a rate for SEK transactions', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -100, currency: 'SEK', date: '2026-05-07' })

    enqueue({ data: [], error: null }) // booked
    enqueue({ data: [], error: null }) // unbooked
    enqueue({ data: [], error: null }) // suppliers
    enqueue({ data: [], error: null }) // dedup
    enqueue({ data: makeTransaction({ id: 'tx-sek' }), error: null })

    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])
    expect(mockFetchExchangeRate).not.toHaveBeenCalled()
  })

  it('continues normally when booked transaction map query fails', async () => {
    const { supabase, enqueue } = createQueueMockSupabase()
    const raw = makeRaw({ amount: -200 })
    const inserted = makeTransaction({ id: 'tx-mapfail', amount: -200 })

    // Booked map query throws (caught by try/catch in buildExistingTransactionMap)
    enqueue({ error: { message: 'Query failed' } })
    // Unbooked bank-synced transaction map query
    enqueue({ data: [], error: null })
    // Supplier invoices fetch
    enqueue({ data: [], error: null })
    // Batch external_id dedup query (no matches)
    enqueue({ data: [], error: null })
    // Insert
    enqueue({ data: inserted, error: null })

    mockEvaluateMappingRules.mockResolvedValue(makeMappingResult({ confidence: 0.5 }))

    const result = await ingestTransactions(supabase as never, COMPANY_ID, USER_ID, [raw])

    expect(result.imported).toBe(1)
    expect(result.duplicates).toBe(0)
  })
})