@komekoo/astro-cms 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,128 @@
-# 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' }, // 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`.
+
+## 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`.
+
+## 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,23 @@
+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-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/champs.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'astro/zod';
+import type { OptionsBase } from './types.js';
+import { MOTIF_LIEN, MOTIF_SRC_IMAGE } from './motifs.js';
+export { MOTIF_LIEN, MOTIF_SRC_IMAGE };
+type Bornes = {
+    min?: number;
+    max?: number;
+};
+/** `obligatoire: false` → `ZodOptional<T>` ; absent ou `true` → `T` ; `boolean` non littéral → l'un ou l'autre. */
+export type Finalise<T extends z.ZodType, O extends OptionsBase> = O extends {
+    obligatoire: false;
+} ? z.ZodOptional<T> : O extends {
+    obligatoire: true;
+} ? T : 'obligatoire' extends keyof O ? T | z.ZodOptional<T> : T;
+export declare const champ: {
+    texte: <O extends OptionsBase & Bornes>(o: O) => Finalise<z.ZodString, O>;
+    paragraphe: <O extends OptionsBase & Bornes>(o: O) => Finalise<z.ZodString, O>;
+    richtext: <O extends OptionsBase & {
+        max?: number;
+    }>(o: O) => Finalise<z.ZodString, O>;
+    image: <O extends OptionsBase>(o: O) => Finalise<z.ZodObject<{
+        src: z.ZodString;
+        alt: z.ZodString;
+        largeur: z.ZodInt;
+        hauteur: z.ZodInt;
+    }, z.core.$strict>, O>;
+    date: <O extends OptionsBase>(o: O) => Finalise<z.ZodISODate, O>;
+    lien: <O extends OptionsBase>(o: O) => Finalise<z.ZodString, O>;
+    nombre: <O extends OptionsBase & Bornes & {
+        entier?: boolean;
+        unite?: string;
+    }>(o: O) => Finalise<z.ZodNumber, O>;
+    booleen: <O extends OptionsBase>(o: O) => Finalise<z.ZodBoolean, O>;
+    choix: <const Options extends readonly [string, ...string[]], O extends OptionsBase>(o: O & {
+        options: Options;
+    }) => Finalise<z.ZodEnum<{ [k in Options[number]]: k; } extends infer T ? { [k in keyof T]: T[k]; } : never>, O & {
+        options: Options;
+    }>;
+    liste: <E extends z.ZodType, O extends OptionsBase & Bornes>(o: O & {
+        element: E;
+    }) => Finalise<z.ZodArray<E>, O & {
+        element: E;
+    }>;
+    groupe: <S extends Record<string, z.ZodType>, O extends OptionsBase>(o: O & {
+        champs: S;
+    }) => Finalise<z.ZodObject<{ -readonly [P in keyof S]: S[P]; }, z.core.$strict>, O & {
+        champs: S;
+    }>;
+};

package/dist/champs.js

