مؤسسات الدفع: تطبيق منشور البنك المركزي التونسي 2026-10

// payment-institution.ts — BCT Circular 2026-10
// Amounts are in millimes (1 dinar = 1,000 millimes), always whole numbers.
export type Millimes = number;
export const TND = (dinars: number): Millimes => Math.round(dinars * 1000);
 
export type HolderKind = 'natural' | 'legal';
export type AccountKind = 'level1' | 'level2' | 'level3' | 'merchant';
 
export interface Account {
  id: string;
  holderId: string;
  holderKind: HolderKind;
  kind: AccountKind;
  balance: Millimes;
}
 
export interface Limits {
  balanceCap: Millimes | null;              // null = no ceiling
  dailyCashWithdrawalCap: Millimes | null;  // null = none set by the text
}
 
// Article 17 for client accounts; Article 23 exempts merchant accounts.
export const LIMITS: Record<AccountKind, Limits> = {
  level1: { balanceCap: TND(1_500), dailyCashWithdrawalCap: null },
  level2: { balanceCap: TND(5_000), dailyCashWithdrawalCap: TND(3_000) },
  level3: { balanceCap: TND(20_000), dailyCashWithdrawalCap: TND(10_000) },
  merchant: { balanceCap: null, dailyCashWithdrawalCap: null },
};
 
export class RuleError extends Error {
  constructor(public readonly article: string, detail: string) {
    super(`${article}: ${detail}`);
  }
}

export type OpeningRequest = Omit<Account, 'balance'>;
 
export function assertCanOpen(existing: readonly Account[], req: OpeningRequest): Account {
  if (req.kind === 'level1' && req.holderKind !== 'natural') {
    throw new RuleError('Art. 17', 'a level 1 account is reserved for natural persons');
  }
  const isClient = (k: AccountKind) => k !== 'merchant';
  if (isClient(req.kind) && existing.some((a) => a.holderId === req.holderId && isClient(a.kind))) {
    throw new RuleError('Art. 21', 'this holder already has a client payment account');
  }
  return { ...req, balance: 0 };
}

export type OperationType =
  | 'cash_deposit'
  | 'cash_withdrawal'
  | 'transfer_in'
  | 'transfer_out'
  | 'cash_transfer'      // Art. 2, fourth dash: transfer funded by handing over cash
  | 'foreign_receipt'    // Art. 2: funds received from abroad (dinar counter-value)
  | 'merchant_receipt'   // a payment accepted by a merchant (Art. 23)
  | 'direct_debit'
  | 'payment';
 
export interface Operation {
  id: string;
  accountId: string;
  type: OperationType;
  amount: Millimes;          // always positive; the type gives the direction
  executedAt: Date;
  channel: string;           // your own channel codes, used for RAM06
  justificationRef?: string; // Art. 3: capped operations must be justified
}
 
const CREDITS: ReadonlySet<OperationType> = new Set<OperationType>([
  'cash_deposit', 'transfer_in', 'cash_transfer', 'foreign_receipt', 'merchant_receipt',
]);
export const isCredit = (t: OperationType): boolean => CREDITS.has(t);
 
// Article 3: per-operation ceilings.
export const PER_OPERATION_CAP: Partial<Record<OperationType, Millimes>> = {
  cash_transfer: TND(3_000),
  foreign_receipt: TND(20_000),
};
 
export function assertOperationCaps(op: Operation): void {
  const cap = PER_OPERATION_CAP[op.type];
  if (cap === undefined) return;
  if (op.amount > cap) {
    throw new RuleError('Art. 3', `${op.type} is capped at ${cap / 1000} TND per operation`);
  }
  if (!op.justificationRef) {
    throw new RuleError('Art. 3', `${op.type} must be duly justified`);
  }
}

// Tunisia is UTC+1 all year (no daylight saving since 2009).
const TUNIS_OFFSET_MS = 60 * 60 * 1000;
export const tunisDay = (d: Date): string =>
  new Date(d.getTime() + TUNIS_OFFSET_MS).toISOString().slice(0, 10);
 
