@mostajs/wagon-engine 0.0.0-stage → 0.1.1

package/src/wagon.mjs

@@ -0,0 +1,856 @@
+/**
+ * @mostajs/wagon-engine — LE WAGON : tout le SaaS sauf ce qu'il vend. On ne le modifie pas pour greffer un service :
+ * la greffe écrit wagon.config.mjs, charge/ et legal/ (extrait du gabarit mosta-wagon 0.11.0, le 26/10/2026).
+ * @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+ *
+ * Plan B de l'audit du 01/10/2026 (saas-making/methode/AUDIT-WAGON-MDSEAL-01102026.md) : le wagon de
+ * mdseal en gabarit. Les PAGES viennent de @mostajs/wagon-ui ; la LOGIQUE, des modules publiés :
+ *   comptes, membres, clés ........ @mostajs/comptes
+ *   paliers, quotas, paiement ..... @mostajs/subscriptions-plan (createBilling, createStripeSale)
+ *   mot de passe, code par courriel @mostajs/auth-lite (+ vues @mostajs/auth-ui)
+ *   sessions ...................... @mostajs/auth-plug (magasinSessions)
+ *   CSRF, en-têtes ................ @mostajs/garde-http
+ * Ce fichier n'est que l'ATTELAGE : les routes, et ce qu'elles passent d'un module à l'autre, sous forme de
+ * fabrique (`creerWagon`) ; `demarrer` (demarrer.mjs) la monte d'après le .env de la greffe.
+ *
+ * Les règles de mdseal qu'il garde : le compte naît au palier gratuit et seul le webhook le fait monter ;
+ * le quota se contrôle AVANT le travail ; « non compris » (403) et « épuisé » (429 + Retry-After) ne se
+ * confondent pas ; la clé n'est montrée qu'une fois ; un refus d'identifiants ne dit jamais lequel était
+ * faux ; l'administration est invisible (404) à qui n'est pas administrateur.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { openIsolatedDialect } from '@mostajs/data-plug';
+import { creerWagonUi, esc } from '@mostajs/wagon-ui';
+import { creerComptes, schemasComptes } from '@mostajs/comptes';
+import { createBilling, createStripeSale, createPrepaidSale, billingSchemas, checkLimits, assertMonotonicPlans } from '@mostajs/subscriptions-plan/server';
+import { PaymentSchema } from '@mostajs/payment';
+import { formatNumber, resolveFormatLocale } from '@mostajs/i18n';
+import { createPasswordAuth, createEmailCodeAuth, SessionSchema, ipClient, memoryLimiter } from '@mostajs/auth-lite';
+import { emailCodeEmailHtml, emailCodeEmailText, emailCodeForm, emailLinkConfirmPage, AUTH_CSS } from '@mostajs/auth-ui';
+import { magasinSessions } from '@mostajs/auth-plug';
+import { requeteLegitime, enTetesSecurite, cookieStrict } from '@mostajs/garde-http';
+import { mdToHtml } from '@mostajs/markdown-html';
+import { getEnv } from '@mostajs/config';
+import { suivrePalette } from './palette.mjs';
+
+const COURRIEL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const PERIODE = { jour: 'day', mois: 'month' };
+const META = { account: 'wagon_compte', plan: 'wagon_plan' };
+/**
+ * 0.3 — LA VENTE PRÉPAYÉE (Chargily, PayPal, SATIM : pas de prélèvement automatique), à côté de Stripe.
+ * Les textes du choix du moyen de paiement, et les domaines des banques que la CSP doit laisser passer :
+ * Chrome applique `form-action` aux REDIRECTIONS qui suivent un formulaire.
+ */
+const TEXTES_PAIEMENT = {
+  fr: { choisir: 'Choisissez votre moyen de paiement', stripe: 'Carte bancaire internationale — abonnement mensuel', chargily: 'CIB ou Edahabia (Chargily)', paypal: 'PayPal', satim: 'CIB (SATIM)',
+    month: '1 mois', year: '1 an', parMois: '/mois', unique: 'Paiement unique, sans renouvellement automatique : à la fin de la période, le palier revient au gratuit.',
+    jusquau: 'Votre palier {plan} est payé jusqu’au {date}.',
+    avisSujet: '{marque} — prochain prélèvement le {date}', avisTexte: 'Votre abonnement sera prélevé de {montant} le {date}.',
+    avisGerer: 'Pour changer de palier, de carte, ou résilier : {adresse}, puis « Gérer mon abonnement ».',
+    venteFermee: 'La vente est fermée tant que les conditions générales de vente ne sont pas publiées.', nonPropose: 'Ce palier n’est pas proposé à la vente.', dejaAbonne: 'Vous avez déjà un abonnement en cours : changez de palier depuis « Gérer mon abonnement ».',
+    gerer: 'Gérer mon abonnement', prepayeEnCours: 'Votre période payée court jusqu’au {date} : un nouveau paiement sera possible à son terme.' },
+  en: { choisir: 'Choose how to pay', stripe: 'International card — monthly subscription', chargily: 'CIB or Edahabia (Chargily)', paypal: 'PayPal', satim: 'CIB (SATIM)',
+    month: '1 month', year: '1 year', parMois: '/month', unique: 'One-off payment, no automatic renewal: when the period ends, the tier returns to free.',
+    jusquau: 'Your {plan} tier is paid until {date}.',
+    avisSujet: '{marque} — next payment on {date}', avisTexte: 'Your subscription will be charged {montant} on {date}.',
+    avisGerer: 'To change tier or card, or to cancel: {adresse}, then “Manage my subscription”.',
+    venteFermee: 'Sales are closed until the terms of sale are published.', nonPropose: 'This tier is not for sale.', dejaAbonne: 'You already have a subscription: change tier from “Manage my subscription”.',
+    gerer: 'Manage my subscription', prepayeEnCours: 'Your paid period runs until {date}: a new payment will be possible when it ends.' },
+  ar: { choisir: 'اختر وسيلة الدفع', stripe: 'بطاقة بنكية دولية — اشتراك شهري', chargily: 'سي آي بي أو الذهبية (Chargily)', paypal: 'باي بال', satim: 'سي آي بي (SATIM)',
+    month: 'شهر واحد', year: 'سنة واحدة', parMois: '/شهر', unique: 'دفعة واحدة دون تجديد تلقائي: تعود الفئة إلى المجانية عند نهاية المدة.',
+    jusquau: 'فئتك {plan} مدفوعة حتى {date}.',
+    avisSujet: '{marque} — الاقتطاع القادم يوم {date}', avisTexte: 'سيُقتطع من اشتراكك مبلغ {montant} يوم {date}.',
+    avisGerer: 'لتغيير الفئة أو البطاقة أو للإلغاء: {adresse}، ثم «إدارة اشتراكي».',
+    venteFermee: 'البيع مغلق إلى أن تُنشر الشروط العامة للبيع.', nonPropose: 'هذه الفئة غير معروضة للبيع.', dejaAbonne: 'لديك اشتراك جارٍ بالفعل: غيّر الفئة من «إدارة اشتراكي».',
+    gerer: 'إدارة اشتراكي', prepayeEnCours: 'مدتك المدفوعة سارية حتى {date}: يمكن دفع جديد عند انتهائها.' },
+};
+/**
+ * 0.5 (audit du 09/10/2026) — LE COMPTE DU CLIENT : changer son mot de passe, le retrouver, partir avec ses données,
+ * supprimer son compte (RGPD), se déconnecter par un POST. Textes propres au gabarit, en trois langues.
+ */
+const TEXTES_COMPTE = {
+  fr: { gerer: 'Mon compte', motDePasse: 'Changer mon mot de passe', actuel: 'Mot de passe actuel', nouveau: 'Nouveau mot de passe', confirmer: 'Le même, encore',
+    enregistrer: 'Enregistrer', mauvais: 'Mot de passe actuel incorrect.', differents: 'Les deux saisies diffèrent.', oublie: 'Mot de passe oublié ?',
+    oubliTitre: 'Retrouver l’accès', oubliAide: 'Indiquez votre courriel : si un compte y correspond, vous recevrez un lien pour choisir un nouveau mot de passe.',
+    envoyer: 'Envoyer le lien', envoye: 'Si un compte correspond à {courriel}, un lien vient de lui être envoyé. Il vaut 30 minutes.',
+    reinit: 'Choisir un nouveau mot de passe', lienMort: 'Ce lien n’est plus valable : demandez-en un nouveau.', courrielSujet: '{marque} — choisir un nouveau mot de passe',
+    courrielTexte: 'Pour choisir un nouveau mot de passe, ouvrez ce lien (valable 30 minutes) :', courrielIgnorer: 'Si vous n’avez rien demandé, ignorez ce message.',
+    exporter: 'Télécharger mes données', supprimer: 'Supprimer mon compte', supprimerAide: 'La suppression efface votre identité et vos données ; les factures sont conservées, anonymisées, le temps exigé par la loi. Pour confirmer, saisissez votre courriel.',
+    confirmation: 'Votre courriel', supprimerBouton: 'Supprimer définitivement', confirmationFausse: 'Le courriel saisi ne correspond pas.',
+    abonnementActif: 'Résiliez d’abord votre abonnement (« Gérer mon abonnement »).', deconnexion: 'Se déconnecter', deconnexionAide: 'Fermer votre session sur cet appareil ?',
+    trop: 'Trop d’inscriptions depuis cette adresse : réessayez dans quelques minutes.' },
+  en: { gerer: 'My account', motDePasse: 'Change my password', actuel: 'Current password', nouveau: 'New password', confirmer: 'The same, again',
+    enregistrer: 'Save', mauvais: 'Current password is incorrect.', differents: 'The two entries differ.', oublie: 'Forgot your password?',
+    oubliTitre: 'Recover access', oubliAide: 'Enter your email: if an account matches, you will receive a link to choose a new password.',
+    envoyer: 'Send the link', envoye: 'If an account matches {courriel}, a link has just been sent. It is valid for 30 minutes.',
+    reinit: 'Choose a new password', lienMort: 'This link is no longer valid: ask for a new one.', courrielSujet: '{marque} — choose a new password',
+    courrielTexte: 'To choose a new password, open this link (valid for 30 minutes):', courrielIgnorer: 'If you did not ask for anything, ignore this message.',
+    exporter: 'Download my data', supprimer: 'Delete my account', supprimerAide: 'Deletion erases your identity and your data; invoices are kept, anonymised, for the period required by law. To confirm, type your email.',
+    confirmation: 'Your email', supprimerBouton: 'Delete for good', confirmationFausse: 'The email typed does not match.',
+    abonnementActif: 'Cancel your subscription first (“Manage my subscription”).', deconnexion: 'Sign out', deconnexionAide: 'Close your session on this device?',
+    trop: 'Too many sign-ups from this address: try again in a few minutes.' },
+  ar: { gerer: 'حسابي', motDePasse: 'تغيير كلمة المرور', actuel: 'كلمة المرور الحالية', nouveau: 'كلمة المرور الجديدة', confirmer: 'نفسها مرة أخرى',
+    enregistrer: 'حفظ', mauvais: 'كلمة المرور الحالية غير صحيحة.', differents: 'الإدخالان مختلفان.', oublie: 'نسيت كلمة المرور؟',
+    oubliTitre: 'استعادة الوصول', oubliAide: 'أدخل بريدك الإلكتروني: إن كان له حساب، ستتلقى رابطًا لاختيار كلمة مرور جديدة.',
+    envoyer: 'إرسال الرابط', envoye: 'إن كان لـ {courriel} حساب، فقد أُرسل إليه رابط صالح لمدة 30 دقيقة.',
+    reinit: 'اختيار كلمة مرور جديدة', lienMort: 'هذا الرابط لم يعد صالحًا: اطلب رابطًا جديدًا.', courrielSujet: '{marque} — اختيار كلمة مرور جديدة',
+    courrielTexte: 'لاختيار كلمة مرور جديدة، افتح هذا الرابط (صالح لمدة 30 دقيقة):', courrielIgnorer: 'إن لم تطلب شيئًا، تجاهل هذه الرسالة.',
+    exporter: 'تنزيل بياناتي', supprimer: 'حذف حسابي', supprimerAide: 'يمحو الحذف هويتك وبياناتك؛ وتُحفظ الفواتير مجهولة الهوية المدة التي يفرضها القانون. للتأكيد، اكتب بريدك الإلكتروني.',
+    confirmation: 'بريدك الإلكتروني', supprimerBouton: 'حذف نهائي', confirmationFausse: 'البريد المكتوب غير مطابق.',
+    abonnementActif: 'ألغِ اشتراكك أولًا («إدارة اشتراكي»).', deconnexion: 'تسجيل الخروج', deconnexionAide: 'إغلاق جلستك على هذا الجهاز؟',
+    trop: 'تسجيلات كثيرة من هذا العنوان: أعد المحاولة بعد دقائق.' },
+};
+const DOMAINES_BANQUES = {
+  chargily: 'https://pay.chargily.net https://pay.chargily.com',
+  paypal: 'https://www.paypal.com https://www.sandbox.paypal.com',
+  satim: 'https://cib.satim.dz https://test.satim.dz',
+};
+const montant = (mineures, devise, lang) => formatNumber(resolveFormatLocale(lang), Number(mineures) / 100, { style: 'currency', currency: devise });
+
+/** Le message d'un PLAFOND atteint (wagon-ui n'a que celui des clés d'API). */
+const PLAFOND_ATTEINT = { fr: 'Plafond de votre palier atteint : {n} ({ressource}).', en: 'Your tier limit is reached: {n} ({ressource}).', ar: 'بلغتَ حدّ فئتك: {n} ({ressource}).' };
+
+/** Le mot de passe stocké — seulement son empreinte (auth-lite), par utilisateur. */
+const CredentialSchema = {
+  name: 'WagonCredential', collection: 'wagon_credentials', timestamps: false,
+  fields: { user: { type: 'string', required: true }, hash: { type: 'string', required: true }, updatedAt: { type: 'string' } },
+  relations: {}, indexes: [{ fields: { user: 'asc' }, unique: true }],
+};
+/**
+ * 0.4 (audit du 09/10/2026) — les administrateurs CONFIRMÉS. Un courriel déclaré (config.admins, WAGON_ADMINS) ne
+ * donne l'administration qu'une fois sa détention prouvée : connexion par code ou par lien reçu à ce courriel, ou
+ * confirmation faite sur le serveur (scripts/admin.mjs). Sans cela, quiconque inscrivait ce courriel AVANT son
+ * titulaire prenait l'administration.
+ */
+const AdminSchema = {
+  name: 'WagonAdmin', collection: 'wagon_admins', timestamps: false,
+  fields: { courriel: { type: 'string', required: true }, confirmeLe: { type: 'date' }, par: { type: 'string' } },
+  relations: {}, indexes: [{ fields: { courriel: 'asc' }, unique: true }],
+};
+export const schemasWagon = () => {
+  const vus = new Set();
+  // `Payment` (@mostajs/payment) : une ligne par session de banque, que le webhook retrouve pour clore la vente.
+  // Déclarée même sans banque prépayée — incident RestoTrax du 19/08/2026 : « no such table: payments » APRÈS
+  // que le client eut engagé son paiement.
+  return [...schemasComptes(), ...billingSchemas(), PaymentSchema, SessionSchema, CredentialSchema, AdminSchema].filter((s) => (vus.has(s.name) ? false : vus.add(s.name)));
+};
+
+const lireCorps = (req, max = 1_000_000) => new Promise((ok, ko) => {
+  const c = []; let n = 0;
+  req.on('data', (x) => { n += x.length; if (n > max) { req.destroy(); ko(new Error('corps trop gros')); } else c.push(x); });
+  req.on('end', () => ok(Buffer.concat(c))); req.on('error', ko);
+});
+const cookieDe = (req, nom) => (req.headers.cookie || '').split(';').map((s) => s.trim()).find((s) => s.startsWith(`${nom}=`))?.slice(nom.length + 1);
+
+/**
+ * @param {object} o
+ * @param {object} o.config     wagon.config.mjs
+ * @param {object} o.charge     charge/index.mjs
+ * @param {string | { dialect: string, uri: string }} o.sgbd  chemin sqlite, ou { dialect, uri } (0.5)
+ * @param {string} o.baseUrl    l'origine publique (https://…)
+ * @param {any}    [o.stripe]   une instance Stripe (absente : la vente se refuse, le reste tourne)
+ * @param {string} [o.webhookSecret]
+ * @param {{ envoyer: Function } | null} [o.transport]  les courriels (code de connexion)
+ * @param {{ banques?: Record<string, string>, port?: object }} [o.paiement]  0.3 — vente prépayée : les banques ACTIVES
+ *        et leur devise (`{ chargily: 'DZD', paypal: 'EUR' }`, server.mjs ne garde que celles dont le .env porte les
+ *        clés) ; `port` remplace @mostajs/payment (essais)
+ */
+/** 0.5 — le commit en service (posé par le déployeur dans le dossier de l'instance) et l'heure de démarrage. */
+const lireRevision = (racine) => { try { return readFileSync(join(racine, 'REVISION'), 'utf8').trim() || null; } catch { return null; } };
+export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null, webhookSecret = '', transport = null, journal = console, paiement = null, racine = process.cwd() }) {
+  const origine = String(baseUrl || '').replace(/\/$/, '');
+  const REVISION = lireRevision(racine); const DEMARRE_LE = new Date().toISOString();
+  const https = /^https:/.test(origine);
+  const S = Object.fromEntries(schemasWagon().map((s) => [s.name, s]));
+  // 0.5 (audit du 09/10/2026) — `sgbd` : un chemin sqlite (comme avant), ou { dialect, uri } d'après le .env
+  // (WAGON_DB_DIALECT, WAGON_SGBD) : la base des comptes n'est plus figée en sqlite.
+  const base = typeof sgbd === 'string' ? { dialect: 'sqlite', uri: sgbd } : { dialect: sgbd?.dialect ?? 'sqlite', uri: sgbd?.uri };
+  const d = await openIsolatedDialect({ ...base, schemaStrategy: 'update' }, schemasWagon());
+  // 0.4 — la charge ouvre SA base au démarrage, pas au premier client (DEVRULES-SAAS-APP §5.2).
+  if (typeof charge.amorcer === 'function') await charge.amorcer();
+
+  // Deux sortes de ressources : les QUOTAS périodiques (consommés par jour ou par mois, comptés par la
+  // facturation) et les PLAFONDS (`plafond: true` — un stock : « 1 voyage actif », « 10 étapes par voyage »),
+  // comptés par la charge sur ses propres données et contrôlés par ctx.plafond(). Les deux s'affichent sur
+  // /tarifs ; seuls les quotas ont une jauge de consommation dans /compte.
+  const ressources = charge.ressources ?? [];
+  const periodiques = ressources.filter((r) => !r.plafond);
+  const facturation = createBilling({ dialect: d, freePlan: config.planGratuit ?? 'gratuit',
+    resources: Object.fromEntries(periodiques.map((r) => [r.cle, { limit: r.limite, period: PERIODE[r.periode] ?? 'day' }])) });
+  const comptes = creerComptes({ dialect: d, facturation, planInitial: config.planGratuit ?? 'gratuit', limiteCles: 'maxCles', envCle: https ? 'live' : 'test' });
+  // Le thème : une fonction de wagon.config.mjs, ou Palette Studio (`palette: { source, projet }`), comme qatrax.dev.
+  const palette = config.palette?.source && config.palette?.projet ? suivrePalette({ ...config.palette, journal }) : null;
+  const theme = typeof config.theme === 'function' ? config.theme : palette ? () => palette.css() : null;
+  const ui = creerWagonUi({ marque: config.marque, couleurs: config.couleurs, langues: config.langues, liens: charge.liens ?? [], ressources, textes: charge.textes ?? {},
+    entete: config.entete ?? 'simple', theme,
+    // 0.9 (wagon-ui 0.6) — la feuille de style de l'application, de confiance, posée sur toutes les pages.
+    css: typeof config.css === 'string' ? config.css : '',
+    // 0.5 (wagon-ui 0.5) — en-tête collant, bouton d'appel, langue en menu déroulant : déclarés par wagon.config.mjs.
+    collant: config.collant === true, appel: config.appel ?? null, selecteurLangue: config.selecteurLangue ?? 'liens' });
+  const sessions = magasinSessions({ dialect: d, schema: S.Session, nom: 'wagon_session', jours: 30 });
+  // 0.5 — les sessions expirées se purgent au démarrage puis toutes les six heures (auth-plug 0.3) ; les inscriptions
+  // sont freinées par adresse (config.freinInscription, défaut : 10 puis 1 par minute).
+  const purgerSessions = () => sessions.purger?.().catch((e) => journal.warn(`wagon : purge des sessions : ${e?.message ?? e}`));
+  purgerSessions(); setInterval(purgerSessions, 6 * 3600 * 1000).unref?.();
+  const freinInscription = memoryLimiter({ limits: { byIp: config.freinInscription ?? { capacity: 10, refillPerSec: 1 / 60 } } });
+  const motsDePasse = createPasswordAuth({
+    credentials: {
+      get: async (u) => { const r = await d.findOne(S.WagonCredential, { user: String(u) }); return r ? { hash: r.hash, updatedAt: r.updatedAt } : null; },
+      set: async (u, rec) => { const r = await d.findOne(S.WagonCredential, { user: String(u) }); if (r) await d.update(S.WagonCredential, String(r.id), rec); else await d.create(S.WagonCredential, { user: String(u), ...rec }); },
+    },
+    findUser: async (l) => { const u = await d.findOne(S.User, { email: l }); return u ? { id: String(u.id) } : null; },
+  });
+  const codes = createEmailCodeAuth({ findUser: async (l) => { const u = await d.findOne(S.User, { email: l }); return u ? { id: String(u.id) } : null; } });
+  const vente = stripe ? createStripeSale({
+    billing: facturation, stripe, webhookSecret, metadataKeys: META,
+    urls: { success: `${origine}/paiement/merci`, cancel: `${origine}/tarifs` },
+    customers: {
+      get: async (id) => (await d.findById(S.Account, id))?.stripeCustomerId ?? null,
+      set: async (id, c) => { await d.update(S.Account, id, { stripeCustomerId: c }); },
+      describe: async (id) => { const a = await d.findById(S.Account, id); const u = a ? await d.findById(S.User, String(a.owner)) : null; return { email: u?.email, name: a?.name }; },
+      accountOf: async (c) => (await d.findOne(S.Account, { stripeCustomerId: c }))?.id ?? null,
+    },
+  }) : null;
+  const banques = { ...(paiement?.banques ?? {}) };
+  const prepaye = Object.keys(banques).length ? createPrepaidSale({
+    billing: facturation, providers: banques, payment: paiement?.port, metadataKeys: { account: META.account, plan: META.plan, period: 'wagon_periode' },
+    // 0.10 — `return` : SATIM ne notifie pas le serveur, il renvoie l'acheteur (@mostajs/payment ≥ 2.6). Les banques à
+    // webhook (Chargily, PayPal) l'ignorent.
+    urls: { success: `${origine}/paiement/merci`, cancel: `${origine}/tarifs`, webhook: `${origine}/api/paiement/webhook/{provider}`, return: `${origine}/api/paiement/retour/{provider}` },
+  }) : null;
+  /**
+   * 0.10 — les banques SANS webhook (SATIM) : une commande dont l'acheteur n'est pas revenu (onglet fermé) est
+   * réinterrogée de 30 min à 7 jours après son ouverture ; sans confirmation, SATIM l'annulerait.
+   */
+  const SANS_WEBHOOK = ['satim'];
+  async function reprendrePaiements() {
+    const faits = [];
+    for (const banque of Object.keys(banques).filter((b) => SANS_WEBHOOK.includes(b))) {
+      try { faits.push({ banque, ...(await prepaye.reconcilePending({ provider: banque })) }); } catch (e) { journal.warn(`wagon : reprise des paiements ${banque} : ${e?.message ?? e}`); faits.push({ banque, erreur: String(e?.message ?? e) }); }
+    }
+    return faits;
+  }
+  if (prepaye && Object.keys(banques).some((b) => SANS_WEBHOOK.includes(b))) setInterval(reprendrePaiements, 10 * 60 * 1000).unref?.();
+  const admins = new Set([...(config.admins ?? []), ...String(getEnv('WAGON_ADMINS', '') ?? '').split(',')].map((x) => x.trim().toLowerCase()).filter(Boolean));
+  /** Un courriel est administrateur s'il est DÉCLARÉ et CONFIRMÉ. */
+  const estAdministrateur = async (courriel) => {
+    const c = String(courriel ?? '').toLowerCase();
+    return admins.has(c) && !!(await d.findOne(S.WagonAdmin, { courriel: c }));
+  };
+  /** Confirme un administrateur déclaré qui a un compte ; false sinon (rien à confirmer). */
+  async function confirmerAdmin(courriel, par = 'serveur') {
+    const c = String(courriel ?? '').trim().toLowerCase();
+    if (!admins.has(c) || !(await d.findOne(S.User, { email: c }))) return false;
+    if (!(await d.findOne(S.WagonAdmin, { courriel: c }))) await d.create(S.WagonAdmin, { courriel: c, confirmeLe: new Date(), par });
+    return true;
+  }
+  /** Après une connexion par code ou par lien : la détention du courriel est prouvée. */
+  const apresPreuveCourriel = async (userId) => {
+    const u = await d.findById(S.User, String(userId));
+    if (u?.email && admins.has(String(u.email).toLowerCase())) await confirmerAdmin(u.email, 'courriel');
+  };
+  const CSP = {
+    // Les vues portent des styles en ligne ; AUCUN script, lui. Le paiement redirige après un formulaire :
+    // Chrome applique form-action aux redirections — sans Stripe ici, le bouton « payer » ne mènerait nulle part.
+    'style-src': "'self' 'unsafe-inline'",
+    'form-action': ["'self' https://checkout.stripe.com https://billing.stripe.com", ...Object.keys(banques).map((b) => DOMAINES_BANQUES[b] ?? '')].join(' ').trim(),
+  };
+  const ENTETES = enTetesSecurite({ https, csp: CSP });
+  // 0.11 — les pages de la charge qui demandent le micro, la caméra… (`charge.permissions`, garde-http ≥ 0.2) :
+  // `{ '/exercice': {...}, '/exercice/*': {...} }`. Calculés UNE fois : une déclaration fautive arrête le démarrage.
+  // Le chemin exact d'abord, puis le préfixe le plus long ; toute autre page garde le refus par défaut.
+  const ENTETES_PAR_PAGE = Object.entries(charge.permissions ?? {}).map(([motif, permissions]) => {
+    if (!/^\/[^*\s]*(\/\*)?$/.test(motif)) throw new TypeError(`charge.permissions : motif de page invalide : ${motif} (« /page » ou « /dossier/* »)`);
+    const prefixe = motif.endsWith('/*') ? motif.slice(0, -1) : null;
+    return { motif, prefixe, entetes: enTetesSecurite({ https, csp: CSP, permissions }) };
+  }).sort((a, b) => (a.prefixe ? 1 : 0) - (b.prefixe ? 1 : 0) || (b.prefixe?.length ?? 0) - (a.prefixe?.length ?? 0));
+  const entetesDe = (chemin) => ENTETES_PAR_PAGE.find((p) => (p.prefixe ? chemin.startsWith(p.prefixe) : chemin === p.motif))?.entetes ?? ENTETES;
+
+  // La part anonyme : un compteur par adresse et par jour, en mémoire (perdu au redémarrage, assumé).
+  const anonymes = new Map(); const depuis = Date.now();
+  const jour = () => new Date().toISOString().slice(0, 10);
+  const planAnonyme = async () => d.findOne(S.Plan, { slug: config.planAnonyme ?? 'anonyme' });
+
+  async function catalogue() {
+    for (const p of config.paliers ?? []) {
+      const existant = await d.findOne(S.Plan, { slug: p.slug });
+      if (!existant) await d.create(S.Plan, { currency: 'eur', interval: 'month', active: true, ...p, limits: { ...p.limits } });
+      else {
+        // 0.4 (audit du 09/10/2026) — la configuration fait foi pour l'OFFRE : un palier retiré de la vente le devient en
+        // base au démarrage ; un prix changé oublie l'ancien tarif Stripe (recréé par catalogueStripe). Les limites,
+        // elles, se règlent dans /admin/plans.
+        const actif = p.active !== false;
+        const maj = {};
+        if (Boolean(existant.active === true || existant.active === 1) !== actif) maj.active = actif;
+        if (p.name && existant.name !== p.name) maj.name = p.name;
+        if (p.sortOrder !== undefined && Number(existant.sortOrder) !== Number(p.sortOrder)) maj.sortOrder = p.sortOrder;
+        if (p.price !== undefined && Number(existant.price) !== Number(p.price)) { maj.price = p.price; maj.stripePriceId = null; }
+        if (Object.keys(maj).length) await d.update(S.Plan, String(existant.id), maj);
+      }
+      // Les prix PRÉPAYÉS suivent la configuration (le prix récurrent, lui, vit chez Stripe ; les limites, dans /admin).
+      if (existant && p.prepaid && JSON.stringify(typeof existant.prepaid === 'string' ? JSON.parse(existant.prepaid) : existant.prepaid ?? null) !== JSON.stringify(p.prepaid)) {
+        await d.update(S.Plan, String(existant.id), { prepaid: p.prepaid });
+      }
+    }
+  }
+  async function catalogueStripe() {
+    if (!stripe) throw new Error('Stripe n’est pas configuré');
+    const faits = [];
+    for (const p of await d.find(S.Plan, {})) {
+      if (!(Number(p.price) > 0) || p.stripePriceId) continue;
+      const prod = await stripe.products.create({ name: `${config.marque.nom} — ${p.name}`, metadata: { [META.plan]: p.slug } });
+      const prix = await stripe.prices.create({ product: prod.id, unit_amount: Number(p.price), currency: p.currency || 'eur', recurring: { interval: p.interval || 'month' } });
+      await d.update(S.Plan, String(p.id), { stripePriceId: prix.id });
+      faits.push({ palier: p.slug, prix: prix.id });
+    }
+    return faits;
+  }
+  const paliersEnBase = async () => (await d.find(S.Plan, {})).sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
+
+  /**
+   * Les textes légaux : <dossierLegal>/<doc>.<lang>.md (ou le français), champs {{…}} remplis par la configuration.
+   * 0.4 (audit du 09/10/2026) — un document INCOMPLET (jeton sans valeur, « ⚖️ … À FAIRE TRANCHER » non tranché) ne
+   * se sert pas : il aurait l'air d'exister (SAAS-APP §7.2). `{{PAIEMENT}}` dit les moyens réellement actifs.
+   */
+  const NOMS_MOYENS = { stripe: 'Stripe (carte bancaire)', chargily: 'Chargily (CIB, Edahabia)', paypal: 'PayPal', satim: 'SATIM (CIB)' };
+  const signales = new Set();
+  function documentLegal(doc, lang) {
+    const dossier = config.dossierLegal ?? join(racine, 'legal');   // la greffe, plus le moteur
+    const f = [lang, 'fr'].map((l) => join(dossier, `${doc}.${l}.md`)).find((x) => existsSync(x));
+    if (!f) return { html: '', complet: false };
+    const moyens = [...(stripe ? ['stripe'] : []), ...Object.keys(paiement?.banques ?? {})].map((m) => NOMS_MOYENS[m] ?? m).join(', ');
+    const valeurs = { SERVICE: config.marque.nom, DOMAINE: origine.replace(/^https?:\/\//, ''), CONTACT_EMAIL: config.marque.courriel ?? '', PAIEMENT: moyens, ...(config.legal ?? {}) };
+    const manquants = new Set();
+    const texte = readFileSync(f, 'utf8').replace(/\{\{(\w+)\}\}/g, (m, k) => { if (valeurs[k]) return String(valeurs[k]); manquants.add(k); return ''; });
+    const aTrancher = /⚖️|À FAIRE TRANCHER/.test(texte);
+    const complet = !manquants.size && !aTrancher;
+    if (!complet && !signales.has(doc)) {
+      signales.add(doc);
+      journal.warn(`wagon : /${doc} incomplet, non servi${manquants.size ? ` — jetons sans valeur : ${[...manquants].join(', ')}` : ''}${aTrancher ? ' — décisions « À FAIRE TRANCHER » ouvertes' : ''}`);
+    }
+    // mdToHtml rend { html, toc } — pas une chaîne (constaté le 01/10/2026 : la page affichait « [object Object] »).
+    return { html: complet ? mdToHtml(texte).html : '', complet };
+  }
+
+  async function vueEspace(compte) {
+    const actif = await facturation.activePlan(String(compte.id));
+    const quotas = {};
+    for (const r of periodiques) {
+      const v = await facturation.check(String(compte.id), r.cle);
+      quotas[r.cle] = { courant: v.current, limite: v.limit === -1 ? null : v.limit, restant: v.limit === -1 ? null : Math.max(0, v.limit - v.current) };
+    }
+    const cles = (await comptes.cles.lister(String(compte.id))).map((c) => ({ prefix: c.prefix, label: c.label, enabled: c.enabled, usageCount: c.usageCount }));
+    const factures = (await d.find(S.Invoice, { account: String(compte.id) })).map((f) => ({ createdAt: f.createdAt, amount: f.amount, currency: f.currency, status: f.status, hostedUrl: f.hostedUrl }));
+    return { plan: actif?.plan ?? null, quotas, cles, factures, portailPossible: !!(stripe && compte.stripeCustomerId), limites: actif?.limits ?? {} };
+  }
+
+  /**
+   * 0.4 — repris de qatrax.dev : l'AVIS AVANT PRÉLÈVEMENT (`invoice.upcoming`) : montant, date, et où gérer son
+   * abonnement. Dans la première langue du site ; rien si le client Stripe ne correspond à aucun compte.
+   */
+  async function avisEcheance(f) {
+    if (!transport) return;
+    const client = typeof f.customer === 'string' ? f.customer : f.customer?.id;
+    const a = client ? await d.findOne(S.Account, { stripeCustomerId: client }) : null;
+    const u = a ? await d.findById(S.User, String(a.owner)) : null;
+    if (!u?.email) return;
+    const L = ui.langues[0]; const T = TEXTES_PAIEMENT[L] ?? TEXTES_PAIEMENT.fr;
+    const quand = f.next_payment_attempt ?? f.period_end;
+    const date = quand ? new Date(Number(quand) * 1000).toLocaleDateString(resolveFormatLocale(L), { timeZone: 'UTC', day: '2-digit', month: '2-digit', year: 'numeric' }) : '—';
+    const somme = montant(Number(f.amount_due ?? 0), String(f.currency ?? 'eur').toUpperCase(), L);
+    const remplir = (x, v) => Object.entries(v).reduce((acc, [k, val]) => acc.replaceAll(`{${k}}`, val), x);
+    await transport.envoyer({
+      to: u.email, subject: remplir(T.avisSujet, { marque: config.marque.nom, date }),
+      text: [config.marque.nom, '', remplir(T.avisTexte, { montant: somme, date }), '', remplir(T.avisGerer, { adresse: `${origine}/compte` }), ''].join('\n'),
+    });
+  }
+
+  async function handler(req, res) {
+    const url = new URL(req.url, 'http://wagon.local');
+    const chemin = url.pathname;
+    const methode = req.method;
+    for (const [k, v] of Object.entries(entetesDe(chemin))) res.setHeader(k, v);
+    // 0.8 — une instance de RECETTE (`indexer: false`) ne s'indexe pas, quelle que soit la page.
+    if (config.indexer === false) res.setHeader('x-robots-tag', 'noindex, nofollow');
+
+    // La langue : ?lang= (retenue dans un cookie), puis le cookie, puis le navigateur, puis la première configurée.
+    const demandee = url.searchParams.get('lang');
+    const accepte = String(req.headers['accept-language'] || '').split(',').map((x) => x.trim().slice(0, 2)).find((l) => ui.langues.includes(l));
+    const lang = ui.langues.includes(demandee) ? demandee : ui.langues.includes(cookieDe(req, 'wagon_lang')) ? cookieDe(req, 'wagon_lang') : accepte ?? ui.langues[0];
+    if (ui.langues.includes(demandee)) res.setHeader('set-cookie', cookieStrict('wagon_lang', demandee, { maxAge: 365 * 86400, https }));
+    const t = ui.t(lang);
+    const TC = TEXTES_COMPTE[lang] ?? TEXTES_COMPTE.fr;
+
+    const envoyer = (code, html, en = {}) => { res.writeHead(code, { 'content-type': 'text/html; charset=utf-8', ...en }); res.end(html); return true; };
+    const json = (code, o, en = {}) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8', ...en }); res.end(`${JSON.stringify(o)}\n`); return true; };
+    const rediriger = (vers, en = {}) => { res.writeHead(303, { location: vers, ...en }); res.end(); return true; };
+    const corps = () => lireCorps(req);
+    const formulaire = async () => Object.fromEntries(new URLSearchParams((await corps()).toString('utf8')));
+    // `corpsJson({ strict: true })` (0.4) : null quand le corps n'est pas un objet JSON — la charge répond 400 au lieu
+    // d'ignorer en silence une modification illisible. Sans option : {} comme avant.
+    const corpsJson = async ({ strict = false } = {}) => {
+      try { const o = JSON.parse((await corps()).toString('utf8') || '{}'); return o && typeof o === 'object' && !Array.isArray(o) ? o : (strict ? null : {}); } catch { return strict ? null : {}; }
+    };
+
+    // La session (cookie) et le compte qu'elle ouvre.
+    const jeton = cookieDe(req, 'wagon_session');
+    const s = jeton ? await sessions.lire(jeton) : null;
+    const qui = s ? await comptes.qui(String(s.user ?? s.userId ?? '')) : null;
+    const estAdmin = !!(qui && await estAdministrateur(qui.utilisateur.courriel));
+    // 0.5 — `chemin` : la page réelle (canonique, liens de langue) ; `actif` reste l'onglet (wagon-ui 0.5.1).
+    const page = (o) => ui.page({ lang, connecte: !!qui, base: origine, chemin, ...o });
+    const ouvrirSession = async (userId, vers = '/compte') => rediriger(vers, { 'set-cookie': cookieStrict('wagon_session', await sessions.ouvrir(userId), { maxAge: 30 * 86400, https }) });
+
+    // 0.5 — la santé : le commit EN SERVICE (fichier REVISION posé par le déployeur) et l'heure de démarrage.
+    if (chemin === '/health' && ['GET', 'HEAD'].includes(methode)) {
+      return json(200, { ok: true, app: config.marque.nom, commit: REVISION, demarreLe: DEMARRE_LE }, { 'cache-control': 'no-store' });
+    }
+
+    // 0.8 (audit du 09/10/2026, référencement) — robots.txt, sitemap.xml, icône. En recette : tout fermé, pas de sitemap.
+    if (chemin === '/robots.txt' && methode === 'GET') {
+      const texte = config.indexer === false ? 'User-agent: *\nDisallow: /\n'
+        : `User-agent: *\n${['/compte', '/admin', '/app', '/api/', '/connexion', '/inscription', '/deconnexion'].map((x) => `Disallow: ${x}`).join('\n')}\nSitemap: ${origine}/sitemap.xml\n`;
+      res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' }); res.end(texte); return true;
+    }
+    if (chemin === '/sitemap.xml' && methode === 'GET') {
+      if (config.indexer === false) { res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' }); res.end('404'); return true; }
+      // Les pages publiques du wagon (un document légal incomplet n'est pas servi, donc pas listé), puis celles de la charge.
+      const pages = ['/', ...(charge.conformite?.tarifs === false ? [] : ['/tarifs']),
+        ...['mentions-legales', 'cgu', 'cgv', 'confidentialite'].filter((doc) => documentLegal(doc, ui.langues[0]).html).map((doc) => `/${doc}`),
+        ...(typeof charge.sitemap === 'function' ? await charge.sitemap() : [])];
+      const xml = `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${[...new Set(pages)].map((x) => `<url><loc>${esc(`${origine}${x}`)}</loc></url>`).join('\n')}\n</urlset>\n`;
+      res.writeHead(200, { 'content-type': 'application/xml; charset=utf-8' }); res.end(xml); return true;
+    }
+    if (chemin === '/favicon.svg' && methode === 'GET') {
+      const fond = esc(config.couleurs?.brand ?? '#0f172a');
+      const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect width="64" height="64" rx="14" fill="${fond}"/><text x="32" y="44" font-size="34" text-anchor="middle" fill="#fff" font-family="sans-serif">${esc(config.marque.symbole || String(config.marque.nom ?? '?').charAt(0))}</text></svg>`;
+      res.writeHead(200, { 'content-type': 'image/svg+xml', 'cache-control': 'public, max-age=86400' }); res.end(svg); return true;
+    }
+    if (chemin === '/favicon.ico' && methode === 'GET') { res.writeHead(301, { location: '/favicon.svg' }); res.end(); return true; }
+
+    // Le webhook : authentifié par sa signature, il ne passe ni par le CSRF ni par une session.
+    if (chemin === '/api/stripe/webhook' && methode === 'POST') {
+      if (!vente || !webhookSecret) return json(503, { ok: false, error: 'paiement non configuré' });
+      const brut = await corps();
+      const r = await vente.handleWebhook(brut, String(req.headers['stripe-signature'] || ''));
+      // 0.4 — repris de qatrax.dev : l'avis avant prélèvement. La signature est vérifiée (200) : le corps est bien
+      // celui de Stripe. Un rejeu (« replay: no effect ») n'envoie pas un second courriel.
+      if (r.status === 200 && r.result !== 'replay: no effect') {
+        try {
+          const evt = JSON.parse(brut.toString('utf8'));
+          if (evt.type === 'invoice.upcoming') await avisEcheance(evt.data?.object ?? {});
+        } catch (e) { journal.warn(`wagon : avis d'échéance non envoyé : ${e?.message ?? e}`); }
+      }
+      return json(r.status, { ok: r.status === 200, result: r.result });
+    }
+
+    // 0.4 — repris de qatrax.dev : le RETOUR du portail Stripe. La session est SameSite=Strict ; une navigation venue
+    // de billing.stripe.com ne l'envoie pas, et l'on se croyait déconnecté. Cette page, servie sans session, relance
+    // la navigation DEPUIS le site : le cookie part, « Mon compte » s'affiche.
+    if (chemin === '/compte/retour' && methode === 'GET') {
+      res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
+      res.end(`<!doctype html><html lang="${lang}"><head><meta charset="utf-8"><meta http-equiv="refresh" content="0;url=/compte"><title>${esc(config.marque.nom)}</title></head><body><p><a href="/compte">${esc(t('espace.compte'))}</a></p></body></html>`);
+      return true;
+    }
+
+    // Les webhooks des banques prépayées : authentifiés par leur signature (vérifiée par @mostajs/payment avec la clé
+    // du .env), ni CSRF ni session. 404 pour une banque non active, 400 pour une signature fausse.
+    if (chemin.startsWith('/api/paiement/webhook/') && methode === 'POST') {
+      if (!prepaye) return json(503, { ok: false, error: 'paiement prépayé non configuré' });
+      const r = await prepaye.handleWebhook(decodeURIComponent(chemin.slice('/api/paiement/webhook/'.length)), (await corps()).toString('utf8'), req.headers);
+      return json(r.status, { ok: r.status === 200, result: r.result });
+    }
+
+    // 0.10 — le RETOUR de l'acheteur, pour les banques sans webhook (SATIM) : retour ET échec y reviennent, en GET (ou
+    // POST). Le paiement se constate comme un webhook — @mostajs/payment réinterroge la banque, rien de l'URL n'est cru —,
+    // puis l'acheteur part vers « merci » s'il a payé, vers les tarifs sinon.
+    if (chemin.startsWith('/api/paiement/retour/') && (methode === 'GET' || methode === 'POST')) {
+      if (!prepaye) return rediriger('/tarifs');
+      const banque = decodeURIComponent(chemin.slice('/api/paiement/retour/'.length));
+      const donnees = methode === 'GET' ? url.searchParams.toString() : (await corps()).toString('utf8');
+      const r = await prepaye.handleWebhook(banque, donnees, req.headers);
+      if (r.status >= 500) journal.warn(`wagon : retour ${banque} : ${r.result}`);
+      return rediriger(r.paid ? '/paiement/merci' : '/tarifs');
+    }
+
+    // La porte de service : une clé d'API ouvre /api/v1/* ; sans clé valable, 401 — jamais une page.
+    let compteCle = null;
+    if (chemin.startsWith('/api/v1/')) {
+      const m = String(req.headers.authorization || '').match(/^Bearer\s+(\S+)$/i);
+      const v = m ? await comptes.cles.verifier(m[1], { ip: ipClient(req) }) : null;
+      if (!v) return json(401, { ok: false, error: 'clé d’API absente, invalide ou révoquée' });
+      compteCle = v.compte;
+      if (chemin === '/api/v1/moi' && methode === 'GET') {
+        const e = await vueEspace(compteCle);
+        return json(200, { ok: true, compte: { nom: compteCle.name }, plan: e.plan?.slug ?? null, quotas: e.quotas });
+      }
+    } else if (!['GET', 'HEAD'].includes(methode)) {
+      const l = requeteLegitime(req, { origine: origine || 'http://localhost' });
+      if (!l.ok) return envoyer(403, page({ titre: '403', contenu: `<h1>403</h1><p class="msg">${esc(l.motif)}</p>` }));
+    }
+
+    // Le contexte que reçoit la charge utile.
+    const compte = compteCle ?? qui?.compte ?? null;
+    const refuser = (v) => {
+      const en = v.permanent ? {} : { 'retry-after': String(v.retryAfterSeconds ?? 60) };
+      const code = v.permanent ? 403 : 429;
+      if (chemin.startsWith('/api/')) return json(code, { ok: false, error: v.reason, permanent: !!v.permanent, retryAfterSeconds: v.retryAfterSeconds, ...(v.plafond ? { plafond: v.resource, limite: v.limit } : {}) }, en);
+      const texte = v.plafond && v.limit ? v.reason : v.permanent ? t('tarifs.aucun') : v.reason;
+      return envoyer(code, page({ titre: String(code), contenu: `<h1>${code}</h1><p class="msg">${esc(texte)}</p><p><a class="bouton" href="/tarifs">${esc(t('nav.tarifs'))}</a></p>` }), en);
+    };
+    /** Le palier de la requête : celui du compte, sinon le palier anonyme. */
+    const palier = async () => {
+      if (compte) {
+        const a = await facturation.activePlan(String(compte.id));
+        const l = a?.limits ?? {};
+        return { slug: a?.plan?.slug ?? null, nom: a?.plan?.name ?? null, limites: typeof l === 'string' ? JSON.parse(l) : l };
+      }
+      const p = await planAnonyme();
+      return { slug: p?.slug ?? null, nom: p?.name ?? null, limites: p ? (typeof p.limits === 'string' ? JSON.parse(p.limits) : p.limits) : {} };
+    };
+    /**
+     * Un PLAFOND (ressource `plafond: true`) : la charge compte ce qu'elle détient (`actuel`), le wagon dit si
+     * une unité de plus tient dans le palier. Refus toujours définitif (403) — un stock ne se recharge pas
+     * avec le temps ; il se libère (suppression, archivage) ou se relève (palier supérieur).
+     */
+    const plafond = async (cle, actuel) => {
+      const r = ressources.find((x) => x.cle === cle && x.plafond);
+      if (!r) throw new Error(`ressource « ${cle} » : pas un plafond déclaré par la charge`);
+      const limite = Number((await palier()).limites?.[r.limite] ?? 0);
+      const n = Number(actuel) || 0;
+      if (limite === -1) return { allowed: true, plafond: true, resource: cle, current: n, limit: -1 };
+      if (!limite) return { allowed: false, permanent: true, plafond: true, resource: cle, current: n, limit: 0, reason: 'plan does not include this resource' };
+      if (n < limite) return { allowed: true, plafond: true, resource: cle, current: n, limit: limite };
+      const libelle = (o) => (typeof o === 'string' ? o : o?.[lang] ?? o?.fr ?? cle);
+      return { allowed: false, permanent: true, plafond: true, resource: cle, current: n, limit: limite,
+        reason: (PLAFOND_ATTEINT[lang] ?? PLAFOND_ATTEINT.fr).replace('{n}', String(limite)).replace('{ressource}', libelle(r.libelle)) };
+    };
+    const consommer = async (cle) => {
+      // Un plafond ne se « consomme » pas : il se contrôle par ctx.plafond(cle, actuel).
+      if (ressources.some((x) => x.cle === cle && x.plafond)) throw new Error(`ressource « ${cle} » : plafond, utiliser ctx.plafond()`);
+      if (compte) return facturation.consume(String(compte.id), cle);
+      const r = periodiques.find((x) => x.cle === cle);
+      const p = await planAnonyme();
+      if (!r || !p) return { allowed: false, permanent: true, reason: 'not included' };
+      const k = `${ipClient(req)}|${cle}|${jour()}`;
+      const v = checkLimits(typeof p.limits === 'string' ? JSON.parse(p.limits) : p.limits, { limit: r.limite, period: PERIODE[r.periode] ?? 'day' }, anonymes.get(k) ?? 0);
+      if (v.allowed) anonymes.set(k, (anonymes.get(k) ?? 0) + 1);
+      return v;
+    };
+    // 0.3.1 — `admin` : la session est celle d'un administrateur (config.admins + WAGON_ADMINS) — pour qu'une
+    // charge réserve ses outils (ex. l'outil de l'agence de travel) sans recalculer la liste.
+    const ctx = { chemin, methode, lang, t, ui, page, envoyer, json, rediriger, formulaire, corpsJson, compte, consommer, refuser, palier, plafond, admin: estAdmin && !compteCle };
+    if (charge.routes && (await charge.routes(req, res, ctx))) return true;
+    if (chemin.startsWith('/api/')) return json(404, { ok: false, error: 'introuvable' });
+
+    // ── Les pages du wagon ──
+    if (chemin === '/' && methode === 'GET') {
+      const a = charge.accueil?.[lang] ?? charge.accueil?.fr ?? { titre: config.marque.nom };
+      return envoyer(200, page({ actif: '/', titre: config.marque.nom, contenu: ui.accueil({ lang, ...a }) }));
+    }
+    if (chemin === '/tarifs' && methode === 'GET') return envoyer(200, page({ actif: '/tarifs', titre: t('tarifs.titre'), contenu: ui.tarifs({ lang, paliers: await paliersEnBase() }) }));
+    if ((chemin === '/aide' || chemin === '/apropos') && methode === 'GET') {
+      const md = config[chemin.slice(1)]?.[lang] ?? config[chemin.slice(1)]?.fr ?? '';
+      return envoyer(200, page({ actif: chemin, titre: t(`nav.${chemin.slice(1)}`), contenu: mdToHtml(md).html }));
+    }
+    // Sept adresses, quatre documents : les alias en 301 vers l'adresse canonique (SAAS-APP §7.1).
+    const ALIAS_LEGAUX = { '/legal': '/mentions-legales', '/conditions': '/cgv', '/privacy': '/confidentialite' };
+    if (ALIAS_LEGAUX[chemin] && methode === 'GET') {
+      res.writeHead(301, { location: `${ALIAS_LEGAUX[chemin]}${url.search}` }); res.end(); return true;
+    }
+    for (const doc of ['mentions-legales', 'cgu', 'cgv', 'confidentialite']) {
+      if (chemin === `/${doc}` && methode === 'GET') {
+        const { html } = documentLegal(doc, lang);
+        return envoyer(html ? 200 : 404, page({ actif: chemin, titre: t(`legal.${doc === 'mentions-legales' ? 'mentions' : doc}`), contenu: ui.legal({ lang, doc, html }) }));
+      }
+    }
+
+    // L'inscription : le compte naît au palier GRATUIT ; un palier payant passe ensuite par le paiement.
+    const methodeConnexion = config.connexion === 'code' ? 'code' : 'motdepasse';
+    // 0.5 — « mot de passe oublié » n'existe que si un courriel peut partir : un accusé de réception d'un message que
+    // personne n'enverra serait pire qu'une page absente (auth-plug T-KIT-5).
+    const oubliPossible = methodeConnexion === 'motdepasse' && !!transport;
+    if (chemin === '/inscription') {
+      const tous = await paliersEnBase();
+      const palierDe = (slug) => tous.find((p) => p.slug === slug && p.active !== false) ?? tous.find((p) => p.slug === (config.planGratuit ?? 'gratuit'));
+      if (methode === 'GET') return envoyer(200, page({ titre: t('inscription.titre'), contenu: ui.inscription({ lang, palier: palierDe(url.searchParams.get('plan')), methode: methodeConnexion, minMotDePasse: motsDePasse.policy.minLength }) }));
+      if (!freinInscription.take(`ip:${ipClient(req)}`).ok) return envoyer(429, page({ titre: t('inscription.titre'), contenu: `<p class="msg">${esc((TEXTES_COMPTE[lang] ?? TEXTES_COMPTE.fr).trop)}</p>` }), { 'retry-after': '60' });
+      const f = await formulaire();
+      const palier = palierDe(f.plan);
+      const courriel = String(f.courriel ?? '').trim().toLowerCase();
+      const refus = (m) => envoyer(200, page({ titre: t('inscription.titre'), contenu: ui.inscription({ lang, palier, erreur: m, methode: methodeConnexion, minMotDePasse: motsDePasse.policy.minLength }) }));
+      if (!COURRIEL.test(courriel) || !String(f.nom ?? '').trim()) return refus(t('inscription.courrielAide'));
+      if (await d.findOne(S.User, { email: courriel })) return refus(t('inscription.deja'));
+      if (methodeConnexion === 'motdepasse') {
+        const reproches = motsDePasse.checkPolicy(String(f.motdepasse ?? ''), { login: courriel });
+        if (reproches.length) return refus(t('espace.faible', { motifs: reproches.map((x) => t(`espace.${{ 'too-short': 'tropCourt', 'too-long': 'tropLong' }[x.code ?? x] ?? 'trivial'}`)).join(', ') }));
+      }
+      const { compte: c, utilisateur } = await comptes.creer({ nom: String(f.nom).trim(), courriel });
+      if (methodeConnexion === 'motdepasse') await motsDePasse.setPassword(utilisateur.id, String(f.motdepasse), { login: courriel });
+      // La clé d'API de bienvenue — sauf si le palier n'en accorde aucune (maxCles 0) : le compte naît sans clé
+      // au lieu d'échouer (avant le 08/10/2026 : erreur 500 PLAFOND_CLES à l'inscription).
+      let cle = null;
+      try { cle = (await comptes.cles.creer(String(c.id), { label: t('espace.vosCles'), portees: {} })).full; } catch (e) { if (e.code !== 'PLAFOND_CLES') throw e; }
+      const paiement = Number(palier?.price) > 0 ? { compteId: String(c.id), planSlug: palier.slug } : null;
+      const contenu = ui.inscriptionFaite({ lang, cle, base: origine, paiement });
+      if (methodeConnexion === 'code') return envoyer(200, page({ titre: t('inscription.faite'), contenu }));
+      return envoyer(200, page({ titre: t('inscription.faite'), contenu }), { 'set-cookie': cookieStrict('wagon_session', await sessions.ouvrir(utilisateur.id), { maxAge: 30 * 86400, https }) });
+    }
+
+    // La connexion : mot de passe, ou code + lien par courriel. Un refus ne dit jamais lequel était faux.
+    if (chemin === '/connexion') {
+      if (methode === 'GET') return envoyer(200, page({ titre: t('espace.seConnecter'), contenu: ui.connexion({ lang, methode: methodeConnexion }) + (oubliPossible ? `<p class="hint"><a href="/connexion/oubli">${esc(TC.oublie)}</a></p>` : '') }));
+      const f = await formulaire();
+      if (methodeConnexion === 'motdepasse') {
+        const r = await motsDePasse.login(String(f.courriel ?? ''), String(f.motdepasse ?? ''), { ip: ipClient(req) });
+        if (r.ok) return ouvrirSession(r.userId);
+        return envoyer(r.reason === 'throttled' ? 429 : 200, page({ titre: t('espace.seConnecter'), contenu: ui.connexion({ lang, erreur: t('espace.identifiantsFaux') }) }));
+      }
+      const courriel = String(f.courriel ?? '').trim().toLowerCase();
+      const dfi = await codes.request(courriel, { ip: ipClient(req) });
+      if (dfi && transport) {
+        const c = { code: dfi.code, linkUrl: `${origine}/connexion/lien?t=${dfi.token}`, expiresAt: dfi.expiresAt, fromName: config.marque.nom };
+        transport.envoyer({ to: courriel, subject: `${config.marque.nom} — ${t('espace.seConnecter')}`, text: emailCodeEmailText(c), html: emailCodeEmailHtml(c) }).catch((e) => journal.warn(`wagon : courriel non parti : ${e?.message ?? e}`));
+      }
+      return envoyer(200, page({ titre: t('espace.seConnecter'), contenu: `<style>${AUTH_CSS}</style>${emailCodeForm({ action: '/connexion/code', email: courriel, labels: { againHref: '/connexion' } })}` }));
+    }
+    if (chemin === '/connexion/code' && methode === 'POST') {
+      const f = await formulaire();
+      const r = await codes.verifyCode(String(f.email ?? ''), String(f.code ?? ''), { ip: ipClient(req) });
+      if (r.ok) { await apresPreuveCourriel(r.userId); return ouvrirSession(r.userId); }
+      return envoyer(200, page({ titre: t('espace.seConnecter'), contenu: `<style>${AUTH_CSS}</style>${emailCodeForm({ action: '/connexion/code', email: String(f.email ?? ''), error: t('espace.identifiantsFaux'), labels: { againHref: '/connexion' } })}` }));
+    }
+    if (chemin === '/connexion/lien') {
+      if (methode === 'GET') {
+        const tk = url.searchParams.get('t') || ''; const l = await codes.peekLink(tk);
+        return envoyer(200, page({ titre: t('espace.seConnecter'), contenu: `<style>${AUTH_CSS}</style>${emailLinkConfirmPage({ action: '/connexion/lien', token: tk, state: l.ok ? 'ok' : l.reason, labels: { againHref: '/connexion' } })}` }));
+      }
+      const r = await codes.verifyLink(String((await formulaire()).token ?? ''));
+      if (r.ok) { await apresPreuveCourriel(r.userId); return ouvrirSession(r.userId); }
+      return rediriger('/connexion');
+    }
+    // 0.5 — la déconnexion est un POST (protégé par le CSRF) ; un GET (lien piégé, prélecture) ne fait que la proposer.
+    if (chemin === '/deconnexion') {
+      if (methode !== 'POST') return envoyer(200, page({ titre: TC.deconnexion, contenu: `<h1>${esc(TC.deconnexion)}</h1><p>${esc(TC.deconnexionAide)}</p><form method="post" action="/deconnexion"><button class="bouton">${esc(TC.deconnexion)}</button></form>` }));
+      if (jeton) await sessions.fermer(jeton);
+      return rediriger('/', { 'set-cookie': cookieStrict('wagon_session', '', { maxAge: 0, https }) });
+    }
+
+    // 0.5 — mot de passe OUBLIÉ : un lien par courriel (auth-lite requestReset / consumeReset). Proposé seulement si un
+    // courriel peut partir. Même réponse qu'un compte existe ou non ; le courriel part APRÈS la réponse.
+    if (oubliPossible && chemin === '/connexion/oubli') {
+      if (methode === 'GET') return envoyer(200, page({ titre: TC.oubliTitre, contenu: `<h1>${esc(TC.oubliTitre)}</h1><p>${esc(TC.oubliAide)}</p><form method="post" action="/connexion/oubli"><label>${esc(t('espace.courriel'))} <input type="email" name="courriel" required></label> <button class="bouton">${esc(TC.envoyer)}</button></form>` }));
+      const courriel = String((await formulaire()).courriel ?? '').trim().toLowerCase();
+      const r = COURRIEL.test(courriel) ? await motsDePasse.requestReset(courriel, { ip: ipClient(req) }) : null;
+      envoyer(200, page({ titre: TC.oubliTitre, contenu: `<h1>${esc(TC.oubliTitre)}</h1><p class="msg">${esc(TC.envoye.replace('{courriel}', courriel))}</p>` }));
+      if (r) {
+        const lienReinit = `${origine}/connexion/reinitialiser?t=${encodeURIComponent(r.token)}`;
+        Promise.resolve(transport.envoyer({ to: courriel, subject: TC.courrielSujet.replace('{marque}', config.marque.nom), text: [config.marque.nom, '', TC.courrielTexte, lienReinit, '', TC.courrielIgnorer, ''].join('\n') }))
+          .catch((e) => journal.warn(`wagon : courriel de réinitialisation non parti : ${e?.message ?? e}`));
+      }
+      return true;
+    }
+    if (oubliPossible && chemin === '/connexion/reinitialiser') {
+      const formulaireReinit = (tk, erreur = '') => `<h1>${esc(TC.reinit)}</h1>${erreur ? `<p class="msg">${esc(erreur)}</p>` : ''}<form method="post" action="/connexion/reinitialiser"><input type="hidden" name="t" value="${esc(tk)}"><p><label>${esc(TC.nouveau)} <input type="password" name="nouveau" required autocomplete="new-password"></label></p><p><label>${esc(TC.confirmer)} <input type="password" name="confirmer" required autocomplete="new-password"></label></p><button class="bouton">${esc(TC.enregistrer)}</button></form>`;
+      if (methode === 'GET') return envoyer(200, page({ titre: TC.reinit, contenu: formulaireReinit(url.searchParams.get('t') ?? '') }));
+      const f = await formulaire();
+      if (String(f.nouveau ?? '') !== String(f.confirmer ?? '')) return envoyer(400, page({ titre: TC.reinit, contenu: formulaireReinit(String(f.t ?? ''), TC.differents) }));
+      const r = await motsDePasse.consumeReset(String(f.t ?? ''), String(f.nouveau ?? ''));
+      if (!r.ok) return envoyer(400, page({ titre: TC.reinit, contenu: r.reason === 'policy' ? formulaireReinit(String(f.t ?? ''), t('espace.faible', { motifs: (r.issues ?? []).join(', ') })) : `<h1>${esc(TC.reinit)}</h1><p class="msg">${esc(TC.lienMort)}</p><p><a href="/connexion/oubli">${esc(TC.oublie)}</a></p>` }));
+      await sessions.fermerToutes(String(r.userId));
+      return ouvrirSession(r.userId);
+    }
+
+    // L'espace du client.
+    if (chemin.startsWith('/compte') || chemin === '/paiement') {
+      if (!qui) return rediriger('/connexion');
+      const c = qui.compte;
+      if (chemin === '/compte' && methode === 'GET') {
+        // 0.3 — une période prépayée se dit, avec sa date de fin (wagon-ui ne l'affiche pas).
+        const actif = await facturation.activePlan(String(c.id));
+        const sub = actif?.subscription;
+        const T = TEXTES_PAIEMENT[lang] ?? TEXTES_PAIEMENT.fr;
+        const fin = sub?.currentPeriodEnd && !sub?.stripeSubId && Number(actif?.plan?.price) > 0
+          ? `<p class="hint">${esc(T.jusquau.replace('{plan}', actif.plan.name).replace('{date}', new Date(sub.currentPeriodEnd).toLocaleDateString(resolveFormatLocale(lang), { day: 'numeric', month: 'long', year: 'numeric' })))}</p>` : '';
+        const gestion = `<section class="gestion-compte"><h2>${esc(TC.gerer)}</h2><ul>${methodeConnexion === 'motdepasse' ? `<li><a href="/compte/mot-de-passe">${esc(TC.motDePasse)}</a></li>` : ''}<li><a href="/compte/export">${esc(TC.exporter)}</a></li><li><a href="/compte/supprimer">${esc(TC.supprimer)}</a></li></ul><form method="post" action="/deconnexion"><button class="bouton">${esc(TC.deconnexion)}</button></form></section>`;
+        return envoyer(200, page({ actif: '/compte', titre: t('espace.compte'), contenu: ui.espace({ lang, vue: await vueEspace(c) }) + fin + gestion }));
+      }
+      // 0.5 — changer son mot de passe : l'actuel d'abord ; les AUTRES sessions sont fermées, celle-ci rouverte.
+      if (chemin === '/compte/mot-de-passe' && methodeConnexion === 'motdepasse') {
+        const formulaireMdp = (erreur = '') => `<h1>${esc(TC.motDePasse)}</h1>${erreur ? `<p class="msg">${esc(erreur)}</p>` : ''}<form method="post" action="/compte/mot-de-passe"><p><label>${esc(TC.actuel)} <input type="password" name="actuel" required autocomplete="current-password"></label></p><p><label>${esc(TC.nouveau)} <input type="password" name="nouveau" required autocomplete="new-password"></label></p><p><label>${esc(TC.confirmer)} <input type="password" name="confirmer" required autocomplete="new-password"></label></p><button class="bouton">${esc(TC.enregistrer)}</button></form>`;
+        if (methode === 'GET') return envoyer(200, page({ actif: '/compte', titre: TC.motDePasse, contenu: formulaireMdp() }));
+        const f = await formulaire();
+        const courriel = String(qui.utilisateur.courriel);
+        const verif = await motsDePasse.login(courriel, String(f.actuel ?? ''), { ip: ipClient(req) });
+        if (!verif.ok) return envoyer(400, page({ actif: '/compte', titre: TC.motDePasse, contenu: formulaireMdp(TC.mauvais) }));
+        if (String(f.nouveau ?? '') !== String(f.confirmer ?? '')) return envoyer(400, page({ actif: '/compte', titre: TC.motDePasse, contenu: formulaireMdp(TC.differents) }));
+        const r = await motsDePasse.setPassword(String(verif.userId), String(f.nouveau ?? ''), { login: courriel });
+        if (!r.ok) return envoyer(400, page({ actif: '/compte', titre: TC.motDePasse, contenu: formulaireMdp(t('espace.faible', { motifs: (r.issues ?? []).join(', ') })) }));
+        await sessions.fermerToutes(String(verif.userId));
+        return ouvrirSession(verif.userId);
+      }
+      // 0.5 — partir avec ses données (RGPD, portabilité) : un fichier JSON.
+      if (chemin === '/compte/export' && methode === 'GET') {
+        const u = await d.findOne(S.User, { email: String(qui.utilisateur.courriel) });
+        const vue = await vueEspace(c);
+        const donnees = {
+          exporteLe: new Date().toISOString(), service: config.marque.nom,
+          utilisateur: { courriel: u?.email, prenom: u?.firstName, nom: u?.lastName, langue: u?.locale, creeLe: u?.createdAt },
+          compte: { nom: c.name, palier: vue.plan?.name ?? null },
+          factures: vue.factures ?? [], cles: (vue.cles ?? []).map((k) => ({ prefix: k.prefix, label: k.label, active: k.enabled })),
+          charge: typeof charge.exporterCompte === 'function' ? await charge.exporterCompte(String(c.id)) : null,
+        };
+        res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'content-disposition': `attachment; filename="mes-donnees-${jour()}.json"`, 'cache-control': 'no-store' });
+        res.end(`${JSON.stringify(donnees, null, 2)}\n`);
+        return true;
+      }
+      // 0.5 — supprimer son compte (RGPD, effacement) : le courriel retapé en confirmation ; un abonnement Stripe en
+      // cours se résilie d'abord. L'identité et les données s'effacent ; les factures restent, rattachées à un compte
+      // anonymisé (obligation comptable).
+      if (chemin === '/compte/supprimer') {
+        const formulaireSup = (erreur = '') => `<h1>${esc(TC.supprimer)}</h1><p>${esc(TC.supprimerAide)}</p>${erreur ? `<p class="msg">${esc(erreur)}</p>` : ''}<form method="post" action="/compte/supprimer"><p><label>${esc(TC.confirmation)} <input type="email" name="confirmation" required></label></p><button class="bouton">${esc(TC.supprimerBouton)}</button></form>`;
+        if (methode === 'GET') return envoyer(200, page({ actif: '/compte', titre: TC.supprimer, contenu: formulaireSup() }));
+        const courriel = String(qui.utilisateur.courriel).toLowerCase();
+        if (String((await formulaire()).confirmation ?? '').trim().toLowerCase() !== courriel) return envoyer(400, page({ actif: '/compte', titre: TC.supprimer, contenu: formulaireSup(TC.confirmationFausse) }));
+        const actif = await facturation.activePlan(String(c.id));
+        if (actif?.subscription?.stripeSubId) return envoyer(400, page({ actif: '/compte', titre: TC.supprimer, contenu: formulaireSup(TC.abonnementActif) }));
+        const u = await d.findOne(S.User, { email: courriel });
+        if (typeof charge.effacerCompte === 'function') await charge.effacerCompte(String(c.id));
+        for (const k of await d.find(S.ApiKey, { account: String(c.id) })) await d.delete(S.ApiKey, String(k.id));
+        for (const m of await d.find(S.AccountMember, { user: String(u?.id ?? '') })) await d.delete(S.AccountMember, String(m.id));
+        for (const x of await d.find(S.WagonCredential, { user: String(u?.id ?? '') })) await d.delete(S.WagonCredential, String(x.id));
+        for (const x of await d.find(S.WagonAdmin, { courriel })) await d.delete(S.WagonAdmin, String(x.id));
+        if (u) await sessions.fermerToutes(String(u.id));
+        // Le compte reste (ses factures y sont rattachées) mais ne dit plus rien de personne ; l'utilisateur est ANONYMISÉ
+        // et verrouillé plutôt que supprimé (le compte le désigne comme propriétaire).
+        const anonyme = `supprime-${String(c.id).slice(0, 8)}`;
+        await d.update(S.Account, String(c.id), { name: anonyme, metadata: null, status: 'deleted' });
+        if (u) await d.update(S.User, String(u.id), { email: `${anonyme}-${String(u.id).slice(0, 8)}@supprime.invalid`, firstName: '—', lastName: '—', phone: null, avatar: null, status: 'locked', stripeCustomerId: null });
+        return rediriger('/', { 'set-cookie': cookieStrict('wagon_session', '', { maxAge: 0, https }) });
+      }
+      if (chemin === '/compte/cles' && methode === 'POST') {
+        const f = await formulaire();
+        try {
+          const k = await comptes.cles.creer(String(c.id), { label: String(f.libelle ?? '').slice(0, 60), portees: {} });
+          return envoyer(200, page({ actif: '/compte', titre: t('espace.compte'), contenu: ui.espace({ lang, vue: await vueEspace(c), cleNeuve: k.full }) }));
+        } catch (e) { return envoyer(200, page({ actif: '/compte', titre: t('espace.compte'), contenu: ui.espace({ lang, vue: await vueEspace(c), erreur: e.code === 'PLAFOND_CLES' ? t('espace.plafondAtteint', { n: (await vueEspace(c)).limites.maxCles }) : e.message }) })); }
+      }
+      if (chemin === '/compte/cles/revoquer' && methode === 'POST') {
+        await comptes.cles.revoquer(String(c.id), String((await formulaire()).prefix ?? ''));
+        return rediriger('/compte');
+      }
+      if (chemin === '/compte/portail' && methode === 'POST') {
+        const frais = await d.findById(S.Account, String(c.id));
+        if (!stripe || !frais?.stripeCustomerId) return rediriger('/compte');
+        const p = await stripe.billingPortal.sessions.create({ customer: frais.stripeCustomerId, return_url: `${origine}/compte/retour` });
+        return rediriger(p.url);
+      }
+      if (chemin === '/paiement' && methode === 'POST') {
+        // Le compte est celui de la SESSION : le champ « compte » du formulaire n'est jamais cru.
+        const f = await formulaire();
+        const planSlug = String(f.plan ?? ''); const banque = String(f.banque ?? ''); const periode = String(f.periode ?? '');
+        const refus = (m, plus = '') => envoyer(200, page({ titre: t('tarifs.titre'), contenu: `<p class="msg">${esc(m)}</p>${plus}` }));
+        // 0.4 (audit du 09/10/2026) — on ne vend que ce qui est PROPOSÉ (palier actif et payant) ; un abonné Stripe ne
+        // s'abonne pas une seconde fois (Stripe prélèverait les deux) ; une période prépayée en cours n'est pas écrasée.
+        {
+          const TP = TEXTES_PAIEMENT[lang] ?? TEXTES_PAIEMENT.fr;
+          // Pas de vente sans CGV complètes (DEVRULES §11.10 : la page légale conditionne le droit d'encaisser).
+          if (!documentLegal('cgv', 'fr').complet) return refus(TP.venteFermee);
+          const voulu = await d.findOne(S.Plan, { slug: planSlug });
+          const vendable = voulu && voulu.active !== false && voulu.active !== 0 && (Number(voulu.price) > 0 || Object.keys(voulu.prepaid ?? {}).length);
+          if (!vendable) return refus(TP.nonPropose);
+          const actif = await facturation.activePlan(String(c.id));
+          const sub = actif?.subscription;
+          if (sub?.stripeSubId) return refus(TP.dejaAbonne, `<form method="post" action="/compte/portail"><button class="bouton">${esc(TP.gerer)}</button></form>`);
+          if (sub && Number(actif.plan?.price) > 0 && sub.currentPeriodEnd && new Date(sub.currentPeriodEnd).getTime() > Date.now()) {
+            return refus(TP.prepayeEnCours.replace('{date}', new Date(sub.currentPeriodEnd).toLocaleDateString(resolveFormatLocale(lang), { day: 'numeric', month: 'long', year: 'numeric' })));
+          }
+        }
+        // Une banque prépayée choisie : Chargily, PayPal… (un mois ou un an, payé d'avance).
+        if (banque && banque !== 'stripe') {
+          if (!prepaye) return refus(t('tarifs.encours'));
+          const r = await prepaye.openCheckout({ accountId: String(c.id), planSlug, provider: banque, period: periode });
+          return r.ok ? rediriger(r.url) : refus(r.reason);
+        }
+        const offres = prepaye && !banque ? await prepaye.offers(planSlug) : [];
+        const plan = await d.findOne(S.Plan, { slug: planSlug });
+        const stripePossible = !!(vente && plan?.stripePriceId);
+        // Plusieurs moyens : on les montre ; Stripe seul (ou choisi) : on y va directement, comme avant la 0.3.
+        if (offres.length) {
+          const T = TEXTES_PAIEMENT[lang] ?? TEXTES_PAIEMENT.fr;
+          const bouton = (champs, libelle) => `<li><form method="post" action="/paiement">${Object.entries({ plan: planSlug, ...champs }).map(([k, v]) => `<input type="hidden" name="${k}" value="${esc(v)}">`).join('')}<button class="bouton">${esc(libelle)}</button></form></li>`;
+          const lignes = [
+            ...(stripePossible ? [bouton({ banque: 'stripe' }, `${T.stripe} — ${ui.euros(plan.price, lang)}${T.parMois}`)] : []),
+            ...offres.map((o) => bouton({ banque: o.provider, periode: o.period }, `${T[o.provider] ?? o.provider} — ${T[o.period]} : ${montant(o.amount, o.currency, lang)}`)),
+          ];
+          return envoyer(200, page({ titre: T.choisir, contenu: `<h1>${esc(T.choisir)}</h1><p><b>${esc(plan?.name ?? planSlug)}</b></p><ul class="choix-paiement">${lignes.join('')}</ul><p class="hint">${esc(T.unique)}</p>` }));
+        }
+        const r = vente ? await vente.openCheckout({ accountId: String(c.id), planSlug, locale: lang === 'ar' ? 'auto' : lang }) : { ok: false, reason: t('tarifs.encours') };
+        if (r.ok) return rediriger(r.url);
+        return refus(r.reason);
+      }
+    }
+    if (chemin === '/paiement/merci' && methode === 'GET') return envoyer(200, page({ titre: t('inscription.merci'), contenu: ui.merci({ lang }) }));
+
+    // L'administration : invisible (404) à qui n'est pas administrateur.
+    if (chemin.startsWith('/admin/') && estAdmin) {
+      if (chemin === '/admin/plans') {
+        let message = '';
+        if (methode === 'POST') {
+          const f = await formulaire();
+          const tous = await paliersEnBase();
+          const cles = [...ressources.map((r) => r.limite), 'maxCles'];
+          const nouveaux = tous.map((p) => ({ ...p, limits: { ...(typeof p.limits === 'string' ? JSON.parse(p.limits) : p.limits), ...Object.fromEntries(cles.filter((k) => f[`${p.slug}.${k}`] !== undefined).map((k) => [k, Number(f[`${p.slug}.${k}`])])) } }));
+          try {
+            assertMonotonicPlans(nouveaux, cles);
+            for (const p of nouveaux) await d.update(S.Plan, String(p.id), { limits: p.limits });
+            message = t('admin.enregistre');
+          } catch (e) { message = e.message; }
+        }
+        return envoyer(200, page({ titre: t('admin.titre'), contenu: ui.adminPaliers({ lang, offres: await paliersEnBase(), message }) }));
+      }
+      if (chemin === '/admin/usage' && methode === 'GET') {
+        const lignes = []; const parRessource = {}; let payants = 0;
+        for (const a of await d.find(S.Account, {})) {
+          const actif = await facturation.activePlan(String(a.id));
+          if (Number(actif?.plan?.price) > 0) payants += 1;
+          const l = { nom: a.name, plan: actif?.plan?.name ?? '—', actif: a.status === 'active', parRessource: {} };
+          const limites = typeof actif?.limits === 'string' ? JSON.parse(actif.limits) : (actif?.limits ?? {});
+          for (const r of ressources.filter((x) => x.plafond)) {
+            const lim = Number(limites[r.limite] ?? 0);
+            l.parRessource[r.cle] = { courant: '—', limite: lim === -1 ? null : lim, part: null, fenetre: 0 };
+          }
+          for (const r of periodiques) {
+            const v = await facturation.check(String(a.id), r.cle);
+            l.parRessource[r.cle] = { courant: v.current, limite: v.limit === -1 ? null : v.limit, part: v.limit > 0 ? Math.round((v.current / v.limit) * 100) : null, fenetre: v.current };
+            parRessource[r.cle] = (parRessource[r.cle] ?? 0) + v.current;
+          }
+          lignes.push(l);
+        }
+        const auj = jour(); const anon = [...anonymes.entries()].filter(([k]) => k.endsWith(auj));
+        return envoyer(200, page({ titre: t('usage.titre'), contenu: ui.adminUsage({ lang,
+          usage: { jours: 1, totaux: { comptes: lignes.length, actifs: lignes.filter((x) => x.actif).length, payants, erreurs: 0, parRessource }, lignes },
+          anonyme: { depuis, visiteursJour: new Set(anon.map(([k]) => k.split('|')[0])).size, adressesJour: new Set(anon.map(([k]) => k.split('|')[0])).size, operationsJour: anon.reduce((s2, [, v]) => s2 + v, 0), seaux: anonymes.size } }) }));
+      }
+    }
+
+    return envoyer(404, page({ titre: t('erreur.introuvable'), contenu: ui.introuvable({ lang }) }));
+  }
+
+  return {
+    handler: (req, res) => handler(req, res).catch((e) => { journal.error(e); if (!res.headersSent) { res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' }); res.end('Erreur interne'); } }),
+    catalogue, catalogueStripe, dialect: d, schemas: S, comptes, facturation, confirmerAdmin, reprendrePaiements,
+    /** Fixe le mot de passe d'un compte depuis le serveur (mot de passe perdu) ; lève si la règle le refuse. */
+    async fixerMotDePasse(courriel, motdepasse) {
+      const c = String(courriel ?? '').trim().toLowerCase();
+      const u = await d.findOne(S.User, { email: c });
+      if (!u) return false;
+      const reproches = motsDePasse.checkPolicy(String(motdepasse ?? ''), { login: c });
+      if (reproches?.length) throw new Error(reproches.join(' ; '));
+      await motsDePasse.setPassword(String(u.id), String(motdepasse), { login: c });
+      return true;
+    },
+    fermer: () => d.disconnect(),
+  };
+}