@@ -0,0 +1,58 @@
+import { z } from 'astro/zod';
+import { MOTIF_LIEN, MOTIF_SRC_IMAGE } from './motifs.js';
+export { MOTIF_LIEN, MOTIF_SRC_IMAGE };
+/** Appose la méta CMS puis, si le champ n'est pas obligatoire, `.optional()`. */
+function finaliser(schema, o, editeur, extra = {}) {
+    const cms = { editeur, libelle: o.libelle };
+    if (o.aide !== undefined)
+        cms.aide = o.aide;
+    if (o.onglet !== undefined) {
+        if (o.onglet === '')
+            throw new Error(`onglet du champ « ${o.libelle} » : texte non vide attendu`);
+        cms.onglet = o.onglet;
+    }
+    if (extra.unite !== undefined)
+        cms.unite = extra.unite;
+    const avecMeta = schema.meta({ cms });
+    return (o.obligatoire === false ? avecMeta.optional() : avecMeta);
+}
+function chaine({ min, max }) {
+    let s = z.string();
+    if (min !== undefined)
+        s = s.min(min);
+    if (max !== undefined)
+        s = s.max(max);
+    return s;
+}
+export const champ = {
+    texte: (o) => finaliser(chaine(o), o, 'texte'),
+    paragraphe: (o) => finaliser(chaine(o), o, 'paragraphe'),
+    richtext: (o) => finaliser(chaine({ max: o.max }), o, 'richtext'),
+    image: (o) => finaliser(z.strictObject({
+        src: z.string().regex(MOTIF_SRC_IMAGE),
+        alt: z.string().max(250),
+        largeur: z.int().positive(),
+        hauteur: z.int().positive(),
+    }), o, 'image'),
+    date: (o) => finaliser(z.iso.date(), o, 'date'),
+    lien: (o) => finaliser(z.string().regex(MOTIF_LIEN), o, 'lien'),
+    nombre: (o) => {
+        let s = o.entier ? z.int() : z.number();
+        if (o.min !== undefined)
+            s = s.min(o.min);
+        if (o.max !== undefined)
+            s = s.max(o.max);
+        return finaliser(s, o, 'nombre', { unite: o.unite });
+    },
+    booleen: (o) => finaliser(z.boolean(), o, 'booleen'),
+    choix: (o) => finaliser(z.enum(o.options), o, 'choix'),
+    liste: (o) => {
+        let s = z.array(o.element);
+        if (o.min !== undefined)
+            s = s.min(o.min);
+        if (o.max !== undefined)
+            s = s.max(o.max);
+        return finaliser(s, o, 'liste');
+    },
+    groupe: (o) => finaliser(z.strictObject(o.champs), o, 'groupe'),
+};

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+/** Cœur testable de la CLI : renvoie le code de sortie. */
+export declare function executerCli(argv: string[], racine: string): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { parseArgs } from 'node:util';
+import { chargerOptions } from './integration.js';
+import { formaterViolations } from './noyau/contenus.js';
+import { ErreurCms } from './noyau/erreurs.js';
+import { synchroniser, verifier } from './noyau/operations.js';
+const AIDE = `Usage : komekoo-cms <commande>
+
+Commandes :
+  sync    génère cms.schema.json et ai/manifest.json
+  check   vérifie les fichiers générés et valide les contenus (code 1 si problème)
+
+Options :
+  -h, --help   affiche cette aide`;
+/** Cœur testable de la CLI : renvoie le code de sortie. */
+export async function executerCli(argv, racine) {
+    const { positionals, values } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: { help: { type: 'boolean', short: 'h' } },
+    });
+    const commande = positionals[0];
+    if (values.help || (commande !== 'sync' && commande !== 'check')) {
+        console.error(AIDE);
+        return values.help && commande === undefined ? 0 : 2;
+    }
+    try {
+        const options = await chargerOptions(racine);
+        if (commande === 'sync') {
+            const ecrits = await synchroniser(racine, options);
+            console.log(ecrits.length === 0 ? 'Fichiers à jour.' : ecrits.map((f) => `réécrit : ${f}`).join('\n'));
+            return 0;
+        }
+        const violations = await verifier(racine, options);
+        if (violations.length === 0) {
+            console.log('Aucun problème.');
+            return 0;
+        }
+        console.log(formaterViolations(violations));
+        return 1;
+    }
+    catch (e) {
+        if (!(e instanceof ErreurCms))
+            throw e;
+        console.error(e.message);
+        return 1;
+    }
+}
+function estPrincipal() {
+    const script = process.argv[1];
+    if (script === undefined)
+        return false;
+    try {
+        return import.meta.url === pathToFileURL(realpathSync(script)).href;
+    }
+    catch {
+        return false;
+    }
+}
+if (estPrincipal()) {
+    try {
+        process.exitCode = await executerCli(process.argv.slice(2), process.cwd());
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        process.exitCode = 1;
+    }
+}