export function post(account: Account, op: Operation, history: readonly Operation[]): Account {
  if (op.accountId !== account.id) throw new RuleError('Ledger', 'operation posted to the wrong account');
  if (!Number.isInteger(op.amount) || op.amount <= 0) {
    throw new RuleError('Ledger', 'amount must be a positive whole number of millimes');
  }
  assertOperationCaps(op);
  const limits = LIMITS[account.kind];
 
  if (isCredit(op.type)) {
    if (account.kind === 'merchant' && op.type !== 'merchant_receipt') {
      throw new RuleError('Art. 23', 'a merchant account is credited only by accepted payments');
    }
    if (account.kind !== 'merchant' && op.type === 'merchant_receipt') {
      throw new RuleError('Art. 23', 'merchant receipts go to a merchant account');
    }
    const next = account.balance + op.amount;
    if (limits.balanceCap !== null && next > limits.balanceCap) {
      throw new RuleError('Art. 17', `balance would exceed ${limits.balanceCap / 1000} TND`);
    }
    return { ...account, balance: next };
  }
 
  const next = account.balance - op.amount;
  if (next < 0) throw new RuleError('Art. 22', 'a payment account can never be overdrawn');
 
  const cap = limits.dailyCashWithdrawalCap;
  if (op.type === 'cash_withdrawal' && cap !== null) {
    const day = tunisDay(op.executedAt);
    const used = history
      .filter((o) => o.accountId === account.id && o.type === 'cash_withdrawal' && tunisDay(o.executedAt) === day)
      .reduce((sum, o) => sum + o.amount, 0);
    if (used + op.amount > cap) {
      throw new RuleError('Art. 17', `cash withdrawals are capped at ${cap / 1000} TND per day`);
    }
  }
  return { ...account, balance: next };
}

import { createHash } from 'node:crypto';
 
export interface RegisterEntry {
  seq: number;
  op: Operation;
  balanceAfter: Millimes;
  retainUntil: Date;
  prevHash: string;
  hash: string;
}
 
// Article 16: kept for at least ten years from the date of execution.
export function retainUntil(executedAt: Date): Date {
  const d = new Date(executedAt.getTime());
  d.setUTCFullYear(d.getUTCFullYear() + 10);
  return d;
}
 
const digest = (prevHash: string, seq: number, op: Operation, balanceAfter: Millimes): string =>
  createHash('sha256')
    .update(JSON.stringify([prevHash, seq, op.id, op.accountId, op.type, op.amount,
      op.executedAt.toISOString(), op.channel, op.justificationRef ?? null, balanceAfter]))
    .digest('hex');
 
export function append(register: readonly RegisterEntry[], op: Operation, balanceAfter: Millimes): RegisterEntry {
  const last = register[register.length - 1];
  const seq = last ? last.seq + 1 : 1;
  const prevHash = last ? last.hash : 'genesis';
  return { seq, op, balanceAfter, retainUntil: retainUntil(op.executedAt), prevHash,
    hash: digest(prevHash, seq, op, balanceAfter) };
}
 
// Returns the first broken sequence number, or null if the chain is intact.
export function verifyChain(register: readonly RegisterEntry[]): number | null {
  let prev = 'genesis';
  for (const [i, e] of register.entries()) {
    if (e.seq !== i + 1 || e.prevHash !== prev || e.hash !== digest(prev, e.seq, e.op, e.balanceAfter)) return e.seq;
    prev = e.hash;
  }
  return null;
}
 
export const mayPurge = (e: RegisterEntry, now: Date): boolean => now.getTime() >= e.retainUntil.getTime();

export interface Reconciliation {
  globalBalance: Millimes;
  sumOfAccounts: Millimes;
  difference: Millimes; // positive = more in the global account than owed to holders
  ok: boolean;
}
 
// Articles 25 and 26: the global account equals the sum of client and merchant balances.
export function reconcile(globalBalance: Millimes, accounts: readonly Account[]): Reconciliation {
  const sumOfAccounts = accounts.reduce((sum, a) => sum + a.balance, 0);
  const difference = globalBalance - sumOfAccounts;
  return { globalBalance, sumOfAccounts, difference, ok: difference === 0 };
}
 
const DAY_MS = 86_400_000;
const isNonWorking = (d: Date, holidays: ReadonlySet<string>): boolean => {
  const weekday = d.getUTCDay();
  return weekday === 0 || weekday === 6 || holidays.has(d.toISOString().slice(0, 10));
};
 
// Article 24: funds reach the global account no later than the next working day after receipt.
// Holidays are an input: the religious ones move every year.
export function depositDeadline(receivedAt: Date, holidays: ReadonlySet<string>): string {
  let d = new Date(`${tunisDay(receivedAt)}T00:00:00Z`);
  do {
    d = new Date(d.getTime() + DAY_MS);
  } while (isNonWorking(d, holidays));
  return d.toISOString().slice(0, 10);
}

