@mostajs/wagon-engine 0.6.1 → 0.8.0

package/CHANGELOG.md

@@ -3,6 +3,41 @@
 **Auteur** : Dr Hamid MADANI <drmdh@msn.com>
 Format : Keep a Changelog ; versions : SemVer.
 
+## [0.8.0] — 2026-10-29
+
+### Ajouté — les membres d'un compte (demandé par CaisseTrax : écart E-08 de SPEC-ECRANS-CAISSETRAX)
+- `ctx.utilisateur` (la personne de la session, sans empreinte) et `ctx.role` (son rôle dans le compte) ; `null`
+  sans session et pour une clé d'API.
+- `ctx.membres` (session seulement) : `lister()` (courriel, nom, rôle, statut `actif` | `invite` | `suspendu`),
+  `inviter({ courriel, nom, role })` → membre du MÊME compte + lien d'activation (`config.invitationJours`, défaut 7),
+  `reinviter(id)`, `changerRole(id, role)`, `retirer(id)`. Le lien part par courriel s'il y a un transport et est
+  TOUJOURS rendu à la charge (un commerce n'a pas toujours de courriel). La charge décide qui peut s'en servir.
+- `charge.vues.connexion({ lang, action, erreur, oubli })` et `charge.vues.reinitialiser({ lang, jeton, utilisateur, erreur,
+  expire, minimum })` : la greffe rend ces deux pages ENTIÈRES (l'écran de SA maquette), erreurs comprises ; le porteur
+  d'un jeton d'invitation est lu sans le consommer (« Bienvenue …, vous êtes invité comme … »).
+- `config.apresConnexion` : la page d'arrivée après connexion ou activation (défaut `/compte`).
+
+### Corrigé
+- Les jetons de réinitialisation vivaient en mémoire : un redémarrage perdait les liens en cours. Ils sont rangés en
+  base (table `wagon_jetons`, empreinte seule).
+- `/connexion/reinitialiser` est servie dès que la connexion est par mot de passe, même sans courriel : le lien d'une
+  invitation remis de la main à la main doit fonctionner. La DEMANDE (`/connexion/oubli`) exige toujours un courriel.
+
+Essais T-WAG-30 à 35 (test-scripts/unit/membres.test.mjs) ; 52/52 ; sabotage vérifié (jetons remis en mémoire →
+T-WAG-32 tombe).
+
+## [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é

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

@@ -4,7 +4,7 @@
 > PayPal), espace client, administration, pages légales, robots/sitemap, sauvegarde, fr/en/ar. Une GREFFE n'apporte que
 > wagon.config.mjs, charge/, legal/ et son .env. N2 (pack). Extrait du gabarit mosta-wagon 0.11.0 le 26/10/2026.
 
-- Version: 0.6.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
+- Version: 0.8.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
 - Chemin: mostajs/mosta-platform-stack/mosta-wagon-engine · gabarit d'une greffe : Entreprise/mosta-wagon
 
 ## ⚙️ D'EMBLÉE : LE .env ET LA CASCADE @mostajs/config
@@ -45,10 +45,12 @@ 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.8 : ctx.utilisateur, ctx.role ; ctx.membres = { lister(), inviter({ courriel, nom, role }) → { utilisateurId, courriel, role, lien, expiresAt, courrielParti }, reinviter(id), changerRole(id, role), retirer(id) } (session seulement ; la charge garde l'accès) ; config.apresConnexion, config.invitationJours ; jetons en base (wagon_jetons) ; /connexion/reinitialiser servie sans courriel ; charge.vues.connexion(…) / charge.vues.reinitialiser({ jeton, utilisateur, erreur, expire }) → page entière.
+  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.1",
+  "version": "0.8.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",

package/src/wagon.mjs

@@ -19,13 +19,15 @@
  * faux ; l'administration est invisible (404) à qui n'est pas administrateur.
  */
 import { readFileSync, existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 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 { 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';
@@ -142,12 +144,21 @@ const AdminSchema = {
   fields: { courriel: { type: 'string', required: true }, confirmeLe: { type: 'date' }, par: { type: 'string' } },
   relations: {}, indexes: [{ fields: { courriel: 'asc' }, unique: true }],
 };
+/**
+ * 0.8 — les JETONS à usage unique (réinitialisation, invitation), RANGÉS EN BASE : jusqu'à la 0.7 ils vivaient en
+ * mémoire, et un redémarrage perdait le lien qu'un invité n'avait pas encore ouvert. Seule l'empreinte est rangée.
+ */
+const JetonSchema = {
+  name: 'WagonJeton', collection: 'wagon_jetons', timestamps: false,
+  fields: { cle: { type: 'string', required: true }, user: { type: 'string', required: true }, expiresAt: { type: 'number', required: true } },
+  relations: {}, indexes: [{ fields: { cle: '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)));
+  return [...schemasComptes(), ...billingSchemas(), PaymentSchema, SessionSchema, CredentialSchema, AdminSchema, JetonSchema].filter((s) => (vus.has(s.name) ? false : vus.add(s.name)));
 };
 
 const lireCorps = (req, max = 1_000_000) => new Promise((ok, ko) => {
@@ -217,13 +228,21 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
   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 identifiants = {
+    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 }); },
+  };
+  const trouverUtilisateur = async (l) => { const u = await d.findOne(S.User, { email: l }); return u ? { id: String(u.id) } : null; };
+  // 0.8 — les jetons en base (voir JetonSchema), partagés par la réinitialisation et l'invitation.
+  const jetons = {
+    get: async (cle) => { const r = await d.findOne(S.WagonJeton, { cle }); return r ? { userId: String(r.user), expiresAt: Number(r.expiresAt) } : null; },
+    put: async (cle, e) => { await d.create(S.WagonJeton, { cle, user: String(e.userId), expiresAt: Number(e.expiresAt) }); },
+    delete: async (cle) => { for (const r of await d.find(S.WagonJeton, { cle })) await d.delete(S.WagonJeton, String(r.id)); },
+  };
+  const motsDePasse = createPasswordAuth({ credentials: identifiants, findUser: trouverUtilisateur, resetTokens: jetons });
+  // L'invitation : même magasin, durée plus longue (un invité n'ouvre pas son courriel dans la demi-heure).
+  const invitations = createPasswordAuth({ credentials: identifiants, findUser: trouverUtilisateur, resetTokens: jetons, limiter: false,
+    resetTtlMs: (config.invitationJours ?? 7) * 86400000 });
   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,
@@ -259,6 +278,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) => {
@@ -446,6 +512,53 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     });
   }
 
+  /**
+   * 0.8 — les MEMBRES du compte d'une session : la charge décide QUI peut s'en servir (le wagon ne connaît pas ses
+   * rôles). Inviter crée un membre du MÊME compte, au mot de passe impossible, et rend un lien d'activation (sept
+   * jours, `config.invitationJours`) : envoyé par courriel s'il y a un transport, toujours rendu à la charge, pour
+   * qu'elle le montre (un commerce n'a pas toujours de courriel).
+   */
+  const membresDe = (compteSession) => {
+    const cid = String(compteSession.id);
+    const lienDe = (token) => `${origine}/connexion/reinitialiser?t=${encodeURIComponent(token)}`;
+    const envoyerInvitation = async (courriel, nom, lien) => {
+      if (!transport) return false;
+      try {
+        await transport.envoyer({ to: courriel, subject: `${config.marque.nom} — invitation`,
+          text: [config.marque.nom, '', `${nom ? `${nom}, v` : 'V'}ous êtes invité(e). Choisissez votre mot de passe :`, lien, '', `Ce lien vaut ${config.invitationJours ?? 7} jours.`, ''].join('\n') });
+        return true;
+      } catch (e) { journal.warn(`wagon : invitation non partie : ${e?.message ?? e}`); return false; }
+    };
+    return {
+      async lister() {
+        const out = [];
+        for (const m of await comptes.membres.lister(cid)) {
+          const u = await d.findById(S.User, m.utilisateurId).catch(() => null);
+          out.push({ ...m, nom: u?.firstName ?? null, statut: u?.status !== 'active' ? 'suspendu' : (await motsDePasse.hasPassword(m.utilisateurId)) ? 'actif' : 'invite' });
+        }
+        return out;
+      },
+      async inviter({ courriel, nom = null, role = 'membre' } = {}) {
+        const r = await comptes.membres.ajouter(cid, courriel, String(role || 'membre'));
+        const n = String(nom ?? '').trim();
+        if (n) await d.update(S.User, r.utilisateurId, { firstName: n });
+        const { token, expiresAt } = await invitations.issueToken(r.utilisateurId);
+        const lien = lienDe(token);
+        return { ...r, nom: n || null, lien, expiresAt: new Date(expiresAt).toISOString(), courrielParti: await envoyerInvitation(r.courriel, n, lien) };
+      },
+      async reinviter(utilisateurId) {
+        const m = (await comptes.membres.lister(cid)).find((x) => x.utilisateurId === String(utilisateurId));
+        if (!m) throw Object.assign(new Error('Cet utilisateur n’est pas membre de ce compte.'), { code: 'NON_MEMBRE' });
+        const u = await d.findById(S.User, m.utilisateurId).catch(() => null);
+        const { token, expiresAt } = await invitations.issueToken(m.utilisateurId);
+        const lien = lienDe(token);
+        return { ...m, lien, expiresAt: new Date(expiresAt).toISOString(), courrielParti: await envoyerInvitation(m.courriel, u?.firstName, lien) };
+      },
+      changerRole: (utilisateurId, role) => comptes.membres.changerRole(cid, String(utilisateurId), String(role)),
+      retirer: (utilisateurId) => comptes.membres.retirer(cid, String(utilisateurId)),
+    };
+  };
+
   async function handler(req, res) {
     const url = new URL(req.url, 'http://wagon.local');
     const chemin = url.pathname;
@@ -556,6 +669,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/')) {
@@ -631,7 +757,11 @@ 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
+      // 0.8 — la PERSONNE de la session (sans empreinte) et son rôle dans le compte ; les membres du compte.
+      utilisateur: compteCle ? null : (qui?.utilisateur ?? null), role: compteCle ? null : (qui?.role ?? null),
+      membres: qui && !compteCle ? membresDe(qui.compte) : null };
     if (charge.routes && (await charge.routes(req, res, ctx))) return true;
     if (chemin.startsWith('/api/')) return json(404, { ok: false, error: 'introuvable' });
 
@@ -667,6 +797,10 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     // 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;
+    // 0.8 — la page qui consomme un jeton est servie dès que l'on se connecte par mot de passe : le lien d'une
+    // INVITATION remis de la main à la main (sans courriel) doit fonctionner. Seule la DEMANDE (/connexion/oubli)
+    // exige un courriel possible.
+    const reinitPossible = methodeConnexion === 'motdepasse';
     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'));
@@ -713,11 +847,18 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     if (chemin === '/connexion') {
       const suite = suiteSure(url.searchParams.get('suite'));
       const action = avecSuite('/connexion', suite);
-      if (methode === 'GET') return envoyer(200, page({ titre: t('espace.seConnecter'), contenu: ui.connexion({ lang, methode: methodeConnexion, action }) + (oubliPossible ? `<p class="hint"><a href="/connexion/oubli">${esc(TC.oublie)}</a></p>` : '') }));
+      // 0.8 — `charge.vues.connexion({ lang, action, erreur, oubli })` rend la page ENTIÈRE à la place de wagon-ui
+      // (champs « courriel » et « motdepasse », POST vers `action`) : l'écran de la maquette de la greffe.
+      const vueConnexion = methodeConnexion === 'motdepasse' && typeof charge.vues?.connexion === 'function' ? charge.vues.connexion : null;
+      if (methode === 'GET') {
+        if (vueConnexion) return envoyer(200, await vueConnexion({ lang, action, erreur: null, oubli: oubliPossible ? '/connexion/oubli' : null }));
+        return envoyer(200, page({ titre: t('espace.seConnecter'), contenu: ui.connexion({ lang, methode: methodeConnexion, action }) + (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, suite ?? '/compte');
+        if (r.ok) return ouvrirSession(r.userId, suite ?? config.apresConnexion ?? '/compte');
+        if (vueConnexion) return envoyer(r.reason === 'throttled' ? 429 : 200, await vueConnexion({ lang, action, erreur: t('espace.identifiantsFaux'), oubli: oubliPossible ? '/connexion/oubli' : null }));
         return envoyer(r.reason === 'throttled' ? 429 : 200, page({ titre: t('espace.seConnecter'), contenu: ui.connexion({ lang, erreur: t('espace.identifiantsFaux'), action }) }));
       }
       const courriel = String(f.courriel ?? '').trim().toLowerCase();
@@ -764,15 +905,36 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
       }
       return true;
     }
-    if (oubliPossible && chemin === '/connexion/reinitialiser') {
+    if (reinitPossible && 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') ?? '') }));
+      // 0.8 — `charge.vues.reinitialiser({ lang, jeton, utilisateur, erreur, expire })` rend la page ENTIÈRE (champs
+      // « t », « nouveau », « confirmer ») : une invitation s'y présente (« Bienvenue …, vous êtes invité comme … »).
+      // `utilisateur` (id, courriel, prenom) est lu sur le jeton SANS le consommer ; null si le lien ne vaut plus.
+      const vueReinit = typeof charge.vues?.reinitialiser === 'function' ? charge.vues.reinitialiser : null;
+      const porteurDe = async (tk) => {
+        const e = tk ? await jetons.get(createHash('sha256').update(String(tk)).digest('base64url')) : null;
+        if (!e || e.expiresAt < Date.now()) return null;
+        const u = await d.findById(S.User, e.userId).catch(() => null);
+        return u ? { id: String(u.id), courriel: u.email, prenom: u.firstName ?? null } : null;
+      };
+      const vueR = async (code, tk, erreur) => {
+        const u = await porteurDe(tk);
+        return envoyer(code, await vueReinit({ lang, jeton: tk, utilisateur: u, erreur, expire: !u, minimum: motsDePasse.policy.minLength }));
+      };
+      if (methode === 'GET') {
+        if (vueReinit) return vueR(200, url.searchParams.get('t') ?? '', null);
+        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) }));
+      if (String(f.nouveau ?? '') !== String(f.confirmer ?? '')) {
+        if (vueReinit) return vueR(400, String(f.t ?? ''), TC.differents);
+        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 && vueReinit) return vueR(400, String(f.t ?? ''), r.reason === 'policy' ? t('espace.faible', { motifs: (r.issues ?? []).join(', ') }) : TC.lienMort);
       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);
+      return ouvrirSession(r.userId, config.apresConnexion ?? '/compte');
     }
 
     // L'espace du client.