create-snapify-app 0.0.0-stage → 1.1.0

package/template/sdk/package.ts

@@ -0,0 +1,298 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+/**
+ * Format de paquet `.snapmod` (Node uniquement) : JSON compressé gzip contenant le manifeste
+ * empaqueté, les fichiers en base64, la signature Ed25519 du manifeste et, pour un module
+ * gratuit, sa licence signée. Le manifeste liste l'empreinte SHA-256 de chaque fichier :
+ * signer le manifeste revient donc à signer tout le contenu.
+ */
+import crypto from 'crypto';
+import zlib from 'zlib';
+import {
+  LICENSE_KEY_PREFIX,
+  MODULE_ID_PATTERN,
+  MODULE_SLOTS,
+  PERMISSION_PATTERN,
+  ROUTE_PATTERN_PUBLIC,
+  SCREENSHOT_FILES,
+  SEMVER_PATTERN,
+  type LicensePayload,
+  type PackageKind,
+  type PackagedManifest,
+  type Signature,
+  type SignedLicense,
+} from './index';
+import { checkFieldDefinition } from './settings';
+
+export const PACKAGE_FORMAT = 'snapmod/1';
+export const PACKAGE_EXTENSION = '.snapmod';
+export const THEME_PACKAGE_EXTENSION = '.snaptheme';
+export const PACKAGE_EXTENSIONS = [PACKAGE_EXTENSION, THEME_PACKAGE_EXTENSION];
+export const packageExtension = (kind: PackageKind) => (kind === 'theme' ? THEME_PACKAGE_EXTENSION : PACKAGE_EXTENSION);
+export const MAX_PACKAGE_BYTES = 20 * 1024 * 1024;
+const MAX_UNPACKED_BYTES = 40 * 1024 * 1024;
+
+/** Seuls ces fichiers peuvent figurer dans un paquet. */
+export const PACKAGE_FILES = ['public.js', 'public.css', 'server.mjs', 'admin.js', 'admin.css', 'README.md', ...SCREENSHOT_FILES] as const;
+
+export interface ModulePackage {
+  format: typeof PACKAGE_FORMAT;
+  manifest: PackagedManifest;
+  files: Record<string, string>;
+  signature?: Signature;
+  license?: SignedLicense;
+}
+
+export class PackageError extends Error {}
+
+/* ------------------------------------------------------------------ */
+/* Primitives                                                          */
+/* ------------------------------------------------------------------ */
+
+/** JSON à clés triées : représentation stable et donc signable. */
+export function canonicalJson(value: unknown): string {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
+  const entries = Object.entries(value as Record<string, unknown>)
+    .filter(([, v]) => v !== undefined)
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(',')}}`;
+}
+
+export const sha256 = (data: Buffer | string) => crypto.createHash('sha256').update(data).digest('hex');
+
+export function publicKeyFromBase64(b64: string): crypto.KeyObject {
+  return crypto.createPublicKey({ key: Buffer.from(b64, 'base64'), format: 'der', type: 'spki' });
+}
+
+export function sign(data: unknown, privateKeyPem: string, kid: string): Signature {
+  const value = crypto.sign(null, Buffer.from(canonicalJson(data)), crypto.createPrivateKey(privateKeyPem)).toString('base64');
+  return { alg: 'ed25519', kid, value };
+}
+
+/** `trusted` : identifiant de clé → clé publique SPKI encodée en base64. */
+export function verify(data: unknown, signature: Signature | undefined, trusted: Record<string, string>): boolean {
+  if (!signature || signature.alg !== 'ed25519' || typeof signature.value !== 'string') return false;
+  const key = trusted[signature.kid];
+  if (!key) return false;
+  try {
+    return crypto.verify(null, Buffer.from(canonicalJson(data)), publicKeyFromBase64(key), Buffer.from(signature.value, 'base64'));
+  } catch {
+    return false;
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* Versions                                                            */
+/* ------------------------------------------------------------------ */
+
+function parseVersion(v: string): [number, number, number] | null {
+  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+
+export function compareVersions(a: string, b: string): number {
+  const pa = parseVersion(a) ?? [0, 0, 0];
+  const pb = parseVersion(b) ?? [0, 0, 0];
+  for (let i = 0; i < 3; i++) if (pa[i] !== pb[i]) return pa[i] - pb[i];
+  return 0;
+}
+
+/** Plages acceptées : `*`, `1.2.3`, `>=1.2.3`, `^1.2.3`. */
+export function satisfies(version: string, range: string): boolean {
+  const r = range.trim();
+  if (r === '*') return true;
+  if (r.startsWith('>=')) return compareVersions(version, r.slice(2)) >= 0;
+  if (r.startsWith('^')) {
+    const base = parseVersion(r.slice(1));
+    const v = parseVersion(version);
+    if (!base || !v) return false;
+    return v[0] === base[0] && compareVersions(version, r.slice(1)) >= 0;
+  }
+  return compareVersions(version, r) === 0;
+}
+
+/* ------------------------------------------------------------------ */
+/* Manifeste                                                           */
+/* ------------------------------------------------------------------ */
+
+const isStr = (v: unknown, max: number) => typeof v === 'string' && v.trim().length > 0 && v.length <= max;
+
+/** Contrôle structurel d'un manifeste ; `packaged` exige les champs ajoutés à l'empaquetage. */
+export function checkManifest(m: PackagedManifest, packaged: boolean): string[] {
+  const issues: string[] = [];
+  if (!m || typeof m !== 'object') return ['manifeste absent'];
+  if (typeof m.id !== 'string' || m.id.length > 64 || !MODULE_ID_PATTERN.test(m.id)) issues.push('identifiant invalide (format éditeur.module)');
+  if (typeof m.version !== 'string' || !SEMVER_PATTERN.test(m.version)) issues.push('version invalide (semver attendu)');
+  if (!isStr(m.name, 60)) issues.push('nom invalide');
+  if (!isStr(m.description, 500)) issues.push('description invalide');
+  if (!m.author || !isStr(m.author.name, 120)) issues.push('auteur invalide');
+  if (m.pricing !== 'free' && m.pricing !== 'paid') issues.push('tarification invalide (free ou paid)');
+  if (!m.engines || !isStr(m.engines.snapify, 40)) issues.push('engines.snapify manquant');
+  if (m.icon !== undefined && !/^[a-z0-9-]{1,40}$/.test(m.icon)) issues.push('icône invalide');
+  if (!Array.isArray(m.permissions) || m.permissions.some((p) => typeof p !== 'string' || !PERMISSION_PATTERN.test(p))) issues.push('permissions invalides');
+  else if (new Set(m.permissions).size !== m.permissions.length) issues.push('permissions en double');
+  if (!Array.isArray(m.slots) || m.slots.some((s) => !MODULE_SLOTS.includes(s))) issues.push('emplacements invalides');
+  if (!Array.isArray(m.settings)) issues.push('réglages invalides');
+  else {
+    m.settings.forEach((f) => issues.push(...checkFieldDefinition(f)));
+    if (new Set(m.settings.map((f) => f.key)).size !== m.settings.length) issues.push('clés de réglage en double');
+  }
+  if (m.kind !== undefined && m.kind !== 'module' && m.kind !== 'theme') issues.push('type de paquet invalide (module ou theme)');
+  if (m.kind === 'theme') {
+    if (m.permissions?.length) issues.push('un thème ne peut pas demander de permissions');
+    if (m.slots?.length) issues.push('un thème ne déclare pas d’emplacements');
+    if (m.entries?.server) issues.push('un thème ne peut pas contenir de code serveur');
+    if (m.entries?.admin) issues.push('un thème ne peut pas contenir de pages d’administration');
+    if (!m.entries?.public) issues.push('entrée public obligatoire pour un thème');
+    if (m.routes?.length || m.widgets?.length || m.adminPages?.length || m.requires || m.uses?.length) issues.push('routes, widgets, pages d’administration et dépendances sont réservés aux modules');
+  }
+  issues.push(...checkExtensions(m));
+  if (m.screenshot !== undefined && (typeof m.screenshot !== 'string' || (packaged && !(SCREENSHOT_FILES as readonly string[]).includes(m.screenshot)))) {
+    issues.push('capture d’écran invalide');
+  }
+  if (!m.entries || typeof m.entries !== 'object' || (!m.entries.public && !m.entries.server && !m.entries.admin)) issues.push('aucune entrée public/server/admin');
+  if (m.slots?.length && !m.entries?.public) issues.push('emplacements déclarés sans entrée public');
+  if ((m.routes?.length || m.widgets?.length) && !m.entries?.public) issues.push('routes ou widgets déclarés sans entrée public');
+  if (m.adminPages?.length && !m.entries?.admin) issues.push('pages d’administration déclarées sans entrée admin');
+  if (packaged) {
+    if (m.entries?.public && m.entries.public !== 'public.js') issues.push('entrée public empaquetée invalide');
+    if (m.entries?.server && m.entries.server !== 'server.mjs') issues.push('entrée server empaquetée invalide');
+    if (m.entries?.admin && m.entries.admin !== 'admin.js') issues.push('entrée admin empaquetée invalide');
+    if (!m.files || typeof m.files !== 'object') issues.push('liste des fichiers manquante');
+    else {
+      for (const [name, meta] of Object.entries(m.files)) {
+        if (!(PACKAGE_FILES as readonly string[]).includes(name)) issues.push(`fichier non autorisé : ${name}`);
+        if (!meta || !/^[a-f0-9]{64}$/.test(meta.sha256) || !Number.isInteger(meta.size) || meta.size < 0) issues.push(`empreinte invalide : ${name}`);
+      }
+      for (const entry of [m.entries?.public, m.entries?.server, m.entries?.admin, m.styles, m.adminStyles, m.screenshot]) if (entry && !m.files[entry]) issues.push(`fichier manquant : ${entry}`);
+    }
+  }
+  return issues;
+}
+
+const LOCAL_ID = /^[a-z][a-z0-9-]{0,39}$/;
+
+/** Routes publiques, widgets, pages d'administration et dépendances (API 1.2). */
+function checkExtensions(m: PackagedManifest): string[] {
+  const issues: string[] = [];
+  if (m.routes !== undefined) {
+    if (!Array.isArray(m.routes) || m.routes.length > 20 || m.routes.some((r) => typeof r !== 'string' || r === '/' || r === '/*' || !ROUTE_PATTERN_PUBLIC.test(r))) {
+      issues.push('routes invalides (ex. /boutique/* ou /panier/)');
+    } else if (m.routes.some((r) => /^\/(administrator|api|_modules|uploads|blog)\//.test(r))) issues.push('route réservée par Snapify');
+  }
+  if (m.widgets !== undefined) {
+    if (!Array.isArray(m.widgets) || m.widgets.length > 20) issues.push('widgets invalides');
+    else {
+      for (const w of m.widgets) {
+        if (!w || !LOCAL_ID.test(w.id ?? '')) issues.push('identifiant de widget invalide');
+        if (!isStr(w?.label, 60)) issues.push(`widget « ${w?.id} » : libellé invalide`);
+        if (!Array.isArray(w?.fields)) issues.push(`widget « ${w?.id} » : champs invalides`);
+        else w.fields.forEach((f) => issues.push(...checkFieldDefinition(f).map((i) => `widget « ${w.id} » : ${i}`)));
+      }
+      if (new Set(m.widgets.map((w) => w?.id)).size !== m.widgets.length) issues.push('widgets en double');
+    }
+  }
+  if (m.adminPages !== undefined) {
+    if (!Array.isArray(m.adminPages) || m.adminPages.length > 10) issues.push('pages d’administration invalides');
+    else {
+      for (const p of m.adminPages) {
+        if (!p || !LOCAL_ID.test(p.id ?? '')) issues.push('identifiant de page d’administration invalide');
+        if (!isStr(p?.label, 40)) issues.push(`page d’administration « ${p?.id} » : libellé invalide`);
+        if (p?.icon !== undefined && !/^[a-z0-9-]{1,40}$/.test(p.icon)) issues.push(`page d’administration « ${p.id} » : icône invalide`);
+      }
+      if (new Set(m.adminPages.map((p) => p?.id)).size !== m.adminPages.length) issues.push('pages d’administration en double');
+    }
+  }
+  if (m.requires !== undefined) {
+    if (!m.requires || typeof m.requires !== 'object' || Array.isArray(m.requires)) issues.push('dépendances invalides');
+    else {
+      for (const [id, range] of Object.entries(m.requires)) {
+        if (!MODULE_ID_PATTERN.test(id) || id === m.id || !isStr(range, 40)) issues.push(`dépendance invalide : ${id}`);
+      }
+    }
+  }
+  if (m.uses !== undefined && (!Array.isArray(m.uses) || m.uses.some((id) => typeof id !== 'string' || !MODULE_ID_PATTERN.test(id) || id === m.id))) {
+    issues.push('modules facultatifs invalides');
+  }
+  return issues;
+}
+
+/* ------------------------------------------------------------------ */
+/* Paquet                                                              */
+/* ------------------------------------------------------------------ */
+
+export function encodePackage(pkg: ModulePackage): Buffer {
+  return zlib.gzipSync(Buffer.from(JSON.stringify(pkg)), { level: 9 });
+}
+
+/** Décompresse et contrôle un paquet : structure, manifeste et empreintes des fichiers. */
+export function decodePackage(buf: Buffer): { pkg: ModulePackage; files: Map<string, Buffer> } {
+  if (buf.length > MAX_PACKAGE_BYTES) throw new PackageError('Paquet trop volumineux (20 Mo maximum)');
+  let pkg: ModulePackage;
+  try {
+    pkg = JSON.parse(zlib.gunzipSync(buf, { maxOutputLength: MAX_UNPACKED_BYTES }).toString('utf8'));
+  } catch {
+    throw new PackageError('Fichier illisible : ce n’est pas un paquet .snapmod valide');
+  }
+  if (!pkg || pkg.format !== PACKAGE_FORMAT) throw new PackageError('Format de paquet non pris en charge');
+  const issues = checkManifest(pkg.manifest, true);
+  if (issues.length) throw new PackageError(`Manifeste invalide : ${issues.join(', ')}`);
+  if (!pkg.files || typeof pkg.files !== 'object') throw new PackageError('Paquet sans fichiers');
+
+  const files = new Map<string, Buffer>();
+  const declared = Object.keys(pkg.manifest.files).sort();
+  const shipped = Object.keys(pkg.files).sort();
+  if (canonicalJson(declared) !== canonicalJson(shipped)) throw new PackageError('Les fichiers du paquet ne correspondent pas au manifeste');
+  for (const name of declared) {
+    const data = Buffer.from(String(pkg.files[name]), 'base64');
+    const meta = pkg.manifest.files[name];
+    if (data.length !== meta.size || sha256(data) !== meta.sha256) throw new PackageError(`Fichier altéré : ${name}`);
+    files.set(name, data);
+  }
+  return { pkg, files };
+}
+
+/* ------------------------------------------------------------------ */
+/* Licences                                                            */
+/* ------------------------------------------------------------------ */
+
+export function encodeLicenseKey(license: SignedLicense): string {
+  return LICENSE_KEY_PREFIX + Buffer.from(JSON.stringify(license)).toString('base64url');
+}
+
+export function decodeLicenseKey(key: string): SignedLicense {
+  const trimmed = key.replace(/\s+/g, '');
+  if (!trimmed.startsWith(LICENSE_KEY_PREFIX)) throw new PackageError('Clé de licence invalide');
+  try {
+    const parsed = JSON.parse(Buffer.from(trimmed.slice(LICENSE_KEY_PREFIX.length), 'base64url').toString('utf8')) as SignedLicense;
+    if (!parsed?.payload || !parsed.signature) throw new Error();
+    return parsed;
+  } catch {
+    throw new PackageError('Clé de licence illisible');
+  }
+}
+
+export function checkLicensePayload(p: LicensePayload): string[] {
+  const issues: string[] = [];
+  if (!p || p.v !== 1) return ['version de licence inconnue'];
+  if (!isStr(p.licenseId, 80)) issues.push('identifiant de licence invalide');
+  if (typeof p.moduleId !== 'string' || !MODULE_ID_PATTERN.test(p.moduleId)) issues.push('module invalide');
+  if (!isStr(p.licensee, 160)) issues.push('titulaire invalide');
+  if (!['free', 'standard', 'pro', 'enterprise'].includes(p.plan)) issues.push('formule invalide');
+  if (!Array.isArray(p.domains) || !p.domains.length || p.domains.some((d) => typeof d !== 'string' || !/^(\*|(\*\.)?[a-z0-9.-]+)$/.test(d))) issues.push('domaines invalides');
+  if (Number.isNaN(Date.parse(p.issuedAt))) issues.push('date d’émission invalide');
+  if (p.expiresAt !== null && Number.isNaN(Date.parse(p.expiresAt))) issues.push('date d’expiration invalide');
+  return issues;
+}
+
+/** Le domaine du site est-il couvert par la licence ? `localhost` est toujours accepté pour le développement. */
+export function domainAllowed(domains: string[], host: string): boolean {
+  const h = host.toLowerCase().replace(/^www\./, '');
+  if (h === 'localhost' || h === '127.0.0.1') return true;
+  return domains.some((d) => d === '*' || d === h || (d.startsWith('*.') && (h === d.slice(2) || h.endsWith(d.slice(1)))));
+}

package/template/sdk/recaptcha.tsx

@@ -0,0 +1,122 @@
+/**
+ * Snapify — champ reCAPTCHA pour les formulaires publics (module hamdiayari.recaptcha)
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ */
+import { useEffect, useRef, useState } from 'react';
+
+export type RecaptchaPublicConfig = {
+  siteKey: string;
+  version: 'v2' | 'v3';
+  action?: string;
+};
+
+declare global {
+  interface Window {
+    grecaptcha?: {
+      ready: (cb: () => void) => void;
+      render: (el: HTMLElement, opts: Record<string, unknown>) => number;
+      getResponse: (id?: number) => string;
+      reset: (id?: number) => void;
+      execute: (siteKey: string, opts: { action: string }) => Promise<string>;
+    };
+    __snapifyRecaptcha?: {
+      siteKey: string;
+      version: 'v2' | 'v3';
+      action: string;
+      getToken: () => Promise<string>;
+    };
+  }
+}
+
+const SCRIPT_ID = 'snapify-recaptcha-script';
+
+function ensureScript(siteKey: string, version: 'v2' | 'v3') {
+  if (document.getElementById(SCRIPT_ID)) return;
+  const s = document.createElement('script');
+  s.id = SCRIPT_ID;
+  s.async = true;
+  s.defer = true;
+  s.src =
+    version === 'v3'
+      ? `https://www.google.com/recaptcha/api.js?render=${encodeURIComponent(siteKey)}`
+      : 'https://www.google.com/recaptcha/api.js?render=explicit';
+  document.head.appendChild(s);
+}
+
+/** Récupère un jeton (v2 widget ou v3 execute). */
+export async function getRecaptchaToken(cfg?: RecaptchaPublicConfig | null): Promise<string> {
+  if (window.__snapifyRecaptcha?.getToken) return window.__snapifyRecaptcha.getToken();
+  if (!cfg?.siteKey) return '';
+  const version = cfg.version === 'v3' ? 'v3' : 'v2';
+  ensureScript(cfg.siteKey, version);
+  await new Promise<void>((resolve, reject) => {
+    let n = 0;
+    const tick = () => {
+      if (window.grecaptcha) return resolve();
+      if (n++ > 50) return reject(new Error('reCAPTCHA indisponible'));
+      setTimeout(tick, 100);
+    };
+    tick();
+  });
+  return new Promise((resolve, reject) => {
+    window.grecaptcha!.ready(() => {
+      if (version === 'v3') {
+        window
+          .grecaptcha!.execute(cfg.siteKey, { action: cfg.action || 'contact' })
+          .then(resolve)
+          .catch(() => reject(new Error('reCAPTCHA v3 impossible')));
+      } else {
+        const token = window.grecaptcha!.getResponse();
+        if (!token) reject(new Error('Cochez la case « Je ne suis pas un robot ».'));
+        else resolve(token);
+      }
+    });
+  });
+}
+
+/** Widget v2 (case à cocher). Invisible pour v3. */
+export function RecaptchaField({ config }: { config?: RecaptchaPublicConfig | null }) {
+  const ref = useRef<HTMLDivElement>(null);
+  const widgetId = useRef<number | null>(null);
+  const [err, setErr] = useState('');
+
+  useEffect(() => {
+    if (!config?.siteKey || config.version === 'v3') return;
+    ensureScript(config.siteKey, 'v2');
+    let cancelled = false;
+    const tryRender = (n = 0) => {
+      if (cancelled || !ref.current) return;
+      if (!window.grecaptcha) {
+        if (n < 50) setTimeout(() => tryRender(n + 1), 100);
+        else setErr('Impossible de charger reCAPTCHA.');
+        return;
+      }
+      window.grecaptcha.ready(() => {
+        if (cancelled || !ref.current || widgetId.current !== null) return;
+        try {
+          widgetId.current = window.grecaptcha!.render(ref.current, {
+            sitekey: config.siteKey,
+            theme: 'light',
+          });
+        } catch {
+          setErr('Widget reCAPTCHA indisponible.');
+        }
+      });
+    };
+    tryRender();
+    return () => {
+      cancelled = true;
+    };
+  }, [config?.siteKey, config?.version]);
+
+  if (!config?.siteKey) return null;
+  if (config.version === 'v3') {
+    return <p className="text-[11px] text-slate-400">Protection anti-robot Google reCAPTCHA activée.</p>;
+  }
+  return (
+    <div className="space-y-1">
+      <div ref={ref} className="g-recaptcha" />
+      {err ? <p className="text-xs text-rose-600">{err}</p> : null}
+    </div>
+  );
+}