export interface Trial {
  genuine: boolean;  // true: a real person with their own valid document
  accepted: boolean; // what the onboarding process decided
}
 
export interface PerformanceReport {
  trials: number;
  falseAcceptanceRate: number; // impostors accepted / impostor trials
  falseRejectionRate: number;  // genuine rejected / genuine trials
  reliability: number;         // correct decisions / all trials
}
 
export function performance(trials: readonly Trial[]): PerformanceReport {
  const impostors = trials.filter((t) => !t.genuine);
  const genuine = trials.filter((t) => t.genuine);
  if (impostors.length === 0 || genuine.length === 0) {
    throw new RuleError('Art. 18', 'the test set needs both genuine and impostor trials');
  }
  const falseAccepts = impostors.filter((t) => t.accepted).length;
  const falseRejects = genuine.filter((t) => !t.accepted).length;
  return {
    trials: trials.length,
    falseAcceptanceRate: falseAccepts / impostors.length,
    falseRejectionRate: falseRejects / genuine.length,
    reliability: (trials.length - falseAccepts - falseRejects) / trials.length,
  };
}

export interface OnboardingEvidence {
  documentAuthenticity: boolean;
  liveness: boolean;
  twoFactor: boolean;
  explicitConsent: boolean;
  encryption: boolean;
  autoKycRecord: boolean;
  register?: PerformanceReport;  // from pre-production, Step 7
  penTestReportRef?: string;     // by a body approved by ANCS
  lastAuditAt?: Date;
  lastMaterialChangeAt?: Date;   // regulatory or technological change since then
}
 
const addYears = (d: Date, years: number): Date => {
  const out = new Date(d.getTime());
  out.setUTCFullYear(out.getUTCFullYear() + years);
  return out;
};
 
// maxFalseAcceptance is your own risk appetite: the circular names the rate, not a threshold.
export function goLiveBlockers(e: OnboardingEvidence, maxFalseAcceptance: number, now: Date): string[] {
  const blockers: string[] = [];
  const required: [keyof OnboardingEvidence, string][] = [
    ['documentAuthenticity', 'document authenticity check'],
    ['liveness', 'liveness check'],
    ['twoFactor', 'two-factor authentication'],
    ['explicitConsent', 'explicit consent to data processing'],
    ['encryption', 'encryption of personal data'],
    ['autoKycRecord', 'automatic KYC record'],
  ];
  for (const [key, label] of required) if (e[key] !== true) blockers.push(`Art. 18: missing ${label}`);
 
  if (!e.register) blockers.push('Art. 18: no pre-production performance register');
  else if (e.register.falseAcceptanceRate > maxFalseAcceptance) {
    blockers.push(`Art. 18: false acceptance ${e.register.falseAcceptanceRate} above ${maxFalseAcceptance}`);
  }
  if (!e.penTestReportRef) blockers.push('Art. 18: no penetration test by an ANCS-approved body');
 
  if (!e.lastAuditAt) blockers.push('Art. 18: no security audit');
  else if (now.getTime() >= addYears(e.lastAuditAt, 2).getTime()) blockers.push('Art. 18: audit older than two years');
  else if (e.lastMaterialChangeAt && e.lastMaterialChangeAt.getTime() > e.lastAuditAt.getTime()) {
    blockers.push('Art. 18: material change since the last audit');
  }
  return blockers;
}

export type Frequency = 'monthly' | 'quarterly' | 'annual';
 
export interface PeriodicReturn {
  code: string;
  frequency: Frequency;
  format: 'XML' | 'PDF';
}
 
const rows = (frequency: Frequency, format: 'XML' | 'PDF', codes: string[]): PeriodicReturn[] =>
  codes.map((code) => ({ code, frequency, format }));
 
