@mostajs/wagon-engine 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -3,6 +3,31 @@
 **Auteur** : Dr Hamid MADANI <drmdh@msn.com>
 Format : Keep a Changelog ; versions : SemVer.
 
+## [0.7.0] — 2026-10-29
+
+### Ajouté
+- **Le paiement ponctuel de la charge** : `ctx.paiement.ouvrir({ moyen, montant, description, reference, metadata,
+  merci, annule })` ouvre une session chez une banque prépayée active (celle qui a un vendeur, 0.6) pour un achat à
+  l'unité de la charge (une place de cours de Speaking) ; `ctx.paiement.moyens` dit les moyens et leur devise ;
+  `ctx.paiement` est `null` sans banque. La banque confirme à `/api/paiement/charge/<moyen>` (webhook authentifié par
+  sa signature, hors CSRF et hors session) ou renvoie l'acheteur à `/api/paiement/charge-retour/<moyen>` (banque
+  réinterrogée, comme SATIM) ; le wagon remet le constat à `charge.paiementRegle({ reference, statut, commande, montant,
+  devise, moyen, metadata })`. Les chemins de retour sont locaux. La ligne `Payment` reste dans la base du wagon.
+  Essai T-ENG-16.
+
+## [0.6.1] — 2026-10-28
+
+### Corrigé
+- **/compte d'une période prépayée dit ce qui a été payé** : le montant et la monnaie de la commande réglée
+  (`Payment`, @mostajs/payment), et sa durée (« Classe — 8 000 DZD — 1 mois »), au lieu du prix Stripe en euros par
+  mois. Relevé par le fondateur après un paiement Chargily sur Speaking. Sans commande retrouvée, le prix prépayé du
+  palier dans la monnaie de la banque. Les paiements prépayés réglés figurent parmi « Vos factures ».
+- Le dinar s'affiche sans décimales (« 8 000 DZD »), comme dans wagon-ui, aussi sur l'écran du choix du paiement.
+- Essais : T-ENG-15 ; T-WAG-13 (suite de conformité) vérifie le montant prépayé dans /compte.
+
+### Dépendances
+- `@mostajs/wagon-ui` ^0.11.1.
+
 ## [0.6.0] — 2026-10-28
 
 ### Ajouté

package/README.md

@@ -50,6 +50,8 @@ await demarrer({ config, charge });
 
 **Le paiement est au choix de l'utilisateur**, parmi les moyens actifs. Un moyen est actif quand ses clés sont dans le `.env` et que son commutateur n'est pas sur `off`. Une banque prépayée doit en plus être proposée par la configuration.
 
+**Un achat à l'unité de la charge (0.7).** `ctx.paiement.ouvrir({ moyen, montant, description, reference, metadata, merci, annule })` ouvre un paiement ponctuel (montant en unités mineures) chez une banque prépayée active ; `ctx.paiement.moyens` les liste, `ctx.paiement` est `null` sans banque. La banque confirme à `/api/paiement/charge/<moyen>` (signature) ou y renvoie l'acheteur (`/api/paiement/charge-retour/<moyen>`) ; le wagon appelle `charge.paiementRegle({ reference, statut, commande, montant, devise, moyen, metadata })`, que la charge écrit idempotent.
+
 ## Juger une greffe
 
 La suite de conformité est publiée avec le moteur. Elle juge la greffe du dossier courant, ou celle que désigne `WAGON_GREFFE` :

package/llms.txt

