@wasto/sdk 1.0.3 → 1.0.4

package/src/roi/calculations.ts

@@ -1,732 +1,732 @@
-/**
- * Moteur ROI déchets — partagé simulateur landing / API / console.
- * Ordres de grandeur pédagogiques (non contractuels).
- */
-
-export const ROI_DEFAULTS = {
-  annualTonnage: 12_000,
-  errorRatePercent: 25,
-  costPerBadTonne: 300,
-  /** Habitants par foyer (proxy si householdCount absent). */
-  peoplePerHousehold: 2.2,
-} as const
-
-/** Coefficients Citeo outre-mer (barème pédagogique MVP). */
-export const CITEO_DOM_MULTIPLIERS = {
-  lightPackaging: 2.3,
-  glass: 1.9,
-  paper: 4.3,
-  communication: 1.25,
-  ambassadors: 1.25,
-  /** Facteur composite simplifié pour majorer un soutien Citeo agrégé saisi. */
-  compositeSupport: 2.3,
-} as const
-
-/** Départements / préfixes INSEE DOM-COM (métropole exclue). */
-export const DOM_INSEE_PREFIXES = [
-  '971', // Guadeloupe
-  '972', // Martinique
-  '973', // Guyane
-  '974', // La Réunion
-  '976', // Mayotte
-] as const
-
-/**
- * Trajectoire TGAP enfouissement (€/t) — barème pédagogique MVP.
- * 2025: 65, 2026: 69, puis +4 €/an jusqu'à 85 €/t en 2030.
- */
-export const TGAP_LANDFILL_EUR_PER_TONNE: Readonly<Record<number, number>> = {
-  2024: 61,
-  2025: 65,
-  2026: 69,
-  2027: 73,
-  2028: 77,
-  2029: 81,
-  2030: 85,
-}
-
-export function currentFiscalYear(now = new Date()): number {
-  return now.getFullYear()
-}
-
-export function getTgapEurPerTonne(fiscalYear: number): number {
-  if (TGAP_LANDFILL_EUR_PER_TONNE[fiscalYear] != null) {
-    return TGAP_LANDFILL_EUR_PER_TONNE[fiscalYear]
-  }
-  if (fiscalYear < 2024) return 61
-  if (fiscalYear > 2030) return 85
-  // Interpolation linéaire hors table
-  const base = 65
-  return base + (fiscalYear - 2025) * 4
-}
-
-/**
- * Ajuste le coût / t mal orientée quand la TGAP change d'année.
- * On conserve le « reste » (traitement hors TGAP) et on y ajoute la nouvelle TGAP.
- */
-export function adjustCostPerBadTonneForTgap(opts: {
-  previousCostPerBadTonne: number
-  previousTgapEurPerTonne: number
-  nextTgapEurPerTonne: number
-}): number {
-  const nonTgap = Math.max(
-    0,
-    opts.previousCostPerBadTonne - opts.previousTgapEurPerTonne,
-  )
-  return roundEuro(nonTgap + opts.nextTgapEurPerTonne)
-}
-
-export type AnnualRoiPoint = {
-  fiscalYear: number
-  tonnageOmr: number
-  errorRatePercent: number
-  costPerBadTonne: number
-  tgapEurPerTonne: number
-  /** GEC réel (snapshot / actions de l'année). */
-  realGecEur: number
-  /** GEC BAU : même tonnage/erreur de référence, TGAP/coût de l'année, sans réduction d'erreur. */
-  bauGecEur: number
-  cenEur: number | null
-  hasSnapshot: boolean
-  annualBilanConfirmed: boolean
-}
-
-/**
- * Série BAU vs réel pour le graphique pluriannuel.
- * `reference` = première année connue (baseline historique).
- */
-export function buildBauVsRealSeries(opts: {
-  fromYear: number
-  toYear: number
-  reference: {
-    tonnageOmr: number
-    errorRatePercent: number
-    costPerBadTonne: number
-    tgapEurPerTonne: number
-  }
-  years: Array<{
-    fiscalYear: number
-    tonnageOmr: number
-    errorRatePercent: number
-    costPerBadTonne: number
-    tgapEurPerTonne: number
-    gecEur: number
-    cenEur: number | null
-    annualBilanConfirmed?: boolean
-  }>
-}): AnnualRoiPoint[] {
-  const byYear = new Map(opts.years.map((y) => [y.fiscalYear, y]))
-  const points: AnnualRoiPoint[] = []
-  for (let y = opts.fromYear; y <= opts.toYear; y++) {
-    const tgap = getTgapEurPerTonne(y)
-    const bauCost = adjustCostPerBadTonneForTgap({
-      previousCostPerBadTonne: opts.reference.costPerBadTonne,
-      previousTgapEurPerTonne: opts.reference.tgapEurPerTonne,
-      nextTgapEurPerTonne: tgap,
-    })
-    const bau = computeGec(
-      opts.reference.tonnageOmr,
-      opts.reference.errorRatePercent,
-      bauCost,
-    )
-    const snap = byYear.get(y)
-    if (snap) {
-      points.push({
-        fiscalYear: y,
-        tonnageOmr: snap.tonnageOmr,
-        errorRatePercent: snap.errorRatePercent,
-        costPerBadTonne: snap.costPerBadTonne,
-        tgapEurPerTonne: snap.tgapEurPerTonne,
-        realGecEur: snap.gecEur,
-        bauGecEur: bau.gecEur,
-        cenEur: snap.cenEur,
-        hasSnapshot: true,
-        annualBilanConfirmed: snap.annualBilanConfirmed === true,
-      })
-    } else {
-      points.push({
-        fiscalYear: y,
-        tonnageOmr: opts.reference.tonnageOmr,
-        errorRatePercent: opts.reference.errorRatePercent,
-        costPerBadTonne: bauCost,
-        tgapEurPerTonne: tgap,
-        realGecEur: bau.gecEur,
-        bauGecEur: bau.gecEur,
-        cenEur: null,
-        hasSnapshot: false,
-        annualBilanConfirmed: false,
-      })
-    }
-  }
-  return points
-}
-
-/** Scénarios pédagogiques alignés lead magnet landing. */
-export const ROI_SCENARIO_DEFS = [
-  {
-    id: 'awareness' as const,
-    label: 'Sensibilisation seule',
-    errorReductionFactor: 0.12,
-    costBase: 8_000,
-    costPerTonne: 0.35,
-  },
-  {
-    id: 'controls' as const,
-    label: 'Formation + contrôles',
-    errorReductionFactor: 0.28,
-    costBase: 45_000,
-    costPerTonne: 1.8,
-  },
-  {
-    id: 'wasto' as const,
-    label: 'Wast-O (app + IA + pilotage)',
-    errorReductionFactor: 0.45,
-    costBase: 18_000,
-    costPerTonne: 0.9,
-  },
-]
-
-export type ImpactConfidenceLevel = 1 | 2 | 3
-
-export type ImpactConfidence = {
-  level: ImpactConfidenceLevel
-  label: string
-  tone: 'low' | 'medium' | 'high'
-  message: string
-  /** Facteur 0–1 appliqué à la réduction d'erreur pour le calcul. */
-  impactFactor: number
-}
-
-export type RoiActionInput = {
-  budgetCapexEur: number
-  budgetOpexEur: number
-  /** Réduction relative 0–100 (ex. 12 = −12 %). */
-  errorReductionPercent: number
-  status?: string
-  name?: string
-  id?: string
-  type?: string
-}
-
-export type RoiEconomicsInput = {
-  annualTonnageOmr: number
-  errorRatePercent: number
-  costPerBadTonne: number
-  citeoSupportGainEur?: number
-  wastoAnnualCostEur?: number
-  /** Taux d'erreur baseline figé (sinon = errorRatePercent courant). */
-  baselineErrorRatePercent?: number | null
-  baselineAnnualTonnageOmr?: number | null
-  /** Si true, majore les soutiens Citeo (DOM). */
-  isDomTerritory?: boolean
-  fiscalYear?: number
-  tgapEurPerTonne?: number
-  /** Bilan annuel consolidé → peut monter l'ICI global à N3. */
-  annualBilanConfirmed?: boolean
-}
-
-export type RoiLiveSignals = {
-  penetrationRatePercent: number
-  activeDevices30d: number
-  validatedVisionScans: number
-  challengeCompletions: number
-  terrainResponses: number
-  annualBilanConfirmed?: boolean
-}
-
-export type RoiIndicators = {
-  /** Gisement Économique Capturable (pertes avant). */
-  gecEur: number
-  baselineBadTonnes: number
-  baselineErrorRatePercent: number
-  afterErrorRatePercent: number
-  /** Réduction combinée effective en points de % d'erreur (ex. 5.6). */
-  combinedErrorReductionPoints: number
-  /** Réduction relative combinée (ex. 22.4 pour −22,4 %). */
-  combinedErrorReductionPercent: number
-  stackingFormula: string
-  afterAnnualLossEur: number
-  afterBadTonnes: number
-  /** Économies brutes = pertes avant − pertes après. */
-  grossSavingsEur: number
-  /** Budgets des seules actions (hors abonnement). */
-  actionsBudgetEur: number
-  /** Ligne abonnement / contrat Wast-O. */
-  wastoAnnualCostEur: number
-  totalActionBudgetsEur: number
-  citeoSupportGainEur: number
-  citeoSupportBaseEur: number
-  citeoDomMultiplier: number
-  isDomTerritory: boolean
-  /**
-   * CEN = économies brutes + Citeo − budgets cumulés
-   * (aligné avec le numérateur du ROI).
-   */
-  cenEur: number
-  /** ROI = (économies + Citeo) / budgets ; null si budget 0. */
-  roiMultiple: number | null
-  overallConfidence: ImpactConfidence
-  disclaimer: string
-}
-
-export const ROI_DISCLAIMER =
-  'Ordres de grandeur pédagogiques fondés sur des hypothèses déclaratives (tonnages, taux d’erreur, budgets). Non contractuels — à affiner avec les données exploitant / SITOM / TGAP.'
-
-function clamp(n: number, min: number, max: number): number {
-  return Math.min(max, Math.max(min, n))
-}
-
-export function roundEuro(n: number): number {
-  return Math.round(n)
-}
-
-export function isDomInseeCode(codeInsee: string | null | undefined): boolean {
-  if (!codeInsee) return false
-  const normalized = codeInsee.trim()
-  return DOM_INSEE_PREFIXES.some((p) => normalized.startsWith(p))
-}
-
-export function detectDomTerritory(opts: {
-  cityInseeCodes?: Array<string | null | undefined>
-  cityGroupCode?: string | null
-  cityGroupName?: string | null
-}): boolean {
-  if (opts.cityInseeCodes?.some((c) => isDomInseeCode(c))) return true
-  const code = (opts.cityGroupCode ?? '').toUpperCase()
-  const name = (opts.cityGroupName ?? '').toUpperCase()
-  if (name.includes('CINOR') || name.includes('REUNION') || name.includes('RÉUNION')) {
-    return true
-  }
-  if (code.includes('974') || code.includes('CINOR')) return true
-  return false
-}
-
-export function applyCiteoDomMultiplier(
-  baseCiteoEur: number,
-  isDom: boolean,
-): { baseEur: number; multiplier: number; effectiveEur: number } {
-  const baseEur = roundEuro(baseCiteoEur)
-  const multiplier = isDom ? CITEO_DOM_MULTIPLIERS.compositeSupport : 1
-  return {
-    baseEur,
-    multiplier,
-    effectiveEur: roundEuro(baseEur * multiplier),
-  }
-}
-
-/** GEC = tonnage × (taux erreur / 100) × €/t */
-export function computeGec(
-  annualTonnage: number,
-  errorRatePercent: number,
-  costPerBadTonne: number,
-): { gecEur: number; badTonnes: number } {
-  const badTonnes = annualTonnage * (errorRatePercent / 100)
-  return {
-    badTonnes: Math.round(badTonnes * 10) / 10,
-    gecEur: roundEuro(badTonnes * costPerBadTonne),
-  }
-}
-
-/**
- * Empilement multiplicatif des réductions relatives d'actions actives.
- * newRate = baseline × Π(1 − r_i/100)
- */
-export function applyStackedErrorReductions(
-  baselineErrorRatePercent: number,
-  reductionsPercent: number[],
-): number {
-  let rate = baselineErrorRatePercent
-  for (const r of reductionsPercent) {
-    const factor = clamp(r, 0, 95) / 100
-    rate = rate * (1 - factor)
-  }
-  return clamp(Math.round(rate * 10) / 10, 1, 99)
-}
-
-export function isActionCountedInRoi(status?: string): boolean {
-  if (!status) return true
-  return status !== 'CANCELLED' && status !== 'PLANNED'
-}
-
-/**
- * ICI — Indice de Confiance de l'Impact.
- * 1 = déclaratif, 2 = proxy live, 3 = mesuré / représentatif.
- */
-export function computeActionImpactConfidence(
-  action: RoiActionInput,
-  live: RoiLiveSignals,
-): ImpactConfidence {
-  const type = (action.type ?? 'OTHER').toUpperCase()
-  const isApp = type === 'WASTO_APP'
-  const hasLiveDigital =
-    live.penetrationRatePercent > 0 ||
-    live.activeDevices30d > 0 ||
-    live.validatedVisionScans > 0 ||
-    live.challengeCompletions > 0
-
-  if (isApp && !hasLiveDigital) {
-    return {
-      level: 1,
-      label: 'Confiance faible',
-      tone: 'low',
-      message: 'Impact théorique (0 utilisateur actif)',
-      impactFactor: 0.25,
-    }
-  }
-
-  if (isApp && live.penetrationRatePercent < 2) {
-    return {
-      level: 1,
-      label: 'Confiance faible',
-      tone: 'low',
-      message: `Pénétration faible (${live.penetrationRatePercent} %) — impact bridé`,
-      impactFactor: 0.5,
-    }
-  }
-
-  if (isApp && live.penetrationRatePercent >= 5) {
-    return {
-      level: 2,
-      label: 'Confiance moyenne',
-      tone: 'medium',
-      message: 'Proxy live app disponible',
-      impactFactor: 1,
-    }
-  }
-
-  if (type === 'AWARENESS' || type === 'TRAINING' || type === 'CONTROLS') {
-    if (live.terrainResponses > 0) {
-      return {
-        level: 2,
-        label: 'Confiance moyenne',
-        tone: 'medium',
-        message: 'Appuyé par des données terrain',
-        impactFactor: 1,
-      }
-    }
-    return {
-      level: 1,
-      label: 'Confiance faible',
-      tone: 'low',
-      message: 'Impact déclaratif (pas encore de preuve mesurée)',
-      impactFactor: 0.85,
-    }
-  }
-
-  return {
-    level: 1,
-    label: 'Confiance faible',
-    tone: 'low',
-    message: 'Impact déclaratif',
-    impactFactor: 0.85,
-  }
-}
-
-export function computeOverallConfidence(
-  actionConfidences: ImpactConfidence[],
-  opts?: { annualBilanConfirmed?: boolean },
-): ImpactConfidence {
-  if (opts?.annualBilanConfirmed) {
-    return {
-      level: 3,
-      label: 'Confiance élevée',
-      tone: 'high',
-      message:
-        'Bilan annuel consolidé (TGAP / exploitant / coût du service) — niveau décideurs',
-      impactFactor: 1,
-    }
-  }
-  if (actionConfidences.length === 0) {
-    return {
-      level: 1,
-      label: 'Confiance faible',
-      tone: 'low',
-      message: 'Aucune action active',
-      impactFactor: 1,
-    }
-  }
-  const minLevel = Math.min(
-    ...actionConfidences.map((c) => c.level),
-  ) as ImpactConfidenceLevel
-  if (minLevel === 1) {
-    return {
-      level: 1,
-      label: 'Confiance faible',
-      tone: 'low',
-      message:
-        'ROI en partie théorique — au moins une action sans preuve live',
-      impactFactor: 1,
-    }
-  }
-  if (minLevel === 2) {
-    return {
-      level: 2,
-      label: 'Confiance moyenne',
-      tone: 'medium',
-      message: 'ROI appuyé par des proxies live',
-      impactFactor: 1,
-    }
-  }
-  return {
-    level: 3,
-    label: 'Confiance élevée',
-    tone: 'high',
-    message: 'ROI adossé à des preuves représentatives',
-    impactFactor: 1,
-  }
-}
-
-export function computeRoiIndicators(
-  economics: RoiEconomicsInput,
-  actions: RoiActionInput[],
-  live?: RoiLiveSignals,
-): RoiIndicators {
-  const baselineRate =
-    economics.baselineErrorRatePercent ?? economics.errorRatePercent
-  const baselineTonnage =
-    economics.baselineAnnualTonnageOmr ?? economics.annualTonnageOmr
-  const cost = economics.costPerBadTonne
-  const liveSignals: RoiLiveSignals = live ?? {
-    penetrationRatePercent: 0,
-    activeDevices30d: 0,
-    validatedVisionScans: 0,
-    challengeCompletions: 0,
-    terrainResponses: 0,
-  }
-
-  const before = computeGec(baselineTonnage, baselineRate, cost)
-
-  const counted = actions.filter((a) => isActionCountedInRoi(a.status))
-  const confidences = counted.map((a) =>
-    computeActionImpactConfidence(a, liveSignals),
-  )
-  const reductions = counted.map((a, i) => {
-    const factor = confidences[i]?.impactFactor ?? 1
-    return Math.max(0, a.errorReductionPercent) * factor
-  })
-  const afterRate =
-    reductions.length > 0
-      ? applyStackedErrorReductions(baselineRate, reductions)
-      : economics.errorRatePercent
-
-  const combinedErrorReductionPoints =
-    Math.round((baselineRate - afterRate) * 10) / 10
-  const combinedErrorReductionPercent =
-    baselineRate > 0
-      ? Math.round((1 - afterRate / baselineRate) * 1000) / 10
-      : 0
-
-  const after = computeGec(economics.annualTonnageOmr, afterRate, cost)
-  const grossSavingsEur = roundEuro(before.gecEur - after.gecEur)
-
-  const actionsBudgetEur = roundEuro(
-    counted.reduce(
-      (sum, a) => sum + (a.budgetCapexEur || 0) + (a.budgetOpexEur || 0),
-      0,
-    ),
-  )
-  const wastoAnnualCostEur = roundEuro(economics.wastoAnnualCostEur ?? 0)
-  const totalActionBudgetsEur = roundEuro(actionsBudgetEur + wastoAnnualCostEur)
-
-  const isDomTerritory = economics.isDomTerritory === true
-  const citeo = applyCiteoDomMultiplier(
-    economics.citeoSupportGainEur ?? 0,
-    isDomTerritory,
-  )
-
-  const cenEur = roundEuro(
-    grossSavingsEur + citeo.effectiveEur - totalActionBudgetsEur,
-  )
-  const roiMultiple =
-    totalActionBudgetsEur > 0
-      ? Math.round(
-          ((grossSavingsEur + citeo.effectiveEur) / totalActionBudgetsEur) *
-            10,
-        ) / 10
-      : null
-
-  const overallConfidence = computeOverallConfidence(confidences, {
-    annualBilanConfirmed:
-      economics.annualBilanConfirmed === true ||
-      liveSignals.annualBilanConfirmed === true,
-  })
-  const stackingParts = reductions
-    .map((r) => `(1 − ${Math.round(r * 10) / 10}/100)`)
-    .join(' × ')
-
-  return {
-    gecEur: before.gecEur,
-    baselineBadTonnes: before.badTonnes,
-    baselineErrorRatePercent: baselineRate,
-    afterErrorRatePercent: afterRate,
-    combinedErrorReductionPoints,
-    combinedErrorReductionPercent,
-    stackingFormula:
-      reductions.length > 0
-        ? `taux_après = ${baselineRate} % × ${stackingParts}`
-        : 'Aucune réduction active',
-    afterAnnualLossEur: after.gecEur,
-    afterBadTonnes: after.badTonnes,
-    grossSavingsEur,
-    actionsBudgetEur,
-    wastoAnnualCostEur,
-    totalActionBudgetsEur,
-    citeoSupportGainEur: citeo.effectiveEur,
-    citeoSupportBaseEur: citeo.baseEur,
-    citeoDomMultiplier: citeo.multiplier,
-    isDomTerritory,
-    cenEur,
-    roiMultiple,
-    overallConfidence,
-    disclaimer: ROI_DISCLAIMER,
-  }
-}
-
-export type ActionContribution = {
-  id?: string
-  name?: string
-  type?: string
-  shareEur: number
-  budgetEur: number
-  confidence: ImpactConfidence
-  effectiveReductionPercent: number
-}
-
-/** Contribution approximative au prorata de la réduction effective (après ICI). */
-export function allocateSavingsByAction(
-  grossSavingsEur: number,
-  actions: RoiActionInput[],
-  live?: RoiLiveSignals,
-): ActionContribution[] {
-  const liveSignals: RoiLiveSignals = live ?? {
-    penetrationRatePercent: 0,
-    activeDevices30d: 0,
-    validatedVisionScans: 0,
-    challengeCompletions: 0,
-    terrainResponses: 0,
-  }
-  const counted = actions.filter((a) => isActionCountedInRoi(a.status))
-  const enriched = counted.map((a) => {
-    const confidence = computeActionImpactConfidence(a, liveSignals)
-    return {
-      action: a,
-      confidence,
-      effectiveReductionPercent:
-        Math.max(0, a.errorReductionPercent) * confidence.impactFactor,
-    }
-  })
-  const totalReduction = enriched.reduce(
-    (s, e) => s + e.effectiveReductionPercent,
-    0,
-  )
-  if (totalReduction <= 0 || enriched.length === 0) {
-    return enriched.map((e) => ({
-      id: e.action.id,
-      name: e.action.name,
-      type: e.action.type,
-      shareEur: 0,
-      budgetEur: roundEuro(
-        (e.action.budgetCapexEur || 0) + (e.action.budgetOpexEur || 0),
-      ),
-      confidence: e.confidence,
-      effectiveReductionPercent: e.effectiveReductionPercent,
-    }))
-  }
-  return enriched.map((e) => {
-    const weight = e.effectiveReductionPercent / totalReduction
-    return {
-      id: e.action.id,
-      name: e.action.name,
-      type: e.action.type,
-      shareEur: roundEuro(grossSavingsEur * weight),
-      budgetEur: roundEuro(
-        (e.action.budgetCapexEur || 0) + (e.action.budgetOpexEur || 0),
-      ),
-      confidence: e.confidence,
-      effectiveReductionPercent:
-        Math.round(e.effectiveReductionPercent * 10) / 10,
-    }
-  })
-}
-
-export function estimateHouseholds(
-  householdCount: number | null | undefined,
-  population: number | null | undefined,
-): number {
-  if (householdCount && householdCount > 0) return householdCount
-  if (population && population > 0) {
-    return Math.round(population / ROI_DEFAULTS.peoplePerHousehold)
-  }
-  return 0
-}
-
-export function computePenetrationRate(
-  activeHouseholdsProxy: number,
-  householdCount: number,
-): number {
-  if (householdCount <= 0) return 0
-  return Math.round((activeHouseholdsProxy / householdCount) * 1000) / 10
-}
-
-/** Simulation pédagogique territoire 100k hab. (validation formules). */
-export function simulateTerritory100kExample() {
-  const economics: RoiEconomicsInput = {
-    annualTonnageOmr: 24_000,
-    errorRatePercent: 25,
-    costPerBadTonne: 300,
-    wastoAnnualCostEur: 18_000,
-    citeoSupportGainEur: 40_000,
-    baselineErrorRatePercent: 25,
-    baselineAnnualTonnageOmr: 24_000,
-  }
-  const actions: RoiActionInput[] = [
-    {
-      id: '1',
-      name: 'Campagne sensibilisation',
-      type: 'AWARENESS',
-      status: 'IN_PROGRESS',
-      budgetCapexEur: 0,
-      budgetOpexEur: 12_000,
-      errorReductionPercent: 12,
-    },
-    {
-      id: '2',
-      name: 'Contrôles de bac',
-      type: 'CONTROLS',
-      status: 'IN_PROGRESS',
-      budgetCapexEur: 5_000,
-      budgetOpexEur: 35_000,
-      errorReductionPercent: 18,
-    },
-    {
-      id: '3',
-      name: 'Wast-O app',
-      type: 'WASTO_APP',
-      status: 'IN_PROGRESS',
-      budgetCapexEur: 0,
-      budgetOpexEur: 0,
-      errorReductionPercent: 20,
-    },
-  ]
-  const live: RoiLiveSignals = {
-    penetrationRatePercent: 3,
-    activeDevices30d: 1200,
-    validatedVisionScans: 400,
-    challengeCompletions: 80,
-    terrainResponses: 50,
-  }
-  const indicators = computeRoiIndicators(economics, actions, live)
-  const households = estimateHouseholds(null, 100_000)
-  return {
-    population: 100_000,
-    households,
-    economics,
-    actions,
-    indicators,
-    contributions: allocateSavingsByAction(
-      indicators.grossSavingsEur,
-      actions,
-      live,
-    ),
-  }
-}
+/**
+ * Moteur ROI déchets — partagé simulateur landing / API / console.
+ * Ordres de grandeur pédagogiques (non contractuels).
+ */
+
+export const ROI_DEFAULTS = {
+  annualTonnage: 12_000,
+  errorRatePercent: 25,
+  costPerBadTonne: 300,
+  /** Habitants par foyer (proxy si householdCount absent). */
+  peoplePerHousehold: 2.2,
+} as const
+
+/** Coefficients Citeo outre-mer (barème pédagogique MVP). */
+export const CITEO_DOM_MULTIPLIERS = {
+  lightPackaging: 2.3,
+  glass: 1.9,
+  paper: 4.3,
+  communication: 1.25,
+  ambassadors: 1.25,
+  /** Facteur composite simplifié pour majorer un soutien Citeo agrégé saisi. */
+  compositeSupport: 2.3,
+} as const
+
+/** Départements / préfixes INSEE DOM-COM (métropole exclue). */
+export const DOM_INSEE_PREFIXES = [
+  '971', // Guadeloupe
+  '972', // Martinique
+  '973', // Guyane
+  '974', // La Réunion
+  '976', // Mayotte
+] as const
+
+/**
+ * Trajectoire TGAP enfouissement (€/t) — barème pédagogique MVP.
+ * 2025: 65, 2026: 69, puis +4 €/an jusqu'à 85 €/t en 2030.
+ */
+export const TGAP_LANDFILL_EUR_PER_TONNE: Readonly<Record<number, number>> = {
+  2024: 61,
+  2025: 65,
+  2026: 69,
+  2027: 73,
+  2028: 77,
+  2029: 81,
+  2030: 85,
+}
+
+export function currentFiscalYear(now = new Date()): number {
+  return now.getFullYear()
+}
+
+export function getTgapEurPerTonne(fiscalYear: number): number {
+  if (TGAP_LANDFILL_EUR_PER_TONNE[fiscalYear] != null) {
+    return TGAP_LANDFILL_EUR_PER_TONNE[fiscalYear]
+  }
+  if (fiscalYear < 2024) return 61
+  if (fiscalYear > 2030) return 85
+  // Interpolation linéaire hors table
+  const base = 65
+  return base + (fiscalYear - 2025) * 4
+}
+
+/**
+ * Ajuste le coût / t mal orientée quand la TGAP change d'année.
+ * On conserve le « reste » (traitement hors TGAP) et on y ajoute la nouvelle TGAP.
+ */
+export function adjustCostPerBadTonneForTgap(opts: {
+  previousCostPerBadTonne: number
+  previousTgapEurPerTonne: number
+  nextTgapEurPerTonne: number
+}): number {
+  const nonTgap = Math.max(
+    0,
+    opts.previousCostPerBadTonne - opts.previousTgapEurPerTonne,
+  )
+  return roundEuro(nonTgap + opts.nextTgapEurPerTonne)
+}
+
+export type AnnualRoiPoint = {
+  fiscalYear: number
+  tonnageOmr: number
+  errorRatePercent: number
+  costPerBadTonne: number
+  tgapEurPerTonne: number
+  /** GEC réel (snapshot / actions de l'année). */
+  realGecEur: number
+  /** GEC BAU : même tonnage/erreur de référence, TGAP/coût de l'année, sans réduction d'erreur. */
+  bauGecEur: number
+  cenEur: number | null
+  hasSnapshot: boolean
+  annualBilanConfirmed: boolean
+}
+
+/**
+ * Série BAU vs réel pour le graphique pluriannuel.
+ * `reference` = première année connue (baseline historique).
+ */
+export function buildBauVsRealSeries(opts: {
+  fromYear: number
+  toYear: number
+  reference: {
+    tonnageOmr: number
+    errorRatePercent: number
+    costPerBadTonne: number
+    tgapEurPerTonne: number
+  }
+  years: Array<{
+    fiscalYear: number
+    tonnageOmr: number
+    errorRatePercent: number
+    costPerBadTonne: number
+    tgapEurPerTonne: number
+    gecEur: number
+    cenEur: number | null
+    annualBilanConfirmed?: boolean
+  }>
+}): AnnualRoiPoint[] {
+  const byYear = new Map(opts.years.map((y) => [y.fiscalYear, y]))
+  const points: AnnualRoiPoint[] = []
+  for (let y = opts.fromYear; y <= opts.toYear; y++) {
+    const tgap = getTgapEurPerTonne(y)
+    const bauCost = adjustCostPerBadTonneForTgap({
+      previousCostPerBadTonne: opts.reference.costPerBadTonne,
+      previousTgapEurPerTonne: opts.reference.tgapEurPerTonne,
+      nextTgapEurPerTonne: tgap,
+    })
+    const bau = computeGec(
+      opts.reference.tonnageOmr,
+      opts.reference.errorRatePercent,
+      bauCost,
+    )
+    const snap = byYear.get(y)
+    if (snap) {
+      points.push({
+        fiscalYear: y,
+        tonnageOmr: snap.tonnageOmr,
+        errorRatePercent: snap.errorRatePercent,
+        costPerBadTonne: snap.costPerBadTonne,
+        tgapEurPerTonne: snap.tgapEurPerTonne,
+        realGecEur: snap.gecEur,
+        bauGecEur: bau.gecEur,
+        cenEur: snap.cenEur,
+        hasSnapshot: true,
+        annualBilanConfirmed: snap.annualBilanConfirmed === true,
+      })
+    } else {
+      points.push({
+        fiscalYear: y,
+        tonnageOmr: opts.reference.tonnageOmr,
+        errorRatePercent: opts.reference.errorRatePercent,
+        costPerBadTonne: bauCost,
+        tgapEurPerTonne: tgap,
+        realGecEur: bau.gecEur,
+        bauGecEur: bau.gecEur,
+        cenEur: null,
+        hasSnapshot: false,
+        annualBilanConfirmed: false,
+      })
+    }
+  }
+  return points
+}
+
+/** Scénarios pédagogiques alignés lead magnet landing. */
+export const ROI_SCENARIO_DEFS = [
+  {
+    id: 'awareness' as const,
+    label: 'Sensibilisation seule',
+    errorReductionFactor: 0.12,
+    costBase: 8_000,
+    costPerTonne: 0.35,
+  },
+  {
+    id: 'controls' as const,
+    label: 'Formation + contrôles',
+    errorReductionFactor: 0.28,
+    costBase: 45_000,
+    costPerTonne: 1.8,
+  },
+  {
+    id: 'wasto' as const,
+    label: 'Wast-O (app + IA + pilotage)',
+    errorReductionFactor: 0.45,
+    costBase: 18_000,
+    costPerTonne: 0.9,
+  },
+]
+
+export type ImpactConfidenceLevel = 1 | 2 | 3
+
+export type ImpactConfidence = {
+  level: ImpactConfidenceLevel
+  label: string
+  tone: 'low' | 'medium' | 'high'
+  message: string
+  /** Facteur 0–1 appliqué à la réduction d'erreur pour le calcul. */
+  impactFactor: number
+}
+
+export type RoiActionInput = {
+  budgetCapexEur: number
+  budgetOpexEur: number
+  /** Réduction relative 0–100 (ex. 12 = −12 %). */
+  errorReductionPercent: number
+  status?: string
+  name?: string
+  id?: string
+  type?: string
+}
+
+export type RoiEconomicsInput = {
+  annualTonnageOmr: number
+  errorRatePercent: number
+  costPerBadTonne: number
+  citeoSupportGainEur?: number
+  wastoAnnualCostEur?: number
+  /** Taux d'erreur baseline figé (sinon = errorRatePercent courant). */
+  baselineErrorRatePercent?: number | null
+  baselineAnnualTonnageOmr?: number | null
+  /** Si true, majore les soutiens Citeo (DOM). */
+  isDomTerritory?: boolean
+  fiscalYear?: number
+  tgapEurPerTonne?: number
+  /** Bilan annuel consolidé → peut monter l'ICI global à N3. */
+  annualBilanConfirmed?: boolean
+}
+
+export type RoiLiveSignals = {
+  penetrationRatePercent: number
+  activeDevices30d: number
+  validatedVisionScans: number
+  challengeCompletions: number
+  terrainResponses: number
+  annualBilanConfirmed?: boolean
+}
+
+export type RoiIndicators = {
+  /** Gisement Économique Capturable (pertes avant). */
+  gecEur: number
+  baselineBadTonnes: number
+  baselineErrorRatePercent: number
+  afterErrorRatePercent: number
+  /** Réduction combinée effective en points de % d'erreur (ex. 5.6). */
+  combinedErrorReductionPoints: number
+  /** Réduction relative combinée (ex. 22.4 pour −22,4 %). */
+  combinedErrorReductionPercent: number
+  stackingFormula: string
+  afterAnnualLossEur: number
+  afterBadTonnes: number
+  /** Économies brutes = pertes avant − pertes après. */
+  grossSavingsEur: number
+  /** Budgets des seules actions (hors abonnement). */
+  actionsBudgetEur: number
+  /** Ligne abonnement / contrat Wast-O. */
+  wastoAnnualCostEur: number
+  totalActionBudgetsEur: number
+  citeoSupportGainEur: number
+  citeoSupportBaseEur: number
+  citeoDomMultiplier: number
+  isDomTerritory: boolean
+  /**
+   * CEN = économies brutes + Citeo − budgets cumulés
+   * (aligné avec le numérateur du ROI).
+   */
+  cenEur: number
+  /** ROI = (économies + Citeo) / budgets ; null si budget 0. */
+  roiMultiple: number | null
+  overallConfidence: ImpactConfidence
+  disclaimer: string
+}
+
+export const ROI_DISCLAIMER =
+  'Ordres de grandeur pédagogiques fondés sur des hypothèses déclaratives (tonnages, taux d’erreur, budgets). Non contractuels — à affiner avec les données exploitant / SITOM / TGAP.'
+
+function clamp(n: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, n))
+}
+
+export function roundEuro(n: number): number {
+  return Math.round(n)
+}
+
+export function isDomInseeCode(codeInsee: string | null | undefined): boolean {
+  if (!codeInsee) return false
+  const normalized = codeInsee.trim()
+  return DOM_INSEE_PREFIXES.some((p) => normalized.startsWith(p))
+}
+
+export function detectDomTerritory(opts: {
+  cityInseeCodes?: Array<string | null | undefined>
+  cityGroupCode?: string | null
+  cityGroupName?: string | null
+}): boolean {
+  if (opts.cityInseeCodes?.some((c) => isDomInseeCode(c))) return true
+  const code = (opts.cityGroupCode ?? '').toUpperCase()
+  const name = (opts.cityGroupName ?? '').toUpperCase()
+  if (name.includes('CINOR') || name.includes('REUNION') || name.includes('RÉUNION')) {
+    return true
+  }
+  if (code.includes('974') || code.includes('CINOR')) return true
+  return false
+}
+
+export function applyCiteoDomMultiplier(
+  baseCiteoEur: number,
+  isDom: boolean,
+): { baseEur: number; multiplier: number; effectiveEur: number } {
+  const baseEur = roundEuro(baseCiteoEur)
+  const multiplier = isDom ? CITEO_DOM_MULTIPLIERS.compositeSupport : 1
+  return {
+    baseEur,
+    multiplier,
+    effectiveEur: roundEuro(baseEur * multiplier),
+  }
+}
+
+/** GEC = tonnage × (taux erreur / 100) × €/t */
+export function computeGec(
+  annualTonnage: number,
+  errorRatePercent: number,
+  costPerBadTonne: number,
+): { gecEur: number; badTonnes: number } {
+  const badTonnes = annualTonnage * (errorRatePercent / 100)
+  return {
+    badTonnes: Math.round(badTonnes * 10) / 10,
+    gecEur: roundEuro(badTonnes * costPerBadTonne),
+  }
+}
+
+/**
+ * Empilement multiplicatif des réductions relatives d'actions actives.
+ * newRate = baseline × Π(1 − r_i/100)
+ */
+export function applyStackedErrorReductions(
+  baselineErrorRatePercent: number,
+  reductionsPercent: number[],
+): number {
+  let rate = baselineErrorRatePercent
+  for (const r of reductionsPercent) {
+    const factor = clamp(r, 0, 95) / 100
+    rate = rate * (1 - factor)
+  }
+  return clamp(Math.round(rate * 10) / 10, 1, 99)
+}
+
+export function isActionCountedInRoi(status?: string): boolean {
+  if (!status) return true
+  return status !== 'CANCELLED' && status !== 'PLANNED'
+}
+
+/**
+ * ICI — Indice de Confiance de l'Impact.
+ * 1 = déclaratif, 2 = proxy live, 3 = mesuré / représentatif.
+ */
+export function computeActionImpactConfidence(
+  action: RoiActionInput,
+  live: RoiLiveSignals,
+): ImpactConfidence {
+  const type = (action.type ?? 'OTHER').toUpperCase()
+  const isApp = type === 'WASTO_APP'
+  const hasLiveDigital =
+    live.penetrationRatePercent > 0 ||
+    live.activeDevices30d > 0 ||
+    live.validatedVisionScans > 0 ||
+    live.challengeCompletions > 0
+
+  if (isApp && !hasLiveDigital) {
+    return {
+      level: 1,
+      label: 'Confiance faible',
+      tone: 'low',
+      message: 'Impact théorique (0 utilisateur actif)',
+      impactFactor: 0.25,
+    }
+  }
+
+  if (isApp && live.penetrationRatePercent < 2) {
+    return {
+      level: 1,
+      label: 'Confiance faible',
+      tone: 'low',
+      message: `Pénétration faible (${live.penetrationRatePercent} %) — impact bridé`,
+      impactFactor: 0.5,
+    }
+  }
+
+  if (isApp && live.penetrationRatePercent >= 5) {
+    return {
+      level: 2,
+      label: 'Confiance moyenne',
+      tone: 'medium',
+      message: 'Proxy live app disponible',
+      impactFactor: 1,
+    }
+  }
+
+  if (type === 'AWARENESS' || type === 'TRAINING' || type === 'CONTROLS') {
+    if (live.terrainResponses > 0) {
+      return {
+        level: 2,
+        label: 'Confiance moyenne',
+        tone: 'medium',
+        message: 'Appuyé par des données terrain',
+        impactFactor: 1,
+      }
+    }
+    return {
+      level: 1,
+      label: 'Confiance faible',
+      tone: 'low',
+      message: 'Impact déclaratif (pas encore de preuve mesurée)',
+      impactFactor: 0.85,
+    }
+  }
+
+  return {
+    level: 1,
+    label: 'Confiance faible',
+    tone: 'low',
+    message: 'Impact déclaratif',
+    impactFactor: 0.85,
+  }
+}
+
+export function computeOverallConfidence(
+  actionConfidences: ImpactConfidence[],
+  opts?: { annualBilanConfirmed?: boolean },
+): ImpactConfidence {
+  if (opts?.annualBilanConfirmed) {
+    return {
+      level: 3,
+      label: 'Confiance élevée',
+      tone: 'high',
+      message:
+        'Bilan annuel consolidé (TGAP / exploitant / coût du service) — niveau décideurs',
+      impactFactor: 1,
+    }
+  }
+  if (actionConfidences.length === 0) {
+    return {
+      level: 1,
+      label: 'Confiance faible',
+      tone: 'low',
+      message: 'Aucune action active',
+      impactFactor: 1,
+    }
+  }
+  const minLevel = Math.min(
+    ...actionConfidences.map((c) => c.level),
+  ) as ImpactConfidenceLevel
+  if (minLevel === 1) {
+    return {
+      level: 1,
+      label: 'Confiance faible',
+      tone: 'low',
+      message:
+        'ROI en partie théorique — au moins une action sans preuve live',
+      impactFactor: 1,
+    }
+  }
+  if (minLevel === 2) {
+    return {
+      level: 2,
+      label: 'Confiance moyenne',
+      tone: 'medium',
+      message: 'ROI appuyé par des proxies live',
+      impactFactor: 1,
+    }
+  }
+  return {
+    level: 3,
+    label: 'Confiance élevée',
+    tone: 'high',
+    message: 'ROI adossé à des preuves représentatives',
+    impactFactor: 1,
+  }
+}
+
+export function computeRoiIndicators(
+  economics: RoiEconomicsInput,
+  actions: RoiActionInput[],
+  live?: RoiLiveSignals,
+): RoiIndicators {
+  const baselineRate =
+    economics.baselineErrorRatePercent ?? economics.errorRatePercent
+  const baselineTonnage =
+    economics.baselineAnnualTonnageOmr ?? economics.annualTonnageOmr
+  const cost = economics.costPerBadTonne
+  const liveSignals: RoiLiveSignals = live ?? {
+    penetrationRatePercent: 0,
+    activeDevices30d: 0,
+    validatedVisionScans: 0,
+    challengeCompletions: 0,
+    terrainResponses: 0,
+  }
+
+  const before = computeGec(baselineTonnage, baselineRate, cost)
+
+  const counted = actions.filter((a) => isActionCountedInRoi(a.status))
+  const confidences = counted.map((a) =>
+    computeActionImpactConfidence(a, liveSignals),
+  )
+  const reductions = counted.map((a, i) => {
+    const factor = confidences[i]?.impactFactor ?? 1
+    return Math.max(0, a.errorReductionPercent) * factor
+  })
+  const afterRate =
+    reductions.length > 0
+      ? applyStackedErrorReductions(baselineRate, reductions)
+      : economics.errorRatePercent
+
+  const combinedErrorReductionPoints =
+    Math.round((baselineRate - afterRate) * 10) / 10
+  const combinedErrorReductionPercent =
+    baselineRate > 0
+      ? Math.round((1 - afterRate / baselineRate) * 1000) / 10
+      : 0
+
+  const after = computeGec(economics.annualTonnageOmr, afterRate, cost)
+  const grossSavingsEur = roundEuro(before.gecEur - after.gecEur)
+
+  const actionsBudgetEur = roundEuro(
+    counted.reduce(
+      (sum, a) => sum + (a.budgetCapexEur || 0) + (a.budgetOpexEur || 0),
+      0,
+    ),
+  )
+  const wastoAnnualCostEur = roundEuro(economics.wastoAnnualCostEur ?? 0)
+  const totalActionBudgetsEur = roundEuro(actionsBudgetEur + wastoAnnualCostEur)
+
+  const isDomTerritory = economics.isDomTerritory === true
+  const citeo = applyCiteoDomMultiplier(
+    economics.citeoSupportGainEur ?? 0,
+    isDomTerritory,
+  )
+
+  const cenEur = roundEuro(
+    grossSavingsEur + citeo.effectiveEur - totalActionBudgetsEur,
+  )
+  const roiMultiple =
+    totalActionBudgetsEur > 0
+      ? Math.round(
+          ((grossSavingsEur + citeo.effectiveEur) / totalActionBudgetsEur) *
+            10,
+        ) / 10
+      : null
+
+  const overallConfidence = computeOverallConfidence(confidences, {
+    annualBilanConfirmed:
+      economics.annualBilanConfirmed === true ||
+      liveSignals.annualBilanConfirmed === true,
+  })
+  const stackingParts = reductions
+    .map((r) => `(1 − ${Math.round(r * 10) / 10}/100)`)
+    .join(' × ')
+
+  return {
+    gecEur: before.gecEur,
+    baselineBadTonnes: before.badTonnes,
+    baselineErrorRatePercent: baselineRate,
+    afterErrorRatePercent: afterRate,
+    combinedErrorReductionPoints,
+    combinedErrorReductionPercent,
+    stackingFormula:
+      reductions.length > 0
+        ? `taux_après = ${baselineRate} % × ${stackingParts}`
+        : 'Aucune réduction active',
+    afterAnnualLossEur: after.gecEur,
+    afterBadTonnes: after.badTonnes,
+    grossSavingsEur,
+    actionsBudgetEur,
+    wastoAnnualCostEur,
+    totalActionBudgetsEur,
+    citeoSupportGainEur: citeo.effectiveEur,
+    citeoSupportBaseEur: citeo.baseEur,
+    citeoDomMultiplier: citeo.multiplier,
+    isDomTerritory,
+    cenEur,
+    roiMultiple,
+    overallConfidence,
+    disclaimer: ROI_DISCLAIMER,
+  }
+}
+
+export type ActionContribution = {
+  id?: string
+  name?: string
+  type?: string
+  shareEur: number
+  budgetEur: number
+  confidence: ImpactConfidence
+  effectiveReductionPercent: number
+}
+
+/** Contribution approximative au prorata de la réduction effective (après ICI). */
+export function allocateSavingsByAction(
+  grossSavingsEur: number,
+  actions: RoiActionInput[],
+  live?: RoiLiveSignals,
+): ActionContribution[] {
+  const liveSignals: RoiLiveSignals = live ?? {
+    penetrationRatePercent: 0,
+    activeDevices30d: 0,
+    validatedVisionScans: 0,
+    challengeCompletions: 0,
+    terrainResponses: 0,
+  }
+  const counted = actions.filter((a) => isActionCountedInRoi(a.status))
+  const enriched = counted.map((a) => {
+    const confidence = computeActionImpactConfidence(a, liveSignals)
+    return {
+      action: a,
+      confidence,
+      effectiveReductionPercent:
+        Math.max(0, a.errorReductionPercent) * confidence.impactFactor,
+    }
+  })
+  const totalReduction = enriched.reduce(
+    (s, e) => s + e.effectiveReductionPercent,
+    0,
+  )
+  if (totalReduction <= 0 || enriched.length === 0) {
+    return enriched.map((e) => ({
+      id: e.action.id,
+      name: e.action.name,
+      type: e.action.type,
+      shareEur: 0,
+      budgetEur: roundEuro(
+        (e.action.budgetCapexEur || 0) + (e.action.budgetOpexEur || 0),
+      ),
+      confidence: e.confidence,
+      effectiveReductionPercent: e.effectiveReductionPercent,
+    }))
+  }
+  return enriched.map((e) => {
+    const weight = e.effectiveReductionPercent / totalReduction
+    return {
+      id: e.action.id,
+      name: e.action.name,
+      type: e.action.type,
+      shareEur: roundEuro(grossSavingsEur * weight),
+      budgetEur: roundEuro(
+        (e.action.budgetCapexEur || 0) + (e.action.budgetOpexEur || 0),
+      ),
+      confidence: e.confidence,
+      effectiveReductionPercent:
+        Math.round(e.effectiveReductionPercent * 10) / 10,
+    }
+  })
+}
+
+export function estimateHouseholds(
+  householdCount: number | null | undefined,
+  population: number | null | undefined,
+): number {
+  if (householdCount && householdCount > 0) return householdCount
+  if (population && population > 0) {
+    return Math.round(population / ROI_DEFAULTS.peoplePerHousehold)
+  }
+  return 0
+}
+
+export function computePenetrationRate(
+  activeHouseholdsProxy: number,
+  householdCount: number,
+): number {
+  if (householdCount <= 0) return 0
+  return Math.round((activeHouseholdsProxy / householdCount) * 1000) / 10
+}
+
+/** Simulation pédagogique territoire 100k hab. (validation formules). */
+export function simulateTerritory100kExample() {
+  const economics: RoiEconomicsInput = {
+    annualTonnageOmr: 24_000,
+    errorRatePercent: 25,
+    costPerBadTonne: 300,
+    wastoAnnualCostEur: 18_000,
+    citeoSupportGainEur: 40_000,
+    baselineErrorRatePercent: 25,
+    baselineAnnualTonnageOmr: 24_000,
+  }
+  const actions: RoiActionInput[] = [
+    {
+      id: '1',
+      name: 'Campagne sensibilisation',
+      type: 'AWARENESS',
+      status: 'IN_PROGRESS',
+      budgetCapexEur: 0,
+      budgetOpexEur: 12_000,
+      errorReductionPercent: 12,
+    },
+    {
+      id: '2',
+      name: 'Contrôles de bac',
+      type: 'CONTROLS',
+      status: 'IN_PROGRESS',
+      budgetCapexEur: 5_000,
+      budgetOpexEur: 35_000,
+      errorReductionPercent: 18,
+    },
+    {
+      id: '3',
+      name: 'Wast-O app',
+      type: 'WASTO_APP',
+      status: 'IN_PROGRESS',
+      budgetCapexEur: 0,
+      budgetOpexEur: 0,
+      errorReductionPercent: 20,
+    },
+  ]
+  const live: RoiLiveSignals = {
+    penetrationRatePercent: 3,
+    activeDevices30d: 1200,
+    validatedVisionScans: 400,
+    challengeCompletions: 80,
+    terrainResponses: 50,
+  }
+  const indicators = computeRoiIndicators(economics, actions, live)
+  const households = estimateHouseholds(null, 100_000)
+  return {
+    population: 100_000,
+    households,
+    economics,
+    actions,
+    indicators,
+    contributions: allocateSavingsByAction(
+      indicators.grossSavingsEur,
+      actions,
+      live,
+    ),
+  }
+}