// Annex 1 bis to Circular 2017-6, as added by Article 50 of Circular 2026-10.
export const ANNEX_1_BIS: PeriodicReturn[] = [
  ...rows('monthly', 'XML', ['RAM05', 'RAM06']),
  ...rows('quarterly', 'XML', ['RCT03', 'RCT04', 'RAT07', 'RST650', 'RROT390', 'RLABFTT330']),
  ...rows('quarterly', 'PDF', ['RGT240140', 'RGT240150']),
  ...rows('annual', 'XML', ['RAA10', 'RAA20', 'RGA210', 'RGA220', 'RGA230', 'RLABFTA310']),
  ...rows('annual', 'PDF', ['RAA783', 'RGA240009', 'RGA240020', 'RGA240030', 'RGA240050', 'RGA240190',
    'RCIA250100', 'RCIA250110', 'RCIA250120', 'RCIA250130', 'RCIA250140', 'RCIA250150', 'RCIA250160',
    'RLABFTA320', 'RLABFTA350']),
];
 
// DR+15, DR+30, DR+45: counted here in calendar days from the reference date.
export const DAYS_AFTER_DR: Record<Frequency, number> = { monthly: 15, quarterly: 30, annual: 45 };
 
const addDays = (isoDay: string, days: number): string =>
  new Date(Date.parse(`${isoDay}T00:00:00Z`) + days * 86_400_000).toISOString().slice(0, 10);
 
const isMonthEnd = (isoDay: string): boolean => addDays(isoDay, 1).slice(8, 10) === '01';
 
export function frequenciesClosingOn(referenceDate: string): Frequency[] {
  if (!isMonthEnd(referenceDate)) return [];
  const month = referenceDate.slice(5, 7);
  const out: Frequency[] = ['monthly'];
  if (['03', '06', '09', '12'].includes(month)) out.push('quarterly');
  if (month === '12') out.push('annual');
  return out;
}
 
export interface Due {
  code: string;
  format: 'XML' | 'PDF' | null; // null: the annex leaves the cell blank
  referenceDate: string;
  due: string;
}
 
export function returnsDue(referenceDate: string): Due[] {
  const closing = frequenciesClosingOn(referenceDate);
  return ANNEX_1_BIS
    .filter((r) => closing.includes(r.frequency))
    .map((r) => ({ code: r.code, format: r.format, referenceDate, due: addDays(referenceDate, DAYS_AFTER_DR[r.frequency]) }));
}
 
// Serious incidents: RROI380 on the day, RROI381 on the day plus ten.
export function incidentReturns(occurredAt: Date): Due[] {
  const day = tunisDay(occurredAt);
  return [
    { code: 'RROI380', format: 'XML', referenceDate: day, due: day },
    { code: 'RROI381', format: null, referenceDate: day, due: addDays(day, 10) },
  ];
}

export interface ChannelLine {
  channel: string;
  count: number;
  amount: Millimes;
}
 
// RAM06: operations by channel, in number and in value, for one month (Tunis time).
export function ram06(ops: readonly Operation[], month: string /* YYYY-MM */): ChannelLine[] {
  const lines = new Map<string, ChannelLine>();
  for (const op of ops) {
    if (tunisDay(op.executedAt).slice(0, 7) !== month) continue;
    const line = lines.get(op.channel) ?? { channel: op.channel, count: 0, amount: 0 };
    line.count += 1;
    line.amount += op.amount;
    lines.set(op.channel, line);
  }
  return [...lines.values()].sort((a, b) => a.channel.localeCompare(b.channel));
}

import { test } from 'node:test';
import assert from 'node:assert/strict';
import {
  TND, assertCanOpen, post, append, verifyChain, mayPurge, reconcile, depositDeadline,
  performance, goLiveBlockers, returnsDue, incidentReturns, ram06, RuleError,
  type Account, type Operation, type OnboardingEvidence,
} from './payment-institution';
 
const at = (iso: string) => new Date(iso);
const acct = (kind: Account['kind'], balance = 0): Account =>
  ({ id: 'A1', holderId: 'H1', holderKind: 'natural', kind, balance });
const op = (type: Operation['type'], dinars: number, iso = '2026-12-28T09:00:00Z', extra: Partial<Operation> = {}): Operation =>
  ({ id: `${type}-${iso}-${dinars}`, accountId: 'A1', type, amount: TND(dinars), executedAt: at(iso), channel: 'app', ...extra });
const article = (fn: () => unknown) => {
  try { fn(); } catch (e) { return (e as RuleError).article; }
  return 'none';
};
 
test('Art. 17: level 1 is for natural persons only', () => {
  assert.equal(article(() => assertCanOpen([], { id: 'X', holderId: 'C1', holderKind: 'legal', kind: 'level1' })), 'Art. 17');
  assert.equal(assertCanOpen([], { id: 'X', holderId: 'C1', holderKind: 'legal', kind: 'level2' }).balance, 0);
});
 
