@komekoo/astro-cms 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,145 @@
-# Temporary Holding Version
+# @komekoo/astro-cms
 
-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.
+CMS git pour sites Astro : les contenus sont des fichiers JSON et Markdown dans `src/content/`, décrits par des
+champs typés (`champ.*`). Le paquet génère le schéma CMS (`cms.schema.json`) et le manifeste destiné aux agents IA
+(`ai/manifest.json`), et vérifie les contenus avant chaque `astro build`.
+
+## Installation
+
+Prérequis : Node ≥ 22.23.4, Astro ^7.4.2.
+
+```sh
+pnpm add @komekoo/astro-cms
+```
+
+## Déclarer les contenus : `src/content.config.ts`
+
+```ts
+// N'importe pas `astro:content` ici : komekoo-cms charge ce fichier hors d'Astro (sync / check).
+import { champ, defineCollection, defineSingleton } from '@komekoo/astro-cms';
+
+// Singleton : un seul fichier, src/content/pages/accueil.json
+const accueil = defineSingleton('accueil', {
+  libelle: "Page d'accueil",
+  schema: {
+    titre: champ.texte({ libelle: 'Titre principal', max: 80 }),
+    image: champ.image({ libelle: 'Image principale' }),
+    presentation: champ.richtext({ libelle: 'Présentation' }),
+    reservation: champ.lien({ libelle: 'Lien de réservation', obligatoire: false }),
+  },
+});
+
+// Collection : un fichier par élément, dans src/content/tarifs/
+const tarifs = defineCollection('tarifs', {
+  libelle: 'Tarifs',
+  format: 'json', // ou 'markdown' (frontmatter YAML + corps)
+  titre: 'prestation', // champ texte servant de titre dans l'admin
+  ordonnable: true, // ajoute un champ `ordre` (entier ≥ 0)
+  schema: {
+    prestation: champ.texte({ libelle: 'Prestation', max: 80 }),
+    categorie: champ.choix({ libelle: 'Catégorie', options: ['Femme', 'Homme', 'Enfant'] }),
+    prix: champ.nombre({ libelle: 'Prix', unite: '€', min: 0 }),
+  },
+});
+
+export const collections = { accueil, tarifs };
+```
+
+Champs disponibles : `texte`, `paragraphe`, `richtext`, `image`, `date`, `lien`, `nombre`, `booleen`, `choix`,
+`liste`, `groupe`. Chacun prend `libelle`, `aide` (facultatif) et `obligatoire` (`true` par défaut). Les types
+TypeScript suivent la déclaration : un champ `obligatoire: false` est typé `T | undefined`, `choix` donne l'union
+de ses options.
+
+- `onglet` (facultatif, texte non vide) : range le champ dans un onglet du formulaire d'administration, par ex.
+  `onglet: 'Référencement Google'`.
+- `adresse` (option de `defineSingleton`, facultative) : adresse publique de la page, par ex. `adresse: '/a-propos'`
+  (`/` suivi de minuscules, chiffres, `-` ou `/`). Elle permet à l'admin d'ouvrir l'aperçu de la page.
+- Images : `src` de la forme `/uploads/…/nom-2400.webp`, avec les variantes `-800.webp`, `-1600.webp` et
+  `-2400.webp` présentes dans `public/uploads/`.
+- Liens : `https://…`, chemin interne `/…`, `mailto:` ou `tel:`.
+- Markdown (`richtext` et corps des articles) : titres 2 et 3, gras, italique, liens, listes, citations, images
+  `/uploads/`, tableaux GFM simples. HTML, code, barré, cases à cocher, notes et lignes horizontales sont refusés.
+
+## Intégration : `astro.config.mjs`
+
+```js
+import { defineConfig } from 'astro/config';
+import cms from '@komekoo/astro-cms/integration';
+
+export default defineConfig({
+  integrations: [
+    cms({
+      site: 'Salon de coiffure à Vichy', // présentation du site dans ai/manifest.json (obligatoire)
+      contact: 'contact@exemple.fr', // contact proposé pour les demandes hors périmètre (obligatoire)
+      url: 'https://exemple.fr', // adresse publique du site, https sans « / » final (obligatoire)
+      admin: { accent: '#5DEFB7', logo: '/uploads/logo-2400.webp', origine: 'https://admin.exemple.fr', apercu: 'https://apercu.exemple.pages.dev' }, // facultatif
+      horsPerimetre: ['Modifier le menu de navigation'], // ajouts à la liste socle (facultatif)
+    }),
+  ],
+});
+```
+
+- `astro dev` et `astro sync` régénèrent `cms.schema.json` et `ai/manifest.json`.
+- `astro build` vérifie les fichiers générés et tous les contenus, puis échoue avec une ligne
+  `fichier:ligne — motif` par problème.
+
+## CLI
+
+```sh
+komekoo-cms sync    # génère cms.schema.json et ai/manifest.json
+komekoo-cms check   # vérifie les fichiers générés et valide les contenus (code 1 si problème)
+```
+
+## Point d'entrée navigateur : `@komekoo/astro-cms/navigateur`
+
+Pour les outils qui tournent dans un navigateur (ex. l'interface d'administration) : n'importe rien de `node:*`,
+`astro` ni `vite`. Exporte `creerAjv` et `MOTS_CLES_CMS` (validation du schéma CMS), `validerMarkdown` (et le
+type `Violation`), `lireFrontmatter`, `ecrireFrontmatter` (écrit `---`, YAML, `---`, corps ; dates entre
+guillemets), `MOTIF_LIEN` et `MOTIF_SRC_IMAGE`.
+
+Options récentes : `url` (obligatoire) et `admin` de `cms()`, `onglet` sur les champs, `adresse` sur les
+singletons, et le bloc `x-cms-site` de `cms.schema.json`.
+
+## Aperçu des pages : `cms()`
+
+```astro
+---
+import { cms } from '@komekoo/astro-cms';
+---
+<h1 {...cms('accueil.titre')}>{page.titre}</h1>
+```
+
+`cms('<page>.<champ>')` marque l'élément comme éditable : l'admin le met à jour pendant la saisie et le relie au champ. Chemin : `<page>.<champ>(.<sous-champ>|.<indice>)*`, pages (singletons) uniquement. Au build, chaque marqueur est vérifié contre `cms.schema.json` ; erreur `page HTML — chemin — motif` si le chemin est inconnu, si un champ image n'est pas sur un `<img>` ou si un champ lien n'est pas sur un `<a>`.
+
+- `defineSingleton(id, { …, apercu: '/contact' })` : page à montrer pour un singleton sans `adresse` (par ex. les Réglages).
+- `cms({ …, admin: { apercu: 'https://apercu.<projet>.pages.dev' } })` : adresse fixe de la branche d'aperçu ; active « Prévisualiser ».
+- Le build ajoute au site `/_cms/chargeur.js` (balise `<script>` dans chaque page), `/_cms/apercu/` et `/_cms/motifs.js`, et un `_headers` avec `Content-Security-Policy: frame-ancestors 'self' <origine admin>` ; `X-Robots-Tag: noindex` si `CF_PAGES_BRANCH` n'est pas `main`. Un `X-Frame-Options` `DENY` ou `SAMEORIGIN` déjà présent déclenche un avertissement : le retirer. Une CSP propre au site doit autoriser `script-src 'self'`.
+- Sous-chemins sans dépendance à Node : `@komekoo/astro-cms/apercu` (protocole d'échange, sans analyseur Markdown), `@komekoo/astro-cms/apercu/arbre` (`versArbre`, Markdown → arbre d'aperçu, à charger à la demande) et `@komekoo/astro-cms/navigateur`.
+
+## Composant `<CmsImage>`
+
+```astro
+---
+import CmsImage from '@komekoo/astro-cms/CmsImage.astro';
+---
+<CmsImage image={page.image} sizes="(min-width: 60rem) 50vw, 100vw" loading="eager" class="heros" />
+```
+
+Produit un `<img>` avec `srcset` sur les variantes 800 / 1600 / 2400, `width`, `height` et `alt`.
+Props : `image` (obligatoire), `sizes` (`100vw` par défaut), `loading` (`lazy` par défaut), `class`, `cms`
+(chemin du marqueur d'aperçu, par ex. `cms="accueil.image"`).
+
+## Limites connues
+
+- `src/content.config.ts` ne doit pas importer `astro:content` : il est chargé hors d'Astro par la CLI.
+- Frontmatter TOML (`+++`) refusé : utiliser YAML (`---`). Mettre les dates entre guillemets
+  (`date: "2026-10-01"`) ; une date nue est lue comme un horodatage YAML et refusée.
+- Node ≥ 22.23.4 (exigence d'Astro 7.4.2).
+- Les fichiers générés (`cms.schema.json`, `ai/manifest.json`) doivent être committés ; un fichier périmé fait
+  échouer `astro build` et `komekoo-cms check`. Pour éviter les conversions CRLF sous Windows, ajouter à
+  `.gitattributes` :
+
+  ```gitattributes
+  **/cms.schema.json text eol=lf
+  **/ai/manifest.json text eol=lf
+  ```

package/dist/ajv.d.ts

@@ -0,0 +1,4 @@
+import { Ajv2020 } from 'ajv/dist/2020.js';
+export declare const MOTS_CLES_CMS: readonly string[];
+/** Ajv 2020-12 strict, formats activés, mots-clés `x-cms*` déclarés. */
+export declare function creerAjv(): Ajv2020;

package/dist/ajv.js

@@ -0,0 +1,24 @@
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+export const MOTS_CLES_CMS = [
+    'x-cms',
+    'x-cms-version',
+    'x-cms-site',
+    'x-cms-libelle',
+    'x-cms-fichier',
+    'x-cms-adresse',
+    'x-cms-apercu',
+    'x-cms-dossier',
+    'x-cms-format',
+    'x-cms-titre',
+    'x-cms-corps',
+    'x-cms-ordonnable',
+];
+/** Ajv 2020-12 strict, formats activés, mots-clés `x-cms*` déclarés. */
+export function creerAjv() {
+    const ajv = new Ajv2020({ strict: true, allErrors: true });
+    addFormats(ajv);
+    for (const mot of MOTS_CLES_CMS)
+        ajv.addKeyword(mot);
+    return ajv;
+}

package/dist/apercu/arbre.d.ts

@@ -0,0 +1,3 @@
+import type { NoeudRiche } from './protocole.js';
+/** Convertit du Markdown en arbre restreint ; tout élément hors du sous-ensemble autorisé devient du texte brut. */
+export declare function versArbre(markdown: string): NoeudRiche[];

package/dist/apercu/arbre.js

@@ -0,0 +1,64 @@
+import { analyseur } from '../noyau/markdown.js';
+import { MOTIF_LIEN, MOTIF_SRC_IMAGE } from '../motifs.js';
+/** Texte brut d'un nœud : sa valeur littérale, ou celle de ses descendants. */
+function toString(noeud) {
+    if ('value' in noeud)
+        return noeud.value;
+    return enfants(noeud).map(toString).join('');
+}
+const enfants = (noeud) => ('children' in noeud ? noeud.children : []);
+function convertirTous(liste) {
+    return liste.flatMap(convertir);
+}
+function balise(t, liste) {
+    return [{ t, c: convertirTous(liste) }];
+}
+function convertir(noeud) {
+    switch (noeud.type) {
+        case 'paragraph':
+            return balise('p', noeud.children);
+        case 'heading':
+            return noeud.depth === 2 || noeud.depth === 3
+                ? balise(noeud.depth === 2 ? 'h2' : 'h3', noeud.children)
+                : [{ t: 'texte', v: toString(noeud) }];
+        case 'strong':
+            return balise('strong', noeud.children);
+        case 'emphasis':
+            return balise('em', noeud.children);
+        case 'list':
+            return balise(noeud.ordered ? 'ol' : 'ul', noeud.children);
+        case 'listItem':
+            return balise('li', noeud.children);
+        case 'blockquote':
+            return balise('blockquote', noeud.children);
+        case 'table': {
+            const [entete, ...corps] = noeud.children;
+            const ligne = (l, cellule) => ({
+                t: 'tr',
+                c: l.children.map((c) => ({ t: cellule, c: convertirTous(c.children) })),
+            });
+            const c = [];
+            if (entete)
+                c.push({ t: 'thead', c: [ligne(entete, 'th')] });
+            c.push({ t: 'tbody', c: corps.map((l) => ligne(l, 'td')) });
+            return [{ t: 'table', c }];
+        }
+        case 'break':
+            return [{ t: 'br' }];
+        case 'text':
+            return [{ t: 'texte', v: noeud.value }];
+        case 'link':
+            return MOTIF_LIEN.test(noeud.url)
+                ? [{ t: 'a', href: noeud.url, c: convertirTous(noeud.children) }]
+                : convertirTous(noeud.children);
+        case 'image':
+            return MOTIF_SRC_IMAGE.test(noeud.url) ? [{ t: 'img', src: noeud.url, alt: noeud.alt ?? '' }] : [];
+        default:
+            return [{ t: 'texte', v: toString(noeud) }];
+    }
+}
+/** Convertit du Markdown en arbre restreint ; tout élément hors du sous-ensemble autorisé devient du texte brut. */
+export function versArbre(markdown) {
+    const racine = analyseur.parse(markdown.replace(/\r\n/g, '\n'));
+    return convertirTous(enfants(racine));
+}

package/dist/apercu/demarrage.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/apercu/demarrage.js

@@ -0,0 +1,5 @@
+// Point d'entrée de l'aperçu dans le site construit. L'intégration remplace la chaîne ci-dessous, guillemets compris,
+// par l'origine de l'admin (chaîne JSON) en copiant ce fichier.
+import { demarrerApercu } from './script.js';
+const ORIGINE_ADMIN = '__KOMEKOO_ORIGINE_ADMIN__';
+demarrerApercu(window, ORIGINE_ADMIN);

package/dist/apercu/index.d.ts

@@ -0,0 +1,2 @@
+export { BALISES_RICHES, lireMessage } from './protocole.js';
+export type { Message, NoeudRiche, ValeurApercu } from './protocole.js';

package/dist/apercu/index.js

@@ -0,0 +1,2 @@
+// Protocole seul : `versArbre` (analyseur Markdown) est servi à part par `@komekoo/astro-cms/apercu/arbre`.
+export { BALISES_RICHES, lireMessage } from './protocole.js';

package/dist/apercu/protocole.d.ts

@@ -0,0 +1,67 @@
+import { MOTIF_CHEMIN_CMS, MOTIF_LIEN, MOTIF_SRC_IMAGE } from '../motifs.js';
+export { MOTIF_CHEMIN_CMS, MOTIF_LIEN, MOTIF_SRC_IMAGE };
+export type NoeudRiche = {
+    t: 'texte';
+    v: string;
+} | {
+    t: 'p' | 'h2' | 'h3' | 'strong' | 'em' | 'ul' | 'ol' | 'li' | 'blockquote' | 'table' | 'thead' | 'tbody' | 'tr' | 'th' | 'td' | 'br';
+    c?: NoeudRiche[];
+} | {
+    t: 'a';
+    href: string;
+    c: NoeudRiche[];
+} | {
+    t: 'img';
+    src: string;
+    alt: string;
+};
+export type ValeurApercu = {
+    type: 'texte';
+    texte: string;
+} | {
+    type: 'image';
+    src: string;
+    srcset: string;
+    alt: string;
+} | {
+    type: 'lien';
+    href: string;
+    texte?: string;
+} | {
+    type: 'riche';
+    arbre: NoeudRiche[];
+} | {
+    type: 'indisponible';
+};
+export type Message = {
+    cms: 1;
+    type: 'bonjour';
+} | {
+    cms: 1;
+    type: 'pret';
+    chemins: string[];
+} | {
+    cms: 1;
+    type: 'valeurs';
+    valeurs: Record<string, ValeurApercu>;
+} | {
+    cms: 1;
+    type: 'actif';
+    chemin: string | null;
+    libelle?: string;
+} | {
+    cms: 1;
+    type: 'clic';
+    chemin: string;
+} | {
+    cms: 1;
+    type: 'lien';
+    adresse: string;
+};
+/** Balises de `NoeudRiche` qui contiennent des enfants, hors `texte`, `a` et `img`. */
+export declare const BALISES_RICHES: ReadonlySet<string>;
+export declare const MAX_CHEMINS = 500;
+/** URL absolue http(s), sans espace ni caractère de contrôle. */
+export declare function estUrlAbsolue(x: unknown): x is string;
+/** Valide strictement un message reçu ; renvoie une copie neuve, ou `null` si quoi que ce soit est refusé. */
+export declare function lireMessage(donnee: unknown): Message | null;

package/dist/apercu/protocole.js

@@ -0,0 +1,176 @@
+// Protocole d'échange entre l'admin et le site (aperçu). Ne dépend que de `../motifs.js` : ce fichier est aussi
+// copié tel quel dans le site construit, où il est chargé comme module du navigateur.
+import { MOTIF_CHEMIN_CMS, MOTIF_LIEN, MOTIF_SRC_IMAGE } from '../motifs.js';
+// Réexportés pour `script.ts`, qui ne doit importer que ce fichier une fois copié dans le site.
+export { MOTIF_CHEMIN_CMS, MOTIF_LIEN, MOTIF_SRC_IMAGE };
+/** Balises de `NoeudRiche` qui contiennent des enfants, hors `texte`, `a` et `img`. */
+export const BALISES_RICHES = new Set([
+    'p', 'h2', 'h3', 'strong', 'em', 'ul', 'ol', 'li', 'blockquote', 'table', 'thead', 'tbody', 'tr', 'th', 'td', 'br',
+]);
+export const MAX_CHEMINS = 500;
+const PROFONDEUR_MAX = 20;
+/** Chemin interne : ni « // » ni « /\ » au début, aucun antislash, espace ni caractère de contrôle. */
+const MOTIF_ADRESSE = /^\/(?![\/\\])[^\s\x00-\x1f\\]*$/;
+const estObjet = (x) => typeof x === 'object' && x !== null && !Array.isArray(x);
+const cles = (o, attendues, facultatives = []) => Object.keys(o).every((k) => attendues.includes(k) || facultatives.includes(k)) && attendues.every((k) => k in o);
+const estChemin = (x) => typeof x === 'string' && MOTIF_CHEMIN_CMS.test(x);
+const estLien = (x) => typeof x === 'string' && MOTIF_LIEN.test(x);
+/** URL absolue http(s), sans espace ni caractère de contrôle. */
+export function estUrlAbsolue(x) {
+    if (typeof x !== 'string' || /[\s\x00-\x1f]/.test(x))
+        return false;
+    try {
+        const protocole = new URL(x).protocol;
+        return protocole === 'https:' || protocole === 'http:';
+    }
+    catch {
+        return false;
+    }
+}
+function srcsetValide(x) {
+    if (typeof x !== 'string')
+        return false;
+    if (x === '')
+        return true;
+    return x.split(',').every((entree) => {
+        const [url, ...reste] = entree.trim().split(/\s+/);
+        return estUrlAbsolue(url) && reste.length <= 1;
+    });
+}
+function lireNoeud(x, profondeur) {
+    if (profondeur > PROFONDEUR_MAX || !estObjet(x))
+        return null;
+    const t = x.t;
+    if (t === 'texte') {
+        return cles(x, ['t', 'v']) && typeof x.v === 'string' ? { t, v: x.v } : null;
+    }
+    if (t === 'img') {
+        if (!cles(x, ['t', 'src', 'alt']) || typeof x.alt !== 'string')
+            return null;
+        // Les arbres de `versArbre` portent des chemins relatifs /uploads/ ; l'admin peut aussi envoyer des URL absolues.
+        const ok = estUrlAbsolue(x.src) || (typeof x.src === 'string' && MOTIF_SRC_IMAGE.test(x.src));
+        return ok ? { t, src: x.src, alt: x.alt } : null;
+    }
+    if (t === 'a') {
+        if (!cles(x, ['t', 'href', 'c']) || !estLien(x.href))
+            return null;
+        const c = lireNoeuds(x.c, profondeur + 1);
+        return c ? { t, href: x.href, c } : null;
+    }
+    if (typeof t === 'string' && BALISES_RICHES.has(t)) {
+        if (!cles(x, ['t'], ['c']))
+            return null;
+        const balise = t;
+        if (x.c === undefined)
+            return { t: balise };
+        const c = lireNoeuds(x.c, profondeur + 1);
+        return c ? { t: balise, c } : null;
+    }
+    return null;
+}
+function lireNoeuds(x, profondeur) {
+    if (!Array.isArray(x))
+        return null;
+    const sortie = [];
+    for (const element of x) {
+        const noeud = lireNoeud(element, profondeur);
+        if (!noeud)
+            return null;
+        sortie.push(noeud);
+    }
+    return sortie;
+}
+function lireValeur(x) {
+    if (!estObjet(x))
+        return null;
+    switch (x.type) {
+        case 'texte':
+            return cles(x, ['type', 'texte']) && typeof x.texte === 'string' ? { type: 'texte', texte: x.texte } : null;
+        case 'image':
+            return cles(x, ['type', 'src', 'srcset', 'alt']) &&
+                estUrlAbsolue(x.src) &&
+                srcsetValide(x.srcset) &&
+                typeof x.alt === 'string'
+                ? { type: 'image', src: x.src, srcset: x.srcset, alt: x.alt }
+                : null;
+        case 'lien': {
+            if (!cles(x, ['type', 'href'], ['texte']) || !estLien(x.href))
+                return null;
+            if (x.texte === undefined)
+                return { type: 'lien', href: x.href };
+            return typeof x.texte === 'string' ? { type: 'lien', href: x.href, texte: x.texte } : null;
+        }
+        case 'riche': {
+            if (!cles(x, ['type', 'arbre']))
+                return null;
+            const arbre = lireNoeuds(x.arbre, 1);
+            return arbre ? { type: 'riche', arbre } : null;
+        }
+        case 'indisponible':
+            return cles(x, ['type']) ? { type: 'indisponible' } : null;
+        default:
+            return null;
+    }
+}
+/** Valide strictement un message reçu ; renvoie une copie neuve, ou `null` si quoi que ce soit est refusé. */
+export function lireMessage(donnee) {
+    if (!estObjet(donnee) || donnee.cms !== 1)
+        return null;
+    switch (donnee.type) {
+        case 'bonjour':
+            return cles(donnee, ['cms', 'type']) ? { cms: 1, type: 'bonjour' } : null;
+        case 'pret': {
+            if (!cles(donnee, ['cms', 'type', 'chemins']))
+                return null;
+            const chemins = donnee.chemins;
+            if (!Array.isArray(chemins) || chemins.length > MAX_CHEMINS)
+                return null;
+            const copie = [];
+            for (const chemin of chemins) {
+                // for…of visite aussi les trous d'un tableau creux (valeur undefined), qui sont donc refusés.
+                if (!estChemin(chemin))
+                    return null;
+                copie.push(chemin);
+            }
+            return { cms: 1, type: 'pret', chemins: copie };
+        }
+        case 'valeurs': {
+            if (!cles(donnee, ['cms', 'type', 'valeurs']) || !estObjet(donnee.valeurs))
+                return null;
+            const valeurs = {};
+            for (const [chemin, brut] of Object.entries(donnee.valeurs)) {
+                const valeur = lireValeur(brut);
+                if (!estChemin(chemin) || !valeur)
+                    return null;
+                valeurs[chemin] = valeur;
+            }
+            return { cms: 1, type: 'valeurs', valeurs };
+        }
+        case 'actif': {
+            if (!cles(donnee, ['cms', 'type', 'chemin'], ['libelle']))
+                return null;
+            const chemin = donnee.chemin;
+            if (chemin !== null && !estChemin(chemin))
+                return null;
+            if (donnee.libelle === undefined)
+                return { cms: 1, type: 'actif', chemin };
+            return typeof donnee.libelle === 'string'
+                ? { cms: 1, type: 'actif', chemin, libelle: donnee.libelle }
+                : null;
+        }
+        case 'clic':
+            return cles(donnee, ['cms', 'type', 'chemin']) && estChemin(donnee.chemin)
+                ? { cms: 1, type: 'clic', chemin: donnee.chemin }
+                : null;
+        case 'lien': {
+            if (!cles(donnee, ['cms', 'type', 'adresse']))
+                return null;
+            const adresse = donnee.adresse;
+            return typeof adresse === 'string' && MOTIF_ADRESSE.test(adresse)
+                ? { cms: 1, type: 'lien', adresse }
+                : null;
+        }
+        default:
+            return null;
+    }
+}

package/dist/apercu/script.d.ts

@@ -0,0 +1,8 @@
+import { type NoeudRiche } from './protocole.js';
+/** Remplace les enfants de `element` par l'arbre, en ne créant que les nœuds et attributs autorisés. */
+export declare function appliquerArbre(element: Element, arbre: NoeudRiche[]): void;
+/**
+ * Démarre l'aperçu dans `fenetre` : écoute les messages de l'admin (`origineAdmin`, fenêtre parente).
+ * Renvoie une fonction d'arrêt.
+ */
+export declare function demarrerApercu(fenetre: Window, origineAdmin: string): () => void;