package/dist/collections.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'astro/zod';
+import { glob } from 'astro/loaders';
+import type { DeclCollection, DeclSingleton } from './types.js';
+/** Clé symbole portant les métadonnées CMS sur l'objet collection (invisible pour Astro). */
+export declare const CMS: unique symbol;
+type Loader = ReturnType<typeof glob>;
+type Forme = Record<string, z.ZodType>;
+type ChampOrdre = {
+    ordre: z.ZodInt;
+};
+/** Schéma strict d'une collection : sa forme, plus `ordre` si elle est ordonnable. */
+export type SchemaCollection<S extends Forme, Ord extends boolean> = z.ZodObject<Ord extends true ? S & ChampOrdre : S, z.core.$strict>;
+/** Type que pose `defineCollection` d'astro:content ; Astro refuse une collection à loader sans lui. */
+declare const TYPE_ASTRO = "content_layer";
+export declare function defineSingleton<S extends Forme>(id: string, o: {
+    libelle: string;
+    adresse?: string;
+    schema: S;
+}): {
+    type: typeof TYPE_ASTRO;
+    loader: Loader;
+    schema: z.ZodObject<S, z.core.$strict>;
+    [CMS]: DeclSingleton;
+};
+export declare function defineCollection<S extends Forme, Ord extends boolean = false>(id: string, o: {
+    libelle: string;
+    format: 'json' | 'markdown';
+    titre: string;
+    ordonnable?: Ord;
+    schema: S;
+}): {
+    type: typeof TYPE_ASTRO;
+    loader: Loader;
+    schema: SchemaCollection<S, Ord>;
+    [CMS]: DeclCollection;
+};
+export declare function lireDecl(c: unknown): DeclSingleton | DeclCollection | undefined;
+export {};

package/dist/collections.js

@@ -0,0 +1,52 @@
+import { z } from 'astro/zod';
+import { glob } from 'astro/loaders';
+import { lireMeta } from './types.js';
+/** Clé symbole portant les métadonnées CMS sur l'objet collection (invisible pour Astro). */
+export const CMS = Symbol.for('komekoo-cms.decl');
+/** Type que pose `defineCollection` d'astro:content ; Astro refuse une collection à loader sans lui. */
+const TYPE_ASTRO = 'content_layer';
+const RE_ADRESSE = /^\/[a-z0-9\-\/]*$/;
+const RE_ID = /^[a-z][a-z0-9-]*$/;
+function verifierId(id) {
+    if (!RE_ID.test(id)) {
+        throw new Error(`id « ${id} » invalide : attendu ${RE_ID.source}`);
+    }
+}
+export function defineSingleton(id, o) {
+    verifierId(id);
+    if (o.adresse !== undefined && !RE_ADRESSE.test(o.adresse)) {
+        throw new Error(`adresse « ${o.adresse} » invalide : attendu ${RE_ADRESSE.source}`);
+    }
+    const decl = { type: 'singleton', id, libelle: o.libelle };
+    if (o.adresse !== undefined)
+        decl.adresse = o.adresse;
+    return {
+        type: TYPE_ASTRO,
+        loader: glob({ pattern: `${id}.json`, base: './src/content/pages' }),
+        schema: z.strictObject(o.schema),
+        [CMS]: decl,
+    };
+}
+export function defineCollection(id, o) {
+    verifierId(id);
+    if (id === 'pages') {
+        throw new Error("l'id « pages » est réservé aux singletons");
+    }
+    const champTitre = o.schema[o.titre];
+    if (!champTitre || lireMeta(champTitre)?.editeur !== 'texte') {
+        throw new Error(`titre « ${o.titre} » doit désigner un champ existant de type texte`);
+    }
+    const ordonnable = o.ordonnable ?? false;
+    const forme = ordonnable ? { ...o.schema, ordre: z.int().min(0) } : o.schema;
+    return {
+        type: TYPE_ASTRO,
+        loader: glob({ pattern: o.format === 'json' ? '**/*.json' : '**/*.md', base: `./src/content/${id}` }),
+        schema: z.strictObject(forme),
+        [CMS]: { type: 'collection', id, libelle: o.libelle, format: o.format, titre: o.titre, ordonnable },
+    };
+}
+export function lireDecl(c) {
+    if (typeof c !== 'object' || c === null)
+        return undefined;
+    return c[CMS];
+}