test('Art. 21: one client account per holder, merchant account aside', () => {
  const existing = [acct('level2')];
  assert.equal(article(() => assertCanOpen(existing, { id: 'B', holderId: 'H1', holderKind: 'natural', kind: 'level3' })), 'Art. 21');
  assert.equal(article(() => assertCanOpen(existing, { id: 'M', holderId: 'H1', holderKind: 'natural', kind: 'merchant' })), 'none');
});
 
test('Art. 17: balance ceilings, inclusive', () => {
  assert.equal(post(acct('level1', TND(1_000)), op('transfer_in', 500), []).balance, TND(1_500));
  assert.equal(article(() => post(acct('level1', TND(1_000)), op('transfer_in', 500.001), [])), 'Art. 17');
  assert.equal(article(() => post(acct('level3', TND(19_999)), op('cash_deposit', 2), [])), 'Art. 17');
});
 
test('Art. 17: daily cash withdrawal cap counts the Tunis day', () => {
  const a = acct('level2', TND(5_000));
  const morning = op('cash_withdrawal', 2_000, '2026-12-28T08:00:00Z');
  assert.equal(article(() => post(a, op('cash_withdrawal', 1_001, '2026-12-28T15:00:00Z'), [morning])), 'Art. 17');
  assert.equal(post(a, op('cash_withdrawal', 1_000, '2026-12-28T15:00:00Z'), [morning]).balance, TND(4_000));
  // 23:30 UTC on the 28th is 00:30 on the 29th in Tunis: a new day.
  assert.equal(post(a, op('cash_withdrawal', 3_000, '2026-12-28T23:30:00Z'), [morning]).balance, TND(2_000));
  // A transfer out is not a cash withdrawal.
  assert.equal(post(a, op('transfer_out', 4_000), [morning]).balance, TND(1_000));
});
 
test('Art. 22: never overdrawn', () => {
  assert.equal(article(() => post(acct('level3', TND(100)), op('payment', 100.001), [])), 'Art. 22');
});
 
test('Art. 23: merchant account takes accepted payments only, no ceiling', () => {
  assert.equal(post(acct('merchant', TND(50_000)), op('merchant_receipt', 10_000), []).balance, TND(60_000));
  assert.equal(article(() => post(acct('merchant'), op('transfer_in', 10), [])), 'Art. 23');
  assert.equal(article(() => post(acct('level2'), op('merchant_receipt', 10), [])), 'Art. 23');
});
 
test('Art. 3: per-operation caps and justification', () => {
  const a = acct('level3');
  assert.equal(article(() => post(a, op('cash_transfer', 3_000.001, undefined, { justificationRef: 'J1' }), [])), 'Art. 3');
  assert.equal(article(() => post(a, op('cash_transfer', 100), [])), 'Art. 3');
  assert.equal(post(a, op('foreign_receipt', 20_000, undefined, { justificationRef: 'SWIFT-1' }), []).balance, TND(20_000));
  assert.equal(article(() => post(a, op('foreign_receipt', 20_000.001, undefined, { justificationRef: 'S' }), [])), 'Art. 3');
});
 
test('Ledger: millimes are whole numbers', () => {
  assert.equal(article(() => post(acct('level2'), { ...op('transfer_in', 1), amount: 1.5 }, [])), 'Ledger');
});
 
test('Art. 16: hash chain and ten-year retention', () => {
  const r1 = append([], op('transfer_in', 10, '2026-12-28T09:00:00Z'), TND(10));
  const r2 = append([r1], op('payment', 4, '2026-12-29T09:00:00Z'), TND(6));
  assert.equal(verifyChain([r1, r2]), null);
  assert.equal(verifyChain([r1, { ...r2, balanceAfter: TND(7) }]), 2);
  assert.equal(r1.retainUntil.toISOString(), '2036-12-28T09:00:00.000Z');
  assert.equal(mayPurge(r1, at('2036-12-28T08:59:59Z')), false);
  assert.equal(mayPurge(r1, at('2036-12-28T09:00:00Z')), true);
});
 
