@fraza/start 0.0.0-stage → 0.3.4

package/CHANGELOG.md

@@ -0,0 +1,180 @@
+# Journal des versions
+
+Historique des versions publiées de `@fraza/start`.
+
+Ce fichier est généré par `fraza-module changelog` à partir des messages de commit. Ne pas le modifier à la main.
+
+## 0.3.4 (2026-10-25)
+
+### Documentation
+
+- update README and CLI configuration (7fecf81)
+
+## 0.3.3 (2026-10-24)
+
+### Action requise
+
+- `npx fraza-doctor --fix`
+
+### Refontes
+
+- **templates/components/fraza/blocks/icon-list** : update icon resolution (d5ad8f2)
+- **components** : remove unused icon module (5fb8291)
+
+## 0.3.2 (2026-10-24)
+
+### Action requise
+
+- `npx fraza-doctor --fix`
+
+### Refontes
+
+- **components/frazaicons** : group imports and update descriptions (9fba523)
+
+## 0.3.1 (2026-10-24)
+
+### Action requise
+
+- `npx fraza-doctor --fix`
+
+### Corrections
+
+- **package.json, package-lock.json** : bump version to 0.3.0 (1a1aa74)
+
+### Refontes
+
+- **cli** : ensure exact package versions for Fraza projects (70fa0a3)
+- **fraza** : update icon names and descriptions (08cdcfe)
+
+### Autres
+
+- fix(fraza(blocks)): update icon imports and labels (863eeab)
+
+## 0.2.6 (2026-10-23)
+
+### Action requise
+
+- `npx fraza-doctor --fix`
+
+### Refontes
+
+- **bin/cli.js, templates/components/fraza/blocks/**/*.render.js, templates/components/fraza/blocks/icon-list/template.js, test/templates.test.js** : update dependencies and imports to use @fraza/icons (8a1bc61)
+
+## 0.2.5 (2026-10-22)
+
+### Action requise
+
+- `npx fraza-doctor --fix`
+
+### Refontes
+
+- **fraza/icons** : update icon descriptions and paths (12490c5)
+
+## 0.2.4 (2026-10-21)
+
+### Action requise
+
+- `npx fraza-doctor --fix`
+
+Maintenance interne, aucun changement de comportement.
+
+## 0.2.3 (2026-10-21)
+
+### Action requise
+
+- `npx fraza-doctor --fix`
+
+### Corrections
+
+- **components/fraza** : update API endpoint URLs (a6839a7)
+
+### Refontes
+
+- rename files from fraza to za (da3f362)
+
+## 0.2.2 (2026-10-20)
+
+### Corrections
+
+- **package.json** : correct bin path (ef61e32)
+
+## 0.2.1 (2026-10-20)
+
+### Ruptures
+
+- decide the admin 404 in the layout of [...admin], render it in the shell
+- boot from @fraza/core/init, import Button by its own entry on the public pages
+- drop app/(public)/loading.js, which made every unknown URL answer 200
+- pin create-next-app to the tested Next, check the prerequisites first
+- track .env.example, keep .env.local and every other .env out of git
+- never copy the registry token into the project .npmrc
+- drop fs-extra, require Node 20.12, test the generation steps
+
+### Action requise
+
+- `npx fraza-doctor --fix`
+
+### Ajouts
+
+- **release** : bump the version in npm run release, patch by default (6a87a26)
+- **release** : check, publish, then tag and push, with changelog and version module (ce8f04a)
+- **templates** : add error, loading and global-error boundaries (8a38c39)
+- **cli** : write every message in French, like the rest of the product (d9b776f)
+- **cli** : pin create-next-app to the tested Next, check the prerequisites first (63d338c)
+- **cli** : track .env.example, keep .env.local and every other .env out of git (f7252c8)
+
+### Corrections
+
+- **templates** : pass the links of an image and an icon list through sanitizeUrl (d268cc2)
+- **templates** : decide the admin 404 in the layout of [...admin], render it in the shell (69c8bca)
+- **templates** : render a linked image from the filename the Medias module resolves (8cfc288)
+- **templates** : boot from @fraza/core/init, import Button by its own entry on the public pages (c62e26c)
+- **templates** : drop app/(public)/loading.js, which made every unknown URL answer 200 (32fd83f)
+- **cli** : give .env.local a header written for it, not the one of .env.example (382a376)
+- **cli** : install the latest patch of the tested Next minor, 16.3.8 (83dea71)
+- **templates** : use the core Button on the home page, drop its hard-coded title (7805ebc)
+- **templates** : clip horizontal overflow without breaking sticky elements (b775491)
+- **templates** : keep the @/* alias of create-next-app in jsconfig.json (2a5edf6)
+- **templates** : title the public pages with FRAZA_NAME instead of an empty string (84fa798)
+- **cli** : never copy the registry token into the project .npmrc (fc9160e)
+
+### Refontes
+
+- **templates** : drop the dead branches of the public catch-all (27e9cb1)
+- **cli** : drop fs-extra, require Node 20.12, test the generation steps (bd10684)
+
+### Documentation
+
+- **readme** : npm run release warns about breaking changes in a patch, it no longer refuses (e913df9)
+- **readme** : say npm run release refuses patch while breaking changes wait (ed209d8)
+- **cli** : say the core now declares Next 16.3.8 as tested (9ddec07)
+- **blocks** : say that two blocks under one id stop the startup (b3ed4ff)
+
+## 0.1.2 (2026-10-19)
+
+### Action requise
+
+- `npx fraza-doctor --fix`
+
+### Ajouts
+
+- write the @fraza-pro scope in .npmrc, no token needed for free packages (3279869)
+
+### Refontes
+
+- **fraza** : update icon list to use local icon import (a0aa439)
+- **api** : remove unused Icons component (ae72fcd)
+
+## 0.1.1 (2026-10-19)
+
+### Action requise
+
+- `npx fraza-doctor --fix`
+
+### Ajouts
+
+- initial Fraza 0.1.0 codebase (85f1053)
+
+### Autres
+
+- Initial commit (402f173)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HYKO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,170 @@
-# Temporary Holding Version
+# @fraza/start
 
-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.
+Crée un projet Fraza : un projet Next.js avec `@fraza/core` déjà branché.
+
+> [!WARNING]
+> Fraza est en version 0.x. L'API, la structure des projets et les fonctionnalités peuvent encore changer d'une version mineure à l'autre.
+
+## Prérequis
+
+- Node.js 20.12 ou plus.
+- Un dossier vide. Seules les métadonnées d'éditeur ou de git y sont tolérées : `.git`, `.vscode`, `.idea`, `.DS_Store`, `LICENSE` par exemple.
+- Le registre npm joignable, sans compte : `@fraza/core` est publié sur npmjs.
+
+Le CLI vérifie les trois avant d'écrire quoi que ce soit : un échec laisse le dossier tel qu'il était.
+
+## Ce que fait le CLI
+
+Lancé dans un dossier vide, `npx @fraza/start` :
+
+1. crée un projet Next.js avec `create-next-app` 16.3.8, le dernier correctif de la version de Next contre laquelle le core est validé (`packages.next.tested` du `supported.json` du core). Toutes les options sont passées, aucune question n'est posée : JavaScript, Tailwind CSS, ESLint, App Router, pas de dossier `src/`, alias `@/*`, sans React Compiler ni Cache Components ;
+2. supprime le dossier `app/` de Next et copie les gabarits Fraza : routes de l'administration, de l'authentification et de l'API, page d'accueil publique (qui suit la mise en route du projet : `.env.local`, tables, premier compte), pages d'erreur et de chargement, gabarits de page, exemples de blocs, `theme.js`, `instrumentation.js` et `jsconfig.json` (l'alias `@/*` de Next, plus `@styles/*` et `@components/*`) ;
+3. ajoute au `package.json` les scripts `dev`, `build` et `postinstall`, qui lancent `fraza-modules sync` ;
+4. masque l'indicateur de développement de Next dans `next.config.mjs` ;
+5. ajoute au `.gitignore` les lignes `!.env.example` et `app/.fraza/`, en gardant la règle `.env*` de Next ;
+6. ajoute un bloc Fraza à l'`AGENTS.md` du projet ;
+7. écrit le `.npmrc` du projet : le scope `@fraza-pro` vers `https://registry.fraza.ca/`, sans jeton ;
+8. installe `@fraza/core` ;
+9. crée `.env.example`, copie du modèle du core suivie par git, et `.env.local`, la même copie remplie pour cette machine (`FRAZA_ENCRYPTION_KEY` générée, `NEXT_PUBLIC_URL` locale), ignorée par git. L'en-tête de `.env.local` est réécrit pour ce fichier : celui du modèle décrit `.env.example`.
+
+## Utilisation
+
+### 1. Lancer le CLI
+
+Les paquets `@fraza` sont publiés sur npmjs : aucune configuration ni connexion n'est demandée. Dans le dossier du nouveau projet :
+
+```bash
+npx @fraza/start
+```
+
+### 2. Configurer les variables d'environnement
+
+Le CLI écrit deux fichiers à partir du modèle du core, qui ne porte que le nécessaire au démarrage :
+
+| Fichier | Contenu | Suivi par git |
+|---|---|---|
+| `.env.example` | Le modèle tel quel, sans aucune valeur secrète. Une variable que le projet ajoute y entre, vide ou avec une valeur d'exemple. | Oui |
+| `.env.local` | Les valeurs de cette machine : base de données, stockage, courriel, clés. | Non |
+
+Remplissez `.env.local`. `FRAZA_ENCRYPTION_KEY` y est déjà : le CLI génère 32 octets aléatoires en hexadécimal. Next.js et les CLI `fraza-*` lisent `.env.local` d'eux-mêmes.
+
+Le `.gitignore` garde la règle `.env*` de `create-next-app` et n'en retire que `.env.example` : un secret ne peut pas partir dans git par un `.env` oublié.
+
+La liste complète des variables, avec leur valeur par défaut et leur effet, est dans la documentation du core, livrée hors ligne dans `node_modules/@fraza/core/dist/docs/03-reference/06-configuration/variables-d-environnement.md`.
+
+`npx fraza-doctor` dit lesquelles manquent vraiment : il connaît toutes les variables du core et de chaque module installé, et ne signale que celles dont l'absence empêche le projet de fonctionner.
+
+### 3. Initialiser la base de données
+
+```bash
+npx fraza-db init
+```
+
+## Les variables en production
+
+Les variables de production se saisissent dans la plateforme d'hébergement (Coolify, par exemple, ou l'environnement d'un conteneur), jamais dans un fichier suivi par git. Partez de `.env.example` pour la liste.
+
+**Copiez `FRAZA_ENCRYPTION_KEY` telle quelle depuis `.env.local`, et ne la changez jamais.** Tout ce que le site chiffre en base l'est avec cette clé : une nouvelle clé rend ces données illisibles. Gardez-en une copie hors du serveur, dans un gestionnaire de mots de passe par exemple.
+
+## Le `.npmrc` et les modules Pro
+
+Le CLI écrit un `.npmrc` dans le projet, avec une ligne et rien d'autre :
+
+```ini
+@fraza-pro:registry=https://registry.fraza.ca/
+```
+
+`@fraza/core` et les modules gratuits viennent de npmjs, sans ligne ni connexion. Aucun jeton n'est recopié, même si `~/.npmrc` en porte un. Sans secret, le fichier reste suivi par git, et la machine de build sait où chercher les modules Pro : sans lui, `npm ci` les cherche sur npmjs et échoue avec un 404.
+
+Chaque version gratuite est aussi publiée sur `https://registry.fraza.ca/`, en copie de secours. Si npmjs devient indisponible, la page « Registre de secours » de la documentation du core explique comment y basculer.
+
+Les modules Pro (`@fraza-pro/module-*`) demandent un jeton. Connectez-vous au registre, puis lancez `fraza-key`, qui écrit le jeton dans le `.npmrc` du projet :
+
+```bash
+npm login --registry=https://registry.fraza.ca/
+npx fraza-key
+```
+
+Le jeton est alors en clair dans un fichier suivi par git : traitez-le comme une clé de licence propre au projet, en lecture seule, distincte du compte qui publie. La page `fraza-key` de la documentation du core détaille ce cas.
+
+## Pages d'erreur, de chargement et de page introuvable
+
+Le projet reçoit six fichiers qui réexportent chacun un composant du core :
+
+| Fichier | Composant du core | Rôle |
+|---|---|---|
+| `app/(admin)/admin/error.js` | `@fraza/core/features/admin/error` | Erreur au rendu d'une page de l'administration. |
+| `app/(admin)/admin/not-found.js` | `@fraza/core/features/admin/not-found` | Page introuvable de l'administration, dans la coquille. |
+| `app/(admin)/admin/[...admin]/layout.js` | `@fraza/core/features/admin/page-layout` | Vérifie la fiche et la permission d'une page d'admin avant que la réponse parte. |
+| `app/(admin)/admin/[...admin]/loading.js` | `@fraza/core/features/admin/loading` | Chargement d'une page de l'administration. |
+| `app/(public)/error.js` | `@fraza/core/shared/public/error` | Erreur au rendu d'une page du site public. |
+| `app/global-error.js` | `@fraza/core/shared/global-error` | Erreur du layout racine lui-même. |
+
+Ceux de l'administration suivent le core et n'ont pas à changer. Ceux du site public sont des gabarits, comme la page 404 : remplacez le réexport par un composant du projet pour leur donner l'allure du site.
+
+Le site public n'a pas de `loading.js`, et ne doit pas en recevoir : il entourerait la page attrape-tout d'un `Suspense`, la réponse partirait avec le statut 200 avant que la page sache si le contenu existe, et toute URL inconnue répondrait 200 au lieu de 404. Une page qui veut un état de chargement pose son propre `Suspense`, après l'appel éventuel à `notFound()`.
+
+Pour la même raison, le `loading.js` de l'administration vit sous `app/(admin)/admin/[...admin]/`, et non dans `app/(admin)/admin/` : à ce niveau, son `Suspense` entourerait aussi le layout de `[...admin]`, qui décide du 404 d'une page inconnue ou refusée. Un projet généré avant ce changement lance `npx fraza-doctor --fix`, qui déplace le fichier et ajoute les deux autres.
+
+## `AGENTS.md` du projet généré
+
+Le CLI ajoute un bloc `fraza-agent-rules` à l'`AGENTS.md` créé par Next.js. Il indique qu'il s'agit d'un projet Fraza et renvoie à la documentation livrée dans le paquet, sous `node_modules/@fraza/core/dist/docs/`. Un agent qui ouvre le dépôt lit ainsi la documentation de la version exacte installée, sans accès réseau.
+
+Le contenu du bloc est dans [`bin/agents-block.md`](./bin/agents-block.md). Il est délimité par ses propres marqueurs : `next dev` ne réécrit que le bloc `nextjs-agent-rules` et laisse celui-ci intact.
+
+## Contribuer
+
+### Installer un core local
+
+La variable `FRAZA_START_CORE_SPEC` remplace la cible du `npm install` du core. Elle vaut `@fraza/core` par défaut. Elle sert aux tests de bout en bout, pour installer un core local au lieu de la version publiée :
+
+```bash
+cd ../core
+npm pack
+cd ../projet-test
+FRAZA_START_CORE_SPEC=../core/fraza-core-0.1.0.tgz npx ../start
+```
+
+En PowerShell, définissez la variable avant de lancer le CLI :
+
+```powershell
+$env:FRAZA_START_CORE_SPEC = "../core/fraza-core-0.1.0.tgz"
+npx ../start
+```
+
+Toute cible acceptée par `npm install` convient : une archive `.tgz`, un dossier ou une version précise. Cette variable sert au développement de Fraza. Un projet normal n'en a pas besoin.
+
+### Vérifier les gabarits
+
+`npm run check:contract` vérifie que `templates/` suit le contrat d'amorçage déclaré par le core, et que la version de `create-next-app` épinglée dans `bin/project.js` est un correctif de la version mineure `packages.next.tested` du `supported.json` du core, au moins égal à celle-ci. Le script cherche un core buildé dans `../core`, puis dans `node_modules/@fraza/core`.
+
+`npm run build` lance cette vérification, puis régénère `THIRD-PARTY-NOTICES.md`.
+
+### Lancer les tests
+
+```bash
+npm test
+```
+
+Les étapes de génération vivent dans `bin/project.js`, sans effet de bord à l'import. Les tests de `test/` les appellent une par une sur un dossier temporaire, avec `node:test` : aucune dépendance à installer.
+
+`test/templates.test.js` lit les imports des gabarits, sans core installé. Le projet atteint `@fraza/core` par ses sous-chemins, jamais par la racine, et `instrumentation.js` démarre par `@fraza/core/init`. Les pages du site public, les gabarits de page et les `render.js` des blocs importent chaque composant et chaque icône par son propre sous-chemin (`@fraza/core/shared/components/Button`, `@fraza/icons/CheckIcon`) : les barrels `shared/components` et `@fraza/icons` tireraient tout le jeu dans le code envoyé au visiteur.
+
+### Publier
+
+Le paquet suit la procédure de publication du core : voir [Publication](https://docs.fraza.ca/docs/contribution/publication). Ses outils sont ceux de `fraza-module`, lancés par `scripts/fraza-module.js` sur le core buildé de `../core`, puis de `node_modules/@fraza/core`. Le paquet n'installe pas le core : le déclarer en dépendance figerait dans le lockfile un core publié, qui peut ne pas encore porter ces outils.
+
+| Script | Rôle |
+|---|---|
+| `npm run sync:version` | Recopie `package.json#version` dans `bin/version.js`, que le CLI affiche au lancement. |
+| `npm run build:changelog` | Régénère `CHANGELOG.md`, `changelog.json` et `package.json#fraza`, avec les gabarits changés (`templateChanged`). |
+| `npm run release` | Vérifie le paquet, monte sa version (`patch` par défaut), committe `chore: bump version to X.Y.Z`, le publie sur npmjs puis sur `registry.fraza.ca`, puis pose l'étiquette `v<version>` et la pousse (`fraza-module release`). |
+| `npm run release:publish` | Publie la version actuelle sur chaque registre où elle manque (`fraza-module publish`). Sert à terminer une publication interrompue. |
+
+Comme pour le core, `npm run release -- minor` monte la version mineure, pour un changement cassant en `0.x`. La commande liste les ruptures en attente depuis la dernière version et avertit si `patch` ne les annonce pas, puis publie quand même le niveau demandé. Avant toute écriture, elle fait aussi un `git fetch` et refuse une branche en retard sur le dépôt distant. `npm run release -- --dry-run` fait ces vérifications et affiche la version calculée sans rien écrire ni publier. `scripts/fraza-module.js` transmet ces arguments au core buildé de `../core`, qui doit donc porter la commande `release`.
+
+## Licence
+
+Licence MIT. Copyright (c) 2026 HYKO. Voir [LICENSE](./LICENSE).
+
+Ce paquet fait partie de Fraza Libre. Les dépendances tierces et leurs licences sont listées dans [THIRD-PARTY-NOTICES.md](./THIRD-PARTY-NOTICES.md).

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,11 @@
+# Avis relatifs aux composants tiers
+
+Ce document inventorie les dépendances de production de `@fraza/start` et leurs licences.
+
+Il est généré par `npm run build:notices` à partir de l'arbre réellement installé. Ne pas le modifier à la main.
+
+`@fraza/start` ne bundle aucun code tiers : les dépendances ci-dessous sont installées séparément par le gestionnaire de paquets, depuis leurs sources respectives. Elles ne sont ni distribuées ni couvertes par la [licence MIT](./LICENSE) de ce paquet. Cet inventaire sert à vérifier qu'aucune licence copyleft ne contamine l'application qui installe le paquet, et à fournir la liste nécessaire aux obligations d'attribution du projet consommateur, dont le build, lui, bundle ces dépendances.
+
+## Résumé
+
+Aucune. `@fraza/start` n'a pas de dépendance de production : tout ce dont il a besoin à l'exécution est déclaré en `peerDependencies` et fourni par le projet consommateur. Il n'y a donc aucun composant tiers à inventorier ici.

package/bin/agents-block.md

@@ -0,0 +1,61 @@
+<!-- BEGIN:fraza-agent-rules -->
+
+# This is a Fraza project
+
+The project was generated by `npx @fraza/start`, and most of the behaviour comes
+from `@fraza/core`: authentication, database, storage, emails, payments, PDF,
+scheduled tasks, administration. Before writing anything, check whether the core
+or an official module already does the job.
+
+## Where the documentation is
+
+It ships inside the package, in French, matching the exact version installed
+here, and readable offline:
+
+`node_modules/@fraza/core/dist/docs/`
+
+The documentation of the official modules lives there too, one folder per
+module, under `node_modules/@fraza/core/dist/docs/06-modules/`. The module
+packages themselves ship no docs folder. Each module's `README.md` covers its
+installation.
+
+## Working rules
+
+Read the relevant page before writing code. Fraza conventions take precedence
+over Next.js habits, and the core often exposes a dedicated API where Next.js
+offers a generic one.
+
+To follow the project theme, light and dark modes included, style with the
+role utilities (`bg-surface`, `text-fg`, `border-line`, `bg-primary`,
+`text-accent`...) rather than Tailwind palette classes or hex values. The
+appearance is set in `theme.js`. See `04-architecture/06-design-system.md` in
+the docs.
+
+Never edit anything in `app/.fraza/`. The directory is regenerated by
+`fraza-modules sync`, which runs on every `npm run dev`, `npm run build` and
+`npm install`.
+
+## The development server
+
+The developer often already has `npm run dev` running, so check
+`http://localhost:3000` before starting one. If it answers, use that server
+rather than a second instance. You may kill and restart it when a change
+requires it.
+
+Leave a server running only if it is the one the developer opened. Always close
+the ones you opened yourself: start them in background, keep track of their
+process, and always kill them before you hand the work back.
+
+`.env.local` holds the values of this machine (database, storage, keys) and is
+never tracked by git. `.env.example` is the tracked template and must stay free
+of any secret: a variable the project adds goes there empty or with a sample
+value. In production, variables are set in the hosting platform, never in a
+tracked file. Never change `FRAZA_ENCRYPTION_KEY`: data already encrypted with
+it would become unreadable.
+
+Environment variables are read at boot only, hot reload never picks up
+`.env.local`. After changing one, restart the server before you trust what you
+see.
+
+
+<!-- END:fraza-agent-rules -->

package/bin/cli.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+	CREATE_NEXT_APP_VERSION,
+	MIN_NODE,
+	REGISTRY_URL,
+	findConflictingEntries,
+	hideDevIndicators,
+	isSupportedNode,
+	withFrazaGitignore,
+	withFrazaScripts,
+	writeAgentsBlock,
+	writeEnvFiles,
+	writeProjectNpmrc,
+} from './project.js';
+import { STARTER_VERSION } from './version.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const c = {
+	reset: '\x1b[0m',
+	dim: '\x1b[2m',
+	green: '\x1b[32m',
+	cyan: '\x1b[36m',
+	red: '\x1b[31m',
+	bold: '\x1b[1m',
+};
+
+// Source de vérité unique des `overrides` de l'écosystème Fraza.
+//
+// npm n'honore `overrides` que depuis le package.json racine du projet installé.
+// Un `overrides` déclaré dans @fraza/core ou dans un module Fraza est ignoré au
+// moment où le site les installe : il n'agit que sur le node_modules du dépôt de
+// la librairie. Le seul endroit qui protège vraiment un site, c'est ici.
+//
+// Le bloc est vide, et c'est l'état normal. Une entrée ne s'ajoute que pour une
+// faille qu'aucune mise à jour amont ne peut corriger, typiquement une version
+// épinglée exactement par une dépendance directe. Elle se retire dès que l'amont
+// est à jour de lui-même : un override laissé en place fige une version pour rien
+// et donne une fausse impression de correctif.
+//
+// Format : { 'nom-du-paquet': '^1.2.3' }
+//
+// Attention, npm refuse un override qui porte sur un paquet déclaré en
+// dependencies du site (erreur EOVERRIDE). Dans ce cas, corriger la dépendance
+// directe plutôt que d'ajouter une entrée ici.
+const SITE_OVERRIDES = {};
+
+// Contributor-only override: the npm spec used to install the core. Defaults to
+// the published package; the e2e test points it at a local tarball.
+const CORE_SPEC = process.env.FRAZA_START_CORE_SPEC || '@fraza/core';
+
+// Every create-next-app question answered on the command line, so the run never
+// stops on a prompt and never depends on preferences saved on this machine.
+// `--no-cache-components` is ignored by 16.3, which does not enable Cache
+// Components, but keeps a later bump of the pin from turning them on: the
+// admin and auth layouts read cookies outside <Suspense>, which fails
+// `next build` under that mode.
+const CREATE_NEXT_APP_ARGS = [
+	'./',
+	'--js',
+	'--tailwind',
+	'--eslint',
+	'--app',
+	'--no-src-dir',
+	'--import-alias "@/*"',
+	'--empty',
+	'--agents-md',
+	'--no-react-compiler',
+	'--no-cache-components',
+	'--use-npm',
+	'--yes',
+];
+
+const step = (msg) => process.stdout.write(`  ${c.dim}◆${c.reset} ${msg}...\n`);
+const done = (msg) => process.stdout.write(`  ${c.green}✓${c.reset} ${msg}\n`);
+const fail = (msg) => process.stdout.write(`  ${c.red}✗${c.reset} ${msg}\n`);
+
+// Vérifications faites avant d'écrire quoi que ce soit : un échec laisse le
+// dossier tel qu'il était.
+function checkPrerequisites(cwd) {
+	if (!isSupportedNode(process.versions.node)) {
+		throw new Error(`Node.js ${process.versions.node} détecté : @fraza/start demande Node.js ${MIN_NODE.join('.')} ou plus.`);
+	}
+
+	const conflicts = findConflictingEntries(cwd);
+	if (conflicts.length > 0) {
+		throw new Error(`Le dossier courant n'est pas vide (${conflicts.join(', ')}). Lancer @fraza/start dans un dossier vide.`);
+	}
+
+	// Un core local (FRAZA_START_CORE_SPEC) ne passe pas par le registre.
+	// `@fraza/core` vient du registre que npm choisit pour `@fraza` : npmjs par
+	// défaut, registry.fraza.ca si la configuration de l'utilisateur l'y envoie.
+	if (CORE_SPEC !== '@fraza/core') return;
+	try {
+		execSync('npm view @fraza/core version', { stdio: 'pipe', timeout: 30_000 });
+	} catch {
+		throw new Error('Le registre npm ne répond pas : @fraza/core n\'a pas pu être lu. Vérifier la connexion, puis relancer.');
+	}
+}
+
+async function initProject() {
+	const cwd = process.cwd();
+	try {
+		console.log(`\n  ${c.bold}${c.cyan}fraza-start${c.reset} ${c.dim}${STARTER_VERSION}${c.reset}\n`);
+
+		checkPrerequisites(cwd);
+		done('Prérequis vérifiés');
+
+		step(`Création du projet Next.js (create-next-app ${CREATE_NEXT_APP_VERSION})`);
+		execSync(`npx --yes create-next-app@${CREATE_NEXT_APP_VERSION} ${CREATE_NEXT_APP_ARGS.join(' ')}`, { stdio: 'inherit' });
+		done('Projet Next.js créé');
+
+		fs.rmSync(path.join(cwd, 'app'), { recursive: true, force: true });
+		done('Dossier app/ de Next supprimé');
+
+		const packageJsonPath = path.join(cwd, 'package.json');
+		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+		const projectName = packageJson.name || 'project';
+		fs.writeFileSync(path.join(cwd, 'README.md'), `# ${projectName}\n\nConstruit avec Next.js, Tailwind CSS et @fraza/core.\n`);
+		fs.writeFileSync(packageJsonPath, `${JSON.stringify(withFrazaScripts(packageJson, SITE_OVERRIDES), null, 2)}\n`);
+		done('README.md et package.json mis à jour');
+
+		const templatesPath = path.join(__dirname, '..', 'templates');
+		if (!fs.existsSync(templatesPath)) {
+			throw new Error('Dossier des gabarits introuvable dans @fraza/start.');
+		}
+		fs.cpSync(templatesPath, cwd, { recursive: true, force: true });
+		done('Gabarits copiés');
+
+		if (hideDevIndicators(path.join(cwd, 'next.config.mjs'))) {
+			done('Indicateur de développement de Next masqué dans next.config.mjs');
+		} else {
+			fail('next.config.mjs non reconnu : ajouter `devIndicators: false` à la main');
+		}
+
+		const gitignorePath = path.join(cwd, '.gitignore');
+		const gitignore = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf-8') : '';
+		fs.writeFileSync(gitignorePath, withFrazaGitignore(gitignore));
+		done('.gitignore mis à jour');
+
+		const agentsBlockPath = path.join(__dirname, 'agents-block.md');
+		if (fs.existsSync(agentsBlockPath)) {
+			const block = fs.readFileSync(agentsBlockPath, 'utf-8').trim();
+			writeAgentsBlock(path.join(cwd, 'AGENTS.md'), block);
+			done('Bloc Fraza ajouté à AGENTS.md');
+		}
+
+		writeProjectNpmrc(path.join(cwd, '.npmrc'));
+		done('.npmrc créé (scope @fraza-pro, sans jeton)');
+
+		// Les gabarits importent leurs icônes de @fraza/icons : le projet le déclare
+		// lui-même, même s'il arrive aussi avec le core. Les dernières versions de
+		// tous les paquets Fraza vont ensemble ; elles sont écrites exactes, et
+		// `npx fraza-update` les fait avancer toutes à la fois.
+		step('Installation de @fraza/core et @fraza/icons');
+		execSync(`npm install --save-exact "${CORE_SPEC}" @fraza/icons`, { stdio: 'inherit' });
+		done('@fraza/core et @fraza/icons installés');
+
+		const envTemplate = path.join(cwd, 'node_modules', '@fraza', 'core', '.env.example');
+		if (!fs.existsSync(envTemplate)) {
+			throw new Error('Modèle .env.example introuvable dans @fraza/core.');
+		}
+		const env = writeEnvFiles(envTemplate, cwd);
+		if (env.example) done('.env.example créé à partir du modèle de @fraza/core');
+		if (env.local) done('.env.local créé, FRAZA_ENCRYPTION_KEY générée');
+
+		const file = (name) => `${c.cyan}${name}${c.reset}`;
+		const dim = (text) => `${c.dim}${text}${c.reset}`;
+
+		console.log(`\n  ${c.green}${c.bold}Projet prêt.${c.reset} Étapes suivantes :\n`);
+		console.log(`  ${dim('1.')} Remplir les variables de ${file('.env.local')}, à commencer par ${file('FRAZA_DATABASE_URL')}`);
+		console.log(`     ${dim('Ce fichier reste sur cette machine. Le modèle sans secret,')} ${file('.env.example')}${dim(', est suivi par git.')}`);
+		console.log(`  ${dim('2.')} Initialiser la base de données`);
+		console.log(`     ${dim('npx fraza-db init')}`);
+		console.log(`  ${dim('3.')} Démarrer le site`);
+		console.log(`     ${dim('npm run dev')}\n`);
+
+		console.log(`  ${c.bold}En production :${c.reset} les variables se saisissent dans la plateforme d'hébergement (Coolify, par exemple),`);
+		console.log(`  ${dim('jamais dans un fichier suivi par git.')} ${file('FRAZA_ENCRYPTION_KEY')} ${dim('se copie telle quelle depuis')} ${file('.env.local')}${dim(' :')}`);
+		console.log(`  ${dim('elle ne doit jamais changer, sinon les données chiffrées avec elle deviennent illisibles.')}\n`);
+
+		console.log(`  ${c.bold}Modules Pro :${c.reset} se connecter au registre, puis écrire le jeton dans ${file('.npmrc')} avec ${file('npx fraza-key')}`);
+		console.log(`     ${dim(`npm login --registry=${REGISTRY_URL}`)}`);
+		console.log(`     ${dim('npx fraza-key')}\n`);
+	} catch (error) {
+		fail(error.message);
+		process.exit(1);
+	}
+}
+
+initProject();