@mostajs/landing 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog — @mostajs/landing
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com>
+
+## [0.1.0] — 2026-10-31
+### Ajouté
+- Modèle en sept blocs et sa validation ; sept langues, arabe de droite à gauche ; public « adultes » ou « écoles ».
+- Rendu HTML sans script, < 50 Ko, première image immédiate puis différées, pied légal de la marque toujours rendu ;
+  UTM et identifiants de clic recopiés dans le bouton ; aperçu en fragment ; `decrirePage` pour @mostajs/ad-platforms.
+- Signature HMAC-SHA256 horodatée, envoi (`envoyer`), récepteur (`creerRecepteur`) et dépôts en mémoire ou en fichiers.

package/LICENSE

@@ -0,0 +1,21 @@
+@mostajs/landing
+Copyright (C) 2026 Dr Hamid MADANI <drmdh@msn.com>
+
+SPDX-License-Identifier: AGPL-3.0-or-later
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+The complete text of the GNU Affero General Public License version 3 is
+available at the URL above and must accompany any distribution of this
+software.

package/README.md

@@ -1,3 +1,65 @@
-# Temporary Holding Version
+# @mostajs/landing
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Licence** : AGPL-3.0-or-later
+
+Les landing pages de pub, de l'éditeur au produit qui les sert :
+
+- un **modèle en sept blocs** (accroche, image, bénéfices, étapes, questions, bouton, mentions), validé sans dépendance ;
+- un **rendu HTML sans aucun script**, sous 50 Ko hors images, lisible de 320 à 1 280 px, en sept langues (l'arabe de droite à gauche), avec un **pied légal toujours présent** ;
+- un **envoi signé** (HMAC-SHA256, horodaté) ;
+- un **récepteur** à monter dans le produit, pour que la page soit servie **sur le domaine du produit**. C'est ce qu'exigent les régies : Google refuse une annonce dont la page est sur un autre domaine (*Destination mismatch*).
+
+Zéro dépendance. Node ≥ 18 (le récepteur et la signature emploient `node:crypto`).
+
+## Installer
+
+```bash
+npm i @mostajs/landing
+```
+
+## Côté éditeur : valider, rendre, publier
+
+```js
+import { validerPage, rendre, decrirePage, envoyer } from '@mostajs/landing';
+
+const page = {
+  slug: 'anglais-au-travail', langue: 'fr', public: 'adultes',
+  blocs: [
+    { type: 'accroche', titre: 'Parle anglais avec assurance au travail' },
+    { type: 'bouton', libelle: 'Commencer', href: '/inscription?plan=essai' },
+  ],
+};
+validerPage(page);                       // { ok: true, erreurs: [] }
+const html = rendre(page, marque);       // page complète, sans script
+const apercu = rendre(page, marque, { fragment: true });   // pour l'aperçu d'un éditeur
+// Ce que lit verifierPage de @mostajs/ad-platforms :
+const description = decrirePage(page, marque, { adresse: 'https://speaking.mostajs.dev/p/anglais-au-travail', domaineProduit: 'speaking.mostajs.dev' });
+await envoyer({ origine: 'https://speaking.mostajs.dev', cle: CLE_DU_PRODUIT, page });   // { ok, status, corps }
+```
+
+## Côté produit : le récepteur
+
+```js
+import { creerRecepteur, depotFichiers } from '@mostajs/landing';
+
+const recepteur = creerRecepteur({
+  cle: () => getEnv('LANDING_CLE'),          // relue à chaque envoi : renouvelable sans redémarrer
+  depot: depotFichiers('data/landing'),      // hors du code : survit au déploiement
+  marque: { nom: 'Speaking', logo: '/static/logo.png', pied: { confidentialite: '/confidentialite', mentions: '/mentions-legales', editeur: '…' } },
+  origine: 'https://speaking.mostajs.dev',
+});
+// dans le routeur : if (await recepteur(req, res)) return;
+```
+
+| Adresse | Effet |
+|---|---|
+| `POST /p/_publier` | corps `{ page }` signé → 201 `{ slug, version, adresse }` ; 401 si la signature est fausse, absente, périmée ou le corps altéré ; 422 si la page est invalide |
+| `POST /p/_retirer` | corps `{ slug }` signé → la page n'est plus servie (ses versions restent) |
+| `GET /p/_marque` | la marque publique du produit (nom, logo, couleurs, pied légal) : l'éditeur y voit que le récepteur est installé |
+| `GET /p/<slug>` | la dernière version, rendue avec la **marque du produit** ; `Cache-Control: public, max-age=60` ; 404 sinon |
+
+Le bouton de la page recopie dans son lien les UTM et identifiants de clic (`fbclid`, `gclid`, `gbraid`, `wbraid`, `ttclid`, `ScCid`) de l'adresse reçue : la source arrive jusqu'à l'inscription sans cookie ni script.
+
+## Ce que le module ne fait pas
+
+Il ne vérifie pas les règles des régies (c'est `@mostajs/ad-platforms`, qui lit `decrirePage`), ne raccourcit pas les liens (`@mostajs/short-link`), et n'héberge pas les images : une image est un chemin du site du produit ou une adresse https.

package/llms.txt

@@ -0,0 +1,28 @@
+# @mostajs/landing — fiche LLM
+> Landing pages de pub : modèle en 7 blocs, rendu HTML sans script (< 50 Ko, pied légal, 7 langues, arabe rtl), envoi signé HMAC, récepteur monté dans le produit (page servie sur SON domaine). Zéro dépendance.
+
+- Version : 0.1.0 · Licence : AGPL-3.0-or-later · Auteur : Dr Hamid MADANI <drmdh@msn.com>
+- Chemin : mostajs/mosta-ads-stack/mosta-landing · ESM · Node ≥ 18 (node:crypto, node:fs)
+- Niveau §5.bis : N1 · technique · multi-domaine · depend_de []
+- Consommateurs : LinksFly (Entreprise/ads, éditeur et publication), Speaking (récepteur /p/)
+
+## EXPORTS
+- Modèle : `BLOCS`, `LANGUES` (fr ar en de es it zh), `RTL` (['ar']), `PUBLICS` (adultes, ecoles), `SLUG` (regex), `sensDe(l)`, `adresseValide(v)` (« /… » sauf « //… », ou https), `validerPage(page)` → { ok, erreurs[{chemin,message}] }, `titreDe(page)`
+- Rendu : `rendre(page, marque, { requete?, fragment?, canonique?, sansImages? })` → HTML ; `decrirePage(page, marque, { adresse, domaineProduit, langueCampagne?, accrocheAnnonce?, html? })` → description lue par `verifierPage` d'ad-platforms ; `lienAvecSource(href, requete)` ; `A_CONSERVER` ; `esc`
+- Textes : `TEXTES`, `textesDe(l)` (titres par défaut, pied légal)
+- Signature : `signer(corps, cle)` → 't=<s>,v1=<hex>' ; `verifierSignature(brut, entete, cle, { tolerance=300 })` → { ok } | { ok:false, motif: absente|illisible|perimee|fausse } ; `ENTETE_SIGNATURE` = 'x-landing-signature'
+- Récepteur : `creerRecepteur({ cle: string|fn, depot, marque: obj|fn, prefixe='/p/', maxOctets=256Ko, origine, journal })` → async (req, res, chemin?) → bool ; sert POST _publier, POST _retirer, GET _marque (marque publique), GET <slug>
+- Dépôts : `depotMemoire({ garder=20 })`, `depotFichiers(dossier, { garder=20 })` — { enregistrer(page) → {slug,version}, derniere(slug), versions(slug), retirer(slug) }
+- Envoi : `envoyer({ origine, cle, page? | retirer?, prefixe, fetch?, delai=10000 })` → { ok, status, corps }
+
+## PAGE
+{ slug, langue, public?, blocs: [ accroche{titre,sousTitre?} (exactement 1) | image{src,alt,legende?} | benefices{elements 1-3 {titre,texte?}} | etapes{titre?,elements 1-5 {titre}} | questions{titre?,elements 1-8 {q,r}} | bouton{libelle,href} | mentions{texte} ], faits?: string[] }
+
+## PIÈGES
+- La MARQUE (pied légal, logo, couleurs) est celle du RÉCEPTEUR, jamais celle de l'expéditeur : l'éditeur ne peut pas changer le pied légal d'un produit.
+- La signature porte sur le corps BRUT : ne pas re-sérialiser le JSON avant de vérifier.
+- Pas d'image d'un autre site que le produit en pratique : la politique de sécurité du produit (img-src 'self') la bloquerait ; https est accepté par le modèle, à l'application de restreindre.
+- `public: 'eleves'` est refusé : pas de pub vers les mineurs.
+
+## ESSAIS
+test-scripts/unit/landing.test.mjs — T-LP-11a, 11b, 12a, 12b, 16a, 16b (10 essais) ; sabotages joués : signature ignorée, première image différée, accroche non échappée, « //hôte » accepté.

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "@mostajs/landing",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Landing pages de pub : modèle en sept blocs (accroche, image, bénéfices, étapes, questions, bouton, mentions), rendu HTML sans script sous 50 Ko avec pied légal, sept langues dont l'arabe de droite à gauche, envoi signé HMAC, récepteur monté dans le produit qui sert la page sur son propre domaine. Zéro dépendance.",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "scripts": {
+    "test": "bash test-scripts/run-tests.sh"
+  },
+  "devDependencies": {
+    "@mostajs/mjs-unit": "^0.11.2"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "llms.txt",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "keywords": ["landing-page", "ads", "utm", "hmac", "rtl", "mostajs"],
+  "mostajs": {
+    "niveau": "N1",
+    "nature": "technique",
+    "reutilisabilite": "multi-domaine",
+    "depend_de": []
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/depots.js

@@ -0,0 +1,49 @@
+/**
+ * @mostajs/landing — où le RÉCEPTEUR garde les pages reçues : une interface, deux réalisations sans dépendance.
+ *   enregistrer(page) → { slug, version }   chaque envoi crée une version ; la dernière est servie
+ *   derniere(slug)    → { page, version, recueLe } | null
+ *   versions(slug)    → [{ version, recueLe }]
+ *   retirer(slug)     → boolean              la page n'est plus servie (les versions restent, pour la trace)
+ * Une application peut fournir le sien (base de données) avec la même forme.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+import { mkdirSync, readFileSync, writeFileSync, renameSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { SLUG } from './modele.js'
+
+/** En mémoire (essais). */
+export function depotMemoire({ garder = 20 } = {}) {
+  const fiches = new Map()
+  return {
+    async enregistrer(page) {
+      const f = fiches.get(page.slug) ?? { retire: false, versions: [] }
+      const version = (f.versions.at(-1)?.version ?? 0) + 1
+      f.versions.push({ version, page, recueLe: new Date().toISOString() }); f.versions = f.versions.slice(-garder); f.retire = false
+      fiches.set(page.slug, f)
+      return { slug: page.slug, version }
+    },
+    async derniere(slug) { const f = fiches.get(slug); return f && !f.retire ? f.versions.at(-1) : null },
+    async versions(slug) { return (fiches.get(slug)?.versions ?? []).map(({ version, recueLe }) => ({ version, recueLe })) },
+    async retirer(slug) { const f = fiches.get(slug); if (!f) return false; f.retire = true; return true },
+  }
+}
+
+/** Dans un dossier (un fichier JSON par slug, écrit par renommage atomique) — survit au redéploiement s'il est hors du code. */
+export function depotFichiers(dossier, { garder = 20 } = {}) {
+  mkdirSync(dossier, { recursive: true })
+  const chemin = (slug) => { if (!SLUG.test(slug)) throw new Error('landing : slug invalide'); return join(dossier, `${slug}.json`) }
+  const lire = (slug) => { const p = chemin(slug); return existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : null }
+  const ecrire = (slug, f) => { const p = chemin(slug); writeFileSync(`${p}.tmp`, JSON.stringify(f), { mode: 0o640 }); renameSync(`${p}.tmp`, p) }
+  return {
+    async enregistrer(page) {
+      const f = lire(page.slug) ?? { retire: false, versions: [] }
+      const version = (f.versions.at(-1)?.version ?? 0) + 1
+      f.versions.push({ version, page, recueLe: new Date().toISOString() }); f.versions = f.versions.slice(-garder); f.retire = false
+      ecrire(page.slug, f)
+      return { slug: page.slug, version }
+    },
+    async derniere(slug) { if (!SLUG.test(String(slug))) return null; const f = lire(slug); return f && !f.retire ? f.versions.at(-1) : null },
+    async versions(slug) { if (!SLUG.test(String(slug))) return []; return (lire(slug)?.versions ?? []).map(({ version, recueLe }) => ({ version, recueLe })) },
+    async retirer(slug) { if (!SLUG.test(String(slug))) return false; const f = lire(slug); if (!f) return false; f.retire = true; ecrire(slug, f); return true },
+  }
+}

package/src/index.js

@@ -0,0 +1,11 @@
+/**
+ * @mostajs/landing — landing pages de pub : modèle en sept blocs, rendu sans script, envoi signé, récepteur.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+export { BLOCS, LANGUES, RTL, PUBLICS, SLUG, sensDe, adresseValide, validerPage, titreDe } from './modele.js'
+export { TEXTES, textesDe } from './textes.js'
+export { rendre, decrirePage, lienAvecSource, A_CONSERVER, esc } from './rendre.js'
+export { signer, verifierSignature, ENTETE_SIGNATURE } from './signature.js'
+export { creerRecepteur } from './recepteur.js'
+export { depotMemoire, depotFichiers } from './depots.js'
+export { envoyer } from './publier.js'

package/src/modele.js

@@ -0,0 +1,77 @@
+/**
+ * @mostajs/landing — le MODÈLE d'une landing page : sept blocs, une langue, un slug stable.
+ *
+ *   accroche   { titre, sousTitre? }                       une seule, obligatoire
+ *   image      { src, alt, legende? }                      src : chemin du site (/…) ou https://
+ *   benefices  { elements: [{ titre, texte? }] }  1 à 3
+ *   etapes     { titre?, elements: [{ titre }] }  1 à 5   « Comment ça marche ? »
+ *   questions  { titre?, elements: [{ q, r }] }   1 à 8
+ *   bouton     { libelle, href }                           href : chemin du site (/…) ou https://
+ *   mentions   { texte }                                   texte libre au-dessus du pied légal
+ *
+ * Une page = UNE langue (fr, ar, en, de, es, it, zh) ; l'arabe s'écrit de droite à gauche. Le pied légal n'est PAS
+ * un bloc : il vient de la marque du produit et est toujours rendu (rendre.js). Validation sans dépendance.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+export const BLOCS = Object.freeze(['accroche', 'image', 'benefices', 'etapes', 'questions', 'bouton', 'mentions'])
+export const LANGUES = Object.freeze(['fr', 'ar', 'en', 'de', 'es', 'it', 'zh'])
+export const RTL = Object.freeze(['ar'])
+export const PUBLICS = Object.freeze(['adultes', 'ecoles'])
+export const SLUG = /^[a-z0-9](?:[a-z0-9-]{0,78}[a-z0-9])?$/
+
+/** Le sens d'écriture d'une langue. */
+export const sensDe = (langue) => (RTL.includes(langue) ? 'rtl' : 'ltr')
+
+/** Une adresse acceptée dans une page : un chemin du site (« /… », pas « //… ») ou une adresse https. */
+export function adresseValide(v) {
+  if (typeof v !== 'string' || !v) return false
+  if (v.startsWith('/') && !v.startsWith('//')) return !/[\s<>"]/.test(v)
+  try { return new URL(v).protocol === 'https:' } catch { return false }
+}
+
+const texte = (v, max) => typeof v === 'string' && v.trim().length > 0 && v.length <= max
+const facultatif = (v, max) => v === undefined || v === null || v === '' || (typeof v === 'string' && v.length <= max)
+
+/** Les règles de chaque bloc : (bloc, erreur(champ, message)) → void. */
+const REGLES = {
+  accroche(b, e) { if (!texte(b.titre, 120)) e('titre', 'titre requis (120 signes au plus)'); if (!facultatif(b.sousTitre, 240)) e('sousTitre', '240 signes au plus') },
+  image(b, e) { if (!adresseValide(b.src)) e('src', 'chemin du site (/…) ou adresse https requis'); if (!texte(b.alt, 160)) e('alt', 'texte de remplacement requis (160 signes au plus)'); if (!facultatif(b.legende, 160)) e('legende', '160 signes au plus') },
+  benefices(b, e) { liste(b, e, 1, 3, (x, f) => { if (!texte(x?.titre, 80)) f('titre', 'titre requis (80 signes au plus)'); if (!facultatif(x?.texte, 200)) f('texte', '200 signes au plus') }) },
+  etapes(b, e) { if (!facultatif(b.titre, 80)) e('titre', '80 signes au plus'); liste(b, e, 1, 5, (x, f) => { if (!texte(x?.titre, 80)) f('titre', 'titre requis (80 signes au plus)') }) },
+  questions(b, e) { if (!facultatif(b.titre, 80)) e('titre', '80 signes au plus'); liste(b, e, 1, 8, (x, f) => { if (!texte(x?.q, 160)) f('q', 'question requise (160 signes au plus)'); if (!texte(x?.r, 600)) f('r', 'réponse requise (600 signes au plus)') }) },
+  bouton(b, e) { if (!texte(b.libelle, 40)) e('libelle', 'libellé requis (40 signes au plus)'); if (!adresseValide(b.href)) e('href', 'chemin du site (/…) ou adresse https requis') },
+  mentions(b, e) { if (!texte(b.texte, 1000)) e('texte', 'texte requis (1 000 signes au plus)') },
+}
+function liste(b, e, min, max, regle) {
+  if (!Array.isArray(b.elements) || b.elements.length < min || b.elements.length > max) { e('elements', `${min} à ${max} éléments`); return }
+  b.elements.forEach((x, i) => regle(x, (champ, m) => e(`elements.${i}.${champ}`, m)))
+}
+
+/**
+ * Valide une page. @returns {{ ok: boolean, erreurs: { chemin: string, message: string }[] }}
+ * @param {{ slug: string, langue: string, public?: string, titre?: string, blocs: object[], faits?: string[] }} page
+ */
+export function validerPage(page) {
+  const erreurs = []
+  const err = (chemin, message) => erreurs.push({ chemin, message })
+  if (!page || typeof page !== 'object') return { ok: false, erreurs: [{ chemin: '', message: 'page requise' }] }
+  if (!SLUG.test(String(page.slug ?? ''))) err('slug', 'minuscules, chiffres et tirets (2 à 80 signes)')
+  if (!LANGUES.includes(page.langue)) err('langue', `une de : ${LANGUES.join(', ')}`)
+  if (page.public !== undefined && !PUBLICS.includes(page.public)) err('public', `un de : ${PUBLICS.join(', ')}`)
+  if (!Array.isArray(page.blocs) || !page.blocs.length) { err('blocs', 'au moins un bloc'); return { ok: false, erreurs } }
+  if (page.blocs.length > 20) err('blocs', '20 blocs au plus')
+  page.blocs.forEach((b, i) => {
+    const type = b?.type
+    if (!BLOCS.includes(type)) { err(`blocs.${i}.type`, `bloc inconnu : ${String(type)}`); return }
+    REGLES[type](b, (champ, m) => err(`blocs.${i}.${champ}`, m))
+  })
+  const accroches = page.blocs.filter((b) => b?.type === 'accroche').length
+  if (accroches !== 1) err('blocs', 'une accroche, et une seule')
+  if (page.faits !== undefined && (!Array.isArray(page.faits) || page.faits.some((f) => typeof f !== 'string'))) err('faits', 'liste de textes')
+  return { ok: erreurs.length === 0, erreurs }
+}
+
+/** Le titre d'une page : celui de son accroche. */
+export const titreDe = (page) => page?.blocs?.find((b) => b?.type === 'accroche')?.titre ?? ''
+
+/** Les sept modèles de départ ne sont pas ici : ils appartiennent à l'application (textes de la marque). */

package/src/publier.js

@@ -0,0 +1,18 @@
+/**
+ * @mostajs/landing — l'ENVOI d'une page (ou de son retrait) au récepteur d'un produit, signé avec sa clé.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+import { signer, ENTETE_SIGNATURE } from './signature.js'
+
+/**
+ * @param {{ origine: string, cle: string, page?: object, retirer?: string, prefixe?: string, fetch?: typeof fetch, delai?: number }} o
+ *   origine : https://speaking.mostajs.dev (le produit) ; page : la page à publier ; retirer : le slug à retirer
+ * @returns {Promise<{ ok: boolean, status: number, corps: any }>}
+ */
+export async function envoyer({ origine, cle, page, retirer, prefixe = '/p/', fetch: f = globalThis.fetch, delai = 10000 }) {
+  const corps = JSON.stringify(retirer ? { slug: retirer } : { page })
+  const adresse = `${String(origine).replace(/\/+$/, '')}${prefixe}${retirer ? '_retirer' : '_publier'}`
+  const r = await f(adresse, { method: 'POST', headers: { 'content-type': 'application/json', [ENTETE_SIGNATURE]: signer(corps, cle) }, body: corps, signal: AbortSignal.timeout(delai), redirect: 'manual' })
+  let lu = null; try { lu = await r.json() } catch { /* corps non JSON */ }
+  return { ok: r.status === 201 || r.status === 200, status: r.status, corps: lu }
+}

package/src/recepteur.js

@@ -0,0 +1,68 @@
+/**
+ * @mostajs/landing — le RÉCEPTEUR, monté dans le produit qui sert les pages (ex. Speaking), sur SON domaine :
+ *   POST <prefixe>_publier   corps JSON { page } signé (x-landing-signature) → 201 { slug, version, adresse }
+ *   POST <prefixe>_retirer   corps JSON { slug } signé → 200 ; la page n'est plus servie
+ *   GET  <prefixe>_marque    la marque PUBLIQUE du produit (nom, logo, couleurs, pied légal) : l'éditeur s'en sert pour
+ *                            l'aperçu et la conformité, et y voit que le récepteur est installé
+ *   GET  <prefixe><slug>     la dernière version, rendue avec la MARQUE du produit (pied légal compris) ; 404 sinon
+ * Signature fausse, absente, périmée ou corps altéré → 401, rien n'est gardé. Page invalide → 422. Corps trop gros → 413.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+import { verifierSignature, ENTETE_SIGNATURE } from './signature.js'
+import { validerPage, SLUG } from './modele.js'
+import { rendre, esc } from './rendre.js'
+
+async function lireBrut(req, max) {
+  const morceaux = []; let n = 0
+  for await (const m of req) { n += m.length; if (n > max) return null; morceaux.push(m) }
+  return Buffer.concat(morceaux).toString('utf8')
+}
+const json = (res, code, o) => { res.writeHead(code, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' }); res.end(JSON.stringify(o)); return true }
+
+/**
+ * @param {{ cle: string|(() => string), depot: object, marque: object|(() => object), prefixe?: string, maxOctets?: number,
+ *   origine?: string, journal?: Pick<Console,'warn'> }} o
+ *   cle : la clé de publication du produit (lue à chaque envoi : elle peut être renouvelée sans redémarrer)
+ *   origine : adresse publique du produit (https://speaking.mostajs.dev), pour l'adresse rendue et la canonique
+ * @returns {(req, res, chemin?: string) => Promise<boolean>} true si la requête est servie
+ */
+export function creerRecepteur({ cle, depot, marque, prefixe = '/p/', maxOctets = 256 * 1024, origine = '', journal = console }) {
+  if (!depot) throw new Error('landing : un dépôt est requis')
+  const cleDe = () => (typeof cle === 'function' ? cle() : cle)
+  const marqueDe = () => (typeof marque === 'function' ? marque() : marque) ?? {}
+  return async function recepteur(req, res, chemin) {
+    const url = new URL(req.url, 'http://recepteur.local')
+    const p = chemin ?? url.pathname
+    if (!p.startsWith(prefixe)) return false
+    const suite = p.slice(prefixe.length)
+
+    if (req.method === 'POST' && (suite === '_publier' || suite === '_retirer')) {
+      const brut = await lireBrut(req, maxOctets)
+      if (brut === null) return json(res, 413, { error: 'corps trop gros' })
+      const v = verifierSignature(brut, req.headers[ENTETE_SIGNATURE], cleDe())
+      if (!v.ok) { journal.warn?.(`landing : envoi refusé (${v.motif})`); return json(res, 401, { error: 'signature refusée', motif: v.motif }) }
+      let corps
+      try { corps = JSON.parse(brut) } catch { return json(res, 400, { error: 'JSON illisible' }) }
+      if (suite === '_retirer') return json(res, 200, { retiree: await depot.retirer(String(corps?.slug ?? '')) })
+      const r = validerPage(corps?.page)
+      if (!r.ok) return json(res, 422, { error: 'page invalide', erreurs: r.erreurs })
+      const { slug, version } = await depot.enregistrer(corps.page)
+      return json(res, 201, { slug, version, adresse: `${origine}${prefixe}${slug}` })
+    }
+
+    if (req.method === 'GET' && suite === '_marque') {
+      const m = marqueDe()
+      return json(res, 200, { recepteur: '@mostajs/landing', nom: m.nom ?? '', logo: m.logo ?? '', couleurs: m.couleurs ?? {}, pied: m.pied ?? {}, prefixe })
+    }
+
+    if ((req.method === 'GET' || req.method === 'HEAD') && SLUG.test(suite)) {
+      const d = await depot.derniere(suite)
+      if (!d) { res.writeHead(404, { 'content-type': 'text/html; charset=utf-8' }); res.end(`<!doctype html><meta charset="utf-8"><title>404</title><p>${esc('Page introuvable.')}</p>`); return true }
+      const html = rendre(d.page, marqueDe(), { requete: url.searchParams, canonique: origine ? `${origine}${prefixe}${suite}` : '' })
+      res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'public, max-age=60', 'x-landing-version': String(d.version) })
+      res.end(req.method === 'HEAD' ? undefined : html)
+      return true
+    }
+    return false
+  }
+}

package/src/rendre.js

@@ -0,0 +1,111 @@
+/**
+ * @mostajs/landing — le RENDU d'une page : HTML complet, sans aucun script, sous 50 Ko hors images, lisible de 320 à
+ * 1 280 px. La première image se charge tout de suite, les autres en différé. Le pied légal (confidentialité, mentions,
+ * éditeur) vient de la MARQUE du produit qui sert la page, jamais de l'expéditeur, et il est toujours rendu.
+ *
+ * Le bouton recopie dans son lien les UTM et identifiants de clic de l'adresse reçue : la source arrive jusqu'à
+ * l'inscription sans cookie ni script.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+import { sensDe, titreDe, adresseValide } from './modele.js'
+import { textesDe } from './textes.js'
+
+/** Les paramètres recopiés de l'adresse reçue vers le bouton (UTM, puis identifiants de clic des régies). */
+export const A_CONSERVER = Object.freeze(['utm_source', 'utm_medium', 'utm_campaign', 'utm_content', 'utm_term', 'utm_id', 'fbclid', 'gclid', 'gbraid', 'wbraid', 'ttclid', 'ScCid'])
+
+export const esc = (s) => String(s ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]))
+const couleur = (v, defaut) => (/^#[0-9a-fA-F]{3,8}$/.test(String(v ?? '')) ? v : defaut)
+
+/** Le lien du bouton, augmenté des paramètres à conserver présents dans la requête (sans écraser ceux du lien). */
+export function lienAvecSource(href, requete, conserver = A_CONSERVER) {
+  if (!adresseValide(href)) return '#'
+  const q = requete instanceof URLSearchParams ? requete : new URLSearchParams(String(requete ?? '').replace(/^\?/, ''))
+  const ajouts = conserver.filter((k) => q.has(k)).map((k) => [k, q.get(k)])
+  if (!ajouts.length) return href
+  const [base, ancre = ''] = href.split('#')
+  const [chemin, existant = ''] = base.split('?')
+  const p = new URLSearchParams(existant)
+  for (const [k, v] of ajouts) if (!p.has(k)) p.set(k, v)
+  return `${chemin}?${p.toString()}${ancre ? `#${ancre}` : ''}`
+}
+
+/** La feuille de style (préfixée par `.lp`, pour l'aperçu dans un éditeur comme pour la page). */
+function feuille(c) {
+  return `.lp{--b:${c.brand};--l:${c.lien};--o:${c.ornement};color:#13233f;font:16px/1.55 system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;max-width:40rem;margin:0 auto;padding:1rem 1.1rem 0;box-sizing:border-box;overflow-wrap:anywhere}
+.lp *{box-sizing:border-box}.lp header{display:flex;align-items:center;justify-content:space-between;gap:1rem;margin-bottom:1rem}
+.lp header img{height:2.4rem;width:auto}.lp header b{font-size:1.1rem;color:var(--b)}
+.lp h1{font-size:clamp(1.6rem,6vw,2.3rem);line-height:1.15;margin:.4rem 0;color:var(--b);text-align:center}
+.lp .sous{text-align:center;color:#41506b;margin:.3rem 0 1rem}.lp figure{margin:1rem 0;text-align:center}
+.lp figure img{max-width:100%;height:auto;border-radius:16px}.lp .img-place{border:2px dashed #c7d3e6;border-radius:16px;padding:2.5rem 1rem;color:#5b6b82;background:#f6f9fd}.lp figcaption{color:#5b6b82;font-size:.9rem}
+.lp .bouton{display:block;text-align:center;background:var(--b);color:#fff;text-decoration:none;font-weight:700;border-radius:14px;padding:.95rem 1rem;margin:1.1rem 0;font-size:1.1rem}
+.lp .benef{display:grid;grid-template-columns:repeat(auto-fit,minmax(9rem,1fr));gap:.8rem;margin:1rem 0;padding:0;list-style:none}
+.lp .benef li{background:#f3f7fc;border-radius:14px;padding:.8rem;text-align:center}.lp .benef b{display:block;color:var(--b)}
+.lp h2{font-size:1.25rem;text-align:center;color:var(--b);margin:1.4rem 0 .6rem}
+.lp ol{display:flex;flex-wrap:wrap;justify-content:center;gap:.6rem;padding:0;list-style:none;counter-reset:e}
+.lp ol li{counter-increment:e;flex:1 1 6rem;text-align:center;font-weight:600}.lp ol li::before{content:counter(e);display:block;margin:0 auto .3rem;width:2.2rem;height:2.2rem;line-height:2.2rem;border-radius:50%;background:var(--l);color:#fff}
+.lp details{border-bottom:1px solid #e3e8f2;padding:.6rem 0}.lp summary{font-weight:600;cursor:pointer}
+.lp .mentions{color:#5b6b82;font-size:.9rem;margin-top:1.2rem}
+.lp footer{border-top:1px solid #e3e8f2;margin-top:1.5rem;padding:1rem 0;text-align:center;font-size:.9rem;color:#5b6b82}
+.lp footer a{color:var(--l);margin:0 .5rem}`
+}
+
+/** Le corps d'un bloc. `n` : rang de l'image (la première ne se charge pas en différé). */
+function bloc(b, T, ctx) {
+  switch (b.type) {
+    case 'accroche': return `<h1>${esc(b.titre)}</h1>${b.sousTitre ? `<p class="sous">${esc(b.sousTitre)}</p>` : ''}`
+    case 'image': {
+      const premiere = ctx.images++ === 0
+      if (ctx.sansImages) return `<figure><div class="img-place" role="img" aria-label="${esc(b.alt)}">${esc(b.alt)}</div>${b.legende ? `<figcaption>${esc(b.legende)}</figcaption>` : ''}</figure>`
+      return `<figure><img src="${esc(b.src)}" alt="${esc(b.alt)}" decoding="async"${premiere ? ' fetchpriority="high"' : ' loading="lazy"'}>${b.legende ? `<figcaption>${esc(b.legende)}</figcaption>` : ''}</figure>`
+    }
+    case 'benefices': return `<ul class="benef">${b.elements.map((x) => `<li><b>${esc(x.titre)}</b>${x.texte ? esc(x.texte) : ''}</li>`).join('')}</ul>`
+    case 'etapes': return `<h2>${esc(b.titre || T.etapes)}</h2><ol>${b.elements.map((x) => `<li>${esc(x.titre)}</li>`).join('')}</ol>`
+    case 'questions': return `<h2>${esc(b.titre || T.questions)}</h2>${b.elements.map((x) => `<details><summary>${esc(x.q)}</summary><p>${esc(x.r)}</p></details>`).join('')}`
+    case 'bouton': return `<a class="bouton" href="${esc(lienAvecSource(b.href, ctx.requete))}">${esc(b.libelle)}</a>`
+    case 'mentions': return `<p class="mentions">${esc(b.texte)}</p>`
+    default: return ''
+  }
+}
+
+/**
+ * @param {object} page   page validée (modele.js)
+ * @param {{ nom: string, logo?: string, couleurs?: { brand?, lien?, ornement? }, pied?: { confidentialite?, mentions?, editeur? } }} marque
+ * @param {{ requete?: string|URLSearchParams, fragment?: boolean, canonique?: string, sansImages?: boolean }} [o]
+ *   fragment : rend le seul contenu (aperçu dans un éditeur), sans <html> ; canonique : adresse publique de la page ;
+ *   sansImages : un cadre portant le texte de remplacement à la place de chaque image et du logo (aperçu servi par un
+ *   autre domaine que le produit, dont la politique de sécurité refuserait les images)
+ * @returns {string}
+ */
+export function rendre(page, marque = {}, { requete = '', fragment = false, canonique = '', sansImages = false } = {}) {
+  const T = textesDe(page.langue)
+  const c = { brand: couleur(marque.couleurs?.brand, '#0b2a5b'), lien: couleur(marque.couleurs?.lien, '#1565d8'), ornement: couleur(marque.couleurs?.ornement, '#f28c28') }
+  const ctx = { images: 0, requete, sansImages }
+  const pied = marque.pied ?? {}
+  const liens = [
+    adresseValide(pied.confidentialite) ? `<a href="${esc(pied.confidentialite)}">${esc(T.confidentialite)}</a>` : '',
+    adresseValide(pied.mentions) ? `<a href="${esc(pied.mentions)}">${esc(T.mentions)}</a>` : '',
+  ].join('')
+  const entete = `<header>${adresseValide(marque.logo) && !sansImages ? `<img src="${esc(marque.logo)}" alt="${esc(marque.nom)}">` : `<b>${esc(marque.nom)}</b>`}</header>`
+  const corps = `<div class="lp" lang="${esc(page.langue)}" dir="${sensDe(page.langue)}">${entete}${page.blocs.map((b) => bloc(b, T, ctx)).join('')}<footer>${liens}${pied.editeur ? `<p>${esc(T.editeur)} : ${esc(pied.editeur)}</p>` : ''}</footer></div>`
+  if (fragment) return `<style>${feuille(c)}</style>${corps}`
+  return `<!doctype html><html lang="${esc(page.langue)}" dir="${sensDe(page.langue)}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${esc(titreDe(page))} — ${esc(marque.nom)}</title>${canonique ? `<link rel="canonical" href="${esc(canonique)}">` : ''}<style>body{margin:0;background:#fff}${feuille(c)}</style></head><body>${corps}</body></html>`
+}
+
+/**
+ * La DESCRIPTION d'une page rendue, telle que la lit `verifierPage` de @mostajs/ad-platforms (ce module n'en dépend
+ * pas : il décrit, l'application vérifie).
+ * @param {object} page @param {object} marque
+ * @param {{ adresse: string, domaineProduit: string, langueCampagne?: string, accrocheAnnonce?: string, html?: string }} o
+ */
+export function decrirePage(page, marque, { adresse, domaineProduit, langueCampagne, accrocheAnnonce, html } = {}) {
+  const rendu = html ?? rendre(page, marque)
+  const hrefs = page.blocs.filter((b) => b.type === 'bouton').map((b) => b.href)
+  const externes = hrefs.filter((h) => { try { return new URL(h).hostname !== domaineProduit } catch { return false } })
+  const textes = page.blocs.flatMap((b) => [b.titre, b.sousTitre, b.texte, b.legende, b.libelle, ...(b.elements ?? []).flatMap((x) => [x.titre, x.texte, x.q, x.r])]).filter(Boolean)
+  return {
+    adresse, domaineProduit, langue: page.langue, langueCampagne: langueCampagne ?? page.langue, public: page.public,
+    pied: { confidentialite: marque.pied?.confidentialite ?? '', mentions: marque.pied?.mentions ?? '', editeur: marque.pied?.editeur ?? '' },
+    boutons: hrefs.length, liensSortie: externes.length, scripts: [], consentement: false, surgissante: false,
+    htmlOctets: Buffer.byteLength(rendu, 'utf8'), titre: titreDe(page), accrocheAnnonce, texte: textes.join(' '), faits: page.faits ?? [],
+  }
+}

package/src/signature.js

@@ -0,0 +1,35 @@
+/**
+ * @mostajs/landing — la SIGNATURE d'un envoi de page (HMAC-SHA256), à la manière des webhooks : l'en-tête porte
+ * l'heure et l'empreinte de « <heure>.<corps> ». Le récepteur refuse une empreinte fausse, un corps altéré et un
+ * envoi trop ancien (rejeu). Comparaison à temps constant. La clé n'est jamais transmise.
+ *   x-landing-signature: t=1761930000,v1=<64 hex>
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+import { createHmac, timingSafeEqual } from 'node:crypto'
+
+export const ENTETE_SIGNATURE = 'x-landing-signature'
+
+const empreinte = (cle, t, corps) => createHmac('sha256', String(cle)).update(`${t}.${corps}`).digest('hex')
+
+/** @returns {string} la valeur de l'en-tête pour ce corps (chaîne exacte envoyée). */
+export function signer(corps, cle, { maintenant = Date.now() } = {}) {
+  if (!cle) throw new Error('landing : clé de publication requise pour signer')
+  const t = Math.floor(maintenant / 1000)
+  return `t=${t},v1=${empreinte(cle, t, corps)}`
+}
+
+/**
+ * @param {string|Buffer} corpsBrut  le corps reçu, tel quel (pas re-sérialisé)
+ * @param {string} entete @param {string} cle
+ * @returns {{ ok: true } | { ok: false, motif: 'absente'|'illisible'|'perimee'|'fausse' }}
+ */
+export function verifierSignature(corpsBrut, entete, cle, { tolerance = 300, maintenant = Date.now() } = {}) {
+  if (!entete || !cle) return { ok: false, motif: 'absente' }
+  const m = /^t=(\d{1,12}),v1=([0-9a-f]{64})$/.exec(String(entete).trim())
+  if (!m) return { ok: false, motif: 'illisible' }
+  const t = Number(m[1])
+  if (Math.abs(Math.floor(maintenant / 1000) - t) > tolerance) return { ok: false, motif: 'perimee' }
+  const attendu = Buffer.from(empreinte(cle, t, Buffer.isBuffer(corpsBrut) ? corpsBrut.toString('utf8') : String(corpsBrut)), 'hex')
+  const recu = Buffer.from(m[2], 'hex')
+  return attendu.length === recu.length && timingSafeEqual(attendu, recu) ? { ok: true } : { ok: false, motif: 'fausse' }
+}

package/src/textes.js

@@ -0,0 +1,14 @@
+/**
+ * @mostajs/landing — les libellés fixes d'une page (titres par défaut, pied légal), dans les sept langues.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+export const TEXTES = Object.freeze({
+  fr: { etapes: 'Comment ça marche ?', questions: 'Questions fréquentes', confidentialite: 'Confidentialité', mentions: 'Mentions légales', editeur: 'Éditeur' },
+  ar: { etapes: 'كيف يعمل؟', questions: 'أسئلة شائعة', confidentialite: 'الخصوصية', mentions: 'الإشعارات القانونية', editeur: 'الناشر' },
+  en: { etapes: 'How it works', questions: 'Frequently asked questions', confidentialite: 'Privacy', mentions: 'Legal notice', editeur: 'Publisher' },
+  de: { etapes: 'So funktioniert es', questions: 'Häufige Fragen', confidentialite: 'Datenschutz', mentions: 'Impressum', editeur: 'Herausgeber' },
+  es: { etapes: '¿Cómo funciona?', questions: 'Preguntas frecuentes', confidentialite: 'Privacidad', mentions: 'Aviso legal', editeur: 'Editor' },
+  it: { etapes: 'Come funziona', questions: 'Domande frequenti', confidentialite: 'Privacy', mentions: 'Note legali', editeur: 'Editore' },
+  zh: { etapes: '如何使用', questions: '常见问题', confidentialite: '隐私', mentions: '法律声明', editeur: '发布者' },
+})
+export const textesDe = (langue) => TEXTES[langue] ?? TEXTES.fr