package/template/sdk/settings.ts

@@ -0,0 +1,84 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+import type { SettingField, SettingFieldType } from './index';
+
+export const SETTING_TYPES: readonly SettingFieldType[] = ['boolean', 'text', 'textarea', 'number', 'select', 'phone', 'paths'];
+export const SETTING_KEY_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]{0,40}$/;
+
+const MAX_TEXT = 20_000;
+const MAX_PATHS = 100;
+
+/** Valeurs par défaut du manifeste. */
+export function defaultSettings(fields: SettingField[]): Record<string, unknown> {
+  return Object.fromEntries(fields.map((f) => [f.key, structuredClone(f.default)]));
+}
+
+function checkValue(field: SettingField, value: unknown): string | null {
+  switch (field.type) {
+    case 'boolean':
+      return typeof value === 'boolean' ? null : 'Valeur oui/non attendue';
+    case 'number': {
+      if (typeof value !== 'number' || !Number.isFinite(value)) return 'Nombre attendu';
+      if (field.min !== undefined && value < field.min) return `Minimum ${field.min}`;
+      if (field.max !== undefined && value > field.max) return `Maximum ${field.max}`;
+      return null;
+    }
+    case 'text':
+    case 'textarea':
+    case 'phone': {
+      if (typeof value !== 'string') return 'Texte attendu';
+      if (value.length > (field.maxLength ?? MAX_TEXT)) return `${field.maxLength ?? MAX_TEXT} caractères maximum`;
+      if (field.required && !value.trim()) return 'Champ obligatoire';
+      if (field.type === 'phone' && value.trim() && value.replace(/\D/g, '').length < 8) return 'Numéro trop court';
+      return null;
+    }
+    case 'select':
+      return typeof value === 'string' && (field.options ?? []).some((o) => o.value === value) ? null : 'Option inconnue';
+    case 'paths':
+      if (!Array.isArray(value) || value.length > MAX_PATHS) return 'Liste d’adresses invalide';
+      return value.every((p) => typeof p === 'string' && /^\/[^\s]{0,200}$/.test(p)) ? null : 'Chaque adresse doit commencer par /';
+  }
+}
+
+/**
+ * Valide un objet de réglages selon le manifeste. Les clés inconnues sont ignorées,
+ * les clés absentes reprennent la valeur `base` (réglages courants) puis la valeur par défaut.
+ */
+export function validateSettings(
+  fields: SettingField[],
+  input: unknown,
+  base: Record<string, unknown> = {}
+): { value: Record<string, unknown>; errors: Record<string, string> } {
+  const source = input && typeof input === 'object' && !Array.isArray(input) ? (input as Record<string, unknown>) : {};
+  const value: Record<string, unknown> = {};
+  const errors: Record<string, string> = {};
+  for (const field of fields) {
+    const candidate = field.key in source ? source[field.key] : field.key in base ? base[field.key] : field.default;
+    const error = checkValue(field, candidate);
+    if (error) errors[field.key] = error;
+    value[field.key] = error ? structuredClone(field.default) : structuredClone(candidate);
+  }
+  return { value, errors };
+}
+
+/** Réglages destinés au navigateur des visiteurs (`public: true`). */
+export function publicSettings(fields: SettingField[], settings: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(fields.filter((f) => f.public).map((f) => [f.key, settings[f.key]]));
+}
+
+/** Vérifie la cohérence d'une définition de champ ; renvoie la liste des problèmes. */
+export function checkFieldDefinition(field: SettingField): string[] {
+  const issues: string[] = [];
+  const where = `réglage « ${field?.key ?? '?'} »`;
+  if (!field || typeof field !== 'object') return ['définition de réglage invalide'];
+  if (!SETTING_KEY_PATTERN.test(field.key ?? '')) issues.push(`${where} : clé invalide`);
+  if (!SETTING_TYPES.includes(field.type)) issues.push(`${where} : type inconnu`);
+  if (typeof field.label !== 'string' || !field.label.trim() || field.label.length > 120) issues.push(`${where} : libellé invalide`);
+  if (field.type === 'select' && (!Array.isArray(field.options) || field.options.length === 0)) issues.push(`${where} : options manquantes`);
+  if (SETTING_TYPES.includes(field.type) && checkValue({ ...field, required: false }, field.default)) issues.push(`${where} : valeur par défaut invalide`);
+  return issues;
+}