test('Arts 24-26: reconciliation and next working day', () => {
  const accounts = [acct('level1', TND(1_200)), { ...acct('merchant', TND(8_800)), id: 'M1' }];
  assert.deepEqual(reconcile(TND(10_000), accounts), { globalBalance: 10_000_000, sumOfAccounts: 10_000_000, difference: 0, ok: true });
  assert.equal(reconcile(TND(10_015), accounts).difference, TND(15));
  const none = new Set<string>();
  assert.equal(depositDeadline(at('2026-12-31T10:00:00Z'), none), '2027-01-01');
  assert.equal(depositDeadline(at('2026-12-31T10:00:00Z'), new Set(['2027-01-01'])), '2027-01-04');
  // Friday 23:30 UTC is Saturday in Tunis: next working day is Monday.
  assert.equal(depositDeadline(at('2027-01-08T23:30:00Z'), none), '2027-01-11');
});
 
test('Art. 18: performance register rates', () => {
  const trials = [
    ...Array.from({ length: 98 }, () => ({ genuine: true, accepted: true })),
    ...Array.from({ length: 2 }, () => ({ genuine: true, accepted: false })),
    ...Array.from({ length: 199 }, () => ({ genuine: false, accepted: false })),
    { genuine: false, accepted: true },
  ];
  const r = performance(trials);
  assert.equal(r.falseAcceptanceRate, 0.005);
  assert.equal(r.falseRejectionRate, 0.02);
  assert.equal(r.reliability, 0.99);
  assert.throws(() => performance([{ genuine: true, accepted: true }]), RuleError);
});
 
test('Art. 18: go-live gate', () => {
  const ready: OnboardingEvidence = {
    documentAuthenticity: true, liveness: true, twoFactor: true, explicitConsent: true, encryption: true, autoKycRecord: true,
    register: { trials: 300, falseAcceptanceRate: 0.005, falseRejectionRate: 0.02, reliability: 0.99 },
    penTestReportRef: 'PT-2026-11', lastAuditAt: at('2026-11-15T00:00:00Z'),
  };
  const now = at('2026-12-20T00:00:00Z');
  assert.deepEqual(goLiveBlockers(ready, 0.01, now), []);
  assert.equal(goLiveBlockers(ready, 0.001, now).length, 1);
  assert.match(goLiveBlockers({ ...ready, liveness: false }, 0.01, now)[0], /liveness/);
  assert.match(goLiveBlockers(ready, 0.01, at('2028-11-15T00:00:00Z'))[0], /two years/);
  assert.match(goLiveBlockers({ ...ready, lastMaterialChangeAt: at('2026-12-01T00:00:00Z') }, 0.01, now)[0], /material change/);
});
 
test('Annex 1 bis: deadlines by reference date', () => {
  assert.deepEqual(returnsDue('2026-12-15'), []);
  const jan = returnsDue('2027-01-31');
  assert.deepEqual(jan.map((d) => d.code), ['RAM05', 'RAM06']);
  assert.equal(jan[0].due, '2027-02-15');
  const feb = returnsDue('2027-02-28');
  assert.equal(feb[0].due, '2027-03-15');
  const mar = returnsDue('2027-03-31');
  assert.equal(mar.length, 10);
  assert.equal(mar.find((d) => d.code === 'RCT03')?.due, '2027-04-30');
  const dec = returnsDue('2027-12-31');
  assert.equal(dec.length, 2 + 8 + 21);
  assert.equal(dec.find((d) => d.code === 'RCIA250100')?.due, '2028-02-14');
});
 
test('Incidents: same day and day plus ten, Tunis time', () => {
  const [now, closing] = incidentReturns(at('2027-02-03T23:15:00Z'));
  assert.equal(now.due, '2027-02-04');
  assert.equal(closing.due, '2027-02-14');
  assert.equal(closing.format, null);
});
 
test('RAM06: count and value by channel for the Tunis month', () => {
  const ops = [
    op('payment', 10, '2027-01-05T09:00:00Z', { channel: 'app' }),
    op('payment', 2.5, '2027-01-06T09:00:00Z', { channel: 'app' }),
    op('cash_deposit', 100, '2027-01-07T09:00:00Z', { channel: 'agent' }),
    op('payment', 1, '2026-12-31T23:30:00Z', { channel: 'app' }), // 00:30 on 1 Jan in Tunis
    op('payment', 7, '2027-01-31T23:30:00Z', { channel: 'app' }), // 00:30 on 1 Feb in Tunis
  ];
  assert.deepEqual(ram06(ops, '2027-01'), [
    { channel: 'agent', count: 1, amount: 100_000 },
    { channel: 'app', count: 3, amount: 13_500 },
  ]);
});