@@ -45,10 +45,11 @@ encore immatriculée → `PAIEMENT_VENDEUR_DZD=…`, `PAIEMENT_VENDEUR_EUR=` (vi
 ## CONTRAT DE LA CHARGE (charge/index.mjs)
 liens · ressources (quota { cle, limite, periode } | plafond { cle, limite, plafond: true }) · accueil (fiche { fr: { titre, lede, actions, preuves } }, ou 0.3 : async (ctx) => ({ titre, contenu, disposition, application, console })) · dispositions (0.3 : { nom: (p) => corps }) · textes ·
 routes(req, res, ctx) (passent en premier ; true si servie) · conformite (essai de quota T-WAG-3) · amorcer() (base au
-démarrage) · exporterCompte(id), effacerCompte(id) (RGPD) · sitemap() · sauvegarde() · permissions (0.11 :
+démarrage) · exporterCompte(id), effacerCompte(id) (RGPD) · sitemap() · sauvegarde() · paiementRegle(p) (0.7) · permissions (0.11 :
 { '/page': { microphone: 'self' }, '/dossier/*': … }, garde-http ≥ 0.2).
 ctx : chemin, methode, lang, t, ui, page({ titre, contenu }), envoyer, json, rediriger, formulaire, corpsJson({ strict }),
 compte, consommer(cle), refuser(v), palier({ compte? }), plafond(cle, n, { compte? }), courriel({ to, subject, text, html? }) → bool, admin.
+  0.7 : ctx.paiement (null sans banque prépayée active) = { moyens: [{ moyen, devise }], ouvrir({ moyen, montant (unités MINEURES), description, reference, metadata, merci: '/chemin', annule: '/chemin' }) → { ok, url, commande } | { ok: false, raison } } — paiement PONCTUEL de la charge (une place de cours…). La banque confirme à /api/paiement/charge/<moyen> (webhook, signature) ou renvoie l'acheteur à /api/paiement/charge-retour/<moyen> (SATIM) ; le wagon appelle alors charge.paiementRegle({ reference, statut: paid|failed|refunded|…, commande, montant (mineures), devise, moyen, metadata }), à écrire IDEMPOTENT (une banque rejoue). merci/annule : chemins locaux seulement.
   0.4 : /inscription?suite=/chemin et /connexion?suite=/chemin — retour à une page LOCALE après inscription (si ni clé ni paiement à montrer ; sinon bouton « Continuer ») ou connexion par mot de passe ; //hôte et adresses absolues ignorés.
   0.3 : ctx.page({ disposition: 'vitrine'|'application'|'console'|'nu'|<fournie>, application: { retour, titre, avatar, onglets, langues }, console: { menu, contexte, utilisateur } }) (wagon-ui 0.10) ; config.jetons { rayon, police, policeTitres, ombre, fond } ; config.marque.logo / logoClair (SVG en ligne ou chemin /…).
   0.2 : { compte } = identifiant d'un compte DÉSIGNÉ (requête sans session bornée par le palier d'un compte rattaché par la charge).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mostajs/wagon-engine",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Le wagon d'un SaaS, une fois pour toutes : comptes, connexion, paliers, quotas, paiement (Stripe, Chargily, SATIM), espace client, administration, pages légales, fr/en/ar. Une greffe n'apporte que wagon.config.mjs, charge/, legal/ et son .env ; la suite de conformité publiée juge la greffe.",
   "keywords": [
     "mostajs",
@@ -52,7 +52,7 @@
     "@mostajs/orm": "^2.12.1",
     "@mostajs/payment": "^2.7.0",
     "@mostajs/subscriptions-plan": "^0.9.0",
-    "@mostajs/wagon-ui": "^0.11.0",
+    "@mostajs/wagon-ui": "^0.11.1",
     "better-sqlite3": "^12.11.1",
     "stripe": "^17.7.0"
   },

package/src/conformite/conformite.test.mjs

@@ -590,6 +590,11 @@ const PRIX_DZD = PAYANT && (PAYANT.prepaid ?? {}).DZD?.month;
   const compte = (await req(base, '/compte', { cookie: c })).texte;
   expect(compte.includes(PAYANT.name)).toBe(true);
   expect(/payé jusqu’au/.test(compte)).toBe(true);
+  // 0.6.1 — le palier dit ce qui a été payé, dans la monnaie de la banque ; pas le prix Stripe en euros (défaut du 28/10/2026)
+  const [, devise, prixPrepaye] = OFFRE;
+  const sansEspace = (x) => x.replace(/[\s\u00a0\u202f]/g, '');
+  expect(sansEspace(compte).includes(sansEspace(String(Number(prixPrepaye.month) / 100)))).toBe(true);
+  expect([compte.includes(devise) || compte.includes('DA') || compte.includes('€'), Number(PAYANT.price) > 0 && devise !== 'EUR' ? compte.includes('€') : false]).toEqual([true, false]);
   expect((await webhook('ok')).status).toBe(200);                                         // rejeu sans effet
   expect((await req(base, '/api/paiement/webhook/inconnue', { method: 'POST', json: '{}', headers: { 'content-type': 'application/json' } })).status).toBe(404);
   await C.fermer();