package/template/sdk/theme.css

@@ -0,0 +1,29 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+/*
+ * Jetons de marque disponibles dans les modules (bg-px-navy, text-px-primary…).
+ * Les valeurs proviennent des variables CSS du site : un module suit automatiquement
+ * l'identité visuelle configurée dans l'administration.
+ */
+@theme inline reference {
+  --color-px-primary: var(--px-primary);
+  --color-px-primary-dark: var(--px-primary-dark);
+  --color-px-primary-light: var(--px-primary-light);
+  --color-px-accent: var(--px-accent);
+  --color-px-accent-mid: var(--px-accent-mid);
+  --color-px-accent-light: var(--px-accent-light);
+  --color-px-navy: var(--px-navy);
+  --color-px-navy-2: var(--px-navy-2);
+  --color-px-surface: var(--px-surface);
+  --color-px-surface-2: var(--px-surface-2);
+  --color-px-border: var(--px-border);
+  --color-px-border-soft: var(--px-border-soft);
+  --color-px-text: var(--px-text);
+  --color-px-muted: var(--px-muted);
+  --font-sans: var(--px-font-body), system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  --font-heading: var(--px-font-heading), var(--px-font-body), system-ui, sans-serif;
+}

package/template/sdk/theme.ts

@@ -0,0 +1,100 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+/**
+ * Contrat d'un thème : composants de présentation (en-tête, pied de page, rendu des blocs…).
+ * Le site hôte charge les données, gère la navigation, l'aperçu et les modules ; le thème
+ * ne fait qu'afficher. React et le contexte du site sont fournis par l'hôte à l'exécution.
+ */
+import { createElement, useContext, type ComponentType, type Context, type ReactNode } from 'react';
+import type { BlockDataMap, BlockKind, BlockStyle, BlogPost, CmsPage, SiteConfigPayload, SiteInfo, TokenValues } from './content';
+
+export interface ThemeRuntimeValue<S = Record<string, unknown>> {
+  site: SiteConfigPayload;
+  info: SiteInfo;
+  /** Valeurs des variables {{telephone}}, {{email}}… utilisables dans les textes. */
+  tokens: TokenValues;
+  /** Options du thème choisies dans « Apparence > Personnaliser ». */
+  settings: S;
+  /** Adresse de la page affichée, toujours terminée par `/`. */
+  path: string;
+  navigate: (path: string) => void;
+  openCookies: () => void;
+  /** Site affiché dans l'aperçu de l'administration (aucune action réelle : formulaires, liens externes). */
+  isPreview: boolean;
+}
+
+export interface ThemeChromeProps {
+  path: string;
+  navigate: (path: string) => void;
+  openCookies: () => void;
+}
+
+export interface BlockProps<K extends BlockKind> {
+  /** Données du bloc, complétées par les valeurs par défaut. */
+  d: BlockDataMap[K];
+  style: BlockStyle;
+}
+
+export type BlockRenderers = { [K in BlockKind]: ComponentType<BlockProps<K>> };
+
+export interface ThemeDefinition {
+  Header: ComponentType<ThemeChromeProps>;
+  Footer: ComponentType<ThemeChromeProps>;
+  /** Rendu de chaque type de bloc. Un bloc sans rendu n'est pas affiché. */
+  blocks: Partial<BlockRenderers>;
+  /** Enveloppe de tout le site : applique les options du thème (variables CSS, classes…). */
+  Layout?: ComponentType<{ children: ReactNode }>;
+  /** Mise en page d'une page ; `children` contient les blocs déjà rendus. */
+  Page?: ComponentType<{ page: CmsPage; children: ReactNode }>;
+  /** Mise en page d'un article ; `children` contient les blocs déjà rendus. */
+  Post?: ComponentType<{ post: BlogPost; children: ReactNode }>;
+  NotFound?: ComponentType<{ navigate: (path: string) => void }>;
+}
+
+export function defineTheme(theme: ThemeDefinition): ThemeDefinition {
+  return theme;
+}
+
+interface HostRuntime {
+  ThemeContext?: Context<ThemeRuntimeValue | null>;
+  isPreview?: boolean;
+  ModuleSlot?: ComponentType<{ name: ModuleSlotName }>;
+  activeModules?: string[];
+  slotModules?: Partial<Record<ModuleSlotName, string[]>>;
+}
+
+const host = () => (globalThis as { __SNAPIFY_RUNTIME__?: HostRuntime }).__SNAPIFY_RUNTIME__;
+
+/** Emplacements que le thème place lui-même dans sa mise en page. */
+export type ModuleSlotName = 'header-actions';
+
+/**
+ * Affiche les éléments des modules actifs pour cet emplacement (ex. icônes panier et compte
+ * dans l'en-tête). Rien n'est rendu si aucun module ne l'utilise.
+ */
+export function ModuleSlot({ name }: { name: ModuleSlotName }) {
+  const Slot = host()?.ModuleSlot;
+  return Slot ? createElement(Slot, { name }) : null;
+}
+
+/** Un module actif occupe-t-il cet emplacement ? */
+export const hasModuleSlot = (name: ModuleSlotName): boolean => !!host()?.slotModules?.[name]?.length;
+
+/** Module actif sur le site (ex. `novalabs.shop`). */
+export const isModuleActive = (id: string): boolean => !!host()?.activeModules?.includes(id);
+
+/** Données du site et options du thème. Utilisable dans tout composant du thème. */
+export function useSnapify<S = Record<string, unknown>>(): ThemeRuntimeValue<S> {
+  const ctx = host()?.ThemeContext;
+  if (!ctx) throw new Error('useSnapify() doit être utilisé dans un thème chargé par Snapify');
+  const value = useContext(ctx);
+  if (!value) throw new Error('useSnapify() appelé hors du site');
+  return value as ThemeRuntimeValue<S>;
+}
+
+/** Équivalent hors composant de `useSnapify().isPreview`. */
+export const isPreviewMode = (): boolean => !!host()?.isPreview;