feat: multi-series SIE import, reusable FiscalYearSelector, library templates in picker (#278)

* feat: multi-series SIE import, reusable FiscalYearSelector, library templates in picker - SIE import preserves each voucher's source series (B/C/I/V/...), essential for Fortnox migrations where series carry semantic meaning (kundfakturor, inbetalningar, etc.). Target numbering still goes through next_voucher_number per series; source (series, number) is stored in the migration mapping for BFNAR 2013:2 audit trail. - Execute route reads company_settings.default_voucher_series as the fallback for vouchers arriving without a series (SIE4I). - Extract shared FiscalYearSelector component; adopt in /reports and /bookkeeping. - Transaction TemplatePicker now surfaces user-created library templates (company + team scope) alongside the static registry, with a helper to convert simple library templates into the BookingTemplate shape. - Exclude 8999 "Årets resultat" from income statement financial section and monthly breakdown so year-end closing entries don't cancel the net result. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test: skip Bokio SIE regression when fixtures are absent /dev_docs is gitignored (contains anonymised customer exports), so the integration test can't find its input files in CI. Gate the suite on fixture presence so it still runs locally. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix: address Greptile review feedback - convertLibraryToBookingTemplate: default entity_applicability to 'all' when the source template has no entity_type, so TemplatePicker doesn't silently hide it for companies with a set entity type. - FiscalYearSelector: fire onReady in the no-company early-return branch so consumers (e.g. ReportsPage) don't get stuck in a loading skeleton while the company context is still hydrating. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-04-20 11:40:15 +02:00
parent d708a85d4c
commit 23664e79cb
15 changed files with 1061 additions and 131 deletions
@@ -1,12 +1,15 @@
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, vi } from 'vitest'
 import {
  generateImportPreview,
  validateIBBalance,
  isBalanceSheetAccount,
  ensureFiscalPeriod,
+  importVouchers,
+  computeVoucherNumberRanges,
 } from '../sie-import'
 import { createQueuedMockSupabase } from '@/tests/helpers'
 import type { ParsedSIEFile, AccountMapping } from '../types'
+import type { SupabaseClient } from '@supabase/supabase-js'

 // --- Helpers ---

@@ -442,3 +445,266 @@ describe('isBalanceSheetAccount', () => {
    expect(isBalanceSheetAccount('8999')).toBe(false)
  })
 })