package/src/wagon.mjs

@@ -25,7 +25,8 @@ 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 { venteAutorisee, vendeursFromEnv } from '@mostajs/payment/server';
+import * as paymentServer from '@mostajs/payment/server';
+const { venteAutorisee, vendeursFromEnv } = paymentServer;
 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';
@@ -118,7 +119,9 @@ const DOMAINES_BANQUES = {
   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 });
+// 0.6.1 — le dinar sans décimales, comme on l'écrit en Algérie (et comme wagon-ui ≥ 0.10.1) : « 8 000 DZD ».
+const montant = (mineures, devise, lang) => formatNumber(resolveFormatLocale(lang), Number(mineures) / 100,
+  { style: 'currency', currency: devise, ...(devise === 'DZD' ? { maximumFractionDigits: 0, minimumFractionDigits: 0 } : {}) });
 
 /** 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}).' };
@@ -257,6 +260,53 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     return faits;
   }
   if (prepaye && Object.keys(banques).some((b) => SANS_WEBHOOK.includes(b))) setInterval(reprendrePaiements, 10 * 60 * 1000).unref?.();
+
+  /**
+   * 0.7 — le PAIEMENT PONCTUEL de la charge (une place de cours, un achat à l'unité), par les banques prépayées
+   * actives (celles qui ont un vendeur) : `ctx.paiement.ouvrir(…)` ouvre la session chez la banque ; la banque confirme
+   * à /api/paiement/charge/<moyen> (webhook) ou y renvoie l'acheteur (/api/paiement/charge-retour/<moyen>, SATIM). Le
+   * paiement se constate par @mostajs/payment (signature vérifiée, ou banque réinterrogée : rien de l'URL n'est cru),
+   * puis le wagon appelle `charge.paiementRegle({ reference, statut, commande, montant, devise, moyen, metadata })`.
+   * Le wagon ne garde que la ligne Payment ; ce que le paiement règle (une réservation…) est l'affaire de la charge,
+   * qui doit être idempotente (une banque rejoue ses webhooks).
+   */
+  const portPaiement = async () => paiement?.port?.createPaymentCheckout ? paiement.port : paymentServer;
+  const CHEMIN_LOCAL = /^\/(?!\/)[^\s]*$/;
+  const paiementCharge = Object.keys(banques).length ? Object.freeze({
+    moyens: Object.entries(banques).map(([moyen, devise]) => ({ moyen, devise: String(devise).toUpperCase() })),
+    /** `montant` en unités MINEURES ; `merci` et `annule` : des chemins de la greffe. Rend { ok, url, commande } ou { ok: false, raison }. */
+    async ouvrir({ moyen, montant, description = '', reference, metadata = {}, merci = '/', annule = '/' }) {
+      const devise = banques[moyen];
+      if (!devise) return { ok: false, raison: `moyen non proposé : ${moyen}` };
+      const m = Math.round(Number(montant));
+      if (!(m > 0)) return { ok: false, raison: 'montant invalide' };
+      if (!reference || !CHEMIN_LOCAL.test(merci) || !CHEMIN_LOCAL.test(annule)) return { ok: false, raison: 'référence ou chemins de retour invalides' };
+      const commande = `ch_${String(reference).replace(/[^\w-]/g, '').slice(0, 40)}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      try {
+        const r = await (await portPaiement()).createPaymentCheckout({
+          dialect: d, providerName: moyen, orderId: commande, amount: m / 100, currency: String(devise).toUpperCase(), description,
+          successUrl: `${origine}${merci}`, cancelUrl: `${origine}${annule}`,
+          webhookUrl: `${origine}/api/paiement/charge/${moyen}`, returnUrl: `${origine}/api/paiement/charge-retour/${moyen}`,
+          metadata: { ...metadata, wagon_charge: String(reference), wagon_merci: merci, wagon_annule: annule },
+        });
+        if (!r?.checkout?.url) return { ok: false, raison: 'la banque n’a pas rendu d’adresse de paiement' };
+        return { ok: true, url: r.checkout.url, commande };
+      } catch (e) { return { ok: false, raison: String(e?.message ?? e) }; }
+    },
+  }) : null;
+  /** Constate un paiement de la charge et le lui remet : { status, paye, meta }. */
+  async function reglerCharge(moyen, corpsBrut, headers) {
+    if (!banques[moyen]) return { status: 404, paye: false, meta: {} };
+    const r = await (await portPaiement()).settlePaymentFromWebhook({ dialect: d, providerName: moyen, body: corpsBrut, headers });
+    if (!r?.ok) return { status: 400, paye: false, meta: {} };
+    const pay = r.payment;
+    const meta = typeof pay?.metadata === 'string' ? JSON.parse(pay.metadata || '{}') : (pay?.metadata ?? {});
+    if (!pay || !r.status || !meta.wagon_charge) return { status: 200, paye: false, meta };
+    try {
+      await charge.paiementRegle?.({ reference: meta.wagon_charge, statut: r.status, commande: String(r.orderId ?? pay.orderId), montant: Math.round(Number(pay.amount) * 100), devise: pay.currency, moyen, metadata: meta });
+    } catch (e) { journal.warn(`wagon : paiementRegle de la charge : ${e?.message ?? e}`); return { status: 500, paye: false, meta }; }
+    return { status: 200, paye: r.status === 'paid', meta };
+  }
   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) => {
@@ -380,7 +430,36 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     return servis.get(lang);
   };
 
-  async function vueEspace(compte) {
+  /**
+   * 0.6.1 — ce qui a été PAYÉ pour une période prépayée (Chargily, SATIM…) : le montant et la monnaie de la commande, et sa
+   * durée. /compte montrait le prix Stripe en euros par mois à une école qui avait payé 8 000 DZD (28/10/2026).
+   */
+  async function tarifPrepaye(sub, plan, lang) {
+    if (!sub?.provider || sub.stripeSubId || sub.provider === 'stripe') return null;
+    const T = TEXTES_PAIEMENT[lang] ?? TEXTES_PAIEMENT.fr;
+    const dire = (centimes, devise, periode) => `${montant(centimes, String(devise).toUpperCase(), lang)}${T[periode] ? ` — ${T[periode]}` : ''}`;
+    // La commande payée (@mostajs/payment la garde) ; sinon, le prix prépayé du palier dans la monnaie de la banque.
+    const p = sub.prepaidOrderId ? await d.findOne(S.Payment, { orderId: String(sub.prepaidOrderId) }).catch(() => null) : null;
+    if (p && Number(p.amount) > 0) {
+      const meta = typeof p.metadata === 'string' ? JSON.parse(p.metadata || '{}') : (p.metadata ?? {});
+      return dire(Math.round(Number(p.amount) * 100), p.currency, meta.wagon_periode);
+    }
+    const devise = banques[sub.provider];
+    const pp = typeof plan?.prepaid === 'string' ? JSON.parse(plan.prepaid || 'null') : plan?.prepaid;
+    const jours = (new Date(sub.currentPeriodEnd).getTime() - new Date(sub.currentPeriodStart).getTime()) / 86400000;
+    const periode = jours >= 300 ? 'year' : 'month';
+    const centimes = Number(pp?.[devise]?.[periode]);
+    return devise && centimes > 0 ? dire(centimes, devise, periode) : null;
+  }
+  /** 0.6.1 — les paiements prépayés réglés du compte, parmi les factures (montant en unités mineures, comme Stripe). */
+  async function paiementsPrepayes(compte) {
+    return (await d.find(S.Payment, { status: 'paid' }).catch(() => [])).filter((p) => {
+      const meta = typeof p.metadata === 'string' ? JSON.parse(p.metadata || '{}') : (p.metadata ?? {});
+      return String(meta[META.account] ?? '') === String(compte.id);
+    }).map((p) => ({ createdAt: p.createdAt, amount: Math.round(Number(p.amount) * 100), currency: p.currency, status: 'paid', hostedUrl: null }));
+  }
+
+  async function vueEspace(compte, lang = 'fr') {
     const actif = await facturation.activePlan(String(compte.id));
     const quotas = {};
     for (const r of periodiques) {
@@ -388,8 +467,10 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
       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 ?? {} };
+    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 })),
+      ...(await paiementsPrepayes(compte))].sort((a, b) => String(b.createdAt ?? '').localeCompare(String(a.createdAt ?? '')));
+    const tarif = await tarifPrepaye(actif?.subscription, actif?.plan, lang);
+    return { plan: actif?.plan ?? null, ...(tarif ? { tarif } : {}), quotas, cles, factures, portailPossible: !!(stripe && compte.stripeCustomerId), limites: actif?.limits ?? {} };
   }
 
   /**
@@ -523,6 +604,19 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
       return rediriger(r.paid ? '/paiement/merci' : '/tarifs');
     }
 
+    // 0.7 — les paiements ponctuels de la charge : webhook (signature) et retour de l'acheteur (banque réinterrogée).
+    if (chemin.startsWith('/api/paiement/charge/') && methode === 'POST') {
+      if (!paiementCharge) return json(503, { ok: false, error: 'paiement non configuré' });
+      const r = await reglerCharge(decodeURIComponent(chemin.slice('/api/paiement/charge/'.length)), (await corps()).toString('utf8'), req.headers);
+      return json(r.status, { ok: r.status === 200 });
+    }
+    if (chemin.startsWith('/api/paiement/charge-retour/') && (methode === 'GET' || methode === 'POST')) {
+      if (!paiementCharge) return rediriger('/');
+      const r = await reglerCharge(decodeURIComponent(chemin.slice('/api/paiement/charge-retour/'.length)), methode === 'GET' ? url.searchParams.toString() : (await corps()).toString('utf8'), req.headers);
+      const vers = r.paye ? r.meta.wagon_merci : r.meta.wagon_annule;
+      return rediriger(typeof vers === 'string' && CHEMIN_LOCAL.test(vers) ? vers : '/');
+    }
+
     // 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/')) {
@@ -598,7 +692,8 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
       if (!transport) return false;
       try { await transport.envoyer(m); return true; } catch (e) { journal.warn(`wagon : courriel de la charge non parti : ${e?.message ?? e}`); return false; }
     };
-    const ctx = { chemin, methode, lang, t, ui, page, envoyer, json, rediriger, formulaire, corpsJson, compte, consommer, refuser, palier, plafond, courriel, admin: estAdmin && !compteCle };
+    const ctx = { chemin, methode, lang, t, ui, page, envoyer, json, rediriger, formulaire, corpsJson, compte, consommer, refuser, palier, plafond, courriel, admin: estAdmin && !compteCle,
+      paiement: paiementCharge };   // 0.7 — null sans banque prépayée active
     if (charge.routes && (await charge.routes(req, res, ctx))) return true;
     if (chemin.startsWith('/api/')) return json(404, { ok: false, error: 'introuvable' });
 
@@ -754,7 +849,7 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
         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 }));
+        return envoyer(200, page({ actif: '/compte', titre: t('espace.compte'), contenu: ui.espace({ lang, vue: await vueEspace(c, lang) }) + 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') {
@@ -773,7 +868,7 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
       // 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 vue = await vueEspace(c, lang);
         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 },
@@ -813,8 +908,8 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
         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 }) })); }
+          return envoyer(200, page({ actif: '/compte', titre: t('espace.compte'), contenu: ui.espace({ lang, vue: await vueEspace(c, lang), cleNeuve: k.full }) }));
+        } catch (e) { return envoyer(200, page({ actif: '/compte', titre: t('espace.compte'), contenu: ui.espace({ lang, vue: await vueEspace(c, lang), erreur: e.code === 'PLAFOND_CLES' ? t('espace.plafondAtteint', { n: (await vueEspace(c, lang)).limites.maxCles }) : e.message }) })); }
       }
       if (chemin === '/compte/cles/revoquer' && methode === 'POST') {
         await comptes.cles.revoquer(String(c.id), String((await formulaire()).prefix ?? ''));