package/dist/images.d.ts

@@ -0,0 +1,8 @@
+export declare const LARGEURS: readonly [800, 1600, 2400];
+export type Variante = {
+    largeur: (typeof LARGEURS)[number];
+    url: string;
+};
+export declare function variantes(src: string): Variante[];
+/** Variantes strictement plus petites que l'original, puis le fichier -2400 (original non agrandi). */
+export declare function srcsetDe(src: string, largeurOriginale: number): string;

package/dist/images.js

@@ -0,0 +1,19 @@
+import { MOTIF_SRC_IMAGE } from './champs.js';
+export const LARGEURS = [800, 1600, 2400];
+export function variantes(src) {
+    if (!MOTIF_SRC_IMAGE.test(src)) {
+        throw new Error(`Chemin d'image invalide : ${src}`);
+    }
+    const base = src.slice(0, -'-2400.webp'.length);
+    return LARGEURS.map((largeur) => ({ largeur, url: `${base}-${largeur}.webp` }));
+}
+/** Variantes strictement plus petites que l'original, puis le fichier -2400 (original non agrandi). */
+export function srcsetDe(src, largeurOriginale) {
+    const toutes = variantes(src);
+    const plusGrande = toutes[toutes.length - 1];
+    const entrees = toutes
+        .filter((v) => v !== plusGrande && v.largeur < largeurOriginale)
+        .map((v) => `${v.url} ${v.largeur}w`);
+    entrees.push(`${plusGrande.url} ${Math.min(largeurOriginale, 2400)}w`);
+    return entrees.join(', ');
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export declare const VERSION_SCHEMA = 1;
+export { champ } from './champs.js';
+export { lireMeta } from './types.js';
+export type { Editeur, MetaCms, OptionsBase, DeclSingleton, DeclCollection } from './types.js';
+export { ErreurCms } from './noyau/erreurs.js';
+export { defineSingleton, defineCollection, lireDecl, CMS } from './collections.js';
+export { creerAjv, MOTS_CLES_CMS } from './ajv.js';
+export { versManifest } from './noyau/manifest.js';
+export type { OptionsCms } from './noyau/manifest.js';
+export { HORS_PERIMETRE_SOCLE } from './socle/hors-perimetre.js';
+export { LARGEURS, variantes, srcsetDe } from './images.js';
+export type { Variante } from './images.js';

package/dist/index.js

@@ -0,0 +1,9 @@
+export const VERSION_SCHEMA = 1;
+export { champ } from './champs.js';
+export { lireMeta } from './types.js';
+export { ErreurCms } from './noyau/erreurs.js';
+export { defineSingleton, defineCollection, lireDecl, CMS } from './collections.js';
+export { creerAjv, MOTS_CLES_CMS } from './ajv.js';
+export { versManifest } from './noyau/manifest.js';
+export { HORS_PERIMETRE_SOCLE } from './socle/hors-perimetre.js';
+export { LARGEURS, variantes, srcsetDe } from './images.js';

package/dist/integration.d.ts

@@ -0,0 +1,9 @@
+import type { AstroIntegration } from 'astro';
+import type { OptionsCms } from './noyau/manifest.js';
+/** `Symbol.for` : la même clé que l'intégration soit chargée par Node ou par Vite (`chargerOptions`). */
+export declare const OPTIONS: unique symbol;
+export default function cms(options: OptionsCms): AstroIntegration & {
+    [OPTIONS]: OptionsCms;
+};
+/** Retrouve les options passées à `cms()` dans `astro.config.mjs` (utilisé par la CLI). */
+export declare function chargerOptions(racine: string): Promise<OptionsCms>;

package/dist/integration.js

@@ -0,0 +1,91 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { chargerConfigAstro } from './noyau/charger.js';
+import { formaterViolations } from './noyau/contenus.js';
+import { MOTIF_SRC_IMAGE, MOTIF_URL_SITE } from './motifs.js';
+import { ErreurCms } from './noyau/erreurs.js';
+import { synchroniser, verifier } from './noyau/operations.js';
+import { ecrireVersion } from './noyau/version.js';
+const NOM = '@komekoo/astro-cms';
+/** `Symbol.for` : la même clé que l'intégration soit chargée par Node ou par Vite (`chargerOptions`). */
+export const OPTIONS = Symbol.for('@komekoo/astro-cms/options');
+const estTexte = (v) => typeof v === 'string' && v.trim() !== '';
+/** Options passées depuis `astro.config.mjs` (JavaScript, non typé) : vérifiées à l'appel de `cms()`. */
+function verifierOptions(options) {
+    const o = (typeof options === 'object' && options !== null ? options : {});
+    for (const cle of ['site', 'contact']) {
+        if (!estTexte(o[cle]))
+            throw new ErreurCms(`${NOM} : option « ${cle} » obligatoire (texte non vide)`, 'astro.config.mjs');
+    }
+    const hp = o.horsPerimetre;
+    if (hp !== undefined && !(Array.isArray(hp) && hp.every((x) => typeof x === 'string'))) {
+        throw new ErreurCms(`${NOM} : option « horsPerimetre » doit être une liste de textes`, 'astro.config.mjs');
+    }
+    const refuser = (cle, attendu) => {
+        throw new ErreurCms(`${NOM} : option « ${cle} » ${attendu}`, 'astro.config.mjs');
+    };
+    if (!estTexte(o.url) || !MOTIF_URL_SITE.test(o.url) || o.url.endsWith('/')) {
+        refuser('url', 'obligatoire : adresse https sans « / » final (ex. https://exemple.fr)');
+    }
+    const admin = o.admin;
+    if (admin === undefined)
+        return;
+    if (typeof admin !== 'object' || admin === null || Array.isArray(admin)) {
+        return refuser('admin', 'doit être un objet { accent?, logo?, origine? }');
+    }
+    const { accent, logo, origine } = admin;
+    if (accent !== undefined && !(typeof accent === 'string' && /^#[0-9A-Fa-f]{6}$/.test(accent))) {
+        refuser('admin.accent', 'doit être une couleur au format #RRGGBB');
+    }
+    if (logo !== undefined && !(typeof logo === 'string' && MOTIF_SRC_IMAGE.test(logo))) {
+        refuser('admin.logo', 'doit être une image téléversée (/uploads/…-2400.webp)');
+    }
+    if (origine !== undefined && !(typeof origine === 'string' && /^https:\/\/[^\s/]+$/.test(origine))) {
+        refuser('admin.origine', 'doit être une origine https sans chemin (ex. https://admin.exemple.fr)');
+    }
+}
+export default function cms(options) {
+    verifierOptions(options);
+    return {
+        name: NOM,
+        [OPTIONS]: options,
+        hooks: {
+            'astro:config:setup': async ({ config, command, addWatchFile, logger }) => {
+                const racine = fileURLToPath(config.root);
+                if (command === 'dev' || command === 'sync')
+                    await synchroniser(racine, options);
+                if (command === 'dev')
+                    addWatchFile(path.join(racine, 'src/content.config.ts'));
+                // Avant la synchronisation de contenu d'Astro (glob loader), qui s'arrête à la première erreur Zod.
+                if (command === 'build') {
+                    const violations = await verifier(racine, options);
+                    if (violations.length === 0)
+                        return;
+                    logger.error(formaterViolations(violations));
+                    throw new ErreurCms(`${violations.length} problème(s) de contenu`);
+                }
+            },
+            'astro:build:done': async ({ dir }) => {
+                await ecrireVersion(fileURLToPath(dir), process.env.CF_PAGES_COMMIT_SHA ?? 'inconnu', options.admin?.origine ?? 'https://cms.komekoo.link');
+            },
+        },
+    };
+}
+function aplatir(valeur) {
+    return Array.isArray(valeur) ? valeur.flatMap(aplatir) : [valeur];
+}
+/** Retrouve les options passées à `cms()` dans `astro.config.mjs` (utilisé par la CLI). */
+export async function chargerOptions(racine) {
+    const config = await chargerConfigAstro(racine);
+    const integrations = config?.integrations;
+    for (const integration of aplatir(integrations)) {
+        if (typeof integration !== 'object' || integration === null)
+            continue;
+        if (integration.name !== NOM)
+            continue;
+        const options = integration[OPTIONS];
+        if (options !== undefined)
+            return options;
+    }
+    throw new ErreurCms(`intégration ${NOM} absente de astro.config.mjs`);
+}

package/dist/motifs.d.ts

@@ -0,0 +1,8 @@
+export declare const MOTIF_SRC_IMAGE: RegExp;
+/**
+ * Schéma autorisé, puis aucun espace ni caractère de contrôle : les navigateurs suppriment tabulations et sauts
+ * de ligne (`/\t/evil.com` → `//evil.com`), d'où leur exclusion aussi juste après la barre oblique initiale.
+ */
+export declare const MOTIF_LIEN: RegExp;
+/** Adresse publique du site : https, sans espace, sans « ? » ni « # » (le « / » final est refusé à part). */
+export declare const MOTIF_URL_SITE: RegExp;

package/dist/motifs.js

@@ -0,0 +1,9 @@
+// Motifs partagés entre le schéma (`champs.ts`, qui dépend d'Astro) et le navigateur : aucun import ici.
+export const MOTIF_SRC_IMAGE = /^\/uploads\/(?:[a-z0-9-]+\/)*[a-z0-9-]+-2400\.webp$/;
+/**
+ * Schéma autorisé, puis aucun espace ni caractère de contrôle : les navigateurs suppriment tabulations et sauts
+ * de ligne (`/\t/evil.com` → `//evil.com`), d'où leur exclusion aussi juste après la barre oblique initiale.
+ */
+export const MOTIF_LIEN = /^(https:\/\/[^\s\x00-\x1f]|\/(?![\/\\\s])|mailto:|tel:)[^\s\x00-\x1f]*$/;
+/** Adresse publique du site : https, sans espace, sans « ? » ni « # » (le « / » final est refusé à part). */
+export const MOTIF_URL_SITE = /^https:\/\/[^\s/?#]+(\/[^\s?#]*)?$/;

package/dist/navigateur.d.ts

@@ -0,0 +1,5 @@
+export { creerAjv, MOTS_CLES_CMS } from './ajv.js';
+export { validerMarkdown } from './noyau/markdown.js';
+export type { Violation } from './noyau/markdown.js';
+export { lireFrontmatter, ecrireFrontmatter } from './noyau/frontmatter.js';
+export { MOTIF_LIEN, MOTIF_SRC_IMAGE, MOTIF_URL_SITE } from './motifs.js';

package/dist/navigateur.js

@@ -0,0 +1,5 @@
+// Point d'entrée sûr pour le navigateur : n'importe rien de `node:*`, `astro` ni `vite`.
+export { creerAjv, MOTS_CLES_CMS } from './ajv.js';
+export { validerMarkdown } from './noyau/markdown.js';
+export { lireFrontmatter, ecrireFrontmatter } from './noyau/frontmatter.js';
+export { MOTIF_LIEN, MOTIF_SRC_IMAGE, MOTIF_URL_SITE } from './motifs.js';

package/dist/noyau/charger.d.ts

@@ -0,0 +1,4 @@
+/** Charge `src/content.config.ts` du site et renvoie ses `collections`. */
+export declare function chargerCollections(racine: string): Promise<Record<string, unknown>>;
+/** Charge `astro.config.mjs` et renvoie son export par défaut. */
+export declare function chargerConfigAstro(racine: string): Promise<unknown>;