+
+describe('computeVoucherNumberRanges', () => {
+  it('returns empty array for no mapping', () => {
+    expect(computeVoucherNumberRanges([])).toEqual([])
+  })
+
+  it('produces one range per series with correct from/to', () => {
+    const ranges = computeVoucherNumberRanges([
+      { sourceId: 'B1', series: 'B', targetNumber: 1 },
+      { sourceId: 'B2', series: 'B', targetNumber: 2 },
+      { sourceId: 'B3', series: 'B', targetNumber: 3 },
+      { sourceId: 'C1', series: 'C', targetNumber: 1 },
+      { sourceId: 'C2', series: 'C', targetNumber: 2 },
+      { sourceId: 'V1', series: 'V', targetNumber: 1 },
+    ])
+
+    expect(ranges).toEqual([
+      { series: 'B', from: 1, to: 3 },
+      { series: 'C', from: 1, to: 2 },
+      { series: 'V', from: 1, to: 1 },
+    ])
+  })
+
+  it('handles non-contiguous target numbers per series', () => {
+    const ranges = computeVoucherNumberRanges([
+      { sourceId: 'B1', series: 'B', targetNumber: 5 },
+      { sourceId: 'B2', series: 'B', targetNumber: 9 },
+    ])
+    expect(ranges).toEqual([{ series: 'B', from: 5, to: 9 }])
+  })
+})
+
+describe('importVouchers — per-voucher series preservation', () => {
+  // Captures the rows passed to `.insert()` so the test can assert on
+  // voucher_series per inserted record. Uses a hand-rolled mock rather than
+  // createQueuedMockSupabase because we need to inspect arguments, not just
+  // return queued data.
+  function buildCapturingSupabase() {
+    const journalEntryInserts: Array<Record<string, unknown>> = []
+    const journalEntryLineInserts: Array<Record<string, unknown>> = []
+    const rpcCalls: Array<{ name: string; args: Record<string, unknown> }> = []
+
+    // Each `next_voucher_number` RPC call auto-increments per series, matching
+    // the DB function's ON CONFLICT behavior.
+    const nextNumberBySeries = new Map<string, number>()
+
+    let syntheticEntryId = 1
+
+    const supabase = {
+      from: vi.fn((table: string) => {
+        if (table === 'chart_of_accounts') {
+          // Return all accounts used in test vouchers as if already active
+          return {
+            select: () => ({
+              eq: () => ({
+                in: (_col: string, accountNumbers: string[]) => ({
+                  then: (resolve: (v: { data: { id: string; account_number: string }[]; error: null }) => void) =>
+                    resolve({
+                      data: accountNumbers.map((num, i) => ({ id: `acc-${i}`, account_number: num })),
+                      error: null,
+                    }),
+                }),
+              }),
+            }),
+          }
+        }
+
+        if (table === 'journal_entries') {
+          return {
+            insert: (rows: Array<Record<string, unknown>>) => {
+              journalEntryInserts.push(...rows)
+              return {
+                select: () => ({
+                  then: (resolve: (v: { data: { id: string }[]; error: null }) => void) =>
+                    resolve({
+                      data: rows.map(() => ({ id: `entry-${syntheticEntryId++}` })),
+                      error: null,
+                    }),
+                }),
+              }
+            },
+          }
+        }
+
+        if (table === 'journal_entry_lines') {
+          return {
+            insert: (rows: Array<Record<string, unknown>>) => {
+              journalEntryLineInserts.push(...rows)
+              return Promise.resolve({ error: null })
+            },
+          }
+        }
+
+        throw new Error(`Unexpected table: ${table}`)
+      }),
+
+      rpc: vi.fn(async (name: string, args: Record<string, unknown>) => {
+        rpcCalls.push({ name, args })
+        if (name === 'next_voucher_number') {
+          const series = args.p_series as string
+          const current = nextNumberBySeries.get(series) ?? 0
+          const next = current + 1
+          nextNumberBySeries.set(series, next)
+          return { data: next, error: null }
+        }
+        if (name === 'reserve_voucher_range') {
+          const series = args.p_series as string
+          const highest = args.p_highest_used as number
+          nextNumberBySeries.set(series, highest)
+          return { data: null, error: null }
+        }
+        if (name === 'release_voucher_range') {
+          return { data: null, error: null }
+        }
+        throw new Error(`Unexpected RPC: ${name}`)
+      }),
+    }
+
+    return {
+      supabase: supabase as unknown as SupabaseClient,
+      journalEntryInserts,
+      journalEntryLineInserts,
+      rpcCalls,
+    }
+  }
+
+  function makeVoucher(
+    series: string,
+    number: number,
+    lines: Array<{ account: string; amount: number }> = [
+      { account: '1510', amount: 1000 },
+      { account: '3001', amount: -1000 },
+    ],
+  ) {
+    return {
+      series,
+      number,
+      date: new Date(2024, 0, 15),
+      description: `Voucher ${series}${number}`,
+      lines,
+    }
+  }
+
+  const baseMap = new Map([
+    ['1510', '1510'],
+    ['3001', '3001'],
+  ])
+
+  it('routes each voucher to its source series (B, C, V → B, C, V)', async () => {
+    const { supabase, journalEntryInserts, rpcCalls } = buildCapturingSupabase()
+    const parsed = makeParsedFile({
+      vouchers: [
+        makeVoucher('B', 1),
+        makeVoucher('B', 2),
+        makeVoucher('C', 1),
+        makeVoucher('V', 1),
+      ],
+    })
+
+    const result = await importVouchers(
+      supabase,
+      'company-1',
+      'user-1',
+      'period-1',
+      parsed,
+      baseMap,
+      'B', // fallback (should not be used here — all vouchers have series)
+    )
+
+    expect(result.created).toBe(4)
+    expect(new Set(result.seriesUsed)).toEqual(new Set(['B', 'C', 'V']))
+
+    const seriesInInserts = journalEntryInserts.map((r) => r.voucher_series)
+    expect(seriesInInserts).toEqual(['B', 'B', 'C', 'V'])
+
+    // Each series reserves its own voucher-number range independently
+    const reserveCalls = rpcCalls.filter((c) => c.name === 'reserve_voucher_range')
+    expect(reserveCalls.map((c) => c.args.p_series)).toEqual(['B', 'C', 'V'])
+  })
+
+  it('falls back to defaultSeries when source voucher has empty series (SIE4I)', async () => {
+    const { supabase, journalEntryInserts } = buildCapturingSupabase()
+    const parsed = makeParsedFile({
+      vouchers: [
+        { ...makeVoucher('', 1) },
+        { ...makeVoucher('', 2) },
+      ],
+    })
+
+    const result = await importVouchers(
+      supabase,
+      'company-1',
+      'user-1',
+      'period-1',
+      parsed,
+      baseMap,
+      'V', // fallback used because source series is empty
+    )
+
+    expect(result.created).toBe(2)
+    expect(result.seriesUsed).toEqual(['V'])
+    expect(journalEntryInserts.every((r) => r.voucher_series === 'V')).toBe(true)
+  })
+
+  it('records source series in voucherNumberMapping for audit trail', async () => {
+    const { supabase } = buildCapturingSupabase()
+    const parsed = makeParsedFile({
+      vouchers: [
+        makeVoucher('B', 1),
+        makeVoucher('C', 7),
+      ],
+    })
+
+    const result = await importVouchers(
+      supabase,
+      'company-1',
+      'user-1',
+      'period-1',
+      parsed,
+      baseMap,
+      'B',
+    )
+
+    expect(result.voucherNumberMapping).toEqual([
+      { sourceId: 'B1', series: 'B', targetNumber: 1 },
+      { sourceId: 'C7', series: 'C', targetNumber: 1 },
+    ])
+  })
+
+  it('assigns independent sequential target numbers per series', async () => {
+    const { supabase, journalEntryInserts } = buildCapturingSupabase()
+    const parsed = makeParsedFile({
+      vouchers: [
+        makeVoucher('B', 1),
+        makeVoucher('B', 2),
+        makeVoucher('B', 3),
+        makeVoucher('C', 1),
+        makeVoucher('C', 2),
+      ],
+    })
+
+    await importVouchers(
+      supabase,
+      'company-1',
+      'user-1',
+      'period-1',
+      parsed,
+      baseMap,
+      'B',
+    )
+
+    const bNumbers = journalEntryInserts
+      .filter((r) => r.voucher_series === 'B')
+      .map((r) => r.voucher_number)
+    const cNumbers = journalEntryInserts
+      .filter((r) => r.voucher_series === 'C')
+      .map((r) => r.voucher_number)
+
+    // Each series starts at 1 and increments independently — not globally continuous
+    expect(bNumbers).toEqual([1, 2, 3])
+    expect(cNumbers).toEqual([1, 2])
+  })
+})
@@ -459,16 +459,26 @@ async function createOpeningBalanceEntry(
 }

 /**
- * Create journal entries from vouchers using batch insert for performance
+ * Create journal entries from vouchers using batch insert for performance.
+ *
+ * Preserves per-voucher series from the source SIE file so customers migrating
+ * from systems like Fortnox (which uses B=kundfakturor, C=inbetalningar, etc.)
+ * retain traceability back to their original bookkeeping. Source voucher
+ * numbers are renumbered per target series via next_voucher_number to avoid
+ * collisions with existing entries; the source (series, number) is preserved
+ * in MigrationDocumentation.voucherNumberMapping for audit trail (BFNAR 2013:2).
+ *
+ * `defaultSeries` is used as a fallback only for vouchers that arrive with an
+ * empty series (e.g., SIE4I import files, per spec §5.15).
 */
-async function importVouchers(
+export async function importVouchers(
  supabase: SupabaseClient,
  companyId: string,
  userId: string,
  fiscalPeriodId: string,
  parsed: ParsedSIEFile,
  accountMap: Map<string, string>,
-  voucherSeries: string
+  defaultSeries: string
 ): Promise<{
  created: number
  ids: string[]
@@ -491,7 +501,8 @@ async function importVouchers(
    mappedLineCount?: number
    originalLineCount?: number
  }[]
-  voucherNumberMapping: Array<{ sourceId: string; targetNumber: number }>
+  voucherNumberMapping: Array<{ sourceId: string; series: string; targetNumber: number }>
+  seriesUsed: string[]
  retriedBatches: number
  failedBatches: number
 }> {
@@ -517,7 +528,8 @@ async function importVouchers(
      mappedLineCount?: number
      originalLineCount?: number
    }[],
-    voucherNumberMapping: [] as Array<{ sourceId: string; targetNumber: number }>,
+    voucherNumberMapping: [] as Array<{ sourceId: string; series: string; targetNumber: number }>,
+    seriesUsed: [] as string[],
    retriedBatches: 0,
    failedBatches: 0,
  }
@@ -525,6 +537,7 @@ async function importVouchers(
  // Pre-filter and prepare all valid vouchers
  interface PreparedVoucher {
    sourceId: string
+    series: string
    date: string
    description: string
    lines: { account_number: string; debit_amount: number; credit_amount: number; line_description: string | null }[]
@@ -653,8 +666,16 @@ async function importVouchers(
      }
    }

+    // Resolve per-voucher series from the parsed SIE record. Fall back to the
+    // caller-supplied default only when the source voucher has no series
+    // (e.g., SIE4I subsystem import files where series/verno are optional).
+    const resolvedSeries = voucher.series && voucher.series.trim()
+      ? voucher.series.trim()
+      : defaultSeries
+
    preparedVouchers.push({
      sourceId: voucherId,
+      series: resolvedSeries,
      date: formatDate(voucher.date),
      description: voucher.description || `Import: ${voucher.series}${voucher.number}`,
      lines,
@@ -689,24 +710,21 @@ async function importVouchers(
    accountIdMap.set(acc.account_number, acc.id)
  }

-  // Get starting voucher number
-  const { data: startNumber } = await supabase.rpc('next_voucher_number', {
-    p_company_id: companyId,
-    p_fiscal_period_id: fiscalPeriodId,
-    p_series: voucherSeries,
-  })
+  // Group prepared vouchers by series so each series' voucher numbers are
+  // reserved and assigned independently. Preserves SIE parse order within a
+  // series (Map maintains insertion order) so the first source voucher in
+  // series B becomes the first target voucher in series B.
+  const seriesGroups = new Map<string, PreparedVoucher[]>()
+  for (const v of preparedVouchers) {
+    const list = seriesGroups.get(v.series)
+    if (list) {
+      list.push(v)
+    } else {
+      seriesGroups.set(v.series, [v])
+    }
+  }

-  const currentVoucherNumber = (startNumber as number) || 1
-
-  // Reserve the full voucher number range upfront to prevent concurrent
-  // operations from claiming numbers in our range during batch insertion.
-  const reservedHighest = currentVoucherNumber + preparedVouchers.length - 1
-  await supabase.rpc('reserve_voucher_range', {
-    p_company_id: companyId,
-    p_fiscal_period_id: fiscalPeriodId,
-    p_series: voucherSeries,
-    p_highest_used: reservedHighest,
-  })
+  results.seriesUsed = [...seriesGroups.keys()]

  // Batch insert journal entries (in chunks of 100) with retry logic.
  // Retries handle transient errors (Supabase rate limits, Cloudflare 500s).
@@ -715,10 +733,35 @@ async function importVouchers(
  const INTER_BATCH_DELAY_MS = 50  // Prevent rate limiting under sustained load
  let retriedBatches = 0
  let failedBatches = 0
-  let highestInsertedVoucher = currentVoucherNumber - 1  // nothing inserted yet

-  for (let batchStart = 0; batchStart < preparedVouchers.length; batchStart += BATCH_SIZE) {
-    const batch = preparedVouchers.slice(batchStart, batchStart + BATCH_SIZE)
+  // Process each series as an independent mini-import. Voucher numbers must
+  // be monotonically increasing within a series; grouping first guarantees
+  // that without needing to interleave series-specific counters in one loop.
+  let seriesIndex = 0
+  for (const [series, groupVouchers] of seriesGroups) {
+    // Get starting voucher number for this series
+    const { data: startNumber } = await supabase.rpc('next_voucher_number', {
+      p_company_id: companyId,
+      p_fiscal_period_id: fiscalPeriodId,
+      p_series: series,
+    })
+
+    const currentVoucherNumber = (startNumber as number) || 1
+
+    // Reserve the full voucher number range upfront to prevent concurrent
+    // operations from claiming numbers in our range during batch insertion.
+    const reservedHighest = currentVoucherNumber + groupVouchers.length - 1
+    await supabase.rpc('reserve_voucher_range', {
+      p_company_id: companyId,
+      p_fiscal_period_id: fiscalPeriodId,
+      p_series: series,
+      p_highest_used: reservedHighest,
+    })
+
+    let highestInsertedVoucher = currentVoucherNumber - 1  // nothing inserted yet
+
+  for (let batchStart = 0; batchStart < groupVouchers.length; batchStart += BATCH_SIZE) {
+    const batch = groupVouchers.slice(batchStart, batchStart + BATCH_SIZE)
    const batchNumber = Math.floor(batchStart / BATCH_SIZE) + 1
    let batchWasRetried = false

@@ -728,7 +771,7 @@ async function importVouchers(
      company_id: companyId,
      fiscal_period_id: fiscalPeriodId,
      voucher_number: currentVoucherNumber + batchStart + i,
-      voucher_series: voucherSeries,
+      voucher_series: series,
      entry_date: v.date,
      description: v.description,
      source_type: 'import',
@@ -803,6 +846,7 @@ async function importVouchers(

      results.voucherNumberMapping.push({
        sourceId: voucher.sourceId,
+        series: voucher.series,
        targetNumber: assignedNumber,
      })

@@ -880,25 +924,30 @@ async function importVouchers(
    }

    // Small delay between batches to prevent Supabase/Cloudflare rate limiting
-    if (batchStart + BATCH_SIZE < preparedVouchers.length) {
+    const isLastBatchInSeries = batchStart + BATCH_SIZE >= groupVouchers.length
+    const isLastSeries = seriesIndex === seriesGroups.size - 1
+    if (!isLastBatchInSeries || !isLastSeries) {
      await new Promise(resolve => setTimeout(resolve, INTER_BATCH_DELAY_MS))
    }
  }

-  // Adjust voucher sequence after insertion.
-  // Range was pre-reserved to `reservedHighest`. If some batches failed,
-  // release the unused portion to avoid burned numbers and gap-explanation friction.
-  if (highestInsertedVoucher < reservedHighest) {
-    const releaseTarget = highestInsertedVoucher >= currentVoucherNumber
-      ? highestInsertedVoucher       // partial success: set to actual highest
-      : currentVoucherNumber - 1     // total failure: roll back fully
-    await supabase.rpc('release_voucher_range', {
-      p_company_id: companyId,
-      p_fiscal_period_id: fiscalPeriodId,
-      p_series: voucherSeries,
-      p_actual_last: releaseTarget,
-      p_reserved_highest: reservedHighest,
-    })
+    // Adjust voucher sequence after insertion for this series.
+    // Range was pre-reserved to `reservedHighest`. If some batches failed,
+    // release the unused portion to avoid burned numbers and gap-explanation friction.
+    if (highestInsertedVoucher < reservedHighest) {
+      const releaseTarget = highestInsertedVoucher >= currentVoucherNumber
+        ? highestInsertedVoucher       // partial success: set to actual highest
+        : currentVoucherNumber - 1     // total failure: roll back fully
+      await supabase.rpc('release_voucher_range', {
+        p_company_id: companyId,
+        p_fiscal_period_id: fiscalPeriodId,
+        p_series: series,
+        p_actual_last: releaseTarget,
+        p_reserved_highest: reservedHighest,
+      })
+    }
+
+    seriesIndex++
  }

  // Propagate batch retry stats
@@ -916,6 +965,29 @@ export function isBalanceSheetAccount(accountNumber: string): boolean {
  return firstDigit >= 1 && firstDigit <= 2
 }

+/**
+ * Compute per-series voucher number ranges from the voucher number mapping.
+ * SIE imports can span multiple series (B, C, V, ...), each with its own
+ * independent target-number range, so the documentation records one range
+ * per series.
+ */
+export function computeVoucherNumberRanges(
+  mapping: Array<{ sourceId: string; series: string; targetNumber: number }>
+): Array<{ series: string; from: number; to: number }> {
+  if (mapping.length === 0) return []
+  const bySeries = new Map<string, { from: number; to: number }>()
+  for (const entry of mapping) {
+    const existing = bySeries.get(entry.series)
+    if (existing) {
+      if (entry.targetNumber < existing.from) existing.from = entry.targetNumber
+      if (entry.targetNumber > existing.to) existing.to = entry.targetNumber
+    } else {
+      bySeries.set(entry.series, { from: entry.targetNumber, to: entry.targetNumber })
+    }
+  }
+  return [...bySeries.entries()].map(([series, range]) => ({ series, ...range }))
+}
+
 /**
 * Create a migration adjustment entry (omföringsverifikation) to reconcile
 * imported voucher movements against the SIE file's closing balances.
@@ -1470,7 +1542,8 @@ export async function executeSIEImport(
    let ibRoundingAdjustment = 0
    let ibExplanation: 'unallocated_result' | 'excluded_accounts' | 'rounding' | null = null
    let migrationAdjustmentInfo = { created: false, deltaAccounts: 0, entryId: null as string | null }
-    let voucherNumberMapping: Array<{ sourceId: string; targetNumber: number }> = []
+    let voucherNumberMapping: Array<{ sourceId: string; series: string; targetNumber: number }> = []
+    let voucherSeriesUsed: string[] = []
    let voucherRetryStats = { retriedBatches: 0, failedBatches: 0 }
    let voucherStats = {
      total: parsed.vouchers.length,
@@ -1480,7 +1553,9 @@ export async function executeSIEImport(
      skippedSingleLine: 0,
      skippedEmpty: 0,
    }
-    const voucherSeries = options.voucherSeries || 'B'
+    // Fallback series for vouchers that arrive without one (SIE4I subsystem files).
+    // Source series from #VER are preserved per-voucher by importVouchers.
+    const defaultSeries = options.voucherSeries || 'B'

    // Validate and import opening balances.
    //
@@ -1591,13 +1666,14 @@ export async function executeSIEImport(
        result.fiscalPeriodId,
        parsed,
        accountMap,
-        voucherSeries
+        defaultSeries
      )

      result.journalEntriesCreated += voucherResults.created
      result.journalEntryIds.push(...voucherResults.ids)
      result.errors.push(...voucherResults.errors)
      voucherNumberMapping = voucherResults.voucherNumberMapping
+      voucherSeriesUsed = voucherResults.seriesUsed
      voucherRetryStats = {
        retriedBatches: voucherResults.retriedBatches,
        failedBatches: voucherResults.failedBatches,
@@ -1694,7 +1770,7 @@ export async function executeSIEImport(
        end: fiscalYearEnd,
      },
      importedAt: new Date().toISOString(),
-      importedBy: companyId,
+      importedBy: userId,
      accountMappings: {
        total: mappingStats.total,
        exact: mappingStats.exact,
@@ -1705,13 +1781,8 @@ export async function executeSIEImport(
      vouchers: voucherStats,
      openingBalanceRounding: ibRoundingAdjustment !== 0 ? ibRoundingAdjustment : null,
      migrationAdjustment: migrationAdjustmentInfo,
-      voucherSeriesUsed: voucherSeries,
-      voucherNumberRange: voucherNumberMapping.length > 0
-        ? {
-            from: voucherNumberMapping[0].targetNumber,
-            to: voucherNumberMapping[voucherNumberMapping.length - 1].targetNumber,
-          }
-        : null,
+      voucherSeriesUsed: voucherSeriesUsed.length > 0 ? voucherSeriesUsed : [defaultSeries],
+      voucherNumberRanges: computeVoucherNumberRanges(voucherNumberMapping),
      voucherNumberMapping,
    }

@@ -383,11 +383,15 @@ export interface MigrationDocumentation {
    entryId: string | null
  }

-  // Voucher number mapping
-  voucherSeriesUsed: string
-  voucherNumberRange: { from: number; to: number } | null
+  // Voucher number mapping.
+  // Per-voucher series is preserved from the source SIE file (e.g., Fortnox uses
+  // B=kundfakturor, C=inbetalningar), so a single import may span multiple series
+  // and each series has its own independent target-number range.
+  voucherSeriesUsed: string[]
+  voucherNumberRanges: Array<{ series: string; from: number; to: number }>
  voucherNumberMapping: Array<{
-    sourceId: string    // e.g. "A1"
+    sourceId: string    // e.g. "B1"
+    series: string      // target series (same as source unless fallback applied)
    targetNumber: number
  }>
 }