test(commercial) : SupplierExportControllerTest sur base fournisseurs (catégories FOURNISSEUR, dédup F3) (ERP-113)

Fait étendre SupplierExportControllerTest à AbstractSupplierApiTestCase au
lieu d'AbstractCommercialApiTestCase. Supprime le seedSupplier() privé (qui
seedait des catégories de type CLIENT via createCategory(), violant RG-2.10)
et le tearDown() redondant, désormais portés par la base sur des catégories
FOURNISSEUR.

Le contact principal utilise le helper addContact() de la base ; le téléphone
secondaire, non porté par ce helper, est posé via le setter sur le contact
retourné. L'assertion de la colonne Catégories dérive le libellé attendu de
supplierCategory('NEGOCIANT') au lieu de hardcoder le préfixe de nom de test.

.claude/rules/backend.md

@@ -6,6 +6,13 @@
 - PHP CS Fixer : regles Symfony + PSR-12 + strict types (commande : `make php-cs-fixer-allow-risky`)
 - Commentaires (docblock, inline, bloc) **en francais** ; code (classes, methodes, variables) en anglais
 
+## Messages de validation (obligatoire)
+
+Toute contrainte `#[Assert\*]` d'une entite metier : **message FR explicite**, et `Assert\Length.max` = `length` de la colonne ORM (coherence 3 niveaux nullable DB <-> NotBlank back <-> required front, ERP-101). RG inter-champs via `#[Assert\Callback]->atPath('<champ>')` (mapping inline front, pas toast). Exceptions miroir Length (Bic/Iban/Regex borne) : whitelist `EntityConstraintsHaveFrenchMessageTest::EXCLUDED_LENGTH_MIRROR`.
+
+Garde-fou : `tests/Architecture/EntityConstraintsHaveFrenchMessageTest` (casse `make test`).
+→ patterns code + exemples + justification complete : skill `backend-entity-conventions`.
+
 ## API Platform (pas de controllers)
 
 - Toujours utiliser `#[ApiResource]` + Providers + Processors — pas de controllers Symfony classiques
@@ -15,61 +22,10 @@
 
 ## Pagination (obligatoire)
 
-**Regle** : toute collection API DOIT etre paginee. Aucun retour de collection complete cote serveur.
+Toute collection API est paginee (defaut 10, max 50 ; `?pagination=false` = echappatoire selects, `?itemsPerPage=25` borne par le max). Standard global dans `config/packages/api_platform.yaml`. Jamais `paginationEnabled: false` hors whitelist `CollectionsArePaginatedTest::EXCLUDED`. Provider custom : ne jamais retourner un `array` brut sur une `CollectionOperationInterface` (court-circuite Hydra) — wrapper un Paginator (ORM : `ApiPlatform\Doctrine\Orm\Paginator` ; DBAL : `DbalPaginator`) et gerer `?pagination=false` via `$this->pagination->isEnabled(...)`.
 
-### Standard global
-
-Pose dans `config/packages/api_platform.yaml` (section `defaults:`) et heritee par toutes les ressources :
-
-| Cle | Valeur | Effet |
-|---|---|---|
-| `pagination_enabled` | `true` | Pagination Hydra active par defaut. |
-| `pagination_items_per_page` | `10` | Taille de page par defaut, aligne sur l'UI `MalioDataTable`. |
-| `pagination_maximum_items_per_page` | `50` | Borne dure : `?itemsPerPage=999` → ramene a 50. Anti deep-fetch. |
-| `pagination_client_items_per_page` | `true` | Le client peut envoyer `?itemsPerPage=25` (bornee par le max). |
-| `pagination_client_enabled` | `true` | Le client peut envoyer `?pagination=false` pour TOUT recuperer (echappatoire selects). |
-
-### Override par ressource (rare)
-
-Si une ressource a besoin d'un autre defaut (ex: payload lourd), utiliser les attributs sur l'operation. **JAMAIS `paginationEnabled: false`** sans whitelist explicite dans `tests/Architecture/CollectionsArePaginatedTest::EXCLUDED`.
-
-```php
-new GetCollection(
-    paginationItemsPerPage: 5,           // override taille par defaut
-    paginationMaximumItemsPerPage: 20,   // override borne max
-)
-```
-
-### Selects et autocompletions
-
-Pour alimenter un `<select>` ou un drawer RBAC (Role, Permission, Site, CategoryType), le front passe :
-
-```ts
-useApi().get('/api/roles?pagination=false')
-```
-
-Le serveur retourne toute la collection, sans `view`. C'est l'echappatoire prevue par `pagination_client_enabled: true`. Sur les ressources a forte volumetrie, preferer une saisie assistee (recherche serveur via `?q=`) — a planifier dans un ticket dedie.
-
-Les tests fonctionnels qui exercent ce comportement doivent egalement passer `?pagination=false` (cf. `CategoryListTest`, `PermissionApiTest`).
-
-### Providers customs et pagination
-
-Un provider custom qui retourne un `array` brut sur une `CollectionOperationInterface` **court-circuite la pagination Hydra** (pas de `totalItems`, pas de `view`). Patterns supportes :
-
-- **ORM** : injecter `ApiPlatform\State\Pagination\Pagination`, wrap un `Doctrine\ORM\Tools\Pagination\Paginator` dans `ApiPlatform\Doctrine\Orm\Paginator`. Exemple : `CategoryProvider`.
-- **DBAL** : implementer un paginator local conforme a `PaginatorInterface`. Exemple : `DbalPaginator` (Core) + `AuditLogProvider`.
-
-Gerer l'echappatoire `?pagination=false` :
-
-```php
-if (!$this->pagination->isEnabled($operation, $context)) {
-    return $qb->getQuery()->getResult(); // tout retourner
-}
-```
-
-### Garde-fou architecture
-
-`tests/Architecture/CollectionsArePaginatedTest` scanne reflexivement toutes les classes `#[ApiResource]` sous `src/` et echoue si une `GetCollection` pose `paginationEnabled: false` hors whitelist `EXCLUDED`. Ajouter une entree a la whitelist requiert une justification courte + un ticket Lesstime ouvert.
+Garde-fou : `tests/Architecture/CollectionsArePaginatedTest` (casse `make test`).
+→ tableau des cles `pagination_*` + selects + providers ORM/DBAL detailles : skill `backend-entity-conventions`.
 
 ## Repositories
 
@@ -100,42 +56,17 @@ Format obligatoire : `module.resource[.subresource].action` en snake_case.
 
 ### Libelle i18n du type d'entite (obligatoire avec `#[Auditable]`)
 
-**Toute entite `#[Auditable]` doit avoir son libelle FR dans le bloc `audit.entity` de `frontend/i18n/locales/fr.json`.** C'est la contrepartie i18n de l'attribut : sans elle, le filtre « Type d'entite » de l'audit-log affiche le type technique brut (ex: `commercial.Client`) au lieu d'un libelle lisible.
+Toute entite `#[Auditable]` doit avoir sa cle `audit.entity.<module>_<entity>` dans `frontend/i18n/locales/fr.json` (cle = `strtolower(module)` + `_` + `strtolower(Entity)`, decision ERP-99). Sans elle, le filtre « Type d'entite » de l'audit-log retombe silencieusement sur le type technique brut (ex: `commercial.Client`). Fait partie de la definition de fini d'une entite auditee.
 
-Pourquoi : le filtre est dynamique (`GET /audit-log-entity-types` renvoie les `entity_type` distincts presents en base) ; des qu'un module audite une entite, son type y apparait. Le front (`formatEntityType`, `audit-log.vue`) construit la cle `audit.entity.<module>_<entity>` et, faute de traduction, **retombe silencieusement** sur le type brut.
-
-Derivation de la cle (emplacement centralise + schema flat — decision ERP-99) :
-
-| FQCN entite | `entity_type` (back) | Cle i18n (flat) |
-|---|---|---|
-| `App\Module\Commercial\Domain\Entity\Client` | `commercial.Client` | `commercial_client` |
-| `App\Module\Commercial\Domain\Entity\ClientAddress` | `commercial.ClientAddress` | `commercial_clientaddress` |
-| `App\Module\Catalog\Domain\Entity\Category` | `catalog.Category` | `catalog_category` |
-
-Regle : `strtolower(module)` + `_` + `strtolower(Entity)`. Ajouter sa cle de libelle audit fait partie de la **definition de fini** d'une entite metier auditee.
-
-**Garde-fou** : `tests/Architecture/AuditableEntitiesHaveI18nLabelTest` scanne les entites `#[Auditable]` et echoue si une seule n'a pas sa cle `audit.entity.*`. Conclusion : creer une entite `#[Auditable]` sans son libelle i18n casse `make test`.
+Garde-fou : `tests/Architecture/AuditableEntitiesHaveI18nLabelTest` (casse `make test`).
+→ derivation detaillee + exemples : skill `backend-entity-conventions`.
 
 ## Timestampable + Blamable (obligatoire pour entites metier)
 
-Toute **nouvelle** entite metier sous `src/Module/*/Domain/Entity/` doit porter les 4 colonnes `created_at` / `updated_at` / `created_by` / `updated_by`, remplies automatiquement. Trois lignes a ajouter a l'entite :
+Toute **nouvelle** entite metier sous `src/Module/*/Domain/Entity/` : `implements TimestampableInterface, BlamableInterface` + `use TimestampableBlamableTrait` (porte les 4 colonnes `created_at` / `updated_at` / `created_by` / `updated_by`, remplies par `TimestampableBlamableSubscriber` au prePersist/preUpdate). La migration cree les 4 colonnes (`created_at`/`updated_at` NOT NULL, `created_by`/`updated_by` nullable `ON DELETE SET NULL`). Referentiel statique justifie : whitelist `EntitiesAreTimestampableBlamableTest::EXCLUDED`.
 
-```php
-use App\Shared\Domain\Contract\BlamableInterface;
-use App\Shared\Domain\Contract\TimestampableInterface;
-use App\Shared\Domain\Trait\TimestampableBlamableTrait;
-
-class MyEntity implements TimestampableInterface, BlamableInterface
-{
-    use TimestampableBlamableTrait; // porte les 4 props + getters/setters
-    // ... reste metier
-}
-```
-
-- Le `TimestampableBlamableSubscriber` (`Shared/Infrastructure/Doctrine/`) remplit les colonnes au `prePersist` / `preUpdate`. Hors contexte HTTP (CLI, cron, migration), le blame reste `null` (libelle « Systeme » cote front).
-- La migration de l'entite doit creer les 4 colonnes (`created_at` / `updated_at` NOT NULL, `created_by` / `updated_by` nullable `ON DELETE SET NULL`).
-- **Garde-fou CI** : `tests/Architecture/EntitiesAreTimestampableBlamableTest` echoue si une entite oublie le pattern. Un referentiel statique justifie (ex: `CategoryType`) doit etre explicitement whiteliste dans la constante `EXCLUDED` avec un commentaire.
-- Spec complete : @docs/specs/M0-categories/spec-back.md § 2.8 + § 2.8.bis
+Garde-fou : `tests/Architecture/EntitiesAreTimestampableBlamableTest` (casse `make test`).
+→ snippet complet : skill `backend-entity-conventions` ; spec : @docs/specs/M0-categories/spec-back.md § 2.8 + § 2.8.bis.
 
 ## Serialization
 
@@ -153,50 +84,7 @@ Exemple : pour qu'`User.profile` soit embarque au lieu d'un lien IRI sous le gro
 
 ## Migrations Doctrine
 
-### Documentation SQL obligatoire (`COMMENT ON COLUMN`)
+Toute migration creant/modifiant une colonne d'une table metier pose un `COMMENT ON COLUMN` (FR, ≤ 200 caracteres, semantique + contrainte/RG, cible pour les FK). Les 4 colonnes Timestampable/Blamable recoivent leur description via le helper centralise `addStandardTimestampableBlamableComments($schema, 'table')`. Bonus : `COMMENT ON TABLE` pour decrire la table.
 
-**Toute migration qui cree ou modifie une colonne d'une table metier doit poser un `COMMENT ON COLUMN` decrivant le champ.** La description est stockee dans `pg_description` et visible dans tous les outils d'admin BDD (DBeaver, DataGrip, pgAdmin), sans avoir a lire les annotations PHP.
-
-**Format de la description** :
-- En francais
-- ≤ 200 caracteres
-- Semantique du champ — contraintes / lien RG si pertinent
-- Pour les colonnes d'identifiant ou FK, mentionner la cible
-
-Exemples :
-
-```php
-// Migration : creation d'une colonne avec son commentaire dans la meme migration
-$this->addSql("ALTER TABLE client ADD COLUMN siren VARCHAR(9) DEFAULT NULL");
-$this->addSql("COMMENT ON COLUMN client.siren IS 'SIREN (9 chiffres) — identifiant legal entreprise. Unique parmi non-archives (RG-1.15).'");
-
-// Cas FK : preciser la cible
-$this->addSql("COMMENT ON COLUMN client.legal_form_id IS 'Reference forme juridique (SARL, SAS, SA...) — FK -> legal_form.id, ON DELETE RESTRICT.'");
-
-// Cas booleen : preciser le sens et la valeur par defaut
-$this->addSql("COMMENT ON COLUMN user.is_admin IS 'Drapeau super-administrateur — bypass complet RBAC. Faux par defaut.'");
-
-// Bonus : decrire la table elle-meme
-$this->addSql("COMMENT ON TABLE client IS 'Repertoire clients (M1 Commercial) — entites archivables.'");
-```
-
-### Helper Timestampable/Blamable
-
-Les 4 colonnes `created_at`, `updated_at`, `created_by`, `updated_by` ajoutees par `TimestampableBlamableTrait` recoivent une description **standardisee** via le helper centralise pour eviter la duplication. Helper a creer ou appeler :
-
-```php
-// Dans la migration, apres avoir ajoute les 4 colonnes :
-$this->addStandardTimestampableBlamableComments($schema, 'client');
-```
-
-L'implementation du helper applique :
-- `created_at` : « Horodatage de creation de la ligne (UTC, rempli automatiquement par TimestampableBlamableSubscriber). »
-- `updated_at` : « Horodatage de derniere modification de la ligne (UTC, rempli automatiquement par TimestampableBlamableSubscriber). »
-- `created_by` : « ID de l'utilisateur ayant cree la ligne — null pour les creations hors HTTP (CLI, migration, fixture). FK -> user.id, ON DELETE SET NULL. »
-- `updated_by` : « ID de l'utilisateur ayant modifie la ligne en dernier — null pour les modifications hors HTTP. FK -> user.id, ON DELETE SET NULL. »
-
-### Garde-fou architecture
-
-`tests/Architecture/ColumnsHaveSqlCommentTest` parcourt `information_schema.columns` filtre sur le schema `public` et echoue si **une seule colonne** n'a pas de `col_description`. Seules les tables system (`doctrine_migration_versions`) et la whitelist `EXCLUDED_TABLES` explicite (commentaire de justification + ticket Lesstime ouvert pour le retrofit) sont tolerees.
-
-Conclusion : si tu crees une colonne sans poser son `COMMENT ON COLUMN`, `make test` casse en CI.
+Garde-fou : `tests/Architecture/ColumnsHaveSqlCommentTest` parcourt `information_schema.columns` (schema `public`) ; une seule colonne sans `col_description` casse `make test` (hors `EXCLUDED_TABLES`).
+→ exemples SQL + textes du helper : skill `backend-entity-conventions`.

.claude/rules/frontend.md

@@ -44,6 +44,44 @@ Tout champ de formulaire / filtre doit utiliser les composants `Malio*` plutot q
 
 Toute autre exception requiert validation avant merge.
 
+## Standard ecran formulaire — reference : ecran Client
+
+**Tout nouvel ecran de formulaire doit ressembler au premier ecran Client** (`frontend/modules/commercial/pages/clients/new.vue` + `[id]/edit.vue`) : meme structure (bloc principal puis onglets), memes marges/espacements, memes blocs de collection (ajout/suppression inline), meme validation inline 422 par champ. C'est la reference visuelle et fonctionnelle des formulaires du projet — s'en inspirer avant d'en creer un nouveau.
+
+## Validation des formulaires — useFormErrors obligatoire (erreur par champ)
+
+**Tout formulaire qui soumet a une API DOIT afficher les erreurs de validation 422 sous le champ concerne, via `useFormErrors`** (`frontend/shared/composables/useFormErrors.ts`). C'est le pendant front de « le back renvoie TOUTES les violations d'une 422 d'un coup » : un seul aller-retour, chaque erreur affichee inline sous son champ (prop `:error` des `Malio*`), pas un toast fourre-tout.
+
+Principe cle : **le nom du champ cote front = le `propertyPath` renvoye par le back**. Aucun mapping manuel champ par champ.
+
+Pattern de reference (champs scalaires) :
+
+```ts
+const { errors, setError, clearErrors, handleApiError } = useFormErrors()
+
+async function submit() {
+    clearErrors()
+    try {
+        await useApi().post('/clients', payload, { toast: false }) // toast: false obligatoire
+    } catch (e) {
+        // 422 → mapping inline par champ (pas de toast) ; autre → toast de fallback.
+        handleApiError(e, { fallbackMessage: t('foo.error') })
+    }
+}
+```
+
+```vue
+<MalioInputText v-model="form.companyName" :error="errors.companyName" />
+<MalioSelect    v-model="form.siren"       :error="errors.siren" />
+```
+
+Regles :
+- **Toujours `{ toast: false }`** sur l'appel API qui veut un mapping inline (sinon le toast natif d'`useApi` masque le fin).
+- **Cas metier specifique** (ex: 409 doublon) : `setError('champ', message)` + toast explicite **avant** de deleguer le reste a `handleApiError`. Cf. `useCategoryForm` (doublon RG-1.07).
+- **Collections** (listes de sous-entites sauvees par un appel par ligne) : une erreur PAR LIGNE via un tableau `ref<Record<string, string>[]>` aligne sur l'index, peuple par `mapViolationsToRecord(error.response._data)` (util pur de `shared/utils/api.ts`). Le composant de ligne expose une prop `:errors` (`Record<string, string>`) bindee sur le `:error` de chaque champ. Cf. `ClientContactBlock` / `ClientAddressBlock` et les submits de `clients/new.vue` / `clients/[id]/edit.vue`.
+
+**Interdit** : se contenter d'un toast global sur une 422 quand le back identifie les champs fautifs (`propertyPath`). Reimplementer un mapping `if/else` par champ a la main au lieu d'`useFormErrors` / `mapViolationsToRecord`.
+
 ## Tableaux de donnees — MalioDataTable obligatoire
 
 Tout affichage LISTE tabulaire (donnees metier paginees, CRUD admin) doit passer par `MalioDataTable` :
@@ -108,6 +146,18 @@ A NE PAS faire :
 - Seuls les deep links "de navigation metier" (ex: ouvrir un detail precis `/users/42`) sont dans l'URL
 - Exceptions autorisees **sur demande explicite** de l'utilisateur
 
+## Validation des formulaires (standard ERP-101)
+
+Regle transverse a TOUS les formulaires front (et a rappeler a l'ecriture de chaque ticket back/front portant un formulaire). Decidee en ERP-101 (declencheur : ecran « Ajouter un client » ERP-63).
+
+- **Champs obligatoires** : prop `required` du composant `Malio*` + etoile (asterisque) rouge dans le label. Ne JAMAIS griser le bouton « Valider » sans feedback : bouton toujours actif + erreurs affichees sous les champs.
+- **Couche de validation autoritaire = le back** : les RG sont re-validees serveur (mode strict). Au `422`, mapper `violations[].propertyPath` vers la prop `error` du champ via `extractApiViolations` (deja utilise par `useCategoryForm`). Zero duplication de RG, zero drift.
+- **Feedback instantane au blur** : uniquement requis / min / max / format (pas de re-implementation des RG metier cote front).
+- **Regles front-only** : celles sans equivalent back (ex. FK nullable cote back mais obligatoire selon un choix UI) sont validees et affichees cote front.
+- **Email — PAS de masque** : un email n'a pas de structure fixe. Normalisation via la prop `lowercase` de `MalioInputEmail` (trim + suppression des espaces + lowercase, coherent avec la normalisation serveur RG-1.21). Le format est valide par la prop `error` (violations serveur ou check au blur), jamais par un masque. Retirer tout shaping email ad hoc des ecrans.
+- **Contrat back attendu** : tout `422` issu d'un Processor/Validator doit porter `violations[].propertyPath` aligne sur les noms de champs du formulaire, pour etre consommable par `extractApiViolations`.
+- **Dependance** : le branchement des props `required` suppose `@malio/layer-ui` a jour (props `required` + etoile — MUI-41 / ERP-101).
+
 ## Interdits
 
 - `modules-loader.ts`, `.module.ts` — le scan des layers est automatique

.claude/skills/backend-entity-conventions/SKILL.md

@@ -0,0 +1,251 @@
+---
+name: backend-entity-conventions
+description: Conventions détaillées des entités métier Starseed (back PHP/Symfony/API Platform) — messages de validation FR sur les contraintes, pagination API Platform et providers ORM/DBAL, libellé i18n du type d'entité auditée, Timestampable/Blamable, COMMENT ON COLUMN des migrations. Charger dès qu'on crée ou modifie une entité Domain, un ApiResource, un Provider/Processor, une contrainte de validation, ou une migration Doctrine. Le résumé court de chaque règle (+ nom du test garde-fou) reste dans .claude/rules/backend.md ; ce skill porte les patterns, tableaux et exemples complets.
+---
+
+# Conventions entités métier — détail
+
+Ce skill contient le détail (patterns code, tableaux, dérivations) des 5 règles back qui ont chacune
+un test Architecture déterministe. L'énoncé court de chaque règle vit dans `.claude/rules/backend.md`
+(chargé à chaque session) ; ici on trouve le « comment » complet.
+
+> Règle d'or : le **test Architecture reste le juge** (il casse `make test`). Ce skill aide à écrire
+> le code juste du premier coup, il ne remplace pas le garde-fou.
+
+---
+
+## 1. Messages de validation (Garde-fou : `EntityConstraintsHaveFrenchMessageTest`)
+
+**Toute contrainte `#[Assert\*]` portée par une entité métier doit avoir un message FR explicite**, et
+**`Assert\Length.max` doit refléter le `length` de la colonne ORM**. C'est le pendant back du mapping
+d'erreur par champ côté front (ERP-101 : `useFormErrors` / `mapViolationsToRecord` affiche sous chaque
+champ le `message` renvoyé par le back).
+
+Pourquoi :
+- Sans `message:` explicite, Symfony renvoie le défaut **anglais** (« This value is not a valid email
+  address. »). La locale FR globale (`default_locale: fr` dans `framework.yaml`) sert de FILET via
+  `validators.fr.xlf`, mais les contraintes métier portent en plus leur message FR pour un contrôle total.
+- Une colonne string bornée **sans `Assert\Length`** échoue au niveau Postgres (500 générique, non
+  rattachée au champ) au lieu d'une 422 propre. Le `max` doit égaler le `length` ORM (anti-dérive).
+
+Pattern par champ scalaire :
+
+```php
+// Email métier
+#[Assert\Email(message: 'L\'adresse email n\'est pas valide.')]
+
+// Longueur calée sur la colonne (VARCHAR(120))
+#[ORM\Column(length: 120)]
+#[Assert\Length(max: 120, maxMessage: 'Le nom ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+
+// Obligatoire (aligner nullable DB / NotBlank back / required front)
+#[Assert\NotBlank(message: 'Le téléphone est obligatoire.', normalizer: 'trim')]
+```
+
+Cohérence à 3 niveaux pour un champ obligatoire : colonne `nullable` (DB) <-> `Assert\NotBlank` (back)
+<-> `:required` + astérisque (front ERP-101). Les trois doivent s'accorder.
+
+Exceptions au miroir `Length` : un format déjà borné par `Assert\Bic` / `Assert\Iban` (longueur
+garantie) ou par un `Assert\Regex` borné (ex. code postal `{4,5}`, couleur hex `#RRGGBB`) — whitelister
+alors la propriété dans `EntityConstraintsHaveFrenchMessageTest::EXCLUDED_LENGTH_MIRROR` avec justification.
+
+Les règles inter-champs (RG métier : exclusivité distributor/broker RG-1.03, billingEmail RG-1.11, etc.)
+passent par un `#[Assert\Callback]` qui construit la violation avec `->atPath('<champ>')` — indispensable
+pour que le front la mappe en inline plutôt qu'en toast.
+
+### Garde-fou architecture
+
+`tests/Architecture/EntityConstraintsHaveFrenchMessageTest` scanne réflexivement les entités sous
+`src/Module/*/Domain/Entity/` et échoue si :
+1. une contrainte connue n'a pas de message FR explicite (comparé au défaut Symfony) ;
+2. une colonne string bornée writable n'a pas de `Assert\Length(max == ORM length)` (hors whitelist).
+
+Une contrainte non gérée par le mapping du test le fait échouer : il faut l'ajouter explicitement
+(anti faux positif vert).
+
+---
+
+## 2. Pagination (Garde-fou : `CollectionsArePaginatedTest`)
+
+**Règle** : toute collection API DOIT être paginée. Aucun retour de collection complète côté serveur.
+
+### Standard global
+
+Posé dans `config/packages/api_platform.yaml` (section `defaults:`) et hérité par toutes les ressources :
+
+| Clé | Valeur | Effet |
+|---|---|---|
+| `pagination_enabled` | `true` | Pagination Hydra active par défaut. |
+| `pagination_items_per_page` | `10` | Taille de page par défaut, alignée sur l'UI `MalioDataTable`. |
+| `pagination_maximum_items_per_page` | `50` | Borne dure : `?itemsPerPage=999` → ramené à 50. Anti deep-fetch. |
+| `pagination_client_items_per_page` | `true` | Le client peut envoyer `?itemsPerPage=25` (bornée par le max). |
+| `pagination_client_enabled` | `true` | Le client peut envoyer `?pagination=false` pour TOUT récupérer (échappatoire selects). |
+
+### Override par ressource (rare)
+
+Si une ressource a besoin d'un autre défaut (ex: payload lourd), utiliser les attributs sur l'opération.
+**JAMAIS `paginationEnabled: false`** sans whitelist explicite dans
+`tests/Architecture/CollectionsArePaginatedTest::EXCLUDED`.
+
+```php
+new GetCollection(
+    paginationItemsPerPage: 5,           // override taille par défaut
+    paginationMaximumItemsPerPage: 20,   // override borne max
+)
+```
+
+### Selects et autocomplétions
+
+Pour alimenter un `<select>` ou un drawer RBAC (Role, Permission, Site, CategoryType), le front passe :
+
+```ts
+useApi().get('/api/roles?pagination=false')
+```
+
+Le serveur retourne toute la collection, sans `view`. C'est l'échappatoire prévue par
+`pagination_client_enabled: true`. Sur les ressources à forte volumétrie, préférer une saisie assistée
+(recherche serveur via `?q=`) — à planifier dans un ticket dédié.
+
+Les tests fonctionnels qui exercent ce comportement doivent également passer `?pagination=false`
+(cf. `CategoryListTest`, `PermissionApiTest`).
+
+### Providers customs et pagination
+
+Un provider custom qui retourne un `array` brut sur une `CollectionOperationInterface`
+**court-circuite la pagination Hydra** (pas de `totalItems`, pas de `view`). Patterns supportés :
+
+- **ORM** : injecter `ApiPlatform\State\Pagination\Pagination`, wrap un
+  `Doctrine\ORM\Tools\Pagination\Paginator` dans `ApiPlatform\Doctrine\Orm\Paginator`. Exemple : `CategoryProvider`.
+- **DBAL** : implémenter un paginator local conforme à `PaginatorInterface`. Exemple : `DbalPaginator`
+  (Core) + `AuditLogProvider`.
+
+Gérer l'échappatoire `?pagination=false` :
+
+```php
+if (!$this->pagination->isEnabled($operation, $context)) {
+    return $qb->getQuery()->getResult(); // tout retourner
+}
+```
+
+### Garde-fou architecture
+
+`tests/Architecture/CollectionsArePaginatedTest` scanne réflexivement toutes les classes
+`#[ApiResource]` sous `src/` et échoue si une `GetCollection` pose `paginationEnabled: false` hors
+whitelist `EXCLUDED`. Ajouter une entrée à la whitelist requiert une justification courte + un ticket
+Lesstime ouvert.
+
+---
+
+## 3. Libellé i18n du type d'entité auditée (Garde-fou : `AuditableEntitiesHaveI18nLabelTest`)
+
+**Toute entité `#[Auditable]` doit avoir son libellé FR dans le bloc `audit.entity` de
+`frontend/i18n/locales/fr.json`.** C'est la contrepartie i18n de l'attribut : sans elle, le filtre
+« Type d'entité » de l'audit-log affiche le type technique brut (ex: `commercial.Client`) au lieu d'un
+libellé lisible.
+
+Pourquoi : le filtre est dynamique (`GET /audit-log-entity-types` renvoie les `entity_type` distincts
+présents en base) ; dès qu'un module audite une entité, son type y apparaît. Le front
+(`formatEntityType`, `audit-log.vue`) construit la clé `audit.entity.<module>_<entity>` et, faute de
+traduction, **retombe silencieusement** sur le type brut.
+
+Dérivation de la clé (emplacement centralisé + schéma flat — décision ERP-99) :
+
+| FQCN entité | `entity_type` (back) | Clé i18n (flat) |
+|---|---|---|
+| `App\Module\Commercial\Domain\Entity\Client` | `commercial.Client` | `commercial_client` |
+| `App\Module\Commercial\Domain\Entity\ClientAddress` | `commercial.ClientAddress` | `commercial_clientaddress` |
+| `App\Module\Catalog\Domain\Entity\Category` | `catalog.Category` | `catalog_category` |
+
+Règle : `strtolower(module)` + `_` + `strtolower(Entity)`. Ajouter sa clé de libellé audit fait partie
+de la **définition de fini** d'une entité métier auditée.
+
+**Garde-fou** : `tests/Architecture/AuditableEntitiesHaveI18nLabelTest` scanne les entités `#[Auditable]`
+et échoue si une seule n'a pas sa clé `audit.entity.*`. Conclusion : créer une entité `#[Auditable]`
+sans son libellé i18n casse `make test`.
+
+---
+
+## 4. Timestampable + Blamable (Garde-fou : `EntitiesAreTimestampableBlamableTest`)
+
+Toute **nouvelle** entité métier sous `src/Module/*/Domain/Entity/` doit porter les 4 colonnes
+`created_at` / `updated_at` / `created_by` / `updated_by`, remplies automatiquement. Trois lignes à
+ajouter à l'entité :
+
+```php
+use App\Shared\Domain\Contract\BlamableInterface;
+use App\Shared\Domain\Contract\TimestampableInterface;
+use App\Shared\Domain\Trait\TimestampableBlamableTrait;
+
+class MyEntity implements TimestampableInterface, BlamableInterface
+{
+    use TimestampableBlamableTrait; // porte les 4 props + getters/setters
+    // ... reste métier
+}
+```
+
+- Le `TimestampableBlamableSubscriber` (`Shared/Infrastructure/Doctrine/`) remplit les colonnes au
+  `prePersist` / `preUpdate`. Hors contexte HTTP (CLI, cron, migration), le blame reste `null`
+  (libellé « Système » côté front).
+- La migration de l'entité doit créer les 4 colonnes (`created_at` / `updated_at` NOT NULL,
+  `created_by` / `updated_by` nullable `ON DELETE SET NULL`).
+- **Garde-fou CI** : `tests/Architecture/EntitiesAreTimestampableBlamableTest` échoue si une entité
+  oublie le pattern. Un référentiel statique justifié (ex: `CategoryType`) doit être explicitement
+  whitelisté dans la constante `EXCLUDED` avec un commentaire.
+- Spec complète : @docs/specs/M0-categories/spec-back.md § 2.8 + § 2.8.bis
+
+---
+
+## 5. Migrations Doctrine — COMMENT ON COLUMN (Garde-fou : `ColumnsHaveSqlCommentTest`)
+
+**Toute migration qui crée ou modifie une colonne d'une table métier doit poser un `COMMENT ON COLUMN`
+décrivant le champ.** La description est stockée dans `pg_description` et visible dans tous les outils
+d'admin BDD (DBeaver, DataGrip, pgAdmin), sans avoir à lire les annotations PHP.
+
+**Format de la description** :
+- En français
+- ≤ 200 caractères
+- Sémantique du champ — contraintes / lien RG si pertinent
+- Pour les colonnes d'identifiant ou FK, mentionner la cible
+
+Exemples :
+
+```php
+// Migration : création d'une colonne avec son commentaire dans la même migration
+$this->addSql("ALTER TABLE client ADD COLUMN siren VARCHAR(9) DEFAULT NULL");
+$this->addSql("COMMENT ON COLUMN client.siren IS 'SIREN (9 chiffres) — identifiant legal entreprise. Unique parmi non-archives (RG-1.15).'");
+
+// Cas FK : préciser la cible
+$this->addSql("COMMENT ON COLUMN client.legal_form_id IS 'Reference forme juridique (SARL, SAS, SA...) — FK -> legal_form.id, ON DELETE RESTRICT.'");
+
+// Cas booléen : préciser le sens et la valeur par défaut
+$this->addSql("COMMENT ON COLUMN user.is_admin IS 'Drapeau super-administrateur — bypass complet RBAC. Faux par defaut.'");
+
+// Bonus : décrire la table elle-même
+$this->addSql("COMMENT ON TABLE client IS 'Repertoire clients (M1 Commercial) — entites archivables.'");
+```
+
+### Helper Timestampable/Blamable
+
+Les 4 colonnes `created_at`, `updated_at`, `created_by`, `updated_by` ajoutées par
+`TimestampableBlamableTrait` reçoivent une description **standardisée** via le helper centralisé pour
+éviter la duplication. Helper à créer ou appeler :
+
+```php
+// Dans la migration, après avoir ajouté les 4 colonnes :
+$this->addStandardTimestampableBlamableComments($schema, 'client');
+```
+
+L'implémentation du helper applique :
+- `created_at` : « Horodatage de creation de la ligne (UTC, rempli automatiquement par TimestampableBlamableSubscriber). »
+- `updated_at` : « Horodatage de derniere modification de la ligne (UTC, rempli automatiquement par TimestampableBlamableSubscriber). »
+- `created_by` : « ID de l'utilisateur ayant cree la ligne — null pour les creations hors HTTP (CLI, migration, fixture). FK -> user.id, ON DELETE SET NULL. »
+- `updated_by` : « ID de l'utilisateur ayant modifie la ligne en dernier — null pour les modifications hors HTTP. FK -> user.id, ON DELETE SET NULL. »
+
+### Garde-fou architecture
+
+`tests/Architecture/ColumnsHaveSqlCommentTest` parcourt `information_schema.columns` filtré sur le
+schéma `public` et échoue si **une seule colonne** n'a pas de `col_description`. Seules les tables
+système (`doctrine_migration_versions`) et la whitelist `EXCLUDED_TABLES` explicite (commentaire de
+justification + ticket Lesstime ouvert pour le retrofit) sont tolérées.
+
+Conclusion : si tu crées une colonne sans poser son `COMMENT ON COLUMN`, `make test` casse en CI.

README.md

@@ -1,209 +1,362 @@
 # Starseed
 
-CRM/ERP — Symfony 8 (API Platform 4) + Nuxt 4
+CRM/ERP en architecture **modular monolith DDD** — Symfony 8 (API Platform 4) + Nuxt 4.
+
+Le backend est la **source de vérité unique** : il décide des modules actifs et de
+l'organisation de la sidebar. Le frontend scanne `frontend/modules/*/` comme layers
+Nuxt et consomme l'API pour la navigation.
+
+---
+
+## Sommaire
+
+- [Stack](#stack)
+- [Prérequis](#prérequis)
+- [Démarrage rapide](#démarrage-rapide)
+- [Dev local : avec ou sans données de seed](#dev-local--avec-ou-sans-données-de-seed)
+- [Comptes (dev)](#comptes-dev)
+- [Bases de données : dev et test](#bases-de-données--dev-et-test)
+- [Tests](#tests)
+- [Déploiement : seed RBAC en recette / prod](#déploiement--seed-rbac-en-recette--prod)
+- [Commandes make](#commandes-make)
+- [Architecture](#architecture)
+- [Structure du dépôt](#structure-du-dépôt)
+- [CI/CD](#cicd)
+- [Conventions](#conventions)
+
+---
 
 ## Stack
 
 - **Backend** : PHP 8.4, Symfony 8, API Platform 4, Doctrine ORM, PostgreSQL 16
-- **Frontend** : Nuxt 4 (SPA), Vue 3, Pinia, Tailwind CSS, @malio/layer-ui
-- **Auth** : JWT HTTP-only cookie (Lexik)
+- **Frontend** : Nuxt 4 (SPA, SSR off), Vue 3, Pinia, Tailwind CSS, @malio/layer-ui, @nuxtjs/i18n
+- **Auth** : JWT HTTP-only cookie (Lexik), login sur `/login_check`
 - **Infra** : Docker Compose (dev + prod multi-stage)
 - **CI/CD** : Gitea Actions (auto-tag + build Docker)
 
-## Quick Start
+| Service       | Port |
+|---------------|------|
+| API (Nginx)   | 8083 |
+| Frontend dev  | 3004 |
+| PostgreSQL    | 5437 |
+
+---
+
+## Prérequis
+
+- Docker + Docker Compose
+- `make`
+- `nvm` (la version de Node est fixée par `.nvmrc`, voir `make node-use`)
+
+Toutes les commandes `make` s'exécutent dans le container PHP (`php-starseed-fpm`) ;
+rien n'est requis sur l'hôte hormis Docker — **sauf les tests E2E**, qui tournent sur
+l'hôte (navigateur réel, voir [Tests](#tests)).
+
+---
+
+## Démarrage rapide
 
 ```bash
-make start           # Demarrer les containers Docker
-make install         # Composer, migrations, fixtures, build Nuxt
+make start      # Démarre les containers Docker
+make install    # Composer + clés JWT + migrations + permissions + BDD de test
+make dev-nuxt   # Serveur Nuxt avec hot reload (http://localhost:3004)
 ```
 
-Dev frontend (hot reload) :
+`make install` prépare une base de dev **vierge** (schéma + RBAC structurel, sans
+données de démo) et la base de **test**. Pour obtenir des comptes et des données de
+démo prêtes à l'emploi, lis la section suivante.
+
+> Override local possible : `make` lit `infra/dev/.env.docker`, surchargé par
+> `infra/dev/.env.docker.local` s'il existe (créé automatiquement par `make env-init`).
+
+---
+
+## Dev local : avec ou sans données de seed
+
+Le projet distingue deux états de base de données de dev. Les **fixtures Doctrine sont
+en `require-dev`** : elles n'existent qu'en dev, jamais dans le build de prod.
+
+### Sans données de seed (base vierge)
+
+C'est ce que produit `make install`. La base contient :
+
+- le **schéma** complet (toutes les migrations jouées) ;
+- les **rôles système** `admin` / `user` (seedés en SQL par la migration RBAC) ;
+- le **catalogue de permissions** synchronisé (`app:sync-permissions`).
+
+Mais **aucun compte utilisateur ni donnée métier**. Pour pouvoir te connecter,
+crée toi-même un compte :
 
 ```bash
-make dev-nuxt        # Port 3003
+make shell
+php bin/console app:create-user admin monMotDePasse --admin   # compte ROLE_ADMIN
 ```
 
-## Ports
+Optionnel — provisionner les **rôles métier** (bureau / compta / commerciale / usine
++ matrice RBAC § 2.7) sans comptes de démo :
 
-| Service    | Port |
-|------------|------|
-| API (Nginx)| 8083 |
-| Frontend   | 3004 |
-| PostgreSQL | 5437 |
+```bash
+php bin/console app:seed-rbac
+```
 
-## Commandes
+Cet état est utile pour repartir d'une base propre, reproduire un bug sur données
+minimales, ou tester un parcours d'onboarding réel.
 
-| Commande | Description |
-|----------|-------------|
-| `make start` | Demarrer les containers |
-| `make stop` | Arreter les containers |
-| `make restart` | Redemarrer les containers |
-| `make install` | Install complet |
-| `make reset` | Tout supprimer et reinstaller |
-| `make dev-nuxt` | Serveur dev Nuxt (hot reload) |
-| `make shell` | Shell dans le container PHP |
-| `make cache-clear` | Vider le cache Symfony |
-| `make migration-migrate` | Lancer les migrations |
-| `make fixtures` | Charger les fixtures |
-| `make db-reset` | Reset BDD + migrations + fixtures |
-| `make test` | PHPUnit (tests back) |
-| `make nuxt-test` | Vitest (tests unitaires front) |
-| `make test-e2e` | Playwright (tests E2E front) |
-| `make test-e2e-ui` | Playwright UI interactive (debug) |
-| `make seed-e2e` | Seed les 6 personas E2E |
-| `make install-e2e-deps` | One-time : Chromium + libs systeme (sudo) |
-| `make php-cs-fixer-allow-risky` | Fix code style PHP |
-| `make logs-dev` | Tail logs Symfony |
+### Avec données de seed (base de démo)
+
+`make db-reset` (ou `make fixtures` après un `make install`) recharge la base de dev
+avec un jeu complet de données de démonstration, **idempotent** :
+
+```bash
+make db-reset   # ATTENTION : drop + recrée la base de dev, puis charge tout le seed
+```
+
+Ce que les fixtures posent :
+
+- **3 utilisateurs système** : `admin` (ROLE_ADMIN), `alice`, `bob` (ROLE_USER),
+  rattachés à des sites distincts ;
+- **3 sites** : Chatellerault, Saint-Jean, Pommevic ;
+- **les comptes de démo RBAC métier** (`bureau`, `compta`, `commerciale`, `usine`,
+  mot de passe `demo`) avec la matrice § 2.7 attachée ;
+- les **référentiels et données métier** des modules (catégories, clients de démo,
+  référentiels comptables…).
+
+Toutes les fixtures sont rejouables sans effet de bord (lookup par clé naturelle,
+aucun doublon).
+
+> Différence avec `make install` : `install` ne charge **pas** les fixtures sur la base
+> de dev (il alimente uniquement la base de test). Utilise `make db-reset` ou
+> `make fixtures` quand tu veux des données de démo en dev.
+
+---
+
+## Comptes (dev)
+
+Disponibles uniquement après `make db-reset` / `make fixtures` (état « avec seed ») :
+
+| Username      | Password | Rôle       | RBAC métier                                                   |
+|---------------|----------|------------|---------------------------------------------------------------|
+| `admin`       | `admin`  | ROLE_ADMIN | bypass complet (`is_admin`)                                   |
+| `alice`       | `alice`  | ROLE_USER  | —                                                             |
+| `bob`         | `bob`    | ROLE_USER  | —                                                             |
+| `bureau`      | `demo`   | ROLE_USER  | clients : view + manage                                       |
+| `compta`      | `demo`   | ROLE_USER  | clients : view + accounting.view / manage                     |
+| `commerciale` | `demo`   | ROLE_USER  | clients : view + manage (Information obligatoire — RG-1.04)   |
+| `usine`       | `demo`   | ROLE_USER  | aucun accès clients                                           |
+
+---
+
+## Bases de données : dev et test
+
+Deux bases distinctes vivent dans le **même container PostgreSQL** (port 5437) :
+
+| Base       | Environnement | Construite par                       | Usage                          |
+|------------|---------------|--------------------------------------|--------------------------------|
+| `<db>`      | `dev`         | `make install` / `make db-reset`     | développement manuel, dev-nuxt |
+| `<db>_test` | `test`        | `make test-db-setup`                 | PHPUnit (jamais touchée à la main) |
+
+Le suffixe `_test` est appliqué **automatiquement** par Doctrine quand `APP_ENV=test`
+(config `when@test` dans `config/packages/doctrine.yaml`). La base de test est donc
+totalement **isolée** de la base de dev : lancer `make test` ne touche jamais tes
+données de dev.
+
+`make test-db-setup` fait davantage que jouer les migrations, car certaines structures
+ne sont pas portées par des migrations « métier » :
+
+1. `doctrine:migrations:migrate` — schéma métier réel ;
+2. `doctrine:schema:update --force` — crée les tables mappées en `when@test`
+   uniquement (entités de test) ;
+3. `app:apply-column-comments` — réapplique les `COMMENT ON COLUMN` que
+   `schema:update` efface sur les tables managées par l'ORM (garde-fou
+   `ColumnsHaveSqlCommentTest`) ;
+4. `fixtures:load` → `sync-permissions` → `seed-rbac` — dans cet ordre précis
+   (le purger des fixtures vide la table `permission`, donc la sync passe après) ;
+5. recréation des **index partiels uniques** (`LOWER(...) WHERE ...`) non exprimables
+   en attributs ORM, indispensables aux tests d'unicité (RG-1.07, RG-1.16, RG-1.03/1.29).
+
+`make install` et `make db-reset` appellent déjà `test-db-setup` : tu n'as à le
+relancer à la main que si la base de test diverge (nouvelle migration, nouvelle
+permission) sans vouloir reseed la base de dev.
+
+---
 
 ## Tests
 
-- **Back** : `make test` (PHPUnit). Fixtures dediees sous `tests/Fixtures/`.
-- **Front unitaire** : `make nuxt-test` (Vitest, happy-dom). Composables, utils, stores — rapide, <30s.
-- **Front E2E** : `make test-e2e` (Playwright). Couvre login + matrice RBAC sidebar. Suite volontairement minimaliste (11 tests) — voir la regle d'or dans `CLAUDE.md`.
+| Suite             | Commande         | Outil                | Où                                |
+|-------------------|------------------|----------------------|-----------------------------------|
+| Back              | `make test`      | PHPUnit              | container PHP, base `<db>_test`   |
+| Front unitaire    | `make nuxt-test` | Vitest (happy-dom)   | container Node, < 30 s            |
+| Front E2E         | `make test-e2e`  | Playwright           | **hôte** (navigateur réel requis) |
+| Tout (back+front) | `make test-all`  | PHPUnit + Vitest     | —                                 |
+
+### Tests back (PHPUnit)
 
-**Bootstrap E2E (une fois par poste)** :
 ```bash
-make install-e2e-deps   # Telecharge Chromium + libs systeme via apt (sudo)
+make test                       # toute la suite
+make test FILES=tests/Module/Commercial   # un dossier / fichier ciblé
 ```
 
-**Workflow E2E** :
+PHPUnit force `APP_ENV=test` (`phpunit.dist.xml`) : les tests tournent **toujours**
+sur la base `<db>_test`, jamais sur la base de dev. Prérequis : que la base de test
+existe — c'est le cas après `make install`. Si elle a divergé, rejoue
+`make test-db-setup` (cf. [Bases de données](#bases-de-données--dev-et-test)).
+
+### Tests front unitaires (Vitest)
+
 ```bash
-# Terminal 1 : containers + dev server
+make nuxt-test   # composables, utils, stores — rapide et stable
+```
+
+C'est la **place par défaut** pour étendre la couverture (cf. règle d'or ci-dessous).
+
+### Tests E2E (Playwright)
+
+Suite volontairement minimaliste (login + matrice RBAC sidebar). **Règle d'or : un
+nouveau test E2E ne s'ajoute que si un bug critique est passé en prod** — sinon,
+préférer un test Vitest ou étendre un persona existant.
+
+Bootstrap (une fois par poste) :
+
+```bash
+make install-e2e-deps   # télécharge Chromium + libs système (apt/dnf, sudo)
+```
+
+Workflow :
+
+```bash
+# Terminal 1 — containers, seed des personas, serveur dev
 make start && make seed-e2e && make dev-nuxt
 
-# Terminal 2 : tests
-make test-e2e
+# Terminal 2 — tests
+make test-e2e            # headless
+make test-e2e-ui         # UI interactive (debug)
 ```
 
+> Toute permission testable touche **3 miroirs** à garder alignés : `config/sidebar.php`,
+> `frontend/tests/e2e/_fixtures/personas.ts`, `SeedE2ECommand.php`.
+
+---
+
+## Déploiement : seed RBAC en recette / prod
+
+Les fixtures Doctrine étant en `require-dev`, elles sont **absentes du build de prod**.
+Le RBAC métier (rôles `bureau` / `compta` / `commerciale` / `usine` + matrice § 2.7)
+est seedé par une **commande applicative idempotente**, jouée dans l'étape de release,
+**après** les migrations et la synchronisation des permissions :
+
+```bash
+php bin/console doctrine:migrations:migrate --no-interaction
+php bin/console app:sync-permissions      # pose les permissions (commercial.clients.*, …)
+php bin/console app:seed-rbac             # PROD : rôles + matrice § 2.7 (sans comptes démo)
+```
+
+En **recette / staging**, ajouter le flag pour disposer de logins de test. Le mot de
+passe est fourni **explicitement** (jamais en dur, jamais committé) :
+
+```bash
+php bin/console app:seed-rbac --with-demo-users --password='<mot-de-passe>'
+# ou via la variable d'environnement RBAC_DEMO_PASSWORD
+```
+
+La commande est rejouable sans effet de bord (aucun doublon de rôle, de lien ou de
+compte). Pour créer un premier administrateur en prod :
+
+```bash
+php bin/console app:create-user <username> <password> --admin
+```
+
+---
+
+## Commandes make
+
+`make` (sans argument) ou `make help` affiche l'aide colorée. Les principales :
+
+| Commande                       | Description                                              |
+|--------------------------------|----------------------------------------------------------|
+| `make start` / `stop` / `restart` | Cycle de vie des containers                          |
+| `make install`                 | Install complet (base dev vierge + base de test)         |
+| `make reset`                   | Tout supprimer et réinstaller (**drop la BDD**)          |
+| `make dev-nuxt`                | Serveur Nuxt hot reload (port 3004)                      |
+| `make shell` / `shell-root`    | Shell bash dans le container PHP                         |
+| `make migration-migrate`       | Jouer les migrations Doctrine                            |
+| `make fixtures`                | Charger les fixtures (données de démo dev)               |
+| `make sync-permissions`        | Synchroniser le catalogue RBAC                           |
+| `make seed-rbac`               | Seed RBAC métier (rôles + matrice § 2.7)                 |
+| `make db-reset`                | Reset base dev : drop + migrate + fixtures + RBAC        |
+| `make test-db-setup`           | (Re)construire la base de test                           |
+| `make test`                    | PHPUnit (back)                                           |
+| `make nuxt-test`               | Vitest (front unitaire)                                  |
+| `make test-all`                | PHPUnit + Vitest                                         |
+| `make test-e2e` / `test-e2e-ui`| Playwright (E2E, sur l'hôte)                             |
+| `make seed-e2e`                | Seed des 6 personas E2E                                  |
+| `make php-cs-fixer-allow-risky`| Fix du code style PHP                                    |
+| `make php-cs-fixer-check`      | Dry-run du fixer (CI / avant push)                       |
+| `make logs-dev`                | Tail des logs Symfony                                    |
+
+---
+
 ## Architecture
 
-**Modular Monolith DDD** : chaque module est un bounded context autonome, activable/desactivable par tenant. Le backend est la seule source de verite pour l'activation et l'organisation de la sidebar.
+**Modular Monolith DDD** : chaque module est un bounded context autonome,
+activable / désactivable par tenant. Le backend est la seule source de vérité pour
+l'activation des modules et l'organisation de la sidebar.
 
 - `config/modules.php` — liste des modules actifs
 - `config/sidebar.php` — structure de la sidebar (sections + items avec module owner)
-- `GET /api/sidebar` — retourne les sections filtrees par les modules actifs + les routes desactivees
-- Frontend : chaque `frontend/modules/*/` est auto-detecte comme layer Nuxt, la sidebar est fetchee de l'API
+- `GET /api/modules` — IDs des modules actifs (public)
+- `GET /api/sidebar` — sections filtrées par modules actifs + routes désactivées (public)
 
-Pour desactiver un module : commenter sa ligne dans `config/modules.php`, clear cache. Ses items de sidebar disparaissent et ses routes sont bloquees par le middleware front.
+**Désactiver un module** : commenter sa ligne dans `config/modules.php`, vider le cache.
+Ses items de sidebar disparaissent et ses routes sont bloquées par le middleware front.
+Le code reste dans le bundle (layer auto-détecté) → réactivation instantanée.
 
-Pour reorganiser la sidebar (ex: deplacer un item d'une section a l'autre) : editer `config/sidebar.php` uniquement, le code des modules n'est pas touche.
+**Réorganiser la sidebar** : éditer `config/sidebar.php` uniquement — le code des
+modules n'est pas touché.
 
-## Structure
+**Communication inter-modules** : jamais d'import direct d'un module à l'autre. Passer
+par `Shared/Domain/Contract/` (interfaces) ou des domain events.
+
+---
+
+## Structure du dépôt
 
 ```
 src/                              # Backend Symfony
-  Kernel.php
-  Shared/                         # Noyau technique partage
-    Domain/
-      ValueObject/                # Email, ...
-      Event/                      # DomainEventInterface
-      Contract/                   # Interfaces inter-modules
-    Application/
-      Bus/                        # CommandBusInterface, QueryBusInterface
-    Infrastructure/
-      ApiPlatform/
-        Resource/                 # AppVersion, ModulesResource, SidebarResource
-        State/                    # AppVersionProvider, ModulesProvider, SidebarProvider
+  Shared/                         # Noyau technique partagé (Domain/, Application/Bus/, Infrastructure/ApiPlatform/)
   Module/
-    Core/                         # Module obligatoire (auth, users)
-      CoreModule.php              # Declaration (ID, LABEL, REQUIRED)
-      Domain/
-        Entity/                   # User
-        Repository/               # UserRepositoryInterface
-        Event/                    # UserCreated
-      Application/
-        DTO/                      # UserOutput
-      Infrastructure/
-        Doctrine/                 # DoctrineUserRepository, Migrations/
-        ApiPlatform/State/
-          Provider/               # MeProvider
-          Processor/              # UserPasswordHasherProcessor
-        Console/                  # CreateUserCommand
-        DataFixtures/             # AppFixtures
-    Commercial/                   # Autre module (exemple)
-      CommercialModule.php
+    Core/                         # Module obligatoire (auth, users, RBAC)
+      CoreModule.php              # Déclaration (ID, LABEL, REQUIRED, permissions())
+      Domain/ Application/ Infrastructure/
+    Commercial/ Catalog/ Sites/   # Modules métier
 config/
-  modules.php                     # Source de verite activation
-  sidebar.php                     # Source de verite navigation
-  version.yaml
-  packages/                       # Config Symfony
-  jwt/                            # Cles JWT
-migrations/                       # Anciennes migrations
+  modules.php                     # Source de vérité : activation
+  sidebar.php                     # Source de vérité : navigation
+  packages/                       # Config Symfony (doctrine, api_platform, security…)
+migrations/                       # Migrations d'initialisation (namespace racine : setup, RBAC, seed de base)
 frontend/                         # App Nuxt 4 (SPA)
-  app/
-    layouts/                      # default.vue, auth.vue
-    middleware/                   # auth.global.ts, modules.global.ts
-  shared/                         # Code partage (hors modules)
-    composables/                  # useApi, useAppVersion, useSidebar
-    components/ui/                # AppTopNav, ...
-    stores/                       # auth, ui
-    services/                     # auth
-    types/                        # SidebarSection, UserData
-    utils/                        # api (Hydra)
-  modules/                        # Modules auto-detectes comme layers Nuxt
-    core/
-      nuxt.config.ts              # Marqueur layer
-      pages/                      # index, login, logout
-    commercial/
-      nuxt.config.ts
-      pages/                      # commercial.vue
-  app.vue
-  nuxt.config.ts                  # Scanne modules/*/ automatiquement
-  i18n/locales/                   # Traductions (sidebar.*, etc.)
-  assets/                         # CSS, images
-  public/                         # Fichiers statiques
+  app/                            # Shell : layouts, middlewares (auth.global, modules.global)
+  shared/                         # Code inter-modules (composables, stores, utils, types)
+  modules/                        # Layers Nuxt auto-détectés (core/, commercial/…)
+  i18n/locales/                   # Traductions (sidebar.*, audit.entity.*, …)
 infra/
-  dev/                            # Docker dev (Dockerfile, nginx, php.ini, xdebug)
+  dev/                            # Docker dev (Dockerfile, nginx, php.ini, xdebug, .env.docker)
   prod/                           # Docker prod (multi-stage, nginx, php-prod.ini)
 .gitea/workflows/                 # CI Gitea (auto-tag, build Docker)
-.claude/
-  skills/create-module/           # Skill Claude Code pour scaffolder un module
 ```
 
+---
+
 ## CI/CD
 
 - **Auto Tag** : push sur `develop` → bump `config/version.yaml` → tag `vX.Y.Z`
 - **Build Docker** : push tag `v*` → build image multi-stage → push Gitea Registry
 
 Secrets requis dans Gitea :
+
 - `RELEASE_TOKEN` — PAT avec droits `write:repository`
 - `REGISTRY_TOKEN` — token pour le registry Docker
 
-## Déploiement — seed RBAC (recette / prod)
-
-Le RBAC métier (rôles `bureau` / `compta` / `commerciale` / `usine` + matrice § 2.7)
-est seedé par une **commande applicative idempotente** (présente dans le build prod,
-contrairement aux fixtures Doctrine en `require-dev`). À jouer dans l'étape de release,
-**après** les migrations et la synchronisation des permissions :
-
-```bash
-php bin/console doctrine:migrations:migrate --no-interaction
-php bin/console app:sync-permissions          # pose les permissions commercial.clients.*
-php bin/console app:seed-rbac                  # PROD : rôles + matrice § 2.7 (sans comptes démo)
-```
-
-En **recette / staging**, ajouter le flag pour disposer de logins de test (mot de passe
-fourni explicitement, jamais en dur) :
-
-```bash
-php bin/console app:seed-rbac --with-demo-users --password='<mot-de-passe>'
-# ou via la variable d'env RBAC_DEMO_PASSWORD
-```
-
-La commande est rejouable sans effet de bord (aucun doublon de rôle, de lien ou de compte).
-En dev, `make db-reset` produit le même résultat (rôles + matrice + comptes démo).
-
-## Credentials (dev)
-
-| Username | Password | Role | RBAC métier |
-|----------|----------|------|-------------|
-| admin | admin | ROLE_ADMIN | bypass (is_admin) |
-| alice | alice | ROLE_USER | — |
-| bob | bob | ROLE_USER | — |
-| bureau | demo | ROLE_USER | clients : view + manage |
-| compta | demo | ROLE_USER | clients : view + accounting.view/manage |
-| commerciale | demo | ROLE_USER | clients : view + manage (Information obligatoire — RG-1.04) |
-| usine | demo | ROLE_USER | aucun accès clients |
+---
 
 ## Conventions
 
@@ -213,4 +366,13 @@ En dev, `make db-reset` produit le même résultat (rôles + matrice + comptes d
 <type>(<scope optionnel>) : <message>
 ```
 
-Types : `build`, `chore`, `ci`, `docs`, `feat`, `fix`, `perf`, `refactor`, `revert`, `style`, `test`
+Espaces obligatoires autour du `:`. Types : `build`, `chore`, `ci`, `docs`, `feat`,
+`fix`, `perf`, `refactor`, `revert`, `style`, `test`.
+
+### Langue
+
+- UI et communication : **français**
+- Code (classes, méthodes, variables) : **anglais**
+- Commentaires (PHP, TS, Vue) : **français**
+
+> Règles détaillées : `CLAUDE.md` et `.claude/rules/`.

composer.json

@@ -33,6 +33,7 @@
         "symfony/runtime": "8.0.*",
         "symfony/security-bundle": "8.0.*",
         "symfony/serializer": "8.0.*",
+        "symfony/translation": "8.0.*",
         "symfony/twig-bundle": "8.0.*",
         "symfony/uid": "8.0.*",
         "symfony/validator": "8.0.*",

composer.lock

@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "aada2e60fd7563f1498b5505b37e3f4b",
+    "content-hash": "2dc5db01e7f5d6aecd5956749b21a092",
     "packages": [
         {
             "name": "api-platform/doctrine-common",
@@ -7657,6 +7657,99 @@
             ],
             "time": "2026-03-30T15:14:47+00:00"
         },
+        {
+            "name": "symfony/translation",
+            "version": "v8.0.10",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/translation.git",
+                "reference": "f63e9342e12646a57c91ef8a366a4f9d8e557b67"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/translation/zipball/f63e9342e12646a57c91ef8a366a4f9d8e557b67",
+                "reference": "f63e9342e12646a57c91ef8a366a4f9d8e557b67",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=8.4",
+                "symfony/polyfill-mbstring": "^1.0",
+                "symfony/translation-contracts": "^3.6.1"
+            },
+            "conflict": {
+                "nikic/php-parser": "<5.0",
+                "symfony/http-client-contracts": "<2.5",
+                "symfony/service-contracts": "<2.5"
+            },
+            "provide": {
+                "symfony/translation-implementation": "2.3|3.0"
+            },
+            "require-dev": {
+                "nikic/php-parser": "^5.0",
+                "psr/log": "^1|^2|^3",
+                "symfony/config": "^7.4|^8.0",
+                "symfony/console": "^7.4|^8.0",
+                "symfony/dependency-injection": "^7.4|^8.0",
+                "symfony/finder": "^7.4|^8.0",
+                "symfony/http-client-contracts": "^2.5|^3.0",
+                "symfony/http-kernel": "^7.4|^8.0",
+                "symfony/intl": "^7.4|^8.0",
+                "symfony/polyfill-intl-icu": "^1.21",
+                "symfony/routing": "^7.4|^8.0",
+                "symfony/service-contracts": "^2.5|^3",
+                "symfony/yaml": "^7.4|^8.0"
+            },
+            "type": "library",
+            "autoload": {
+                "files": [
+                    "Resources/functions.php"
+                ],
+                "psr-4": {
+                    "Symfony\\Component\\Translation\\": ""
+                },
+                "exclude-from-classmap": [
+                    "/Tests/"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Fabien Potencier",
+                    "email": "fabien@symfony.com"
+                },
+                {
+                    "name": "Symfony Community",
+                    "homepage": "https://symfony.com/contributors"
+                }
+            ],
+            "description": "Provides tools to internationalize your application",
+            "homepage": "https://symfony.com",
+            "support": {
+                "source": "https://github.com/symfony/translation/tree/v8.0.10"
+            },
+            "funding": [
+                {
+                    "url": "https://symfony.com/sponsor",
+                    "type": "custom"
+                },
+                {
+                    "url": "https://github.com/fabpot",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/nicolas-grekas",
+                    "type": "github"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+                    "type": "tidelift"
+                }
+            ],
+            "time": "2026-05-06T11:30:54+00:00"
+        },
         {
             "name": "symfony/translation-contracts",
             "version": "v3.6.1",

config/packages/test/doctrine.yaml

@@ -0,0 +1,12 @@
+doctrine:
+    dbal:
+        connections:
+            # Force le profiling DBAL en environnement de test independamment de
+            # APP_DEBUG. Sans cela, la CI tourne en APP_DEBUG=0 (prod-like) et le
+            # service `doctrine.debug_data_holder` n'est pas enregistre : le test
+            # anti-N+1 (SupplierListTest::testListQueryCountDoesNotGrowWithRowCount)
+            # qui compte les requetes via ce holder echoue alors en CI alors qu'il
+            # passe en local (APP_DEBUG=1). Activer le profiling ici garde le test
+            # actif precisement la ou il compte (CI), sans impacter la prod.
+            default:
+                profiling: true

config/packages/translation.yaml

@@ -0,0 +1,12 @@
+framework:
+    # Locale par defaut FR (ERP-107) : les messages natifs des contraintes
+    # Symfony (Email, NotBlank, Length, Iban, Bic...) sont alors servis en
+    # francais via validators.fr.xlf. C'est le FILET ; les contraintes metier
+    # portent en plus un `message:` FR explicite, teste par
+    # tests/Architecture/EntityConstraintsHaveFrenchMessageTest.
+    default_locale: fr
+    translator:
+        default_path: '%kernel.project_dir%/translations'
+        fallbacks:
+            - fr
+        providers:

config/sidebar.php

@@ -38,6 +38,29 @@ declare(strict_types=1);
  */
 
 return [
+    // Section "Commerciale" : pole metier principal, remontee en tete de sidebar (ERP-71).
+    // L'ordre interne des onglets et les permissions restent inchanges (simple deplacement
+    // du bloc, aucun gate touche).
+    [
+        'label' => 'sidebar.commercial.section',
+        'icon'  => 'mdi:account-arrow-left-outline',
+        'items' => [
+            [
+                'label'      => 'sidebar.commercial.clients',
+                'to'         => '/clients',
+                'icon'       => 'mdi:account-group-outline',
+                'module'     => 'commercial',
+                'permission' => 'commercial.clients.view',
+            ],
+            [
+                'label'      => 'sidebar.commercial.suppliers',
+                'to'         => '/suppliers',
+                'icon'       => 'mdi:account-arrow-left-outline',
+                'module'     => 'commercial',
+                'permission' => 'commercial.suppliers.view',
+            ],
+        ],
+    ],
     // Section "Administration" : regroupe toutes les pages de configuration
     // applicative (RBAC, users, sites, audit log).
     //
@@ -99,25 +122,6 @@ return [
             ],
         ],
     ],
-    [
-        'label' => 'sidebar.commercial.section',
-        'icon'  => 'mdi:account-arrow-left-outline',
-        'items' => [
-            [
-                'label'      => 'sidebar.commercial.clients',
-                'to'         => '/clients',
-                'icon'       => 'mdi:account-group-outline',
-                'module'     => 'commercial',
-                'permission' => 'commercial.clients.view',
-            ],
-            [
-                'label'  => 'sidebar.commercial.suppliers',
-                'to'     => '/suppliers',
-                'icon'   => 'mdi:account-arrow-left-outline',
-                'module' => 'commercial',
-            ],
-        ],
-    ],
     // Section "Mon compte" : espace personnel. Accessible a tout user authentifie
     // (aucune permission RBAC requise, tous les items restent dans `core` pour
     // rester toujours presents meme quand les modules metier sont desactives).

config/version.yaml

@@ -1,2 +1,2 @@
 parameters:
-    app.version: '0.1.74'
+    app.version: '0.1.89'

docs/specs/M1-clients/2026-06-04-validation-blocs-collection-design.md

@@ -0,0 +1,146 @@
+# Validation « tous les blocs » sur les onglets à blocs dynamiques (Client M1)
+
+> Date : 2026-06-04 · Module : Commercial (M1 Clients) · Tickets liés : ERP-101 / ERP-107
+> Écrans : `clients/new.vue`, `clients/[id]/edit.vue` · Onglets concernés : Contacts, Adresses, RIB
+
+## 1. Problème
+
+À la soumission des onglets à **blocs d'ajout dynamiques** (Contacts / Adresses / RIB), la validation
+par champ ne s'affiche pas correctement. Deux causes **distinctes et cumulées** :
+
+### Cause A — 500 back qui court-circuite la validation (cause racine)
+
+Les opérations `Post` des sous-ressources sont déclarées ainsi :
+
+```php
+new Post(
+    uriTemplate: '/clients/{clientId}/contacts',
+    uriVariables: ['clientId' => new Link(fromClass: Client::class, toProperty: 'client')],
+    processor: ClientContactProcessor::class,
+)
+```
+
+Au stade « read » du POST, API Platform résout `clientId` via `LinksHandlerTrait` (branche `toProperty`,
+`vendor/api-platform/doctrine-orm/State/LinksHandlerTrait.php:134-141`). La requête générée porte sur
+l'entité **enfant** :
+
+```sql
+SELECT o FROM ClientContact o INNER JOIN o.client c WHERE c.id = :clientId
+```
+
+exécutée via `ItemProvider::provide` → `getOneOrNullResult()`
+(`vendor/api-platform/doctrine-orm/State/ItemProvider.php:89`). Donc :
+
+| Nb d'enfants du client | Lignes retournées | Résultat |
+|---|---|---|
+| 0 | 0 | `null` → OK (cas du test CI actuel) |
+| 1 | 1 | OK |
+| **≥ 2** | **≥ 2** | **`NonUniqueResultException` → HTTP 500** |
+
+Conséquence : un client à ≥2 contacts (resp. adresses, RIB) ne peut plus en recevoir un nouveau.
+La 500 survient **avant** la déserialisation/validation → aucune 422 n'est produite → `mapRowError`
+(qui ne mappe que les 422) retombe sur un toast générique.
+
+Les **3** sous-ressources ont strictement la même config → même bug latent (contacts est juste le
+premier à sauter car les clients de démo ont 3 contacts).
+
+### Cause B — la boucle front s'arrête au premier bloc en erreur
+
+`submitContacts` / `submitAddresses` / boucle RIB de `submitAccounting` (dans `new.vue` ET `edit.vue`)
+font `return` dans le `catch` du premier bloc en échec :
+
+```js
+catch (error) {
+    if (!mapRowError(error, contactErrors, index)) { toast(...) }
+    return   // ← stoppe : les blocs suivants ne sont jamais validés ni affichés
+}
+```
+
+→ même une fois le 500 corrigé, seules les erreurs du **premier** bloc fautif s'afficheraient.
+
+## 2. Objectif
+
+À la validation d'un onglet collection, **tenter tous les blocs** et **afficher l'erreur inline sous
+chaque champ fautif, pour chaque bloc**, en un seul aller-retour de soumission. Pas de toast récapitulatif
+(décision : inline seul, cohérent ERP-101). Pas de toast succès tant qu'au moins un bloc reste en erreur.
+
+Hors périmètre : le workflow incrémental (créer le client, puis débloquer les onglets) reste inchangé ;
+les onglets scalaires (Principal / Information / Comptabilité-scalaires) fonctionnent déjà et ne sont pas
+touchés.
+
+## 3. Conception
+
+### 3.1 Back — supprimer le read cassé du POST (cause racine)
+
+Sur les opérations `Post` de `ClientContact`, `ClientAddress`, `ClientRib` :
+
+- Ajouter **`read: false`**. Le stade « read » est inutile : le `*Processor::linkParent` rattache déjà le
+  parent manuellement via `$em->getRepository(Client::class)->find($clientId)`. Pattern déjà employé dans
+  le projet (`Sites/.../CurrentSiteResource.php`).
+- Durcir les 3 `linkParent` : si `find($clientId)` renvoie `null`, lever
+  `Symfony\Component\HttpKernel\Exception\NotFoundHttpException` (préserve le **404** sur parent
+  inexistant — sans le read, on régresserait sinon en 500 au persist sur `client_id NOT NULL`).
+
+Effet : plus de `getOneOrNullResult` foireux → déserialisation + validation Symfony s'exécutent → **422
+propre par champ** avec `violations[].propertyPath` (déjà garanti par ERP-107 : messages FR explicites).
+
+Aucune autre modification (security, normalizationContext, processor restant) n'est nécessaire.
+
+### 3.2 Front — collecter les erreurs de tous les blocs
+
+Dans `submitContacts`, `submitAddresses`, et la boucle RIB de `submitAccounting`, **dans `new.vue` ET
+`edit.vue`** :
+
+- Conserver la réinitialisation du tableau d'erreurs en début de submit (`xxxErrors.value = []`).
+- Introduire un drapeau local `hasError`. Dans le `catch`, remplacer `return` par
+  `hasError = true; continue` → la boucle tente/valide **tous** les blocs ; chaque 422 se mappe sur
+  `xxxErrors[index]` via `mapRowError` (mécanique existante, inchangée).
+- Après la boucle : si `hasError` → **ne pas** appeler `completeTab(...)`, **pas** de toast succès. Sinon
+  → comportement actuel (`completeTab` + toast succès).
+- Les blocs déjà créés (id non-null) repassent en `PATCH` au resubmit → idempotent, pas de doublon.
+- Awaits **séquentiels** conservés (volume faible, ordre des blocs préservé, pas de course).
+
+Le binding inline est déjà en place côté template (`:errors="contactErrors[index]"` /
+`:error="ribErrors[index]?.iban"` …). Aucun changement de composant `Malio*` requis.
+
+### 3.3 Réutilisation / isolation
+
+Le bloc « boucle de soumission d'une collection avec collecte d'erreurs par index » est dupliqué 3× × 2
+pages. Pour rester testable et DRY, extraire un helper de soumission de collection (ex.
+`submitCollection(rows, { buildBody, post, patch, errors })` retournant `{ hasError }`) consommé par les
+6 sites d'appel. À acter dans le plan d'implémentation (option : garder inline si l'extraction dégrade la
+lisibilité — décision lors du plan).
+
+## 4. Tests
+
+### Back (TDD — échouent d'abord)
+
+Dans `tests/Module/Commercial/Api/ClientSubResourceApiTest` :
+
+- `testPostContactToClientWithTwoExistingContactsReturns201` : seed un client + 2 contacts, POST un 3ᵉ →
+  attendu **201** (rouge aujourd'hui : 500).
+- `testPostContactInvalidEmailOnClientWithExistingContactsReturns422` : même seed, POST email invalide →
+  **422** avec `propertyPath=email` et message FR (vérifie que la validation est bien atteinte).
+- Variantes germes pour adresses et RIB (au moins une chacune) pour verrouiller les 3 sous-ressources.
+
+Pré-requis : helper de seed de contacts/adresses/RIB dans `AbstractCommercialApiTestCase` (ajouter si
+absent).
+
+### Front (Vitest)
+
+- Si helper `submitCollection` extrait : test unitaire « 3 blocs, le 2ᵉ renvoie 422 → les erreurs du 2ᵉ
+  sont mappées, les blocs 1 et 3 sont tentés, `hasError = true`, tab non complété ».
+- Sinon : test de composant sur `ClientContactBlock` + page, vérifiant l'affichage inline multi-blocs.
+
+### Vérifications finales
+
+`make test` + `make php-cs-fixer-allow-risky` (back), `make nuxt-test` (front). Golden path manuel :
+client à 3 contacts, ajouter un 4ᵉ avec email invalide → 422 inline sous l'email du bon bloc, pas de 500.
+
+## 5. Impact / risques
+
+- API contract : POST sous-ressource passe de 500→201/422 (correction) ; 404 préservé sur parent
+  inexistant. Pas de changement de payload ni de réponse de succès.
+- Le test fonctionnel CI actuel (POST sur client à 0 contact) reste vert.
+- Régression possible si un consommateur dépendait du read implicite du parent au POST : aucun identifié
+  (les 3 processors gèrent déjà le rattachement manuellement).

docs/specs/M1-clients/2026-06-04-validation-blocs-collection-plan.md

@@ -0,0 +1,633 @@
+# Validation « tous les blocs » — onglets à blocs dynamiques (Client M1) — Plan d'implémentation
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Permettre la validation 422 par champ sur TOUS les blocs des onglets Contacts / Adresses / RIB d'un client (création + édition), en supprimant la 500 `NonUniqueResultException` qui les bloque dès ≥2 enfants et en ne stoppant plus la boucle front au premier bloc en erreur.
+
+**Architecture:** Côté back, on retire le stade « read » inutile du POST des 3 sous-ressources (`read: false`) — le parent est déjà rattaché manuellement par le processor — et on durcit ce rattachement (404 si parent absent). Côté front, on factorise la boucle de soumission de collection dans `useClientFormErrors().submitRows(...)` qui tente tous les blocs et collecte les erreurs par index, puis on branche les 6 sites d'appel (`new.vue` + `edit.vue` × contacts/adresses/RIB).
+
+**Tech Stack:** Symfony 8 / API Platform 4 (PHP 8.4, PHPUnit) ; Nuxt 4 / Vue 3 / TypeScript / Vitest.
+
+**Spec de référence :** `docs/superpowers/specs/2026-06-04-client-collection-blocks-validation-design.md`
+
+**Pré-vol :** `make start` (containers up), branche de travail = celle de la MR (`feat/erp-107-validation-messages-fr`) ou une branche dédiée selon décision utilisateur.
+
+---
+
+## Structure des fichiers
+
+**Back — modifiés :**
+- `src/Module/Commercial/Domain/Entity/ClientContact.php` — `read: false` sur `Post`
+- `src/Module/Commercial/Domain/Entity/ClientAddress.php` — `read: false` sur `Post`
+- `src/Module/Commercial/Domain/Entity/ClientRib.php` — `read: false` sur `Post`
+- `src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/ClientContactProcessor.php` — `linkParent` → 404
+- `.../Processor/ClientAddressProcessor.php` — idem
+- `.../Processor/ClientRibProcessor.php` — idem
+- `tests/Module/Commercial/Api/AbstractCommercialApiTestCase.php` — helper `seedContact()`
+- `tests/Module/Commercial/Api/ClientSubResourceApiTest.php` — tests de non-régression
+
+**Front — modifiés :**
+- `frontend/modules/commercial/composables/useClientFormErrors.ts` — méthode `submitRows()`
+- `frontend/modules/commercial/composables/__tests__/useClientFormErrors.spec.ts` — créé (test unitaire)
+- `frontend/modules/commercial/pages/clients/new.vue` — branchements (3 submits)
+- `frontend/modules/commercial/pages/clients/[id]/edit.vue` — branchements (3 submits)
+
+---
+
+## Task 1 : Back — test rouge (POST sur client à ≥2 enfants)
+
+**Files:**
+- Modify: `tests/Module/Commercial/Api/AbstractCommercialApiTestCase.php`
+- Test: `tests/Module/Commercial/Api/ClientSubResourceApiTest.php`
+
+- [ ] **Step 1 : Ajouter un helper de seed de contact à la base de test**
+
+Dans `AbstractCommercialApiTestCase.php`, ajouter (sous `seedClient`, avant `cleanupCommercialTestData`) :
+
+```php
+    /**
+     * Seede directement un ClientContact en base (sans passer par l'API), pour
+     * preparer un client deja dote de N contacts. Au moins le prenom est pose
+     * (RG-1.05 / CHECK chk_client_contact_name).
+     */
+    protected function seedContact(ClientEntity $client, string $firstName): \App\Module\Commercial\Domain\Entity\ClientContact
+    {
+        $em      = $this->getEm();
+        $contact = new \App\Module\Commercial\Domain\Entity\ClientContact();
+        $contact->setClient($client);
+        $contact->setFirstName($firstName);
+        $em->persist($contact);
+        $em->flush();
+
+        return $contact;
+    }
+```
+
+- [ ] **Step 2 : Écrire les tests rouges**
+
+Dans `ClientSubResourceApiTest.php`, ajouter dans la section `// === Contacts ===` :
+
+```php
+    /**
+     * Regression ERP (bug subresource Link toProperty) : POST d'un contact sur un
+     * client qui en a DEJA >= 2 ne doit pas exploser en 500
+     * (NonUniqueResultException sur la resolution du parent), mais creer (201).
+     */
+    public function testPostContactOnClientWithTwoExistingContactsReturns201(): void
+    {
+        $client = $this->createAdminClient();
+        $seed   = $this->seedClient('Contact Multi');
+        $this->seedContact($seed, 'Alpha');
+        $this->seedContact($seed, 'Beta');
+
+        $client->request('POST', '/api/clients/'.$seed->getId().'/contacts', [
+            'headers' => ['Content-Type' => self::LD, 'Accept' => self::LD],
+            'json'    => ['firstName' => 'Gamma'],
+        ]);
+
+        self::assertResponseStatusCodeSame(201);
+    }
+
+    /**
+     * Meme contexte (>= 2 contacts existants) : un email invalide doit produire
+     * une 422 par champ (la validation est bien atteinte), pas une 500.
+     */
+    public function testPostInvalidContactOnPopulatedClientReturns422OnField(): void
+    {
+        $client = $this->createAdminClient();
+        $seed   = $this->seedClient('Contact Multi Bad');
+        $this->seedContact($seed, 'Alpha');
+        $this->seedContact($seed, 'Beta');
+
+        $response = $client->request('POST', '/api/clients/'.$seed->getId().'/contacts', [
+            'headers' => ['Content-Type' => self::LD, 'Accept' => self::LD],
+            'json'    => ['firstName' => 'Gamma', 'email' => 'pas-un-email'],
+        ]);
+
+        self::assertResponseStatusCodeSame(422);
+        $byPath = [];
+        foreach ($response->toArray(false)['violations'] ?? [] as $v) {
+            $byPath[$v['propertyPath']] = $v['message'];
+        }
+        self::assertArrayHasKey('email', $byPath);
+        self::assertSame('L\'adresse email n\'est pas valide.', $byPath['email']);
+    }
+```
+
+- [ ] **Step 3 : Lancer les tests, vérifier qu'ils échouent (500 au lieu de 201/422)**
+
+Run : `make test` (ou ciblé dans le container : `docker exec php-starseed-fpm php bin/phpunit --filter ClientSubResourceApiTest`)
+Expected : les 2 nouveaux tests ÉCHOUENT (HTTP 500 `NonUniqueResultException`). `testPostContactOnClient...` reçoit 500, pas 201.
+
+- [ ] **Step 4 : Commit (test rouge)**
+
+```bash
+git add tests/Module/Commercial/Api/AbstractCommercialApiTestCase.php tests/Module/Commercial/Api/ClientSubResourceApiTest.php
+git commit -m "test(commercial) : reproduit la 500 NonUniqueResult au POST contact sur client peuple (ERP-107)"
+```
+
+---
+
+## Task 2 : Back — fix (read:false + linkParent durci) → tests verts
+
+**Files:**
+- Modify: `src/Module/Commercial/Domain/Entity/ClientContact.php:48-57`
+- Modify: `src/Module/Commercial/Domain/Entity/ClientAddress.php:61-70`
+- Modify: `src/Module/Commercial/Domain/Entity/ClientRib.php:52-61`
+- Modify: `.../State/Processor/ClientContactProcessor.php:76-94`
+- Modify: `.../State/Processor/ClientAddressProcessor.php:63-81`
+- Modify: `.../State/Processor/ClientRibProcessor.php:65-83`
+
+- [ ] **Step 1 : `read: false` sur les 3 opérations `Post`**
+
+`ClientContact.php`, opération `Post` — ajouter la ligne `read: false,` :
+
+```php
+        new Post(
+            uriTemplate: '/clients/{clientId}/contacts',
+            uriVariables: [
+                'clientId' => new Link(fromClass: Client::class, toProperty: 'client'),
+            ],
+            // read:false : pas de stade lecture du parent (le Link toProperty
+            // resoudrait l'enfant et casse en NonUniqueResult des >= 2 enfants).
+            // Le parent est rattache par ClientContactProcessor::linkParent.
+            read: false,
+            security: "is_granted('commercial.clients.manage')",
+            normalizationContext: ['groups' => ['client_contact:read']],
+            denormalizationContext: ['groups' => ['client_contact:write']],
+            processor: ClientContactProcessor::class,
+        ),
+```
+
+`ClientAddress.php` — idem dans son `Post` (`security: commercial.clients.manage`, processor `ClientAddressProcessor`), commentaire pointant `ClientAddressProcessor::linkParent`.
+
+`ClientRib.php` — idem dans son `Post` (`security: commercial.clients.accounting.manage`, processor `ClientRibProcessor`), commentaire pointant `ClientRibProcessor::linkParent`.
+
+- [ ] **Step 2 : Durcir les 3 `linkParent` (404 si parent absent)**
+
+Dans chaque processor, ajouter l'import en tête de fichier :
+
+```php
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+```
+
+`ClientContactProcessor::linkParent` — remplacer le bloc final par :
+
+```php
+        if (null === $clientId) {
+            return;
+        }
+
+        $client = $clientId instanceof Client
+            ? $clientId
+            : $this->em->getRepository(Client::class)->find($clientId);
+
+        // read:false sur le POST : sans stade lecture, un parent introuvable
+        // n'est plus intercepte en amont -> 404 explicite (sinon 500 au persist
+        // sur client_id NOT NULL).
+        if (!$client instanceof Client) {
+            throw new NotFoundHttpException('Client introuvable.');
+        }
+
+        $contact->setClient($client);
+```
+
+`ClientAddressProcessor::linkParent` — idem avec `$address->setClient($client);`.
+`ClientRibProcessor::linkParent` — idem avec `$rib->setClient($client);`.
+
+- [ ] **Step 3 : Lancer les tests, vérifier qu'ils passent**
+
+Run : `make test`
+Expected : les 2 tests de Task 1 PASSENT (201 + 422 `propertyPath=email`). Aucun test existant cassé (notamment `testPostContactInvalidEmailReturns422WithFrenchMessageOnField` et les tests d'archi ERP-107 restent verts).
+
+- [ ] **Step 4 : Lint PHP**
+
+Run : `make php-cs-fixer-allow-risky`
+Expected : 0 fichier à corriger (ou corrections appliquées et re-vérifiées).
+
+- [ ] **Step 5 : Commit (fix back)**
+
+```bash
+git add src/Module/Commercial/Domain/Entity/ClientContact.php src/Module/Commercial/Domain/Entity/ClientAddress.php src/Module/Commercial/Domain/Entity/ClientRib.php src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/ClientContactProcessor.php src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/ClientAddressProcessor.php src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/ClientRibProcessor.php
+git commit -m "fix(commercial) : POST sous-ressource client en read:false + parent 404 (corrige 500 NonUniqueResult, ERP-107)"
+```
+
+---
+
+## Task 3 : Back — germes adresses + RIB (verrouille les 3 sous-ressources)
+
+**Files:**
+- Modify: `tests/Module/Commercial/Api/AbstractCommercialApiTestCase.php` (helpers `seedAddress`, `seedRib`)
+- Test: `tests/Module/Commercial/Api/ClientSubResourceApiTest.php`
+
+- [ ] **Step 1 : Helpers de seed adresse + RIB**
+
+Dans `AbstractCommercialApiTestCase.php`, ajouter :
+
+```php
+    /** Seede une adresse minimale valide (RG : CP/ville/rue requis). */
+    protected function seedAddress(ClientEntity $client, string $city): \App\Module\Commercial\Domain\Entity\ClientAddress
+    {
+        $em      = $this->getEm();
+        $address = new \App\Module\Commercial\Domain\Entity\ClientAddress();
+        $address->setClient($client);
+        $address->setPostalCode('33000');
+        $address->setCity($city);
+        $address->setStreet('1 rue du Test');
+        $em->persist($address);
+        $em->flush();
+
+        return $address;
+    }
+
+    /** Seede un RIB valide (BIC/IBAN conformes). */
+    protected function seedRib(ClientEntity $client, string $label): \App\Module\Commercial\Domain\Entity\ClientRib
+    {
+        $em  = $this->getEm();
+        $rib = new \App\Module\Commercial\Domain\Entity\ClientRib();
+        $rib->setClient($client);
+        $rib->setLabel($label);
+        $rib->setBic('BNPAFRPPXXX');
+        $rib->setIban('FR1420041010050500013M02606');
+        $em->persist($rib);
+        $em->flush();
+
+        return $rib;
+    }
+```
+
+> Note : si une propriété est non-nullable et absente ci-dessus (ex. `position`, flags d'adresse), poser les setters correspondants avec une valeur par défaut neutre — vérifier les entités `ClientAddress` / `ClientRib` au moment de l'écriture.
+
+- [ ] **Step 2 : Tests de non-régression adresses + RIB**
+
+Dans `ClientSubResourceApiTest.php`, section adresses puis RIB :
+
+```php
+    public function testPostAddressOnClientWithTwoExistingAddressesReturns201(): void
+    {
+        $client = $this->createAdminClient();
+        $seed   = $this->seedClient('Addr Multi');
+        $this->seedAddress($seed, 'Bordeaux');
+        $this->seedAddress($seed, 'Lyon');
+
+        $client->request('POST', '/api/clients/'.$seed->getId().'/addresses', [
+            'headers' => ['Content-Type' => self::LD, 'Accept' => self::LD],
+            'json'    => ['postalCode' => '75001', 'city' => 'Paris', 'street' => '2 rue Neuve'],
+        ]);
+
+        self::assertResponseStatusCodeSame(201);
+    }
+
+    public function testPostRibOnClientWithTwoExistingRibsReturns201(): void
+    {
+        $client = $this->createAdminClient();
+        $seed   = $this->seedClient('Rib Multi');
+        $this->seedRib($seed, 'Compte 1');
+        $this->seedRib($seed, 'Compte 2');
+
+        $client->request('POST', '/api/clients/'.$seed->getId().'/ribs', [
+            'headers' => ['Content-Type' => self::LD, 'Accept' => self::LD],
+            'json'    => ['label' => 'Compte 3', 'bic' => self::VALID_BIC, 'iban' => self::VALID_IBAN],
+        ]);
+
+        self::assertResponseStatusCodeSame(201);
+    }
+```
+
+> Le POST RIB exige `commercial.clients.accounting.manage` — `admin` (ROLE_ADMIN) l'a. Si une 403 apparaît, vérifier le compte de test.
+
+- [ ] **Step 3 : Lancer, vérifier vert**
+
+Run : `make test`
+Expected : PASS (les 2 nouveaux tests verts grâce au fix de Task 2).
+
+- [ ] **Step 4 : Commit**
+
+```bash
+git add tests/Module/Commercial/Api/AbstractCommercialApiTestCase.php tests/Module/Commercial/Api/ClientSubResourceApiTest.php
+git commit -m "test(commercial) : verrouille POST adresses/RIB sur client peuple (ERP-107)"
+```
+
+---
+
+## Task 4 : Front — helper `submitRows` + test unitaire
+
+**Files:**
+- Modify: `frontend/modules/commercial/composables/useClientFormErrors.ts`
+- Create: `frontend/modules/commercial/composables/__tests__/useClientFormErrors.spec.ts`
+
+- [ ] **Step 1 : Écrire le test rouge**
+
+Créer `useClientFormErrors.spec.ts` :
+
+```ts
+import { describe, it, expect, vi } from 'vitest'
+import { useClientFormErrors } from '../useClientFormErrors'
+
+// Construit une erreur facon useApi : 422 avec violations Hydra.
+function http422(path: string, message: string) {
+    return { response: { status: 422, _data: { violations: [{ propertyPath: path, message }] } } }
+}
+
+describe('useClientFormErrors.submitRows', () => {
+    it('tente TOUS les blocs et mappe les erreurs par index, sans stopper au premier echec', async () => {
+        const { contactErrors, submitRows } = useClientFormErrors()
+        const seen: number[] = []
+        const onUnmapped = vi.fn()
+
+        const saveRow = async (_row: unknown, index: number) => {
+            seen.push(index)
+            if (index === 1) throw http422('email', 'Email invalide')
+        }
+
+        const hasError = await submitRows(
+            [{ a: 0 }, { a: 1 }, { a: 2 }],
+            contactErrors,
+            saveRow,
+            onUnmapped,
+        )
+
+        expect(seen).toEqual([0, 1, 2])            // tous les blocs tentes
+        expect(hasError).toBe(true)
+        expect(contactErrors.value[1]).toEqual({ email: 'Email invalide' })
+        expect(contactErrors.value[0]).toBeUndefined()
+        expect(onUnmapped).not.toHaveBeenCalled()  // 422 mappee, pas de fallback
+    })
+
+    it('saute les lignes filtrees par shouldSkip et renvoie false si tout passe', async () => {
+        const { contactErrors, submitRows } = useClientFormErrors()
+        const saved: number[] = []
+
+        const hasError = await submitRows(
+            [{ skip: true }, { skip: false }],
+            contactErrors,
+            async (_row, index) => { saved.push(index) },
+            vi.fn(),
+            (row: { skip: boolean }) => row.skip,
+        )
+
+        expect(saved).toEqual([1])
+        expect(hasError).toBe(false)
+    })
+})
+```
+
+- [ ] **Step 2 : Lancer, vérifier l'échec**
+
+Run : `make nuxt-test` (ou ciblé : `docker exec <node> npx vitest run useClientFormErrors`)
+Expected : FAIL — `submitRows` n'existe pas encore.
+
+- [ ] **Step 3 : Implémenter `submitRows`**
+
+Dans `useClientFormErrors.ts`, ajouter la méthode (dans la fonction, après `mapRowError`) et l'exposer dans le `return` :
+
+```ts
+    /**
+     * Soumet TOUS les blocs d'une collection (contacts/adresses/RIB) en collectant
+     * les erreurs par index : on n'arrete PAS au premier bloc en echec (ERP-101).
+     * Reinitialise le tableau d'erreurs cible, tente chaque ligne via `saveRow`,
+     * mappe les 422 inline (mapRowError) ou delegue le fallback a `onUnmappedError`.
+     * Retourne true si au moins un bloc a echoue (le caller ne valide alors pas l'onglet).
+     */
+    async function submitRows<T>(
+        rows: T[],
+        target: Ref<Record<string, string>[]>,
+        saveRow: (row: T, index: number) => Promise<void>,
+        onUnmappedError: (error: unknown, index: number) => void,
+        shouldSkip?: (row: T, index: number) => boolean,
+    ): Promise<boolean> {
+        target.value = []
+        let hasError = false
+        for (let index = 0; index < rows.length; index++) {
+            if (shouldSkip?.(rows[index], index)) {
+                continue
+            }
+            try {
+                await saveRow(rows[index], index)
+            }
+            catch (error) {
+                if (!mapRowError(error, target, index)) {
+                    onUnmappedError(error, index)
+                }
+                hasError = true
+            }
+        }
+
+        return hasError
+    }
+```
+
+Ajouter `submitRows` à l'objet retourné par `useClientFormErrors`.
+
+- [ ] **Step 4 : Lancer, vérifier vert**
+
+Run : `make nuxt-test`
+Expected : PASS (les 2 cas verts).
+
+- [ ] **Step 5 : Commit**
+
+```bash
+git add frontend/modules/commercial/composables/useClientFormErrors.ts frontend/modules/commercial/composables/__tests__/useClientFormErrors.spec.ts
+git commit -m "feat(commercial) : submitRows collecte les erreurs de tous les blocs de collection (ERP-101)"
+```
+
+---
+
+## Task 5 : Front — brancher `submitRows` dans new.vue + edit.vue
+
+**Files:**
+- Modify: `frontend/modules/commercial/pages/clients/new.vue` (`submitContacts`, `submitAddresses`, boucle RIB de `submitAccounting`)
+- Modify: `frontend/modules/commercial/pages/clients/[id]/edit.vue` (les 3 équivalents)
+
+- [ ] **Step 1 : Récupérer `submitRows` du composable**
+
+Dans `new.vue` ET `edit.vue`, ajouter `submitRows` à la déstructuration de `useClientFormErrors()` :
+
+```ts
+const {
+    mainErrors,
+    informationErrors,
+    accountingErrors,
+    contactErrors,
+    addressErrors,
+    ribErrors,
+    mapRowError,
+    submitRows,
+} = useClientFormErrors()
+```
+
+- [ ] **Step 2 : Réécrire `submitContacts` (new.vue)**
+
+Remplacer le corps de la boucle par un appel à `submitRows` :
+
+```ts
+async function submitContacts(): Promise<void> {
+    if (clientId.value === null || !canValidateContacts.value || tabSubmitting.value) return
+    tabSubmitting.value = true
+    try {
+        const hasError = await submitRows(
+            contacts.value,
+            contactErrors,
+            async (contact) => {
+                const body = {
+                    firstName: contact.firstName || null,
+                    lastName: contact.lastName || null,
+                    jobTitle: contact.jobTitle || null,
+                    phonePrimary: contact.phonePrimary || null,
+                    phoneSecondary: contact.hasSecondaryPhone ? (contact.phoneSecondary || null) : null,
+                    email: contact.email || null,
+                }
+                if (contact.id === null) {
+                    const created = await api.post<ContactResponse>(
+                        `/clients/${clientId.value}/contacts`,
+                        body,
+                        { headers: { Accept: 'application/ld+json' }, toast: false },
+                    )
+                    contact.id = created.id
+                    contact.iri = created['@id'] ?? null
+                }
+                else {
+                    await api.patch(`/client_contacts/${contact.id}`, body, { toast: false })
+                }
+            },
+            (error) => toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) }),
+            (contact) => !isContactNamed(contact),
+        )
+        if (hasError) return
+        completeTab('contact')
+        toast.success({ title: t('commercial.clients.toast.updateSuccess') })
+    }
+    finally {
+        tabSubmitting.value = false
+    }
+}
+```
+
+- [ ] **Step 3 : Réécrire `submitAddresses` (new.vue)**
+
+```ts
+async function submitAddresses(): Promise<void> {
+    if (clientId.value === null || !canValidateAddresses.value || tabSubmitting.value) return
+    tabSubmitting.value = true
+    try {
+        const hasError = await submitRows(
+            addresses.value,
+            addressErrors,
+            async (address) => {
+                const body = {
+                    isProspect: address.isProspect,
+                    isDelivery: address.isDelivery,
+                    isBilling: address.isBilling,
+                    country: address.country,
+                    postalCode: address.postalCode || null,
+                    city: address.city || null,
+                    street: address.street || null,
+                    streetComplement: address.streetComplement || null,
+                    categories: address.categoryIris,
+                    sites: address.siteIris,
+                    contacts: address.contactIris,
+                    billingEmail: isBillingEmailRequired(address) ? (address.billingEmail || null) : null,
+                }
+                if (address.id === null) {
+                    const created = await api.post<{ id: number }>(
+                        `/clients/${clientId.value}/addresses`,
+                        body,
+                        { headers: { Accept: 'application/ld+json' }, toast: false },
+                    )
+                    address.id = created.id
+                }
+                else {
+                    await api.patch(`/client_addresses/${address.id}`, body, { toast: false })
+                }
+            },
+            (error) => toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) }),
+        )
+        if (hasError) return
+        completeTab('address')
+        toast.success({ title: t('commercial.clients.toast.updateSuccess') })
+    }
+    finally {
+        tabSubmitting.value = false
+    }
+}
+```
+
+- [ ] **Step 4 : Réécrire la boucle RIB de `submitAccounting` (new.vue)**
+
+Garder le PATCH scalaire inchangé (1) ; remplacer la boucle (2) :
+
+```ts
+        // 2) POST/PATCH des RIB (erreurs inline par ligne, tous les blocs).
+        const ribHasError = await submitRows(
+            ribs.value,
+            ribErrors,
+            async (rib) => {
+                const body = { label: rib.label, bic: rib.bic, iban: rib.iban }
+                if (rib.id === null) {
+                    const created = await api.post<{ id: number }>(
+                        `/clients/${clientId.value}/ribs`,
+                        body,
+                        { headers: { Accept: 'application/ld+json' }, toast: false },
+                    )
+                    rib.id = created.id
+                }
+                else {
+                    await api.patch(`/client_ribs/${rib.id}`, body, { toast: false })
+                }
+            },
+            (error) => toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) }),
+            (rib) => !ribIsComplete(rib),
+        )
+        if (ribHasError) return
+
+        completeTab('accounting')
+        toast.success({ title: t('commercial.clients.toast.updateSuccess') })
+```
+
+> Retirer le `ribErrors.value = []` désormais fait par `submitRows`. Le `accountingErrors.clearErrors()` du PATCH scalaire reste.
+
+- [ ] **Step 5 : Mirror dans edit.vue**
+
+Appliquer les mêmes réécritures aux `submitContacts` / `submitAddresses` / boucle RIB de `submitAccounting` d'`edit.vue`. Conserver le **fallback d'erreur propre à edit.vue** (si edit.vue utilise `showError(...)` au lieu de `toast.error(...)`, passer ce fallback comme `onUnmappedError`). Vérifier les noms des refs (`clientId` peut y être l'id de route).
+
+- [ ] **Step 6 : Vérifier le typecheck + tests front**
+
+Run : `make nuxt-test`
+Expected : PASS. Aucune régression des specs existantes (`ClientContactBlock.spec.ts`, etc.).
+
+- [ ] **Step 7 : Commit**
+
+```bash
+git add frontend/modules/commercial/pages/clients/new.vue "frontend/modules/commercial/pages/clients/[id]/edit.vue"
+git commit -m "feat(commercial) : valide tous les blocs contacts/adresses/RIB et affiche les erreurs par bloc (ERP-101)"
+```
+
+---
+
+## Task 6 : Vérification finale + golden path manuel
+
+- [ ] **Step 1 : Suite complète back**
+
+Run : `make test` puis `make php-cs-fixer-allow-risky`
+Expected : tout vert, 0 fichier à corriger.
+
+- [ ] **Step 2 : Suite complète front**
+
+Run : `make nuxt-test`
+Expected : tout vert.
+
+- [ ] **Step 3 : Golden path manuel (`make dev-nuxt`, port 3004)**
+
+Scénario : ouvrir un client à 3 contacts (compte `admin`), onglet Contacts, ajouter un bloc avec email invalide + un autre bloc avec prénom/nom vides → Valider.
+Attendu : **pas de 500** ; « L'adresse email n'est pas valide. » sous l'email du bon bloc ET « Le prénom ou le nom du contact est obligatoire. » sous le prénom de l'autre bloc, **affichés simultanément**. L'onglet ne se valide pas tant qu'une erreur subsiste. Idem à vérifier rapidement sur Adresses et RIB.
+
+- [ ] **Step 4 : Si une vérif échoue ou ne peut être lancée, le dire explicitement** (ne pas annoncer « fini »).
+
+---
+
+## Self-review (auteur du plan)
+
+- **Couverture spec §3.1 (back)** : Task 2 (read:false + linkParent 404) ✓ ; §3.2 (front collect-all) : Tasks 4-5 ✓ ; §3.3 (helper réutilisable) : Task 4 `submitRows` ✓ ; §4 tests : Tasks 1, 3 (back), 4 (front) + Task 6 golden path ✓.
+- **Périmètre 3 sous-ressources** : contacts (Task 1-2), adresses + RIB (Task 3 + branchements Task 5) ✓.
+- **Décision « inline seul »** : aucun toast succès si `hasError` ; pas de toast récap ✓.
+- **Pas de placeholder** : le seul point ouvert est la note Task 3 Step 1 (setters non-nullables éventuels d'adresse/RIB à compléter en lisant les entités) — à lever à l'écriture. Cohérence des noms : `submitRows` utilisé identiquement en Task 4 et Task 5.

docs/specs/M1-clients/spec-back.md

@@ -883,6 +883,7 @@ Cf. § 2.6. Pattern Shared standard.
 
 ### Onglet Comptabilité
 
+- **RG-1.30** _(ajoutée — correctif incohérence spec-front/spec-back)_ : à la **validation complète de l'onglet Comptabilité**, les six champs scalaires `siren`, `accountNumber`, `tvaMode`, `nTva`, `paymentDelay`, `paymentType` sont **obligatoires** (alignement sur spec-front § Onglet Comptabilité). Colonnes `nullable` en base (l'onglet est rempli dans un second temps, et l'onglet principal ne les envoie pas) + validateur contextuel `ClientAccountingCompletenessValidator` invoqué par le `ClientProcessor` — même parti que RG-1.04 (Information). Déclenchement : uniquement quand **les six champs sont présents dans le payload** (le front les envoie toujours ensemble via « Valider ») ; un PATCH ciblant un sous-ensemble de champs comptables (édition ponctuelle) n'est pas soumis à la complétude. Chaque champ manquant → 422 sur son `propertyPath` (mapping inline front, ERP-101). `bank` reste hors complétude (conditionnel RG-1.12).
 - **RG-1.12** : Le champ `bank` est visible et obligatoire **uniquement** si `paymentType.code = 'VIREMENT'`. Validation server-side dans le `ClientProcessor` : si `payment_type.code = VIREMENT` et `bank IS NULL` → 422.
 - **RG-1.13** : Les champs RIB (`label`, `bic`, `iban`) sont obligatoires si **au moins un bloc RIB est présent ET** `paymentType.code = 'LCR'`. C'est-à-dire :
   - Si `paymentType.code = LCR` ET `client.ribs.count() = 0` → 422 « Au moins un RIB est obligatoire pour le type LCR ».

docs/specs/M1-clients/spec-front.md

@@ -258,7 +258,8 @@ Le composant `Code postal` + `Ville` + `Adresse` est branché sur **api-adresse.
 
 - Composable dédié `useAddressAutocomplete()` (à créer en M1).
 - Appel HTTP **direct depuis le front** (CORS OK), pas de proxy back.
-- Pattern : à la saisie du code postal (5 chiffres), GET `https://api-adresse.data.gouv.fr/search/?q={cp}&type=municipality` → alimente le select Ville. Sur saisie d'adresse : `?q={addr}&postcode={cp}&type=housenumber` → suggestions adresse.
+- Pattern : à la saisie du code postal (5 chiffres), GET `https://api-adresse.data.gouv.fr/search/?q={cp}&type=municipality` → alimente le select Ville. Sur saisie d'adresse : `?q={addr}&postcode={cp}` (sans filtre `type`) → suggestions adresse.
+    - ⚠ **Ne pas forcer `type=housenumber`** sur la recherche d'adresse (corrigé en ERP-66) : la BAN ne renvoie un résultat de ce type qu'une fois un numéro saisi, donc une recherche par nom de rue (« boulevard du port ») renverrait **0 résultat** pendant toute la frappe. Sans filtre `type`, la BAN classe rues + numéros par pertinence — comportement d'autocomplétion attendu.
 - Cas dégradé : si l'API ne répond pas (offline, timeout), le champ Ville devient un `<MalioInputText>` libre éditable + toast d'avertissement. Validation serveur acceptera la saisie libre.
 
 ## Points laissés ouverts par la V0 (résolus côté back)

docs/specs/M2-suppliers/spec-back.md

@@ -711,91 +711,108 @@ Même pattern que les jumelles `Client*` (`#[Auditable]`, `TimestampableBlamable
 | Scalaires Comptabilité (siren, refs…) | `supplier:read:accounting` | ✅ (gated) | refs (`tvaMode`…) id+label ∈ `supplier:read:accounting` |
 | `ribs[]` (label/bic/iban) | `ribs` ∈ `supplier:read:accounting` | ✅ (gated) | — |
 
-### 4.0.bis Réponses JSON de référence (DoD — à confirmer sur l'API réelle)
+### 4.0.bis Réponses JSON de référence (DoD — RÉELLES, capturées ERP-92)
 
-> **Definition of Done de cette spec back (RETEX M1 §3)** : avant d'écrire les tickets front, créer un fournisseur de test et **coller ici les réponses RÉELLES** de `GET /api/suppliers` et `GET /api/suppliers/{id}`. Les containers n'étant pas lancés au moment de la rédaction, le JSON ci-dessous est le **contrat CIBLE** — à valider/remplacer par la réponse réelle (`make start` puis `curl`). Toute donnée affichée par le front DOIT apparaître dans ce JSON.
+> **Definition of Done CLÔTURÉE (ERP-92, 2026-06-05)** : les réponses ci-dessous sont **réelles**, capturées sur l'API de test via PHPUnit (`SupplierSerializationContractTest`, fournisseur complet seedé). Les `id`/timestamps sont illustratifs (run de test). Toute donnée affichée par le front DOIT apparaître dans ce JSON. Front #93→#96 peuvent démarrer.
+>
+> **2 constats validés à la capture** (cf. § 4.0.ter) :
+> 1. 🔧 **Fix ERP-92** : les réfs comptables (`tvaMode`/`paymentDelay`/`paymentType`/`bank`) sortaient en **IRI nu** (les entités partagées ne portaient que `client:read:accounting`, pas `supplier:read:accounting`). Corrigé → objet `{id, code, label}` embarqué (le front consultation/édition affiche le libellé sans fetch).
+> 2. ℹ️ **Liste « riche »** : le groupe `supplier:read` étant partagé liste+détail, la **collection embarque tout le bloc Information** (et, pour un user `accounting.view`, les scalaires compta + `ribs[]`). Comportement identique au M1 (groupe `client:read` partagé) — la datatable n'affiche que Nom/Catégories/Site(s)/MAJ, mais le payload est complet. Le gating `accounting` reste effectif (Commerciale ne voit ni compta ni `ribs` en liste comme en détail).
 
 > **Forme d'enveloppe confirmée sur le M1 réel** (API Platform 4.2) : JSON-LD **sans préfixe `hydra:`** → clés `member` / `totalItems` / `view`, avec `@type: "Collection"` et `view.@type: "PartialCollectionView"`. `Content-Type: application/ld+json; charset=utf-8`. Pagination défaut 10 confirmée. Login réel = `POST /api/login_check` (nginx réécrit vers `/login_check`), réponse `204` + cookie HttpOnly `BEARER`.
 
-`GET /api/suppliers` (liste, ADMIN) :
+`GET /api/suppliers?search=…` (liste, ADMIN — un membre) :
 ```json
 {
   "@context": "/api/contexts/Supplier",
   "@id": "/api/suppliers",
   "@type": "Collection",
-  "totalItems": 13,
+  "totalItems": 1,
   "member": [
     {
-      "@id": "/api/suppliers/1",
+      "@id": "/api/suppliers/85",
       "@type": "Supplier",
-      "id": 1,
-      "companyName": "RECYCLA SAS",
+      "id": 85,
+      "companyName": "DOD59393F 862875",
       "categories": [
-        {"@id": "/api/categories/12", "id": 12, "code": "NEGOCIANT", "name": "Négociant"}
+        {"@type": "Category", "@id": "/api/categories/2279", "id": 2279, "name": "test_cli_cat_fr_negociant", "code": "NEGOCIANT",
+         "categoryType": {"@id": "/api/category_types/602", "@type": "CategoryType", "id": 602, "code": "FOURNISSEUR", "label": "Fournisseur"},
+         "createdAt": "…", "updatedAt": "…"}
       ],
+      "description": "Fournisseur de test complet.",
+      "competitors": "Concurrent A, Concurrent B",
+      "foundedAt": "2008-04-01T00:00:00+02:00",
+      "employeesCount": 42,
+      "revenueAmount": "1500000.00",
+      "directorName": "Jean Dupont",
+      "profitAmount": "120000.00",
+      "volumeForecast": 8000,
+      "siren": "123456789",
+      "accountNumber": "F0001",
+      "tvaMode": {"@id": "/api/tva_modes/30", "@type": "TvaMode", "id": 30, "code": "FRANCE_VENTES", "label": "France (ventes)"},
+      "nTva": "FR00123456789",
+      "paymentDelay": {"@id": "/api/payment_delays/11", "@type": "PaymentDelay", "id": 11, "code": "J30", "label": "30 jours"},
+      "paymentType": {"@id": "/api/payment_types/14", "@type": "PaymentType", "id": 14, "code": "LCR", "label": "LCR"},
+      "ribs": [
+        {"@id": "/api/supplier_ribs/27", "@type": "SupplierRib", "id": 27, "label": "Compte principal", "bic": "BNPAFRPPXXX", "iban": "FR1420041010050500013M02606", "createdAt": "…", "updatedAt": "…"}
+      ],
+      "createdAt": "…", "updatedAt": "…",
       "sites": [
-        {"@id": "/api/sites/1", "id": 1, "name": "Chatellerault", "postalCode": "86100", "city": "Châtellerault", "color": "#056CF2"},
-        {"@id": "/api/sites/2", "id": 2, "name": "Saint-Jean", "postalCode": "17400", "city": "Fontenet", "color": "#…"}
+        {"@type": "Site", "@id": "/api/sites/87", "id": 87, "name": "Chatellerault", "street": "14 All. d'Argenson", "postalCode": "86100", "city": "Châtellerault", "color": "#056CF2", "fullAddress": "14 All. d'Argenson\n86100 Châtellerault"},
+        {"@type": "Site", "@id": "/api/sites/88", "id": 88, "name": "Saint-Jean", "street": "Z i", "postalCode": "17400", "city": "Fontenet", "color": "#F3CB00", "fullAddress": "Z i\n17400 Fontenet"}
       ],
-      "updatedAt": "2026-02-17T09:30:00+00:00",
       "isArchived": false
     }
   ],
-  "view": {
-    "@id": "/api/suppliers?page=1",
-    "@type": "PartialCollectionView",
-    "first": "/api/suppliers?page=1",
-    "last": "/api/suppliers?page=2",
-    "next": "/api/suppliers?page=2"
-  }
+  "view": {"@id": "/api/suppliers?search=…", "@type": "PartialCollectionView"}
 }
 ```
 
-> Les fournisseurs archivés sont **exclus** du `totalItems` (sur le M1, 14 clients en base → `totalItems: 13` car 1 archivé filtré par le Provider). `categories[]` (avec `code`/`name`) et `sites[]` (avec `name`/`postalCode` — **pas de `code`**) sont **embarqués** (cohérence M1/ERP-62, § 2.12) ; `sites` est l'agrégat dédoublonné des adresses via `Supplier::getSites()`. Fetch-joins repository obligatoires (anti N+1).
+> Les fournisseurs archivés sont **exclus** du `totalItems` (RG-2.17 — filtré par le Provider). `categories[]` (avec `code`/`name`) et `sites[]` (avec `name`/`postalCode` — **pas de `code`**) sont **embarqués** (cohérence M1/ERP-62, § 2.12) ; `sites` est l'agrégat dédoublonné des adresses via `Supplier::getSites()`. Fetch-joins repository (anti N+1) **vérifiés par test** (`SupplierListTest::testListQueryCountDoesNotGrowWithRowCount` : nombre de requêtes constant entre 2 et 4 fournisseurs). ⚠️ Le membre embarque aussi l'**Information complète** et — pour un user `accounting.view` (ici admin) — les **scalaires compta + `ribs[]`** (groupe `supplier:read` partagé liste/détail). Pour la **Commerciale** (sans `accounting.view`), `siren`/`tvaMode`/`paymentType`/`ribs`… **disparaissent** de chaque membre.
 
-`GET /api/suppliers/1` (détail — user avec `accounting.view`) :
+`GET /api/suppliers/85` (détail — user avec `accounting.view`) :
 ```json
 {
-  "@id": "/api/suppliers/1",
+  "@context": "/api/contexts/Supplier",
+  "@id": "/api/suppliers/85",
   "@type": "Supplier",
-  "id": 1,
-  "companyName": "RECYCLA SAS",
+  "id": 85,
+  "companyName": "DOD59393F 862875",
   "categories": [
-    {"@id": "/api/categories/12", "id": 12, "code": "NEGOCIANT", "name": "Négociant"}
+    {"@type": "Category", "@id": "/api/categories/2279", "id": 2279, "name": "test_cli_cat_fr_negociant", "code": "NEGOCIANT",
+     "categoryType": {"@id": "/api/category_types/602", "@type": "CategoryType", "id": 602, "code": "FOURNISSEUR", "label": "Fournisseur"}}
   ],
-  "description": "…", "competitors": "…", "foundedAt": "2008-04-01",
-  "employeesCount": 42, "revenueAmount": "1500000.00", "directorName": "…",
-  "profitAmount": "120000.00", "volumeForecast": 8000,
+  "description": "Fournisseur de test complet.", "competitors": "Concurrent A, Concurrent B",
+  "foundedAt": "2008-04-01T00:00:00+02:00", "employeesCount": 42, "revenueAmount": "1500000.00",
+  "directorName": "Jean Dupont", "profitAmount": "120000.00", "volumeForecast": 8000,
+  "siren": "123456789", "accountNumber": "F0001",
+  "tvaMode": {"@id": "/api/tva_modes/30", "@type": "TvaMode", "id": 30, "code": "FRANCE_VENTES", "label": "France (ventes)"},
+  "nTva": "FR00123456789",
+  "paymentDelay": {"@id": "/api/payment_delays/11", "@type": "PaymentDelay", "id": 11, "code": "J30", "label": "30 jours"},
+  "paymentType": {"@id": "/api/payment_types/14", "@type": "PaymentType", "id": 14, "code": "LCR", "label": "LCR"},
   "contacts": [
-    {"@id": "/api/supplier_contacts/1", "id": 1, "firstName": "Marie", "lastName": "Martin",
-     "jobTitle": "Responsable achats", "phonePrimary": "0612345678", "phoneSecondary": null,
-     "email": "marie.martin@recycla.fr"}
+    {"@id": "/api/supplier_contacts/39", "@type": "SupplierContact", "id": 39, "firstName": "Marie", "lastName": "Martin",
+     "jobTitle": "Responsable achats", "phonePrimary": "0612345678", "email": "marie.martin@seed.test"}
   ],
   "addresses": [
-    {"@id": "/api/supplier_addresses/1", "id": 1, "addressType": "DEPART",
-     "country": "France", "postalCode": "86000", "city": "Poitiers",
-     "street": "12 rue des Acacias", "streetComplement": null,
+    {"@id": "/api/supplier_addresses/33", "@type": "SupplierAddress", "id": 33, "addressType": "DEPART",
+     "country": "France", "postalCode": "86000", "city": "Poitiers", "street": "12 rue des Acacias",
      "bennes": 3, "triageProvider": true,
-     "sites": [{"@id": "/api/sites/1", "id": 1, "name": "Chatellerault", "postalCode": "86100", "city": "Châtellerault", "color": "#056CF2"}],
-     "categories": [{"@id": "/api/categories/12", "id": 12, "code": "NEGOCIANT", "name": "Négociant"}],
-     "contacts": [{"@id": "/api/supplier_contacts/1", "id": 1, "firstName": "Marie", "lastName": "Martin"}]}
+     "sites": [
+       {"@type": "Site", "@id": "/api/sites/87", "id": 87, "name": "Chatellerault", "postalCode": "86100", "city": "Châtellerault", "color": "#056CF2"},
+       {"@type": "Site", "@id": "/api/sites/88", "id": 88, "name": "Saint-Jean", "postalCode": "17400", "city": "Fontenet", "color": "#F3CB00"}
+     ],
+     "contacts": [{"@id": "/api/supplier_contacts/39", "@type": "SupplierContact", "id": 39, "firstName": "Marie", "lastName": "Martin"}],
+     "categories": [{"@type": "Category", "@id": "/api/categories/2279", "id": 2279, "name": "test_cli_cat_fr_negociant", "code": "NEGOCIANT"}]}
   ],
-  "siren": "123456789", "accountNumber": "F0001",
-  "tvaMode": {"@id": "/api/tva_modes/1", "id": 1, "label": "France (ventes)"},
-  "nTva": "FR00123456789",
-  "paymentDelay": {"@id": "/api/payment_delays/2", "id": 2, "label": "30 jours"},
-  "paymentType": {"@id": "/api/payment_types/2", "id": 2, "code": "LCR", "label": "LCR"},
-  "bank": null,
   "ribs": [
-    {"@id": "/api/supplier_ribs/1", "id": 1, "label": "Compte principal",
-     "bic": "SOGEFRPP", "iban": "FR7630003035400005000000123"}
+    {"@id": "/api/supplier_ribs/27", "@type": "SupplierRib", "id": 27, "label": "Compte principal", "bic": "BNPAFRPPXXX", "iban": "FR1420041010050500013M02606"}
   ],
-  "isArchived": false, "archivedAt": null,
-  "updatedAt": "2026-02-17T09:30:00+00:00"
+  "isArchived": false
 }
 ```
 
-> Pour un user **sans** `accounting.view` (ex. Commerciale) : les clés `siren`, `accountNumber`, `tvaMode`, `nTva`, `paymentDelay`, `paymentType`, `bank`, `ribs` **sont absentes** (pas `null` — réellement non sérialisées car le Provider retire le groupe). Le gating par **omission de clé** est confirmé confortable côté front. Le blame `updatedBy` est sérialisé en **IRI** (`"/api/me"` quand c'est l'user courant) — en tenir compte côté front.
+> Pour un user **sans** `accounting.view` (ex. Commerciale) : les clés `siren`, `accountNumber`, `tvaMode`, `nTva`, `paymentDelay`, `paymentType`, `bank`, `ribs` **sont absentes** (pas `null` — réellement non sérialisées : le `SupplierReadGroupContextBuilder` n'ajoute pas le groupe). Gating par **omission de clé** confirmé sur le JSON réel (`SupplierSerializationContractTest::testRibsAbsentForCommercialeWithoutAccountingView` + `testAccountingScalarsGatedByOmission`). `bennes`/`triageProvider`/`addressType`/`addresses[].contacts` restent visibles (onglet Adresse non gaté). NB : ici `bank` est absent (paymentType=LCR sans banque) ; avec un VIREMENT, `bank` est embarqué `{id, code, label}` (fix ERP-92).
 
 ### 4.0.ter Pièges de sérialisation CONSTATÉS sur le M1 réel → parade M2 (OBLIGATOIRE)
 
@@ -1046,7 +1063,7 @@ Le M1 a subi un aller-retour (ERP-68) faute de fixtures alignées. Pour le M2, p
 
 - [x] 3 maillons de sérialisation documentés pour chaque champ liste + détail (§ 4.0)
 - [x] Décision embed vs GetCollection explicite et câblée (embed détail + sous-ressources write — § 3.3 / § 3.4 / § 4.5), **pas de POST-only**
-- [ ] **Réponses JSON RÉELLES** collées (§ 4.0.bis) — *en attente de `make start` + curl (DoD avant tickets front)*
+- [x] **Réponses JSON RÉELLES** collées (§ 4.0.bis) — capturées via PHPUnit (ERP-92, 2026-06-05) ; fix réfs compta IRI→{id,label} inclus
 - [x] Matrice RBAC rôle × onglet + mode strict PATCH (§ 2.9 / RG-2.16)
 - [x] Pagination (n°13), COMMENT ON COLUMN (n°12), Timestampable/Blamable, Audit, routes à plat : rappelés
 - [x] Réutilisations M1 identifiées (référentiels compta partagés, taxonomie code/type, `usePaginatedList`, blocs, archive, normalisation)

docs/superpowers/specs/2026-06-03-form-field-validation-mapping-design.md

@@ -0,0 +1,119 @@
+# ERP-101 — Mapping des erreurs de validation par champ (convention forms)
+
+> Statut : design validé — implémentation TDD en cours
+> Branche : `feat/ERP-101-form-field-validation-mapping`
+> Date : 2026-06-03
+
+## Problème
+
+Quand le back renvoie une **422** (violations API Platform), il renvoie **toutes** les
+violations d'un coup (un `propertyPath` + `message` par champ fautif). Aujourd'hui, seul
+le drawer Catégorie (`useCategoryForm`) exploite ce détail pour afficher l'erreur **sous
+le champ concerné** ; il le fait via un `if/else` manuel par champ, non réutilisable.
+
+Le formulaire Client (≈ 20 champs sur 5 submits, dont 3 collections) ne mappe rien : une
+422 multi-champs ⇒ un seul **toast global**. On veut un retour par champ, et surtout
+**une convention unique réutilisée par tous les modules**.
+
+## Décisions
+
+1. **Primitif générique** plutôt que composable par form : `useFormErrors()` partagé.
+2. **Périmètre complet** sur Client : champs scalaires **et** collections (erreur par ligne).
+
+## Architecture — 3 briques
+
+### 1. `mapViolationsToRecord(data)` — `frontend/shared/utils/api.ts`
+
+Util pur, fondation réutilisée partout. Transforme un payload 422 en
+`Record<propertyPath, message>`. S'appuie sur `extractApiViolations` (déjà existant,
+gère les formats `violations` et `hydra:violations`).
+
+```ts
+export function mapViolationsToRecord(data: unknown): Record<string, string> {
+    const out: Record<string, string> = {}
+    for (const v of extractApiViolations(data)) {
+        if (v.propertyPath) out[v.propertyPath] = v.message
+    }
+    return out
+}
+```
+
+### 2. `useFormErrors()` — `frontend/shared/composables/useFormErrors.ts`
+
+API que tous les forms **scalaires** consomment.
+
+```ts
+const { errors, hasErrors, setServerErrors, setError, clearError, clearErrors, handleApiError } = useFormErrors()
+```
+
+- `errors` : `reactive<Record<string, string>>` indexé par `propertyPath`.
+- `setServerErrors(data)` : `mapViolationsToRecord` → remplit `errors`. Retourne `true`
+  si au moins une violation a été mappée.
+- `setError(field, msg)` / `clearError(field)` / `clearErrors()` : manipulation fine.
+- `hasErrors` : `computed` booléen.
+- `handleApiError(e, opts?)` : dispatch standard depuis une erreur ofetch —
+  **422** → `setServerErrors` (mapping inline, pas de toast) ; **autre** → toast
+  générique de fallback (message extrait via `extractApiErrorMessage`).
+
+Côté template, le nom du champ **est** le `propertyPath` :
+
+```vue
+<MalioInputText v-model="main.companyName" :error="errors.companyName" />
+<MalioInputText v-model="accounting.siren" :error="errors.siren" />
+```
+
+> L'unicité SIREN (RG-1.15) remonte en **422 `UniqueEntity` avec `propertyPath: "siren"`**
+> → mappée automatiquement. Pas de cas 409 spécial (contrairement à Catégorie).
+
+### 3. Collections — erreurs par ligne
+
+Chaque ligne (contact / adresse / RIB) est persistée par **son propre appel API**, donc
+le back renvoie un 422 **relatif à la sous-entité** (`propertyPath: "email"`, `"iban"`…).
+
+- Le parent tient, par collection, un tableau d'erreurs **aligné sur l'index de ligne** :
+  `const contactErrors = ref<Record<string, string>[]>([])`.
+- Au submit de la ligne `i` : `catch` → `contactErrors.value[i] = mapViolationsToRecord(data)`.
+- On `clearErrors` la collection au début de chaque passe de submit.
+- Les blocs reçoivent une prop `:errors` (`Record<string, string>`) et bindent
+  `:error="errors?.email"` sur chaque champ Malio.
+
+## Fichiers touchés
+
+| Fichier | Action |
+|---|---|
+| `shared/utils/api.ts` | + `mapViolationsToRecord` |
+| `shared/composables/useFormErrors.ts` | **nouveau** composable |
+| `modules/commercial/pages/clients/new.vue` | scalaires (Main/Info/Compta) + erreurs par ligne |
+| `modules/commercial/pages/clients/[id]/edit.vue` | idem |
+| `modules/commercial/components/ClientContactBlock.vue` | + prop `:errors`, bind `:error` |
+| `modules/commercial/components/ClientAddressBlock.vue` | + prop `:errors`, bind `:error` |
+| RIB (inline dans new/edit) | bind `:error` par ligne |
+
+## Tests (Vitest — règle « pas d'E2E »)
+
+- `mapViolationsToRecord` : formats `violations` / `hydra:violations`, payload vide,
+  `propertyPath` manquant.
+- `useFormErrors` : `setServerErrors` mappe et retourne `true` / `false` sans violation,
+  `clearErrors`, fallback toast sur non-422.
+
+## Convention posée pour tous les forms
+
+À reporter dans `.claude/rules/frontend.md` une fois le pattern stabilisé :
+
+> Tout form qui veut un retour d'erreur par champ : appels API en `{ toast: false }` +
+> `useFormErrors` pour les champs scalaires (422 inline), `mapViolationsToRecord` par
+> ligne pour les collections. `useCategoryForm` migrera sur `useFormErrors`.
+
+## Fait dans la foulée (post-ERP-101 initial)
+
+- **`useCategoryForm` migré sur `useFormErrors`** : `errors` devient le `reactive` du
+  composable (drawer adapté : `form.errors.name` au lieu de `form.errors.value.name`,
+  bloc `_global` retiré → erreur transverse en toast). 28 tests verts.
+- **Convention reportée dans `.claude/rules/frontend.md`** (section « Validation des
+  formulaires — useFormErrors obligatoire »).
+
+## Hors scope ERP-101 (suivi : ticket ERP-107)
+
+- Langue / présence des messages de validation côté back : le `message` affiché est celui
+  renvoyé par le serveur. Audit des contraintes Symfony (présence d'un `message` FR,
+  contraintes manquantes, violations sans `propertyPath`) tracké dans **ERP-107**.

frontend/i18n/locales/fr.json

@@ -10,7 +10,11 @@
         "confirm": "Confirmer",
         "yes": "Oui",
         "no": "Non",
-        "actions": "Actions"
+        "actions": "Actions",
+        "comingSoon": {
+            "title": "En cours de dev",
+            "subtitle": "Cette fonctionnalité arrive bientôt."
+        }
     },
     "sidebar": {
         "administration": {
@@ -95,8 +99,6 @@
                 "back": "Retour au répertoire",
                 "loading": "Chargement du client…",
                 "notFound": "Client introuvable.",
-                "emptyContacts": "Aucun contact enregistré.",
-                "emptyAddresses": "Aucune adresse enregistrée.",
                 "confirmArchive": {
                     "title": "Archiver le client",
                     "message": "Ce client n'apparaîtra plus dans le répertoire actif. Confirmer l'archivage ?"
@@ -111,8 +113,6 @@
                 "back": "Retour au répertoire",
                 "loading": "Chargement du client…",
                 "notFound": "Client introuvable.",
-                "emptyContacts": "Aucun contact enregistré.",
-                "emptyAddresses": "Aucune adresse enregistrée.",
                 "save": "Valider"
             },
             "validation": {
@@ -133,14 +133,9 @@
                 "duplicateCompany": "Un client portant ce nom de société existe déjà.",
                 "main": {
                     "companyName": "Nom du client (Entreprise)",
-                    "firstName": "Prénom du contact principal",
-                    "lastName": "Nom du contact principal",
-                    "email": "Email",
-                    "phonePrimary": "Téléphone",
-                    "phoneSecondary": "Téléphone (2)",
-                    "addPhone": "Ajouter un numéro",
                     "categories": "Catégorie",
                     "relation": "Distributeur / Courtier",
+                    "relationNone": "Aucun",
                     "relationDistributor": "Dépend du distributeur",
                     "relationBroker": "Dépend du courtier",
                     "distributorName": "Nom du distributeur",
@@ -173,13 +168,18 @@
                     "prospect": "Prospect",
                     "delivery": "Adresse de livraison",
                     "billing": "Facturation",
+                    "addressType": "Type d'adresse",
+                    "addressTypeProspect": "Prospect",
+                    "addressTypeDelivery": "Livraison",
+                    "addressTypeBilling": "Facturation",
+                    "addressTypeDeliveryBilling": "Adresse + Facturation",
                     "categories": "Catégorie",
                     "country": "Pays",
                     "postalCode": "Code postal",
                     "city": "Ville",
                     "street": "Adresse",
                     "streetComplement": "Adresse complémentaire",
-                    "sites": "Sites Starseed",
+                    "sites": "Sites",
                     "contacts": "Contact(s) rattaché(s)",
                     "billingEmail": "Email de facturation",
                     "remove": "Supprimer l'adresse",
@@ -233,7 +233,10 @@
         },
         "sites": {
             "notAuthorized": "Vous n'êtes pas autorisé à sélectionner ce site."
-        }
+        },
+        "title": "Erreur",
+        "generic": "Une erreur est survenue.",
+        "unknown": "Erreur inconnue."
     },
     "sites": {
         "selector": {
@@ -256,7 +259,11 @@
             "commercial_client":      "Client",
             "commercial_clientaddress": "Adresse client",
             "commercial_clientcontact": "Contact client",
-            "commercial_clientrib":   "RIB client"
+            "commercial_clientrib":   "RIB client",
+            "commercial_supplier":    "Fournisseur",
+            "commercial_supplieraddress": "Adresse fournisseur",
+            "commercial_suppliercontact": "Contact fournisseur",
+            "commercial_supplierrib": "RIB fournisseur"
         },
         "empty": "Aucune activité enregistrée",
         "no_results": "Aucun résultat pour ces filtres",
@@ -290,7 +297,8 @@
     "success": {
         "auth": {
             "logout": "Deconnexion reussie"
-        }
+        },
+        "title": "Succès"
     },
     "admin": {
         "roles": {

frontend/modules/catalog/components/CategoryDrawer.vue

@@ -20,7 +20,7 @@
                 :label="t('admin.categories.form.name')"
                 input-class="w-full"
                 :max-length="120"
-                :error="form.errors.value.name"
+                :error="form.errors.name"
                 required
             />
 
@@ -32,15 +32,9 @@
                 :options="typeOptions"
                 :label="t('admin.categories.form.type')"
                 :empty-option-label="t('admin.categories.form.typePlaceholder')"
-                :error="form.errors.value.categoryType"
+                :error="form.errors.categoryType"
                 :disabled="loadingTypes"
             />
-
-            <!-- Erreur transverse (typiquement reseau / 5xx) — separe des
-                 erreurs de validation par champ. -->
-            <p v-if="form.errors.value._global" class="text-sm text-red-600">
-                {{ form.errors.value._global }}
-            </p>
         </form>
 
         <!-- Footer fixe : depuis 1.7.1 le slot #footer est un frere du body

frontend/modules/catalog/composables/__tests__/useCategoryForm.spec.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import type { Category, CategoryType } from '~/modules/catalog/types/category'
+import { useFormErrors } from '~/shared/composables/useFormErrors'
 import { useCategoryForm } from '../useCategoryForm'
 
 // Stubs des auto-imports Nuxt consommes par le composable.
@@ -21,6 +22,9 @@ vi.stubGlobal('useToast', () => ({
     success: mockToastSuccess,
     error: mockToastError,
 }))
+// useFormErrors est un auto-import Nuxt : on expose l'implementation reelle
+// (elle consomme useToast, deja stubbe ci-dessus) pour tester l'integration.
+vi.stubGlobal('useFormErrors', useFormErrors)
 // useI18n.t : on renvoie la cle telle quelle (pratique pour asserter dessus).
 // Quand le composable passe des params (ex: doublon), on les serialise pour
 // pouvoir verifier que l'interpolation a bien recu le bon nom.
@@ -61,7 +65,7 @@ describe('useCategoryForm', () => {
 
             expect(form.name.value).toBe('Vis')
             expect(form.categoryTypeId.value).toBe(1)
-            expect(form.errors.value).toEqual({ name: '', categoryType: '', _global: '' })
+            expect(form.errors).toEqual({})
         })
 
         it('vide le formulaire en mode creation (null)', () => {
@@ -105,7 +109,7 @@ describe('useCategoryForm', () => {
             const ok = form.validate()
 
             expect(ok).toBe(false)
-            expect(form.errors.value.name).toBe('admin.categories.validation.nameRequired')
+            expect(form.errors.name).toBe('admin.categories.validation.nameRequired')
         })
 
         it('signale erreur si name est whitespace-only (trim → vide)', () => {
@@ -116,7 +120,7 @@ describe('useCategoryForm', () => {
             const ok = form.validate()
 
             expect(ok).toBe(false)
-            expect(form.errors.value.name).toBe('admin.categories.validation.nameRequired')
+            expect(form.errors.name).toBe('admin.categories.validation.nameRequired')
         })
 
         it('signale erreur si name fait 1 caractere (< 2, RG-1.04)', () => {
@@ -127,7 +131,7 @@ describe('useCategoryForm', () => {
             const ok = form.validate()
 
             expect(ok).toBe(false)
-            expect(form.errors.value.name).toBe('admin.categories.validation.nameLength')
+            expect(form.errors.name).toBe('admin.categories.validation.nameLength')
         })
 
         it('signale erreur si name fait 121 caracteres (> 120, RG-1.04)', () => {
@@ -138,7 +142,7 @@ describe('useCategoryForm', () => {
             const ok = form.validate()
 
             expect(ok).toBe(false)
-            expect(form.errors.value.name).toBe('admin.categories.validation.nameLength')
+            expect(form.errors.name).toBe('admin.categories.validation.nameLength')
         })
 
         it('signale erreur si categoryTypeId est null (RG-1.05)', () => {
@@ -149,7 +153,7 @@ describe('useCategoryForm', () => {
             const ok = form.validate()
 
             expect(ok).toBe(false)
-            expect(form.errors.value.categoryType).toBe('admin.categories.validation.typeRequired')
+            expect(form.errors.categoryType).toBe('admin.categories.validation.typeRequired')
         })
 
         it('passe quand name et categoryType sont valides', () => {
@@ -160,19 +164,22 @@ describe('useCategoryForm', () => {
             const ok = form.validate()
 
             expect(ok).toBe(true)
-            expect(form.errors.value).toEqual({ name: '', categoryType: '', _global: '' })
+            expect(form.errors).toEqual({})
         })
 
         it('reinitialise les erreurs avant chaque validation', () => {
             const form = useCategoryForm()
-            // Erreur prealable.
-            form.errors.value._global = 'erreur ancienne'
-            form.name.value = 'Vis'
+            // Erreur prealable : une validation en echec peuple errors.name.
+            form.name.value = ''
             form.categoryTypeId.value = 1
+            form.validate()
+            expect(form.errors.name).toBeTruthy()
 
+            // Seconde validation avec des valeurs valides : errors repart vide.
+            form.name.value = 'Vis'
             form.validate()
 
-            expect(form.errors.value._global).toBe('')
+            expect(form.errors).toEqual({})
         })
     })
 
@@ -213,7 +220,7 @@ describe('useCategoryForm', () => {
             await form.submitCreate()
 
             expect(mockToastSuccess).toHaveBeenCalledWith({
-                title: 'Succès',
+                title: 'success.title',
                 message: 'admin.categories.toast.created',
             })
         })
@@ -231,8 +238,8 @@ describe('useCategoryForm', () => {
             expect(result).toBeNull()
             // La cle est interpolee avec le nom soumis : on retrouve "Vis" dans
             // les params i18n (stub serialise les params).
-            expect(form.errors.value.name).toContain('admin.categories.toast.duplicate')
-            expect(form.errors.value.name).toContain('"name":"Vis"')
+            expect(form.errors.name).toContain('admin.categories.toast.duplicate')
+            expect(form.errors.name).toContain('"name":"Vis"')
             expect(mockToastError).toHaveBeenCalledTimes(1)
             const toastArg = mockToastError.mock.calls[0]?.[0] as { message: string }
             expect(toastArg.message).toContain('Vis')
@@ -256,7 +263,7 @@ describe('useCategoryForm', () => {
             const result = await form.submitCreate()
 
             expect(result).toBeNull()
-            expect(form.errors.value.name).toBe('name should not be blank.')
+            expect(form.errors.name).toBe('name should not be blank.')
             // Pas de toast quand on a mappe les violations : l erreur est
             // affichee inline sous le champ concerne.
             expect(mockToastError).not.toHaveBeenCalled()
@@ -279,10 +286,10 @@ describe('useCategoryForm', () => {
 
             await form.submitCreate()
 
-            expect(form.errors.value.categoryType).toBe('Type invalide.')
+            expect(form.errors.categoryType).toBe('Type invalide.')
         })
 
-        it('fallback en erreur globale + toast si le status n est ni 409 ni 422', async () => {
+        it('fallback en toast generique si le status n est ni 409 ni 422', async () => {
             mockPost.mockRejectedValueOnce({
                 response: { status: 500, _data: { 'hydra:description': 'Boom server' } },
             })
@@ -292,9 +299,10 @@ describe('useCategoryForm', () => {
 
             await form.submitCreate()
 
-            expect(form.errors.value._global).toBe('Boom server')
+            // Pas d'erreur inline par champ : l'erreur transverse part en toast.
+            expect(form.errors).toEqual({})
             expect(mockToastError).toHaveBeenCalledWith({
-                title: 'Erreur',
+                title: 'errors.title',
                 message: 'Boom server',
             })
         })
@@ -370,7 +378,7 @@ describe('useCategoryForm', () => {
             await form.submitUpdate(42)
 
             expect(mockToastSuccess).toHaveBeenCalledWith({
-                title: 'Succès',
+                title: 'success.title',
                 message: 'admin.categories.toast.updated',
             })
         })
@@ -386,8 +394,8 @@ describe('useCategoryForm', () => {
             const result = await form.submitUpdate(42)
 
             expect(result).toBeNull()
-            expect(form.errors.value.name).toContain('admin.categories.toast.duplicate')
-            expect(form.errors.value.name).toContain('"name":"Doublon"')
+            expect(form.errors.name).toContain('admin.categories.toast.duplicate')
+            expect(form.errors.name).toContain('"name":"Doublon"')
         })
     })
 
@@ -401,7 +409,7 @@ describe('useCategoryForm', () => {
             expect(mockDelete).toHaveBeenCalledWith('/categories/42', {}, { toast: false })
             expect(ok).toBe(true)
             expect(mockToastSuccess).toHaveBeenCalledWith({
-                title: 'Succès',
+                title: 'success.title',
                 message: 'admin.categories.toast.deleted',
             })
         })
@@ -415,7 +423,6 @@ describe('useCategoryForm', () => {
             const ok = await form.submitDelete(42)
 
             expect(ok).toBe(false)
-            expect(form.errors.value._global).toBe('down')
             expect(mockToastError).toHaveBeenCalled()
         })
     })
@@ -424,15 +431,15 @@ describe('useCategoryForm', () => {
         it('vide le formulaire et les erreurs', () => {
             const form = useCategoryForm()
             form.loadFrom(CAT)
-            form.name.value = 'edit'
-            form.errors.value._global = 'erreur'
+            form.name.value = ''
+            form.validate() // peuple errors.name
             form.submitting.value = true
 
             form.reset()
 
             expect(form.name.value).toBe('')
             expect(form.categoryTypeId.value).toBeNull()
-            expect(form.errors.value).toEqual({ name: '', categoryType: '', _global: '' })
+            expect(form.errors).toEqual({})
             expect(form.submitting.value).toBe(false)
         })
     })

frontend/modules/catalog/composables/useCategoryForm.ts

@@ -12,14 +12,13 @@
  * elles servent juste a eviter l'aller-retour reseau evitable. Le serveur
  * revalide toujours (defense en profondeur).
  *
- * Mapping erreurs API :
- *   - 409 (RG-1.07 doublon) → toast + erreur sur le champ `name`
- *   - 422 (violations API Platform) → mapping sur les champs concernes
- *   - autre → erreur globale `_global` + toast generique
+ * Erreurs par champ : delegue a `useFormErrors` (convention ERP-101). Les
+ * violations 422 sont mappees par `propertyPath` (`name`, `categoryType`) ;
+ * l'erreur globale (status != 422 exploitable) part en toast. Le 409 (doublon
+ * RG-1.07) reste un cas metier specifique : erreur inline sur `name` + toast.
  */
 import { computed, ref } from 'vue'
 import type { Category } from '~/modules/catalog/types/category'
-import { extractApiErrorMessage, extractApiViolations } from '~/shared/utils/api'
 
 /**
  * Erreur HTTP capturee par ofetch. On expose juste les champs utilises ici
@@ -37,6 +36,9 @@ export function useCategoryForm() {
     const { t } = useI18n()
     const toast = useToast()
 
+    // Etat d'erreurs par champ (indexe par propertyPath) + dispatch API 422.
+    const formErrors = useFormErrors()
+
     // State local du formulaire — pas singleton, chaque appel a useCategoryForm
     // cree son propre state (cohérent avec le pattern « un drawer = un form »).
     const name = ref('')
@@ -48,16 +50,6 @@ export function useCategoryForm() {
     const initialName = ref('')
     const initialCategoryTypeId = ref<number | null>(null)
 
-    const errors = ref<{
-        name: string
-        categoryType: string
-        _global: string
-    }>({
-        name: '',
-        categoryType: '',
-        _global: '',
-    })
-
     const submitting = ref(false)
 
     const isDirty = computed(
@@ -72,7 +64,7 @@ export function useCategoryForm() {
      * erreurs et le snapshot initial pour repartir d'un etat propre.
      */
     function loadFrom(category: Category | null): void {
-        errors.value = { name: '', categoryType: '', _global: '' }
+        formErrors.clearErrors()
         if (category) {
             name.value = category.name
             categoryTypeId.value = category.categoryType.id
@@ -92,32 +84,29 @@ export function useCategoryForm() {
      * mais le serveur retrim de toute facon — pas de risque de divergence.
      */
     function validate(): boolean {
-        errors.value = { name: '', categoryType: '', _global: '' }
+        formErrors.clearErrors()
         const trimmedName = name.value.trim()
 
         // RG-1.02 — name obligatoire (vide / whitespace-only).
         if (trimmedName === '') {
-            errors.value.name = t('admin.categories.validation.nameRequired')
+            formErrors.setError('name', t('admin.categories.validation.nameRequired'))
         } else if (trimmedName.length < 2 || trimmedName.length > 120) {
             // RG-1.04 — longueur 2-120 apres trim.
-            errors.value.name = t('admin.categories.validation.nameLength')
+            formErrors.setError('name', t('admin.categories.validation.nameLength'))
         }
 
         // RG-1.05 — categoryType obligatoire.
         if (categoryTypeId.value === null) {
-            errors.value.categoryType = t('admin.categories.validation.typeRequired')
+            formErrors.setError('categoryType', t('admin.categories.validation.typeRequired'))
         }
 
-        return errors.value.name === '' && errors.value.categoryType === ''
+        return !formErrors.errors.name && !formErrors.errors.categoryType
     }
 
     /**
      * Construit le payload POST a partir du state. Le `categoryType` est
      * envoye en IRI Hydra (`/api/category_types/{id}`) — convention API
-     * Platform pour referencer une ressource liee. Retourne un object literal
-     * compatible avec `AnyObject` de `useApi()` (un type nomme strict comme
-     * `CategoryCreateInput` ne serait pas assignable a `Record<string, unknown>`
-     * en TS strict).
+     * Platform pour referencer une ressource liee.
      */
     function buildCreatePayload(): Record<string, unknown> {
         return {
@@ -127,72 +116,24 @@ export function useCategoryForm() {
     }
 
     /**
-     * Mappe les violations 422 d'API Platform sur les champs du formulaire.
-     * Renvoie true des qu'au moins une violation a ete posee — false sinon
-     * (payload sans violations exploitables, ou tous les `propertyPath` hors
-     * du mapping connu). L'extraction Hydra (`violations` / `hydra:violations`)
-     * est centralisee dans `shared/utils/api.ts` pour rester reutilisable
-     * sur les futurs drawers de formulaire.
-     */
-    function mapServerViolations(data: unknown): boolean {
-        const violations = extractApiViolations(data)
-        if (violations.length === 0) return false
-        let mapped = false
-        for (const v of violations) {
-            if (v.propertyPath === 'name') {
-                errors.value.name = v.message
-                mapped = true
-            } else if (v.propertyPath === 'categoryType') {
-                errors.value.categoryType = v.message
-                mapped = true
-            }
-        }
-        return mapped
-    }
-
-    /**
-     * Traite une erreur API : mappe selon le status, declenche les toasts
-     * appropries. Centralise la logique entre create/update.
-     *
-     * - 409 (RG-1.07) : doublon — toast + errors.name avec libelle qui inclut
-     *   le nom soumis.
-     * - 422 : tentative de mapping fin via les violations API Platform — si au
-     *   moins une violation est mappee, pas de toast (erreur affichee inline
-     *   sous le champ concerne).
-     * - autre : message global + toast generique. Le toast natif d'useApi
-     *   est desactive (`toast: false`) pour permettre ce mapping fin ; il faut
-     *   donc en re-emettre un manuellement ici, sinon une 500 reste silencieuse.
-     *
-     * Retourne true si l'erreur a ete reconnue et traitee (409/422 mappes),
-     * false sinon (fallback generique).
+     * Traite une erreur API : 409 (doublon RG-1.07) → erreur inline sur `name`
+     * + toast ; sinon delegue a `useFormErrors.handleApiError` (422 mappe inline
+     * par champ sans toast, autre → toast de fallback). Retourne true si traitee
+     * inline (409/422 mappe), false si fallback toast.
      */
     function handleApiError(e: unknown, attemptedName: string): boolean {
         const status = (e as ApiFetchError)?.response?.status
-        const data = (e as ApiFetchError)?.response?._data
 
         if (status === 409) {
             const duplicateMessage = t('admin.categories.toast.duplicate', {
                 name: attemptedName,
             })
-            errors.value.name = duplicateMessage
-            toast.error({
-                title: 'Erreur',
-                message: duplicateMessage,
-            })
+            formErrors.setError('name', duplicateMessage)
+            toast.error({ title: t('errors.title'), message: duplicateMessage })
             return true
         }
 
-        if (status === 422 && mapServerViolations(data)) {
-            return true
-        }
-
-        const extracted = extractApiErrorMessage(data)
-        errors.value._global = extracted || 'Une erreur est survenue.'
-        toast.error({
-            title: 'Erreur',
-            message: errors.value._global,
-        })
-        return false
+        return formErrors.handleApiError(e, { fallbackMessage: t('errors.generic') })
     }
 
     /**
@@ -203,14 +144,13 @@ export function useCategoryForm() {
     async function submitCreate(): Promise<Category | null> {
         if (!validate()) return null
         submitting.value = true
-        errors.value._global = ''
         const payload = buildCreatePayload()
         try {
             const created = await api.post<Category>('/categories', payload, {
                 toast: false,
             })
             toast.success({
-                title: 'Succès',
+                title: t('success.title'),
                 message: t('admin.categories.toast.created'),
             })
             return created
@@ -230,7 +170,6 @@ export function useCategoryForm() {
     async function submitUpdate(id: number): Promise<Category | null> {
         if (!validate()) return null
         submitting.value = true
-        errors.value._global = ''
         const payload: Record<string, unknown> = {}
         if (name.value !== initialName.value) {
             payload.name = name.value.trim()
@@ -250,7 +189,7 @@ export function useCategoryForm() {
                 toast: false,
             })
             toast.success({
-                title: 'Succès',
+                title: t('success.title'),
                 message: t('admin.categories.toast.updated'),
             })
             return updated
@@ -272,11 +211,11 @@ export function useCategoryForm() {
      */
     async function submitDelete(id: number): Promise<boolean> {
         submitting.value = true
-        errors.value._global = ''
+        formErrors.clearErrors()
         try {
             await api.delete(`/categories/${id}`, {}, { toast: false })
             toast.success({
-                title: 'Succès',
+                title: t('success.title'),
                 message: t('admin.categories.toast.deleted'),
             })
             return true
@@ -297,7 +236,7 @@ export function useCategoryForm() {
         categoryTypeId.value = null
         initialName.value = ''
         initialCategoryTypeId.value = null
-        errors.value = { name: '', categoryType: '', _global: '' }
+        formErrors.clearErrors()
         submitting.value = false
     }
 
@@ -305,7 +244,7 @@ export function useCategoryForm() {
         // State
         name,
         categoryTypeId,
-        errors,
+        errors: formErrors.errors,
         submitting,
         isDirty,
         // Methods

frontend/modules/commercial/components/ClientAddressBlock.vue

@@ -10,41 +10,61 @@
             @click="$emit('remove')"
         />
 
-        <!-- Usage de l'adresse : Prospect exclusif de Livraison/Facturation
-             (RG-1.06/07/08). L'exclusivite est appliquee au toggle (cocher l'un
-             decoche l'autre) plutot qu'en masquant les options. -->
-        <MalioCheckbox
-            :model-value="model.isProspect"
-            :label="t('commercial.clients.form.address.prospect')"
-            group-class="self-center"
+        <!-- Usage de l'adresse : Select unique (plus simple pour l'utilisateur)
+             remplacant les 3 cases. Les options encodent les combinaisons valides
+             (exclusivite Prospect, RG-1.06/07/08) ; le back recoit toujours les
+             drapeaux isProspect / isDelivery / isBilling (aucune RG modifiee). -->
+        <MalioSelect
+            :model-value="addressType"
+            :options="addressTypeOptions"
+            :label="t('commercial.clients.form.address.addressType')"
             :readonly="readonly"
-            @update:model-value="(v: boolean) => toggleFlag('isProspect', v)"
-        />
-        <MalioCheckbox
-            :model-value="model.isDelivery"
-            :label="t('commercial.clients.form.address.delivery')"
-            group-class="self-center"
-            :readonly="readonly"
-            @update:model-value="(v: boolean) => toggleFlag('isDelivery', v)"
-        />
-        <MalioCheckbox
-            :model-value="model.isBilling"
-            :label="t('commercial.clients.form.address.billing')"
-            group-class="self-center"
-            :readonly="readonly"
-            @update:model-value="(v: boolean) => toggleFlag('isBilling', v)"
+            :required="true"
+            @update:model-value="onAddressTypeChange"
         />
 
-        <!-- Cellule vide : laisse un trou en position 4 (ligne 1) pour que
-             Categorie reparte au debut de la ligne suivante. -->
-        <div aria-hidden="true" />
+        <!-- Sites Starseed : multiselect a tags (>= 1 obligatoire, RG-1.10). -->
+        <MalioSelectCheckbox
+            :model-value="model.siteIris"
+            :options="siteOptions"
+            :label="t('commercial.clients.form.address.sites')"
+            :display-tag="true"
+            :readonly="readonly"
+            :required="true"
+            @update:model-value="(v: (string | number)[]) => update('siteIris', v.map(String))"
+        />
+
+        <MalioSelectCheckbox
+            :model-value="model.contactIris"
+            :options="contactOptions"
+            :label="t('commercial.clients.form.address.contacts')"
+            :display-tag="true"
+            :readonly="readonly"
+            @update:model-value="(v: (string | number)[]) => update('contactIris', v.map(String))"
+        />
+
+        <!-- Email de facturation : ligne 1 colonne 4, visible/obligatoire
+             seulement si Facturation (RG-1.11). Sinon un filler comble la
+             colonne pour que Categorie reparte au debut de la ligne 2. -->
+        <MalioInputEmail
+            v-if="isBillingEmailRequired(model)"
+            :model-value="model.billingEmail"
+            :label="t('commercial.clients.form.address.billingEmail')"
+            :required="true"
+            :readonly="readonly"
+            :lowercase="true"
+            :error="errors?.billingEmail"
+            @update:model-value="(v: string) => update('billingEmail', v)"
+        />
+        <div v-else aria-hidden="true" />
 
         <MalioSelectCheckbox
             :model-value="model.categoryIris"
             :options="categoryOptions"
             :label="t('commercial.clients.form.address.categories')"
             :display-tag="true"
-            :disabled="readonly"
+            :readonly="readonly"
+            :required="true"
             @update:model-value="(v: (string | number)[]) => update('categoryIris', v.map(String))"
         />
 
@@ -52,7 +72,8 @@
             :model-value="model.country"
             :options="countryOptions"
             :label="t('commercial.clients.form.address.country')"
-            :disabled="readonly"
+            :readonly="readonly"
+            :required="true"
             @update:model-value="(v: string | number | null) => update('country', String(v ?? 'France'))"
         />
 
@@ -61,6 +82,8 @@
             :label="t('commercial.clients.form.address.postalCode')"
             :mask="POSTAL_CODE_MASK"
             :readonly="readonly"
+            :required="true"
+            :error="errors?.postalCode"
             @update:model-value="onPostalCodeChange"
         />
 
@@ -71,8 +94,10 @@
             :model-value="model.city"
             :options="cityOptions"
             :label="t('commercial.clients.form.address.city')"
-            :disabled="readonly"
+            :readonly="readonly"
             empty-option-label=""
+            :required="true"
+            :error="errors?.city"
             @update:model-value="(v: string | number | null) => update('city', v === null ? null : String(v))"
         />
         <MalioInputText
@@ -80,6 +105,8 @@
             :model-value="model.city"
             :label="t('commercial.clients.form.address.city')"
             :readonly="readonly"
+            :required="true"
+            :error="errors?.city"
             @update:model-value="(v: string) => update('city', v)"
         />
 
@@ -99,6 +126,8 @@
                 :min-search-length="3"
                 :label="t('commercial.clients.form.address.street')"
                 :readonly="readonly"
+                :required="true"
+                :error="errors?.street"
                 @update:model-value="(v: string | number | null) => update('street', v === null ? null : String(v))"
                 @search="onAddressSearch"
                 @select="onAddressSelect"
@@ -108,6 +137,8 @@
                 :model-value="model.street"
                 :label="t('commercial.clients.form.address.street')"
                 :readonly="readonly"
+                :required="true"
+                :error="errors?.street"
                 @update:model-value="(v: string) => update('street', v)"
             />
         </div>
@@ -117,50 +148,20 @@
                 :model-value="model.streetComplement"
                 :label="t('commercial.clients.form.address.streetComplement')"
                 :readonly="readonly"
+                :error="errors?.streetComplement"
                 @update:model-value="(v: string) => update('streetComplement', v)"
             />
         </div>
 
-        <!-- Sites Starseed : cases a cocher inline (>= 1 obligatoire, RG-1.10). -->
-        <div class="flex justify-between">
-            <MalioCheckbox
-                v-for="site in siteOptions"
-                :key="site.value"
-                :model-value="model.siteIris.includes(site.value)"
-                :label="site.label"
-                group-class="w-auto self-center"
-                :readonly="readonly"
-                @update:model-value="(v: boolean) => toggleSite(site.value, v)"
-            />
-        </div>
-
-        <MalioSelectCheckbox
-            :model-value="model.contactIris"
-            :options="contactOptions"
-            :label="t('commercial.clients.form.address.contacts')"
-            :display-tag="true"
-            :disabled="readonly"
-            @update:model-value="(v: (string | number)[]) => update('contactIris', v.map(String))"
-        />
-
-        <!-- Email de facturation : visible/obligatoire seulement si Facturation
-             est coche (RG-1.11). -->
-        <MalioInputText
-            v-if="isBillingEmailRequired(model)"
-            :model-value="model.billingEmail"
-            :label="t('commercial.clients.form.address.billingEmail')"
-            :required="true"
-            :readonly="readonly"
-            @update:model-value="(v: string) => update('billingEmail', v)"
-        />
     </div>
 </template>
 
 <script setup lang="ts">
 import {
-    applyProspectExclusivity,
+    addressFlagsFromType,
+    addressTypeFromFlags,
     isBillingEmailRequired,
-    type AddressFlagsDraft,
+    type AddressType,
 } from '~/modules/commercial/utils/clientFormRules'
 import { useAddressAutocomplete, type AddressSuggestion } from '~/shared/composables/useAddressAutocomplete'
 import type { CategoryOption, RefOption } from '~/modules/commercial/composables/useClientReferentials'
@@ -183,6 +184,8 @@ const props = defineProps<{
     countryOptions: RefOption[]
     removable?: boolean
     readonly?: boolean
+    /** Erreurs serveur 422 de cette ligne, indexees par champ (ERP-101). */
+    errors?: Record<string, string>
 }>()
 
 const emit = defineEmits<{
@@ -197,11 +200,29 @@ const autocomplete = useAddressAutocomplete()
 
 const model = computed(() => props.modelValue)
 
+// Type d'adresse (Select unique) derive des drapeaux back. null tant qu'aucun
+// drapeau n'est pose -> champ vide + bouton « Valider » bloque (cf. parent).
+const addressType = computed<AddressType | null>(() => addressTypeFromFlags(model.value))
+
+const addressTypeOptions = computed<RefOption[]>(() => [
+    { value: 'prospect', label: t('commercial.clients.form.address.addressTypeProspect') },
+    { value: 'delivery', label: t('commercial.clients.form.address.addressTypeDelivery') },
+    { value: 'billing', label: t('commercial.clients.form.address.addressTypeBilling') },
+    { value: 'delivery_billing', label: t('commercial.clients.form.address.addressTypeDeliveryBilling') },
+])
+
+/** Applique le type choisi en repercutant les 3 drapeaux back (immutabilite). */
+function onAddressTypeChange(value: string | number | null): void {
+    if (value === null) return
+    emit('update:modelValue', { ...props.modelValue, ...addressFlagsFromType(value as AddressType) })
+}
+
 // Mode degrade : service BAN indisponible → Ville/Adresse en saisie libre.
 const degraded = ref(false)
 // Villes proposees par la BAN (alimentees a la saisie du code postal).
 const banCityOptions = ref<RefOption[]>([])
-const addressOptions = ref<RefOption[]>([])
+// Adresses proposees par la BAN (alimentees a la saisie d'adresse).
+const banAddressOptions = ref<RefOption[]>([])
 
 // Options ville effectives : on garantit que la ville courante figure toujours
 // dans la liste, sinon MalioSelect (qui resout le libelle depuis ses options)
@@ -214,6 +235,20 @@ const cityOptions = computed<RefOption[]>(() => {
     }
     return banCityOptions.value
 })
+
+// Meme garantie que cityOptions pour le champ Adresse : la rue courante doit
+// toujours figurer dans les options, sinon MalioInputAutocomplete (qui resout
+// l'affichage depuis ses options) laisse le champ VIDE des que la liste de
+// suggestions BAN est vide — typiquement juste apres validation (remontage) ou
+// a l'edition d'une adresse existante (1.12), alors que la valeur est bien
+// persistee. On reinjecte donc la rue liee si la BAN ne l'a pas (re)proposee.
+const addressOptions = computed<RefOption[]>(() => {
+    const current = props.modelValue.street
+    if (current && !banAddressOptions.value.some(o => o.value === current)) {
+        return [{ value: current, label: current }, ...banAddressOptions.value]
+    }
+    return banAddressOptions.value
+})
 const addressLoading = ref(false)
 // Conserve les suggestions d'adresse pour retrouver ville/CP au moment du select.
 let lastAddressSuggestions: AddressSuggestion[] = []
@@ -223,25 +258,6 @@ function update<K extends keyof AddressFormDraft>(field: K, value: AddressFormDr
     emit('update:modelValue', { ...props.modelValue, [field]: value })
 }
 
-/** Coche/decoche un site Starseed rattache a l'adresse (M2M par IRI, RG-1.10). */
-function toggleSite(siteIri: string, selected: boolean): void {
-    const current = props.modelValue.siteIris
-    const next = selected
-        ? [...current, siteIri]
-        : current.filter(iri => iri !== siteIri)
-    update('siteIris', next)
-}
-
-/** Applique l'exclusivite Prospect / (Livraison|Facturation) au changement. */
-function toggleFlag(field: keyof AddressFlagsDraft, value: boolean): void {
-    const flags = applyProspectExclusivity(
-        { isProspect: model.value.isProspect, isDelivery: model.value.isDelivery, isBilling: model.value.isBilling },
-        field,
-        value,
-    )
-    emit('update:modelValue', { ...props.modelValue, ...flags })
-}
-
 /** Bascule définitivement en mode degrade et previent le parent (toast unique). */
 function enterDegraded(): void {
     if (!degraded.value) {
@@ -280,7 +296,7 @@ async function onAddressSearch(query: string): Promise<void> {
         const postalCode = (model.value.postalCode ?? '').replace(/\D/g, '') || undefined
         const suggestions = await autocomplete.searchAddress(query, postalCode)
         lastAddressSuggestions = suggestions
-        addressOptions.value = suggestions.map(s => ({ value: s.street, label: s.label }))
+        banAddressOptions.value = suggestions.map(s => ({ value: s.street, label: s.label }))
     }
     catch {
         enterDegraded()

frontend/modules/commercial/components/ClientContactBlock.vue

@@ -16,24 +16,29 @@
             :model-value="model.lastName"
             :label="t('commercial.clients.form.contact.lastName')"
             :readonly="readonly"
+            :error="errors?.lastName"
             @update:model-value="(v: string) => update('lastName', v)"
         />
         <MalioInputText
             :model-value="model.firstName"
             :label="t('commercial.clients.form.contact.firstName')"
             :readonly="readonly"
+            :error="errors?.firstName"
             @update:model-value="(v: string) => update('firstName', v)"
         />
         <MalioInputText
             :model-value="model.jobTitle"
             :label="t('commercial.clients.form.contact.jobTitle')"
             :readonly="readonly"
+            :error="errors?.jobTitle"
             @update:model-value="(v: string) => update('jobTitle', v)"
         />
         <MalioInputEmail
             :model-value="model.email"
             :label="t('commercial.clients.form.contact.email')"
             :readonly="readonly"
+            :lowercase="true"
+            :error="errors?.email"
             @update:model-value="(v: string) => update('email', v)"
         />
         <MalioInputPhone
@@ -41,6 +46,7 @@
             :label="t('commercial.clients.form.contact.phonePrimary')"
             :mask="PHONE_MASK"
             :readonly="readonly"
+            :error="errors?.phonePrimary"
             :addable="!model.hasSecondaryPhone && !readonly"
             :add-button-label="t('commercial.clients.form.contact.addPhone')"
             @update:model-value="(v: string) => update('phonePrimary', v)"
@@ -52,6 +58,7 @@
             :label="t('commercial.clients.form.contact.phoneSecondary')"
             :mask="PHONE_MASK"
             :readonly="readonly"
+            :error="errors?.phoneSecondary"
             @update:model-value="(v: string) => update('phoneSecondary', v)"
         />
     </div>
@@ -73,6 +80,8 @@ const props = defineProps<{
     removable?: boolean
     /** Bloc en lecture seule (onglet valide). */
     readonly?: boolean
+    /** Erreurs serveur 422 de cette ligne, indexees par champ (ERP-101). */
+    errors?: Record<string, string>
 }>()
 
 const emit = defineEmits<{

frontend/modules/commercial/components/TabPlaceholderBlank.vue

@@ -1,14 +0,0 @@
-<template>
-    <!--
-        Placeholder des onglets non encore implementes (Transport, Statistiques,
-        Rapports, Echanges). Frame vide blanche : aucun champ, aucun bouton,
-        aucun message « En cours » (decision Tristan 28/05). L'orchestrateur passe
-        automatiquement a l'onglet suivant — ce composant n'est qu'une coquille
-        visuelle reutilisee par 1.11/1.12.
-    -->
-    <div class="min-h-[240px] rounded-md bg-white" />
-</template>
-
-<script setup lang="ts">
-// Composant purement presentationnel : aucune prop, aucun event.
-</script>

frontend/modules/commercial/components/__tests__/ClientAddressBlock.spec.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, vi } from 'vitest'
+import { mount } from '@vue/test-utils'
+import { defineComponent, h, ref, computed } from 'vue'
+import { emptyAddress } from '~/modules/commercial/types/clientForm'
+import ClientAddressBlock from '../ClientAddressBlock.vue'
+
+// Le composable BAN est mocke : aucun appel reseau, aucune suggestion chargee.
+// On reproduit ainsi l'etat « adresse persistee, mais liste de suggestions
+// vide » (remontage apres validation / edition d'une adresse existante).
+vi.mock('~/shared/composables/useAddressAutocomplete', () => ({
+    useAddressAutocomplete: () => ({
+        searchCity: vi.fn(),
+        searchAddress: vi.fn(),
+    }),
+}))
+
+// Auto-imports Nuxt/Vue utilises sans import explicite par le composant.
+vi.stubGlobal('useI18n', () => ({ t: (key: string) => key }))
+vi.stubGlobal('ref', ref)
+vi.stubGlobal('computed', computed)
+
+// Stub de MalioInputAutocomplete : expose les `value` des options recues, pour
+// verifier que la rue courante figure bien dans la liste (sinon le composant
+// Malio ne peut pas resoudre/afficher la valeur liee -> champ vide).
+const MalioInputAutocompleteStub = defineComponent({
+    name: 'MalioInputAutocomplete',
+    props: {
+        modelValue: { type: [String, Number, null], default: undefined },
+        options: { type: Array as () => { value: string | number, label: string }[], default: () => [] },
+        loading: { type: Boolean, default: false },
+        minSearchLength: { type: Number, default: 0 },
+        label: { type: String, default: '' },
+        readonly: { type: Boolean, default: false },
+    },
+    emits: ['update:modelValue', 'search', 'select'],
+    setup(props) {
+        return () => h('div', {
+            'data-testid': 'addr-autocomplete',
+            'data-options': JSON.stringify(props.options.map(o => o.value)),
+        })
+    },
+})
+
+function mountBlock(street: string | null) {
+    return mount(ClientAddressBlock, {
+        props: {
+            modelValue: { ...emptyAddress(), street },
+            title: 'Adresse',
+            categoryOptions: [],
+            siteOptions: [],
+            contactOptions: [],
+            countryOptions: [],
+        },
+        global: {
+            stubs: {
+                MalioButtonIcon: true,
+                MalioCheckbox: true,
+                MalioSelect: true,
+                MalioSelectCheckbox: true,
+                MalioInputText: true,
+                MalioInputAutocomplete: MalioInputAutocompleteStub,
+            },
+        },
+    })
+}
+
+describe('ClientAddressBlock — affichage de l\'adresse persistee', () => {
+    it('inclut la rue courante dans les options de l\'autocomplete meme sans recherche BAN', () => {
+        const wrapper = mountBlock('8 Boulevard du Port')
+
+        const el = wrapper.find('[data-testid="addr-autocomplete"]')
+        const values = JSON.parse(el.attributes('data-options') ?? '[]')
+
+        expect(values).toContain('8 Boulevard du Port')
+    })
+})
+
+/**
+ * Stub MalioInputText qui re-expose `label` + `error` recus : permet de cibler
+ * un champ par son libelle et de verifier l'erreur 422 propagee (ERP-101).
+ */
+const MalioInputTextProbe = defineComponent({
+    name: 'MalioInputTextProbe',
+    props: {
+        modelValue: { type: [String, Number, null], default: undefined },
+        error: { type: String, default: '' },
+        label: { type: String, default: '' },
+        readonly: { type: Boolean, default: false },
+    },
+    setup(props) {
+        return () => h('div', {
+            'data-testid': 'addr-text',
+            'data-label': props.label,
+            'data-error': props.error,
+        })
+    },
+})
+
+describe('ClientAddressBlock — mapping erreur par champ (ERP-101)', () => {
+    function mountWithErrors(errors: Record<string, string>) {
+        return mount(ClientAddressBlock, {
+            props: {
+                modelValue: emptyAddress(),
+                title: 'Adresse',
+                categoryOptions: [],
+                siteOptions: [],
+                contactOptions: [],
+                countryOptions: [],
+                errors,
+            },
+            global: {
+                stubs: {
+                    MalioButtonIcon: true,
+                    MalioCheckbox: true,
+                    MalioSelect: true,
+                    MalioSelectCheckbox: true,
+                    MalioInputAutocomplete: MalioInputAutocompleteStub,
+                    MalioInputText: MalioInputTextProbe,
+                },
+            },
+        })
+    }
+
+    it('affiche l\'erreur serveur sur le champ code postal via la prop errors', () => {
+        const wrapper = mountWithErrors({ postalCode: 'Code postal invalide.' })
+
+        const field = wrapper.findAll('[data-testid="addr-text"]').find(
+            el => el.attributes('data-label') === 'commercial.clients.form.address.postalCode',
+        )
+        expect(field?.attributes('data-error')).toBe('Code postal invalide.')
+    })
+})

frontend/modules/commercial/components/__tests__/ClientContactBlock.spec.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest'
+import { mount } from '@vue/test-utils'
+import { defineComponent, h, ref, computed } from 'vue'
+import { emptyContact } from '~/modules/commercial/types/clientForm'
+import ClientContactBlock from '../ClientContactBlock.vue'
+
+// Auto-imports Nuxt/Vue utilises sans import explicite par le composant.
+vi.stubGlobal('useI18n', () => ({ t: (key: string) => key }))
+vi.stubGlobal('ref', ref)
+vi.stubGlobal('computed', computed)
+
+/**
+ * Stub d'un champ Malio qui re-expose la prop `error` recue dans un attribut
+ * data-* : permet de verifier que le bloc propage bien `:errors[champ]` sur le
+ * bon champ (ERP-101 — mapping erreur 422 par champ, par ligne de collection).
+ */
+function errorProbe(testid: string) {
+    return defineComponent({
+        name: `Probe-${testid}`,
+        props: {
+            modelValue: { type: [String, Number, null], default: undefined },
+            error: { type: String, default: '' },
+            label: { type: String, default: '' },
+            readonly: { type: Boolean, default: false },
+        },
+        setup(props) {
+            return () => h('div', { 'data-testid': testid, 'data-error': props.error })
+        },
+    })
+}
+
+function mountBlock(errors?: Record<string, string>) {
+    return mount(ClientContactBlock, {
+        props: {
+            modelValue: emptyContact(),
+            title: 'Contact 1',
+            ...(errors ? { errors } : {}),
+        },
+        global: {
+            stubs: {
+                MalioButtonIcon: true,
+                MalioInputPhone: true,
+                MalioInputText: errorProbe('contact-text'),
+                MalioInputEmail: errorProbe('contact-email'),
+            },
+        },
+    })
+}
+
+describe('ClientContactBlock — mapping erreur par champ (ERP-101)', () => {
+    it('affiche l\'erreur serveur sur le champ email via la prop errors', () => {
+        const wrapper = mountBlock({ email: 'Adresse e-mail invalide.' })
+
+        const email = wrapper.find('[data-testid="contact-email"]')
+        expect(email.attributes('data-error')).toBe('Adresse e-mail invalide.')
+    })
+
+    it('laisse les champs sans erreur quand errors est absent', () => {
+        const wrapper = mountBlock()
+
+        const email = wrapper.find('[data-testid="contact-email"]')
+        expect(email.attributes('data-error')).toBe('')
+    })
+})

frontend/modules/commercial/composables/__tests__/useClientFormErrors.spec.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi } from 'vitest'
+import { useFormErrors } from '~/shared/composables/useFormErrors'
+import { useClientFormErrors } from '../useClientFormErrors'
+
+// useFormErrors (auto-import) expose l'implementation reelle ; elle consomme
+// useToast + useI18n, stubbes ici.
+vi.stubGlobal('useToast', () => ({ error: vi.fn(), success: vi.fn() }))
+vi.stubGlobal('useI18n', () => ({ t: (key: string) => key }))
+vi.stubGlobal('useFormErrors', useFormErrors)
+
+/**
+ * Tests du composable partage `useClientFormErrors` — factorisation du cablage
+ * d'erreurs des ecrans client (creation/edition), suggestion de revue ERP-101.
+ * `mapRowError` ne toaste plus : il retourne un booleen et chaque page garde son
+ * propre fallback (toast.error en creation, showError en edition).
+ */
+describe('useClientFormErrors', () => {
+    it('expose les 3 etats scalaires (vides) et les 3 tableaux d\'erreurs par ligne', () => {
+        const f = useClientFormErrors()
+        expect(f.mainErrors.errors).toEqual({})
+        expect(f.informationErrors.errors).toEqual({})
+        expect(f.accountingErrors.errors).toEqual({})
+        expect(f.contactErrors.value).toEqual([])
+        expect(f.addressErrors.value).toEqual([])
+        expect(f.ribErrors.value).toEqual([])
+    })
+
+    it('mapRowError mappe une 422 sur target[index] et retourne true', () => {
+        const f = useClientFormErrors()
+        const error = {
+            response: {
+                status: 422,
+                _data: { violations: [{ propertyPath: 'email', message: 'Adresse invalide.' }] },
+            },
+        }
+        const mapped = f.mapRowError(error, f.contactErrors, 0)
+        expect(mapped).toBe(true)
+        expect(f.contactErrors.value[0]).toEqual({ email: 'Adresse invalide.' })
+    })
+
+    it('mapRowError retourne false et ne touche pas la cible pour une erreur non-422', () => {
+        const f = useClientFormErrors()
+        const error = { response: { status: 500, _data: {} } }
+        expect(f.mapRowError(error, f.ribErrors, 0)).toBe(false)
+        expect(f.ribErrors.value[0]).toBeUndefined()
+    })
+
+    it('mapRowError retourne false pour une 422 sans violation exploitable', () => {
+        const f = useClientFormErrors()
+        const error = { response: { status: 422, _data: { 'hydra:description': 'Donnees invalides.' } } }
+        expect(f.mapRowError(error, f.addressErrors, 0)).toBe(false)
+        expect(f.addressErrors.value[0]).toBeUndefined()
+    })
+})
+
+// Construit une erreur facon useApi : 422 avec violations Hydra.
+function http422(path: string, message: string) {
+    return { response: { status: 422, _data: { violations: [{ propertyPath: path, message }] } } }
+}
+
+/**
+ * `submitRows` factorise la soumission d'une collection de blocs (contacts /
+ * adresses / RIB) : on tente TOUS les blocs et on collecte les erreurs par index
+ * sans stopper au premier echec (ERP-110 / ERP-101).
+ */
+describe('useClientFormErrors.submitRows', () => {
+    it('tente TOUS les blocs et mappe les erreurs par index, sans stopper au premier echec', async () => {
+        const { contactErrors, submitRows } = useClientFormErrors()
+        const seen: number[] = []
+        const onUnmapped = vi.fn()
+
+        const saveRow = async (_row: unknown, index: number) => {
+            seen.push(index)
+            if (index === 1) throw http422('email', 'Email invalide')
+        }
+
+        const hasError = await submitRows(
+            [{ a: 0 }, { a: 1 }, { a: 2 }],
+            contactErrors,
+            saveRow,
+            onUnmapped,
+        )
+
+        expect(seen).toEqual([0, 1, 2]) // tous les blocs tentes
+        expect(hasError).toBe(true)
+        expect(contactErrors.value[1]).toEqual({ email: 'Email invalide' })
+        expect(contactErrors.value[0]).toBeUndefined()
+        expect(onUnmapped).not.toHaveBeenCalled() // 422 mappee, pas de fallback
+    })
+
+    it('delegue le fallback onUnmappedError pour une erreur non mappable et marque hasError', async () => {
+        const { ribErrors, submitRows } = useClientFormErrors()
+        const onUnmapped = vi.fn()
+
+        const hasError = await submitRows(
+            [{ a: 0 }],
+            ribErrors,
+            async () => { throw { response: { status: 500, _data: {} } } },
+            onUnmapped,
+        )
+
+        expect(hasError).toBe(true)
+        expect(onUnmapped).toHaveBeenCalledTimes(1)
+        expect(ribErrors.value[0]).toBeUndefined()
+    })
+
+    it('saute les lignes filtrees par shouldSkip et renvoie false si tout passe', async () => {
+        const { contactErrors, submitRows } = useClientFormErrors()
+        const saved: number[] = []
+
+        const hasError = await submitRows(
+            [{ skip: true }, { skip: false }],
+            contactErrors,
+            async (_row, index) => { saved.push(index) },
+            vi.fn(),
+            (row: { skip: boolean }) => row.skip,
+        )
+
+        expect(saved).toEqual([1])
+        expect(hasError).toBe(false)
+    })
+})

frontend/modules/commercial/composables/__tests__/useClientReferentials.spec.ts

@@ -28,7 +28,7 @@ describe('useClientReferentials.loadCommon (resilience ERP-102)', () => {
                 return Promise.reject(new Error('403 Forbidden'))
             }
             if (url === '/sites') {
-                return Promise.resolve({ member: [{ '@id': '/api/sites/1', name: 'Chatellerault' }] })
+                return Promise.resolve({ member: [{ '@id': '/api/sites/1', name: 'Chatellerault', postalCode: '86100' }] })
             }
             return Promise.resolve({
                 member: [{ '@id': '/api/x/1', code: 'X', label: 'Libelle X' }],
@@ -40,7 +40,8 @@ describe('useClientReferentials.loadCommon (resilience ERP-102)', () => {
         await refs.loadCommon()
 
         // Resilience : les referentiels OK sont peuples malgre l'echec de /categories.
-        expect(refs.sites.value).toEqual([{ value: '/api/sites/1', label: 'Chatellerault' }])
+        // Le libelle d'un site est son numero de departement (2 premiers chiffres du code postal).
+        expect(refs.sites.value).toEqual([{ value: '/api/sites/1', label: '86' }])
         expect(refs.tvaModes.value).toEqual([{ value: '/api/x/1', label: 'Libelle X' }])
         expect(refs.banks.value).toEqual([{ value: '/api/x/1', label: 'Libelle X' }])
 
@@ -56,7 +57,7 @@ describe('useClientReferentials.loadCommon (resilience ERP-102)', () => {
                 })
             }
             if (url === '/sites') {
-                return Promise.resolve({ member: [{ '@id': '/api/sites/1', name: 'Chatellerault' }] })
+                return Promise.resolve({ member: [{ '@id': '/api/sites/1', name: 'Chatellerault', postalCode: '86100' }] })
             }
             return Promise.resolve({ member: [] })
         })
@@ -67,6 +68,7 @@ describe('useClientReferentials.loadCommon (resilience ERP-102)', () => {
         expect(refs.categories.value).toEqual([
             { value: '/api/categories/1', label: 'Secteur', code: 'SECTEUR' },
         ])
-        expect(refs.sites.value).toEqual([{ value: '/api/sites/1', label: 'Chatellerault' }])
+        // Le libelle d'un site est son numero de departement (2 premiers chiffres du code postal).
+        expect(refs.sites.value).toEqual([{ value: '/api/sites/1', label: '86' }])
     })
 })

frontend/modules/commercial/composables/useClientFormErrors.ts

@@ -0,0 +1,94 @@
+/**
+ * Composable d'erreurs partage des ecrans client (creation + edition, M1
+ * Commercial). Factorise le cablage identique entre `clients/new.vue` et
+ * `clients/[id]/edit.vue` (suggestion de revue ERP-101) :
+ *  - un `useFormErrors` par groupe scalaire (Principal / Information /
+ *    Comptabilite) : violations 422 affichees inline sous chaque champ ;
+ *  - un tableau d'erreurs PAR LIGNE pour chaque collection (contacts /
+ *    adresses / RIB), aligne sur l'index du `v-for`.
+ *
+ * `mapRowError` ne toaste PAS lui-meme : il retourne un booleen (true = mappe
+ * inline). Chaque page conserve ainsi son propre fallback dans le `catch`
+ * (toast generique en creation, `showError` en edition) sans imposer un
+ * comportement commun.
+ */
+import { ref, type Ref } from 'vue'
+import { mapViolationsToRecord } from '~/shared/utils/api'
+
+export function useClientFormErrors() {
+    const mainErrors = useFormErrors()
+    const informationErrors = useFormErrors()
+    const accountingErrors = useFormErrors()
+    const contactErrors = ref<Record<string, string>[]>([])
+    const addressErrors = ref<Record<string, string>[]>([])
+    const ribErrors = ref<Record<string, string>[]>([])
+
+    /**
+     * Mappe l'erreur d'une ligne de collection sur le tableau cible (par index).
+     * 422 avec violations exploitables → erreurs inline sous les champs de la
+     * ligne + retourne true. Sinon → ne touche pas la cible et retourne false
+     * (le caller decide du fallback toast).
+     */
+    function mapRowError(
+        error: unknown,
+        target: Ref<Record<string, string>[]>,
+        index: number,
+    ): boolean {
+        const response = (error as { response?: { status?: number, _data?: unknown } })?.response
+        const mapped = response?.status === 422 ? mapViolationsToRecord(response._data) : {}
+        if (Object.keys(mapped).length > 0) {
+            target.value[index] = mapped
+            return true
+        }
+        return false
+    }
+
+    /**
+     * Soumet TOUS les blocs d'une collection (contacts / adresses / RIB) en
+     * collectant les erreurs par index : on n'arrete PAS au premier bloc en echec
+     * (decision ERP-110 / ERP-101). Reinitialise le tableau d'erreurs cible, tente
+     * chaque ligne via `saveRow`, mappe les 422 inline (mapRowError) ou delegue le
+     * fallback a `onUnmappedError`. `shouldSkip` permet d'ignorer les blocs vides
+     * (non remplis). Retourne true si au moins un bloc a echoue (le caller ne valide
+     * alors pas l'onglet et n'affiche pas de toast succes).
+     */
+    async function submitRows<T>(
+        rows: T[],
+        target: Ref<Record<string, string>[]>,
+        saveRow: (row: T, index: number) => Promise<void>,
+        onUnmappedError: (error: unknown, index: number) => void,
+        shouldSkip?: (row: T, index: number) => boolean,
+    ): Promise<boolean> {
+        target.value = []
+        let hasError = false
+        for (let index = 0; index < rows.length; index++) {
+            // L'index reste borne par rows.length : la ligne existe forcement.
+            const row = rows[index] as T
+            if (shouldSkip?.(row, index)) {
+                continue
+            }
+            try {
+                await saveRow(row, index)
+            }
+            catch (error) {
+                if (!mapRowError(error, target, index)) {
+                    onUnmappedError(error, index)
+                }
+                hasError = true
+            }
+        }
+
+        return hasError
+    }
+
+    return {
+        mainErrors,
+        informationErrors,
+        accountingErrors,
+        contactErrors,
+        addressErrors,
+        ribErrors,
+        mapRowError,
+        submitRows,
+    }
+}

frontend/modules/commercial/composables/useClientReferentials.ts

@@ -45,6 +45,7 @@ interface CategoryMember extends HydraMember {
 
 interface SiteMember extends HydraMember {
     name: string
+    postalCode: string
 }
 
 interface ReferentialMember extends HydraMember {
@@ -101,7 +102,10 @@ export function useClientReferentials() {
             fetchAll<CategoryMember>('/categories')
                 .then((cats) => { categories.value = cats.map(c => ({ value: c['@id'], label: c.name, code: c.code })) }),
             fetchAll<SiteMember>('/sites')
-                .then((sitesList) => { sites.value = sitesList.map(s => ({ value: s['@id'], label: s.name })) }),
+                // Libelle = numero de departement (2 premiers chiffres du code
+                // postal du site), ex: 86100 -> « 86 ». Le code postal est deja
+                // expose par /sites (groupe site:read) — aucune colonne a ajouter.
+                .then((sitesList) => { sites.value = sitesList.map(s => ({ value: s['@id'], label: (s.postalCode ?? '').slice(0, 2) })) }),
             fetchAll<ReferentialMember>('/tva_modes')
                 .then((tva) => { tvaModes.value = tva.map(t => ({ value: t['@id'], label: t.label })) }),
             fetchAll<ReferentialMember>('/payment_delays')

frontend/modules/commercial/pages/clients/[id]/edit.vue

@@ -28,54 +28,24 @@
                     :label="t('commercial.clients.form.main.companyName')"
                     :required="true"
                     :readonly="businessReadonly"
-                />
-                <MalioInputText
-                    v-model="main.lastName"
-                    :label="t('commercial.clients.form.main.lastName')"
-                    :readonly="businessReadonly"
-                />
-                <MalioInputText
-                    v-model="main.firstName"
-                    :label="t('commercial.clients.form.main.firstName')"
-                    :readonly="businessReadonly"
+                    :error="mainErrors.errors.companyName"
                 />
                 <MalioSelectCheckbox
                     :model-value="main.categoryIris"
                     :options="mainCategoryOptions"
                     :label="t('commercial.clients.form.main.categories')"
                     :display-tag="true"
-                    :disabled="businessReadonly"
+                    :readonly="businessReadonly"
+                    :required="true"
+                    :error="mainErrors.errors.categories"
                     @update:model-value="(v: (string | number)[]) => main.categoryIris = v.map(String)"
                 />
-                <MalioInputPhone
-                    v-model="main.phonePrimary"
-                    :label="t('commercial.clients.form.main.phonePrimary')"
-                    :mask="PHONE_MASK"
-                    :required="true"
-                    :readonly="businessReadonly"
-                    add-icon-name="mdi:plus"
-                    :addable="!main.hasSecondaryPhone && !businessReadonly"
-                    :add-button-label="t('commercial.clients.form.main.addPhone')"
-                    @add="main.hasSecondaryPhone = true"
-                />
-                <MalioInputPhone
-                    v-if="main.hasSecondaryPhone"
-                    v-model="main.phoneSecondary"
-                    :label="t('commercial.clients.form.main.phoneSecondary')"
-                    :mask="PHONE_MASK"
-                    :readonly="businessReadonly"
-                />
-                <MalioInputEmail
-                    v-model="main.email"
-                    :label="t('commercial.clients.form.main.email')"
-                    :required="true"
-                    :readonly="businessReadonly"
-                />
                 <MalioSelect
                     :model-value="main.relationType"
                     :options="relationOptions"
                     :label="t('commercial.clients.form.main.relation')"
-                    :disabled="businessReadonly"
+                    :empty-option-label="t('commercial.clients.form.main.relationNone')"
+                    :readonly="businessReadonly"
                     @update:model-value="onRelationChange"
                 />
                 <MalioSelect
@@ -83,7 +53,9 @@
                     :model-value="main.brokerIri"
                     :options="brokerOptions"
                     :label="t('commercial.clients.form.main.brokerName')"
-                    :disabled="businessReadonly"
+                    :readonly="businessReadonly"
+                    :required="true"
+                    :error="mainErrors.errors.broker"
                     @update:model-value="(v: string | number | null) => main.brokerIri = v === null ? null : String(v)"
                 />
                 <MalioSelect
@@ -91,7 +63,9 @@
                     :model-value="main.distributorIri"
                     :options="distributorOptions"
                     :label="t('commercial.clients.form.main.distributorName')"
-                    :disabled="businessReadonly"
+                    :readonly="businessReadonly"
+                    :required="true"
+                    :error="mainErrors.errors.distributor"
                     @update:model-value="(v: string | number | null) => main.distributorIri = v === null ? null : String(v)"
                 />
                 <MalioCheckbox
@@ -112,7 +86,7 @@
             </div>
 
             <!-- ── Onglets : navigation LIBRE, edition independante par onglet ──── -->
-            <MalioTabList v-model="activeTab" :tabs="tabs" class="mt-[60px]">
+            <MalioTabList v-model="activeTab" :tabs="tabs" :max-visible-tabs="5" :max-width="1100" class="mt-[60px]">
                 <!-- Onglet Information -->
                 <template #information>
                     <div class="mt-12 grid grid-cols-4 gap-x-[44px] gap-y-4 bg-white py-4 pl-[28px] pr-[60px] shadow-[0_4px_4px_0_rgba(0,0,0,0.25)]">
@@ -122,38 +96,45 @@
                             resize="none"
                             group-class="row-span-2 pt-1"
                             text-input="h-full text-lg"
-                            :disabled="businessReadonly"
+                            :readonly="businessReadonly"
+                            :error="informationErrors.errors.description"
                         />
                         <MalioInputText
                             v-model="information.competitors"
                             :label="t('commercial.clients.form.information.competitors')"
                             :readonly="businessReadonly"
+                            :error="informationErrors.errors.competitors"
                         />
                         <MalioDate
                             v-model="information.foundedAt"
                             :label="t('commercial.clients.form.information.foundedAt')"
                             :readonly="businessReadonly"
+                            :error="informationErrors.errors.foundedAt"
                         />
                         <MalioInputText
                             v-model="information.employeesCount"
                             :label="t('commercial.clients.form.information.employeesCount')"
                             :mask="EMPLOYEES_MASK"
                             :readonly="businessReadonly"
+                            :error="informationErrors.errors.employeesCount"
                         />
                         <MalioInputAmount
                             v-model="information.revenueAmount"
                             :label="t('commercial.clients.form.information.revenueAmount')"
-                            :disabled="businessReadonly"
+                            :readonly="businessReadonly"
+                            :error="informationErrors.errors.revenueAmount"
                         />
                         <MalioInputText
                             v-model="information.directorName"
                             :label="t('commercial.clients.form.information.directorName')"
                             :readonly="businessReadonly"
+                            :error="informationErrors.errors.directorName"
                         />
                         <MalioInputAmount
                             v-model="information.profitAmount"
                             :label="t('commercial.clients.form.information.profitAmount')"
-                            :disabled="businessReadonly"
+                            :readonly="businessReadonly"
+                            :error="informationErrors.errors.profitAmount"
                         />
                     </div>
                     <div v-if="!businessReadonly" class="mt-12 flex justify-center">
@@ -176,12 +157,10 @@
                             :title="t('commercial.clients.form.contact.title', { n: index + 1 })"
                             :removable="contacts.length > 1"
                             :readonly="businessReadonly"
+                            :errors="contactErrors[index]"
                             @update:model-value="(v) => contacts[index] = v"
                             @remove="askRemoveContact(index)"
                         />
-                        <p v-if="contacts.length === 0" class="text-center text-black/60">
-                            {{ t('commercial.clients.edit.emptyContacts') }}
-                        </p>
                         <div v-if="!businessReadonly" class="flex justify-center gap-6">
                             <MalioButton
                                 variant="secondary"
@@ -215,13 +194,11 @@
                             :country-options="countryOptions"
                             :removable="addresses.length > 1"
                             :readonly="businessReadonly"
+                            :errors="addressErrors[index]"
                             @update:model-value="(v) => addresses[index] = v"
                             @remove="askRemoveAddress(index)"
                             @degraded="onAddressDegraded"
                         />
-                        <p v-if="addresses.length === 0" class="text-center text-black/60">
-                            {{ t('commercial.clients.edit.emptyAddresses') }}
-                        </p>
                         <div v-if="!businessReadonly" class="flex justify-center gap-6">
                             <MalioButton
                                 variant="secondary"
@@ -245,45 +222,57 @@
                 <template v-if="canAccountingView" #accounting>
                     <div class="mt-12 flex flex-col gap-6">
                         <div class="bg-white py-4 pl-[28px] pr-[60px] shadow-[0_4px_4px_0_rgba(0,0,0,0.25)]">
-                            <div class="grid grid-cols-3 gap-x-[80px] gap-y-5">
+                            <div class="grid grid-cols-4 gap-x-[44px] gap-y-4">
                                 <MalioInputText
                                     v-model="accounting.siren"
                                     :label="t('commercial.clients.form.accounting.siren')"
                                     :mask="SIREN_MASK"
                                     :readonly="accountingReadonly"
+                                    :required="true"
+                                    :error="accountingErrors.errors.siren"
                                 />
                                 <MalioInputText
                                     v-model="accounting.accountNumber"
                                     :label="t('commercial.clients.form.accounting.accountNumber')"
                                     :readonly="accountingReadonly"
+                                    :required="true"
+                                    :error="accountingErrors.errors.accountNumber"
                                 />
                                 <MalioSelect
                                     :model-value="accounting.tvaModeIri"
                                     :options="tvaModeOptions"
                                     :label="t('commercial.clients.form.accounting.tvaMode')"
-                                    :disabled="accountingReadonly"
+                                    :readonly="accountingReadonly"
                                     empty-option-label=""
+                                    :required="true"
+                                    :error="accountingErrors.errors.tvaMode"
                                     @update:model-value="(v: string | number | null) => accounting.tvaModeIri = v === null ? null : String(v)"
                                 />
                                 <MalioInputText
                                     v-model="accounting.nTva"
                                     :label="t('commercial.clients.form.accounting.nTva')"
                                     :readonly="accountingReadonly"
+                                    :required="true"
+                                    :error="accountingErrors.errors.nTva"
                                 />
                                 <MalioSelect
                                     :model-value="accounting.paymentDelayIri"
                                     :options="paymentDelayOptions"
                                     :label="t('commercial.clients.form.accounting.paymentDelay')"
-                                    :disabled="accountingReadonly"
+                                    :readonly="accountingReadonly"
                                     empty-option-label=""
+                                    :required="true"
+                                    :error="accountingErrors.errors.paymentDelay"
                                     @update:model-value="(v: string | number | null) => accounting.paymentDelayIri = v === null ? null : String(v)"
                                 />
                                 <MalioSelect
                                     :model-value="accounting.paymentTypeIri"
                                     :options="paymentTypeOptions"
                                     :label="t('commercial.clients.form.accounting.paymentType')"
-                                    :disabled="accountingReadonly"
+                                    :readonly="accountingReadonly"
                                     empty-option-label=""
+                                    :required="true"
+                                    :error="accountingErrors.errors.paymentType"
                                     @update:model-value="onPaymentTypeChange"
                                 />
                                 <MalioSelect
@@ -291,8 +280,10 @@
                                     :model-value="accounting.bankIri"
                                     :options="bankOptions"
                                     :label="t('commercial.clients.form.accounting.bank')"
-                                    :disabled="accountingReadonly"
+                                    :readonly="accountingReadonly"
                                     empty-option-label=""
+                                    :required="true"
+                                    :error="accountingErrors.errors.bank"
                                     @update:model-value="(v: string | number | null) => accounting.bankIri = v === null ? null : String(v)"
                                 />
                             </div>
@@ -312,21 +303,27 @@
                                 v-bind="{ ariaLabel: t('commercial.clients.form.accounting.removeRib') }"
                                 @click="askRemoveRib(index)"
                             />
-                            <div class="grid grid-cols-3 gap-x-[80px] gap-y-5">
+                            <div class="grid grid-cols-4 gap-x-[44px] gap-y-4">
                                 <MalioInputText
                                     v-model="rib.label"
                                     :label="t('commercial.clients.form.accounting.ribLabel')"
                                     :readonly="accountingReadonly"
+                                    :required="isRibRequired"
+                                    :error="ribErrors[index]?.label"
                                 />
                                 <MalioInputText
                                     v-model="rib.bic"
                                     :label="t('commercial.clients.form.accounting.ribBic')"
                                     :readonly="accountingReadonly"
+                                    :required="isRibRequired"
+                                    :error="ribErrors[index]?.bic"
                                 />
                                 <MalioInputText
                                     v-model="rib.iban"
                                     :label="t('commercial.clients.form.accounting.ribIban')"
                                     :readonly="accountingReadonly"
+                                    :required="isRibRequired"
+                                    :error="ribErrors[index]?.iban"
                                 />
                             </div>
                         </div>
@@ -350,10 +347,10 @@
                 </template>
 
                 <!-- Onglets non encore implementes : frame vide (navigation libre). -->
-                <template #transport><TabPlaceholderBlank /></template>
-                <template #statistics><TabPlaceholderBlank /></template>
-                <template #reports><TabPlaceholderBlank /></template>
-                <template #exchanges><TabPlaceholderBlank /></template>
+                <template #transport><ComingSoonPlaceholder /></template>
+                <template #statistics><ComingSoonPlaceholder /></template>
+                <template #reports><ComingSoonPlaceholder /></template>
+                <template #exchanges><ComingSoonPlaceholder /></template>
             </MalioTabList>
         </template>
 
@@ -385,6 +382,7 @@
 import { computed, onMounted, reactive, ref } from 'vue'
 import { useClient } from '~/modules/commercial/composables/useClient'
 import { useClientReferentials, type CategoryOption, type RefOption } from '~/modules/commercial/composables/useClientReferentials'
+import { useClientFormErrors } from '~/modules/commercial/composables/useClientFormErrors'
 import {
     canEditClient,
     categoryOptionsOf,
@@ -412,11 +410,15 @@ import {
     type MainFormDraft,
 } from '~/modules/commercial/utils/clientEdit'
 import {
+    addressTypeFromFlags,
     buildClientFormTabKeys,
+    hasAllRequiredAccountingFields,
     hasAtLeastOneValidContact,
     isBankRequiredForPaymentType,
     isBillingEmailRequired,
+    isContactBlank,
     isContactNamed,
+    isRibBlank,
     isRibRequiredForPaymentType,
 } from '~/modules/commercial/utils/clientFormRules'
 import {
@@ -430,7 +432,6 @@ import {
 import { extractApiErrorMessage } from '~/shared/utils/api'
 
 // Masques de saisie (la normalisation finale reste serveur).
-const PHONE_MASK = '## ## ## ## ##'
 const SIREN_MASK = '#########'
 const EMPLOYEES_MASK = '#######'
 
@@ -495,6 +496,11 @@ function hydrate(detail: ClientDetail): void {
     contacts.value = (detail.contacts ?? []).map(mapContactToDraft)
     addresses.value = (detail.addresses ?? []).map(mapAddressToDraft)
     ribs.value = (detail.ribs ?? []).map(mapRibToDraft)
+    // Chaque bloc reste visible meme vide : si une collection est vide, on amorce
+    // un bloc vierge (non persiste tant qu'incomplet — cf. submit*/canValidate*).
+    if (contacts.value.length === 0) contacts.value.push(emptyContact())
+    if (addresses.value.length === 0) addresses.value.push(emptyAddress())
+    if (ribs.value.length === 0) ribs.value.push(emptyRib())
     // Charge les listes distributeur / courtier si une relation est deja posee.
     if (main.relationType === 'distributeur') referentials.loadDistributors().catch(() => {})
     if (main.relationType === 'courtier') referentials.loadBrokers().catch(() => {})
@@ -613,6 +619,22 @@ function showError(e: unknown, opts: { duplicateCompany?: boolean } = {}): void
     })
 }
 
+// ── Erreurs de validation par champ (ERP-101) ───────────────────────────────
+// Etat d'erreurs factorise avec l'ecran de creation (cf. useClientFormErrors) :
+// un `useFormErrors` par groupe scalaire + un tableau d'erreurs par ligne pour
+// chaque collection (aligne sur l'index visible). `mapRowError` mappe une 422
+// inline et retourne true ; il ne toaste pas, le fallback `showError` reste
+// local a l'edition (cf. catch des submits de collection).
+const {
+    mainErrors,
+    informationErrors,
+    accountingErrors,
+    contactErrors,
+    addressErrors,
+    ribErrors,
+    submitRows,
+} = useClientFormErrors()
+
 // ── Bloc principal ───────────────────────────────────────────────────────────
 const isMainValid = computed(() => {
     const filled = (v: string | null | undefined) => v !== null && v !== undefined && v.trim() !== ''
@@ -621,9 +643,6 @@ const isMainValid = computed(() => {
         || (main.relationType === 'distributeur' && filled(main.distributorIri))
         || (main.relationType === 'courtier' && filled(main.brokerIri))
     return filled(main.companyName)
-        && filled(main.email)
-        && filled(main.phonePrimary)
-        && (filled(main.firstName) || filled(main.lastName))
         && main.categoryIris.length >= 1
         && relationValid
 })
@@ -643,6 +662,7 @@ async function onRelationChange(value: string | number | null): Promise<void> {
 async function submitMain(): Promise<void> {
     if (businessReadonly.value || !isMainValid.value || mainSubmitting.value) return
     mainSubmitting.value = true
+    mainErrors.clearErrors()
     try {
         const updated = await api.patch<ClientDetail>(`/clients/${clientId}`, buildMainPayload(main), {
             headers: { Accept: 'application/ld+json' },
@@ -653,7 +673,17 @@ async function submitMain(): Promise<void> {
         toast.success({ title: t('commercial.clients.toast.updateSuccess') })
     }
     catch (e) {
-        showError(e, { duplicateCompany: true })
+        // 409 = doublon nom de societe → erreur inline + toast ; 422 → mapping
+        // inline par champ ; autre → toast de fallback. Cf. ERP-101.
+        const status = (e as { response?: { status?: number } })?.response?.status
+        if (status === 409) {
+            const message = t('commercial.clients.form.duplicateCompany')
+            mainErrors.setError('companyName', message)
+            toast.error({ title: t('commercial.clients.toast.error'), message })
+        }
+        else {
+            mainErrors.handleApiError(e, { fallbackMessage: t('commercial.clients.toast.error') })
+        }
     }
     finally {
         mainSubmitting.value = false
@@ -665,12 +695,13 @@ async function submitMain(): Promise<void> {
 async function submitInformation(): Promise<void> {
     if (businessReadonly.value || tabSubmitting.value) return
     tabSubmitting.value = true
+    informationErrors.clearErrors()
     try {
         await api.patch(`/clients/${clientId}`, buildInformationPayload(information), { toast: false })
         toast.success({ title: t('commercial.clients.toast.updateSuccess') })
     }
     catch (e) {
-        showError(e)
+        informationErrors.handleApiError(e, { fallbackMessage: t('commercial.clients.toast.error') })
     }
     finally {
         tabSubmitting.value = false
@@ -694,6 +725,9 @@ function askRemoveContact(index: number): void {
         const removed = contacts.value[index]
         if (removed?.id != null) removedContactIds.value.push(removed.id)
         contacts.value.splice(index, 1)
+        contactErrors.value.splice(index, 1)
+        // Garde au moins un bloc visible (cf. amorce a l'hydratation).
+        if (contacts.value.length === 0) contacts.value.push(emptyContact())
     })
 }
 
@@ -705,28 +739,42 @@ function askRemoveContact(index: number): void {
 async function submitContacts(): Promise<void> {
     if (businessReadonly.value || !canValidateContacts.value || tabSubmitting.value) return
     tabSubmitting.value = true
+    contactErrors.value = []
     try {
         for (const id of removedContactIds.value) {
             await api.delete(`/client_contacts/${id}`, {}, { toast: false })
         }
         removedContactIds.value = []
 
-        for (const contact of contacts.value) {
-            if (!isContactNamed(contact)) continue
-            const body = buildContactPayload(contact)
-            if (contact.id === null) {
-                const created = await api.post<{ '@id'?: string, id: number }>(
-                    `/clients/${clientId}/contacts`,
-                    body,
-                    { headers: { Accept: 'application/ld+json' }, toast: false },
-                )
-                contact.id = created.id
-                contact.iri = created['@id'] ?? null
-            }
-            else {
-                await api.patch(`/client_contacts/${contact.id}`, body, { toast: false })
-            }
-        }
+        // On tente TOUS les blocs (collecte des erreurs par index, ERP-110). Seuls
+        // les blocs TOTALEMENT vides sont ignores : un bloc partiellement rempli
+        // sans nom (email seul) est soumis -> 422 RG-1.05 inline sous le bloc.
+        const hasError = await submitRows(
+            contacts.value,
+            contactErrors,
+            async (contact) => {
+                const body = buildContactPayload(contact)
+                if (contact.id === null) {
+                    const created = await api.post<{ '@id'?: string, id: number }>(
+                        `/clients/${clientId}/contacts`,
+                        body,
+                        { headers: { Accept: 'application/ld+json' }, toast: false },
+                    )
+                    contact.id = created.id
+                    contact.iri = created['@id'] ?? null
+                }
+                else {
+                    await api.patch(`/client_contacts/${contact.id}`, body, { toast: false })
+                }
+            },
+            error => showError(error),
+            // On ne saute QUE les amorces neuves (id null) totalement vides. Un
+            // bloc existant vide est soumis -> 422 RG-1.05 inline (sinon la modif
+            // serait perdue en silence avec un faux toast de succes).
+            contact => contact.id === null && isContactBlank(contact),
+        )
+        // Tant qu'un bloc reste en erreur : pas de toast succes.
+        if (hasError) return
         toast.success({ title: t('commercial.clients.toast.updateSuccess') })
     }
     catch (e) {
@@ -742,7 +790,10 @@ const canValidateAddresses = computed(() =>
     addresses.value.length > 0
     && addresses.value.every((a) => {
         const filledBillingEmail = a.billingEmail !== null && a.billingEmail.trim() !== ''
-        return a.siteIris.length >= 1 && (!isBillingEmailRequired(a) || filledBillingEmail)
+        return addressTypeFromFlags(a) !== null
+            && a.siteIris.length >= 1
+            && a.categoryIris.length >= 1
+            && (!isBillingEmailRequired(a) || filledBillingEmail)
     }),
 )
 
@@ -755,6 +806,9 @@ function askRemoveAddress(index: number): void {
         const removed = addresses.value[index]
         if (removed?.id != null) removedAddressIds.value.push(removed.id)
         addresses.value.splice(index, 1)
+        addressErrors.value.splice(index, 1)
+        // Garde au moins un bloc visible (cf. amorce a l'hydratation).
+        if (addresses.value.length === 0) addresses.value.push(emptyAddress())
     })
 }
 
@@ -771,26 +825,34 @@ function onAddressDegraded(): void {
 async function submitAddresses(): Promise<void> {
     if (businessReadonly.value || !canValidateAddresses.value || tabSubmitting.value) return
     tabSubmitting.value = true
+    addressErrors.value = []
     try {
         for (const id of removedAddressIds.value) {
             await api.delete(`/client_addresses/${id}`, {}, { toast: false })
         }
         removedAddressIds.value = []
 
-        for (const address of addresses.value) {
-            const body = buildAddressPayload(address, isBillingEmailRequired(address))
-            if (address.id === null) {
-                const created = await api.post<{ id: number }>(
-                    `/clients/${clientId}/addresses`,
-                    body,
-                    { headers: { Accept: 'application/ld+json' }, toast: false },
-                )
-                address.id = created.id
-            }
-            else {
-                await api.patch(`/client_addresses/${address.id}`, body, { toast: false })
-            }
-        }
+        // On tente TOUS les blocs d'adresse (collecte des erreurs par index, ERP-110).
+        const hasError = await submitRows(
+            addresses.value,
+            addressErrors,
+            async (address) => {
+                const body = buildAddressPayload(address, isBillingEmailRequired(address))
+                if (address.id === null) {
+                    const created = await api.post<{ id: number }>(
+                        `/clients/${clientId}/addresses`,
+                        body,
+                        { headers: { Accept: 'application/ld+json' }, toast: false },
+                    )
+                    address.id = created.id
+                }
+                else {
+                    await api.patch(`/client_addresses/${address.id}`, body, { toast: false })
+                }
+            },
+            error => showError(error),
+        )
+        if (hasError) return
         toast.success({ title: t('commercial.clients.toast.updateSuccess') })
     }
     catch (e) {
@@ -819,6 +881,7 @@ function ribIsComplete(rib: { label: string | null, bic: string | null, iban: st
 }
 
 const canValidateAccounting = computed(() => {
+    if (!hasAllRequiredAccountingFields(accounting)) return false
     if (isBankRequired.value && accounting.bankIri === null) return false
     if (isRibRequired.value && !ribs.value.some(ribIsComplete)) return false
     return true
@@ -833,6 +896,9 @@ function askRemoveRib(index: number): void {
         const removed = ribs.value[index]
         if (removed?.id != null) removedRibIds.value.push(removed.id)
         ribs.value.splice(index, 1)
+        ribErrors.value.splice(index, 1)
+        // Garde au moins un bloc RIB visible (cf. amorce a l'hydratation).
+        if (ribs.value.length === 0) ribs.value.push(emptyRib())
     })
 }
 
@@ -845,29 +911,53 @@ function askRemoveRib(index: number): void {
 async function submitAccounting(): Promise<void> {
     if (accountingReadonly.value || !canValidateAccounting.value || tabSubmitting.value) return
     tabSubmitting.value = true
+    accountingErrors.clearErrors()
+    // Reset des erreurs RIB des le debut : l'etape 1 (PATCH scalaires) peut
+    // echouer et `return` avant submitRows (qui porte sinon le reset), laissant
+    // des erreurs de RIB obsoletes affichees sous les blocs.
+    ribErrors.value = []
     try {
-        await api.patch(`/clients/${clientId}`, buildAccountingPayload(accounting, isBankRequired.value), { toast: false })
+        // 1) PATCH des scalaires comptables (erreurs inline sur leurs champs).
+        try {
+            await api.patch(`/clients/${clientId}`, buildAccountingPayload(accounting, isBankRequired.value), { toast: false })
+        }
+        catch (error) {
+            accountingErrors.handleApiError(error, { fallbackMessage: t('commercial.clients.toast.error') })
+            return
+        }
 
         for (const id of removedRibIds.value) {
             await api.delete(`/client_ribs/${id}`, {}, { toast: false })
         }
         removedRibIds.value = []
 
-        for (const rib of ribs.value) {
-            if (!ribIsComplete(rib)) continue
-            const body = buildRibPayload(rib)
-            if (rib.id === null) {
-                const created = await api.post<{ id: number }>(
-                    `/clients/${clientId}/ribs`,
-                    body,
-                    { headers: { Accept: 'application/ld+json' }, toast: false },
-                )
-                rib.id = created.id
-            }
-            else {
-                await api.patch(`/client_ribs/${rib.id}`, body, { toast: false })
-            }
-        }
+        // 2) POST/PATCH des RIB (erreurs inline par ligne, tous les blocs tentes).
+        // Seuls les blocs RIB TOTALEMENT vides sont ignores : un RIB partiel (ex.
+        // IBAN seul) est soumis -> 422 NotBlank (label / bic / iban) inline.
+        const ribHasError = await submitRows(
+            ribs.value,
+            ribErrors,
+            async (rib) => {
+                const body = buildRibPayload(rib)
+                if (rib.id === null) {
+                    const created = await api.post<{ id: number }>(
+                        `/clients/${clientId}/ribs`,
+                        body,
+                        { headers: { Accept: 'application/ld+json' }, toast: false },
+                    )
+                    rib.id = created.id
+                }
+                else {
+                    await api.patch(`/client_ribs/${rib.id}`, body, { toast: false })
+                }
+            },
+            error => showError(error),
+            // On ne saute QUE les amorces neuves (id null) totalement vides. Un
+            // RIB existant vide est soumis -> 422 NotBlank inline (sinon la modif
+            // serait perdue en silence avec un faux toast de succes).
+            rib => rib.id === null && isRibBlank(rib),
+        )
+        if (ribHasError) return
         toast.success({ title: t('commercial.clients.toast.updateSuccess') })
     }
     catch (e) {

frontend/modules/commercial/pages/clients/[id]/index.vue

@@ -52,43 +52,23 @@
                     :label="t('commercial.clients.form.main.companyName')"
                     readonly
                 />
-                <MalioInputText
-                    :model-value="client.lastName"
-                    :label="t('commercial.clients.form.main.lastName')"
-                    readonly
-                />
-                <MalioInputText
-                    :model-value="client.firstName"
-                    :label="t('commercial.clients.form.main.firstName')"
-                    readonly
-                />
                 <MalioSelectCheckbox
                     :model-value="categoryIris"
                     :options="mainCategoryOptions"
                     :label="t('commercial.clients.form.main.categories')"
                     :display-tag="true"
-                    disabled
-                />
-                <MalioInputPhone
-                    v-for="(phone, index) in mainPhones"
-                    :key="index"
-                    :model-value="phone"
-                    :label="index === 0 ? t('commercial.clients.form.main.phonePrimary') : t('commercial.clients.form.main.phoneSecondary')"
-                    :mask="PHONE_MASK"
-                    readonly
-                />
-                <MalioInputEmail
-                    :model-value="client.email"
-                    :label="t('commercial.clients.form.main.email')"
                     readonly
                 />
+                <!-- Relation toujours affichee (vide = « Aucun »), comme en edition. -->
                 <MalioSelect
-                    v-if="relation.type"
                     :model-value="relation.type"
                     :options="relationOptions"
                     :label="t('commercial.clients.form.main.relation')"
-                    disabled
+                    :empty-option-label="t('commercial.clients.form.main.relationNone')"
+                    readonly
                 />
+                <!-- Nom du distributeur/courtier : conditionnel (libelle type-dependant,
+                     aucune valeur sans relation — meme comportement qu'en edition). -->
                 <MalioInputText
                     v-if="relation.type"
                     :model-value="relation.name"
@@ -104,7 +84,7 @@
             </div>
 
             <!-- ── Onglets (navigation libre, tout en lecture seule) ─────────── -->
-            <MalioTabList v-model="activeTab" :tabs="tabs" class="mt-[60px]">
+            <MalioTabList v-model="activeTab" :tabs="tabs" :max-visible-tabs="5" :max-width="1100" class="mt-[60px]">
                 <!-- Onglet Information -->
                 <template #information>
                     <div class="mt-12 grid grid-cols-4 gap-x-[44px] gap-y-4 bg-white py-4 pl-[28px] pr-[60px] shadow-[0_4px_4px_0_rgba(0,0,0,0.25)]">
@@ -114,7 +94,7 @@
                             resize="none"
                             group-class="row-span-2 pt-1"
                             text-input="h-full text-lg"
-                            disabled
+                            readonly
                         />
                         <MalioInputText
                             :model-value="information.competitors"
@@ -134,7 +114,7 @@
                         <MalioInputAmount
                             :model-value="information.revenueAmount"
                             :label="t('commercial.clients.form.information.revenueAmount')"
-                            disabled
+                            readonly
                         />
                         <MalioInputText
                             :model-value="information.directorName"
@@ -144,7 +124,7 @@
                         <MalioInputAmount
                             :model-value="information.profitAmount"
                             :label="t('commercial.clients.form.information.profitAmount')"
-                            disabled
+                            readonly
                         />
                     </div>
                 </template>
@@ -159,9 +139,6 @@
                             :title="t('commercial.clients.form.contact.title', { n: index + 1 })"
                             readonly
                         />
-                        <p v-if="contacts.length === 0" class="text-center text-black/60">
-                            {{ t('commercial.clients.consultation.emptyContacts') }}
-                        </p>
                     </div>
                 </template>
 
@@ -174,14 +151,11 @@
                             :model-value="view.draft"
                             :title="t('commercial.clients.form.address.title', { n: index + 1 })"
                             :category-options="view.categoryOptions"
-                            :site-options="view.siteOptions"
+                            :site-options="allSiteOptions"
                             :contact-options="contactOptions"
                             :country-options="countryOptions"
                             readonly
                         />
-                        <p v-if="addressViews.length === 0" class="text-center text-black/60">
-                            {{ t('commercial.clients.consultation.emptyAddresses') }}
-                        </p>
                     </div>
                 </template>
 
@@ -189,7 +163,7 @@
                 <template v-if="canAccountingView" #accounting>
                     <div class="mt-12 flex flex-col gap-6">
                         <div class="bg-white py-4 pl-[28px] pr-[60px] shadow-[0_4px_4px_0_rgba(0,0,0,0.25)]">
-                            <div class="grid grid-cols-3 gap-x-[80px] gap-y-5">
+                            <div class="grid grid-cols-4 gap-x-[44px] gap-y-4">
                                 <MalioInputText
                                     :model-value="accounting.siren"
                                     :label="t('commercial.clients.form.accounting.siren')"
@@ -206,7 +180,7 @@
                                     :options="tvaModeOptions"
                                     :label="t('commercial.clients.form.accounting.tvaMode')"
                                     empty-option-label=""
-                                    disabled
+                                    readonly
                                 />
                                 <MalioInputText
                                     :model-value="accounting.nTva"
@@ -218,14 +192,14 @@
                                     :options="paymentDelayOptions"
                                     :label="t('commercial.clients.form.accounting.paymentDelay')"
                                     empty-option-label=""
-                                    disabled
+                                    readonly
                                 />
                                 <MalioSelect
                                     :model-value="accounting.paymentTypeIri"
                                     :options="paymentTypeOptions"
                                     :label="t('commercial.clients.form.accounting.paymentType')"
                                     empty-option-label=""
-                                    disabled
+                                    readonly
                                 />
                                 <MalioSelect
                                     v-if="accounting.bankIri"
@@ -233,7 +207,7 @@
                                     :options="bankOptions"
                                     :label="t('commercial.clients.form.accounting.bank')"
                                     empty-option-label=""
-                                    disabled
+                                    readonly
                                 />
                             </div>
                         </div>
@@ -244,7 +218,7 @@
                             :key="rib.id ?? index"
                             class="bg-white py-4 pl-[28px] pr-[60px] shadow-[0_4px_4px_0_rgba(0,0,0,0.25)]"
                         >
-                            <div class="grid grid-cols-3 gap-x-[80px] gap-y-5">
+                            <div class="grid grid-cols-4 gap-x-[44px] gap-y-4">
                                 <MalioInputText
                                     :model-value="rib.label"
                                     :label="t('commercial.clients.form.accounting.ribLabel')"
@@ -266,10 +240,10 @@
                 </template>
 
                 <!-- Onglets non encore implementes : frame vide (navigation libre). -->
-                <template #transport><TabPlaceholderBlank /></template>
-                <template #statistics><TabPlaceholderBlank /></template>
-                <template #reports><TabPlaceholderBlank /></template>
-                <template #exchanges><TabPlaceholderBlank /></template>
+                <template #transport><ComingSoonPlaceholder /></template>
+                <template #statistics><ComingSoonPlaceholder /></template>
+                <template #reports><ComingSoonPlaceholder /></template>
+                <template #exchanges><ComingSoonPlaceholder /></template>
             </MalioTabList>
         </template>
 
@@ -319,10 +293,9 @@ import {
     type ClientDetail,
     type SelectOption,
 } from '~/modules/commercial/utils/clientConsultation'
-import { formatPhoneFR } from '~/shared/utils/phone'
+import { emptyAddress, emptyContact, emptyRib } from '~/modules/commercial/types/clientForm'
 
-// Masques d'affichage (purement visuels, la donnee reste celle du serveur).
-const PHONE_MASK = '## ## ## ## ##'
+// Masque d'affichage (purement visuel, la donnee reste celle du serveur).
 const SIREN_MASK = '#########'
 
 const { t } = useI18n()
@@ -330,6 +303,7 @@ const route = useRoute()
 const router = useRouter()
 const toast = useToast()
 const { can, canAny } = usePermissions()
+const authStore = useAuthStore()
 
 // Gating de la route : la consultation exige `view`. Usine (sans view) est
 // redirige vers le repertoire (lui-meme protege). Cf. matrice § 2.7.
@@ -354,13 +328,6 @@ const headerTitle = computed(() => client.value?.companyName ?? t('commercial.cl
 const relation = computed(() => (client.value ? relationOf(client.value) : { type: null, name: null }))
 const categoryIris = computed(() => (client.value?.categories ?? []).map(c => c['@id']))
 
-// Telephones du formulaire principal, formates XX XX XX XX XX (RG d'affichage).
-const mainPhones = computed(() =>
-    [client.value?.phonePrimary, client.value?.phoneSecondary]
-        .filter((p): p is string => Boolean(p))
-        .map(formatPhoneFR),
-)
-
 const information = computed(() => ({
     description: client.value?.description ?? null,
     competitors: client.value?.competitors ?? null,
@@ -372,10 +339,21 @@ const information = computed(() => ({
     directorName: client.value?.directorName ?? null,
 }))
 
-const contacts = computed(() => (client.value?.contacts ?? []).map(mapContactToDraft))
+// Chaque bloc reste visible meme vide en consultation : si la collection est
+// vide, on affiche un bloc vierge en lecture seule (pas de message « Aucun … »).
+const contacts = computed(() => {
+    const list = (client.value?.contacts ?? []).map(mapContactToDraft)
+    return list.length ? list : [emptyContact()]
+})
 // Vue par adresse : brouillon + options (sites/categories) propres a l'adresse.
-const addressViews = computed(() => (client.value?.addresses ?? []).map(mapAddressView))
-const ribs = computed(() => (client.value?.ribs ?? []).map(mapRibToDraft))
+const addressViews = computed(() => {
+    const views = (client.value?.addresses ?? []).map(mapAddressView)
+    return views.length ? views : [{ draft: emptyAddress(), siteOptions: [], categoryOptions: [] }]
+})
+const ribs = computed(() => {
+    const list = (client.value?.ribs ?? []).map(mapRibToDraft)
+    return list.length ? list : [emptyRib()]
+})
 // Draft comptable (tout null si l'utilisateur n'a pas accounting.view).
 const accounting = computed(() => mapAccountingDraft(client.value ?? ({} as ClientDetail)))
 
@@ -385,6 +363,18 @@ const accounting = computed(() => mapAccountingDraft(client.value ?? ({} as Clie
 const mainCategoryOptions = computed(() => categoryOptionsOf(client.value?.categories))
 const contactOptions = computed(() => contactOptionsOf(client.value?.contacts))
 
+// Liste COMPLETE des sites disponibles, issue de /api/me (groupe me:read — donc
+// pas de 403 pour les roles metier, contrairement a GET /sites). Libelle = numero
+// de departement (2 premiers chiffres du code postal). Permet d'afficher TOUJOURS
+// toutes les cases « Sites » (86 / 17 / 82) dans le bloc adresse, meme celles non
+// rattachees a l'adresse consultee (les rattachees restent cochees via siteIris).
+const allSiteOptions = computed<SelectOption[]>(() =>
+    (authStore.user?.sites ?? []).map(s => ({
+        value: `/api/sites/${s.id}`,
+        label: (s.postalCode ?? '').slice(0, 2),
+    })),
+)
+
 const relationOptions = computed<SelectOption[]>(() => [
     { value: 'distributeur', label: t('commercial.clients.form.main.relationDistributor') },
     { value: 'courtier', label: t('commercial.clients.form.main.relationBroker') },

frontend/modules/commercial/pages/clients/new.vue

@@ -22,50 +22,24 @@
                 :label="t('commercial.clients.form.main.companyName')"
                 :required="true"
                 :readonly="mainLocked"
-            />
-            <MalioInputText
-                v-model="main.lastName"
-                :label="t('commercial.clients.form.main.lastName')"
-                :readonly="mainLocked"
-            />
-            <MalioInputText
-                v-model="main.firstName"
-                :label="t('commercial.clients.form.main.firstName')"
-                :readonly="mainLocked"
+                :error="mainErrors.errors.companyName"
             />
             <MalioSelectCheckbox
                 :model-value="main.categoryIris"
                 :options="referentials.categories.value"
                 :label="t('commercial.clients.form.main.categories')"
                 :display-tag="true"
-                :disabled="mainLocked"
-                @update:model-value="(v: (string | number)[]) => main.categoryIris = v.map(String)"
-            />
-            <!-- Telephones : 1 par defaut, le bouton « + » revele le 2e (max 2, RG-1.02). -->
-            <MalioInputPhone
-                v-for="(_, index) in mainPhones"
-                :key="index"
-                v-model="mainPhones[index]"
-                :label="t('commercial.clients.form.main.phonePrimary')"
-                :mask="PHONE_MASK"
-                :required="index === 0"
                 :readonly="mainLocked"
-                add-icon-name="mdi:plus"
-                :addable="mainPhones.length === 1 && !mainLocked"
-                :add-button-label="t('commercial.clients.form.main.addPhone')"
-                @add="addMainPhone"
-            />
-            <MalioInputEmail
-                v-model="main.email"
-                :label="t('commercial.clients.form.main.email')"
                 :required="true"
-                :readonly="mainLocked"
+                :error="mainErrors.errors.categories"
+                @update:model-value="(v: (string | number)[]) => main.categoryIris = v.map(String)"
             />
             <MalioSelect
                 :model-value="main.relationType"
                 :options="relationOptions"
                 :label="t('commercial.clients.form.main.relation')"
-                :disabled="mainLocked"
+                :empty-option-label="t('commercial.clients.form.main.relationNone')"
+                :readonly="mainLocked"
                 @update:model-value="onRelationChange"
             />
             <MalioSelect
@@ -73,7 +47,9 @@
                 :model-value="main.brokerIri"
                 :options="referentials.brokers.value"
                 :label="t('commercial.clients.form.main.brokerName')"
-                :disabled="mainLocked"
+                :readonly="mainLocked"
+                :required="true"
+                :error="mainErrors.errors.broker"
                 @update:model-value="(v: string | number | null) => main.brokerIri = v === null ? null : String(v)"
             />
             <MalioSelect
@@ -81,7 +57,9 @@
                 :model-value="main.distributorIri"
                 :options="referentials.distributors.value"
                 :label="t('commercial.clients.form.main.distributorName')"
-                :disabled="mainLocked"
+                :readonly="mainLocked"
+                :required="true"
+                :error="mainErrors.errors.distributor"
                 @update:model-value="(v: string | number | null) => main.distributorIri = v === null ? null : String(v)"
             />
             <MalioCheckbox
@@ -114,38 +92,45 @@
                         resize="none"
                         group-class="row-span-2 pt-1"
                         text-input="h-full text-lg"
-                        :disabled="isValidated('information')"
+                        :readonly="isValidated('information')"
+                        :error="informationErrors.errors.description"
                     />
                     <MalioInputText
                         v-model="information.competitors"
                         :label="t('commercial.clients.form.information.competitors')"
                         :readonly="isValidated('information')"
+                        :error="informationErrors.errors.competitors"
                     />
                     <MalioDate
                         v-model="information.foundedAt"
                         :label="t('commercial.clients.form.information.foundedAt')"
                         :readonly="isValidated('information')"
+                        :error="informationErrors.errors.foundedAt"
                     />
                     <MalioInputText
                         v-model="information.employeesCount"
                         :label="t('commercial.clients.form.information.employeesCount')"
                         :mask="EMPLOYEES_MASK"
                         :readonly="isValidated('information')"
+                        :error="informationErrors.errors.employeesCount"
                     />
                     <MalioInputAmount
                         v-model="information.revenueAmount"
                         :label="t('commercial.clients.form.information.revenueAmount')"
-                        :disabled="isValidated('information')"
+                        :readonly="isValidated('information')"
+                        :error="informationErrors.errors.revenueAmount"
                     />
                     <MalioInputText
                         v-model="information.directorName"
                         :label="t('commercial.clients.form.information.directorName')"
                         :readonly="isValidated('information')"
+                        :error="informationErrors.errors.directorName"
                     />
                     <MalioInputAmount
                         v-model="information.profitAmount"
                         :label="t('commercial.clients.form.information.profitAmount')"
-                        :disabled="isValidated('information')"
+                        :readonly="isValidated('information')"
+                        :error="informationErrors.errors.profitAmount"
                     />
                 </div>
                 <div v-if="!isValidated('information')" class="mt-12 flex justify-center">
@@ -171,6 +156,7 @@
                         :title="t('commercial.clients.form.contact.title', { n: index + 1 })"
                         :removable="index > 0"
                         :readonly="isValidated('contact')"
+                        :errors="contactErrors[index]"
                         @update:model-value="(v) => contacts[index] = v"
                         @remove="askRemoveContact(index)"
                     />
@@ -207,6 +193,7 @@
                         :country-options="countryOptions"
                         :removable="index > 0"
                         :readonly="isValidated('address')"
+                        :errors="addressErrors[index]"
                         @update:model-value="(v) => addresses[index] = v"
                         @remove="askRemoveAddress(index)"
                         @degraded="onAddressDegraded"
@@ -233,45 +220,57 @@
             <template v-if="canAccountingView" #accounting>
                 <div class="mt-12 flex flex-col gap-6">
                     <div class="bg-white py-4 pl-[28px] pr-[60px] shadow-[0_4px_4px_0_rgba(0,0,0,0.25)]">
-                        <div class="grid grid-cols-3 gap-x-[80px] gap-y-5">
+                        <div class="grid grid-cols-4 gap-x-[44px] gap-y-4">
                             <MalioInputText
                                 v-model="accounting.siren"
                                 :label="t('commercial.clients.form.accounting.siren')"
                                 :mask="SIREN_MASK"
                                 :readonly="accountingReadonly"
+                                :required="true"
+                                :error="accountingErrors.errors.siren"
                             />
                             <MalioInputText
                                 v-model="accounting.accountNumber"
                                 :label="t('commercial.clients.form.accounting.accountNumber')"
                                 :readonly="accountingReadonly"
+                                :required="true"
+                                :error="accountingErrors.errors.accountNumber"
                             />
                             <MalioSelect
                                 :model-value="accounting.tvaModeIri"
                                 :options="referentials.tvaModes.value"
                                 :label="t('commercial.clients.form.accounting.tvaMode')"
-                                :disabled="accountingReadonly"
+                                :readonly="accountingReadonly"
                                 empty-option-label=""
+                                :required="true"
+                                :error="accountingErrors.errors.tvaMode"
                                 @update:model-value="(v: string | number | null) => accounting.tvaModeIri = v === null ? null : String(v)"
                             />
                             <MalioInputText
                                 v-model="accounting.nTva"
                                 :label="t('commercial.clients.form.accounting.nTva')"
                                 :readonly="accountingReadonly"
+                                :required="true"
+                                :error="accountingErrors.errors.nTva"
                             />
                             <MalioSelect
                                 :model-value="accounting.paymentDelayIri"
                                 :options="referentials.paymentDelays.value"
                                 :label="t('commercial.clients.form.accounting.paymentDelay')"
-                                :disabled="accountingReadonly"
+                                :readonly="accountingReadonly"
                                 empty-option-label=""
+                                :required="true"
+                                :error="accountingErrors.errors.paymentDelay"
                                 @update:model-value="(v: string | number | null) => accounting.paymentDelayIri = v === null ? null : String(v)"
                             />
                             <MalioSelect
                                 :model-value="accounting.paymentTypeIri"
                                 :options="referentials.paymentTypes.value"
                                 :label="t('commercial.clients.form.accounting.paymentType')"
-                                :disabled="accountingReadonly"
+                                :readonly="accountingReadonly"
                                 empty-option-label=""
+                                :required="true"
+                                :error="accountingErrors.errors.paymentType"
                                 @update:model-value="onPaymentTypeChange"
                             />
                             <MalioSelect
@@ -279,8 +278,10 @@
                                 :model-value="accounting.bankIri"
                                 :options="referentials.banks.value"
                                 :label="t('commercial.clients.form.accounting.bank')"
-                                :disabled="accountingReadonly"
+                                :readonly="accountingReadonly"
                                 empty-option-label=""
+                                :required="true"
+                                :error="accountingErrors.errors.bank"
                                 @update:model-value="(v: string | number | null) => accounting.bankIri = v === null ? null : String(v)"
                             />
                         </div>
@@ -301,21 +302,27 @@
                             v-bind="{ ariaLabel: t('commercial.clients.form.accounting.removeRib') }"
                             @click="askRemoveRib(index)"
                         />
-                        <div class="grid grid-cols-3 gap-x-[80px] gap-y-5">
+                        <div class="grid grid-cols-4 gap-x-[44px] gap-y-4">
                             <MalioInputText
                                 v-model="rib.label"
                                 :label="t('commercial.clients.form.accounting.ribLabel')"
                                 :readonly="accountingReadonly"
+                                :required="isRibRequired"
+                                :error="ribErrors[index]?.label"
                             />
                             <MalioInputText
                                 v-model="rib.bic"
                                 :label="t('commercial.clients.form.accounting.ribBic')"
                                 :readonly="accountingReadonly"
+                                :required="isRibRequired"
+                                :error="ribErrors[index]?.bic"
                             />
                             <MalioInputText
                                 v-model="rib.iban"
                                 :label="t('commercial.clients.form.accounting.ribIban')"
                                 :readonly="accountingReadonly"
+                                :required="isRibRequired"
+                                :error="ribErrors[index]?.iban"
                             />
                         </div>
                     </div>
@@ -341,7 +348,7 @@
             <!-- Onglet non encore implemente : frame vide, passage automatique.
                  Statistiques / Rapports / Echanges sont edit-only (absents a la
                  creation) — cf. buildClientFormTabKeys. -->
-            <template #transport><TabPlaceholderBlank /></template>
+            <template #transport><ComingSoonPlaceholder /></template>
         </MalioTabList>
 
         <!-- Modal de confirmation generique (suppression contact/adresse/RIB). -->
@@ -371,13 +378,18 @@
 <script setup lang="ts">
 import { computed, onMounted, reactive, ref, watch } from 'vue'
 import { useClientReferentials, type RefOption } from '~/modules/commercial/composables/useClientReferentials'
+import { useClientFormErrors } from '~/modules/commercial/composables/useClientFormErrors'
 import {
+    addressTypeFromFlags,
     buildClientFormTabKeys,
     CLIENT_FORM_PLACEHOLDER_TABS,
+    hasAllRequiredAccountingFields,
     hasAtLeastOneValidContact,
     isBankRequiredForPaymentType,
     isBillingEmailRequired,
+    isContactBlank,
     isContactNamed,
+    isRibBlank,
     isRibRequiredForPaymentType,
 } from '~/modules/commercial/utils/clientFormRules'
 import {
@@ -388,11 +400,9 @@ import {
     type ContactFormDraft,
     type RibFormDraft,
 } from '~/modules/commercial/types/clientForm'
-import { formatPhoneFR } from '~/shared/utils/phone'
 import { extractApiErrorMessage } from '~/shared/utils/api'
 
 // Masques de saisie (la normalisation finale reste serveur).
-const PHONE_MASK = '## ## ## ## ##'
 const SIREN_MASK = '#########'
 // Masque « nombre » du champ Nombre de salaries : chiffres uniquement (max 7).
 const EMPLOYEES_MASK = '#######'
@@ -422,6 +432,22 @@ function apiErrorMessage(error: unknown): string {
     return extractApiErrorMessage(data) || t('commercial.clients.toast.error')
 }
 
+// ── Erreurs de validation par champ (ERP-101) ───────────────────────────────
+// Etat d'erreurs factorise entre creation et edition (cf. useClientFormErrors) :
+// un `useFormErrors` par groupe scalaire (Principal / Information / Comptabilite)
+// + un tableau d'erreurs par ligne pour chaque collection (contacts/adresses/RIB).
+// `mapRowError` mappe une 422 inline et retourne true ; il ne toaste pas, le
+// fallback reste local a la creation (cf. catch des submits de collection).
+const {
+    mainErrors,
+    informationErrors,
+    accountingErrors,
+    contactErrors,
+    addressErrors,
+    ribErrors,
+    submitRows,
+} = useClientFormErrors()
+
 useHead({ title: t('commercial.clients.form.title') })
 
 // Gating de la route : la creation est reservee a `manage`. Compta (accounting
@@ -444,9 +470,6 @@ const tabSubmitting = ref(false)
 // ── Formulaire principal ────────────────────────────────────────────────────
 const main = reactive({
     companyName: null as string | null,
-    firstName: null as string | null,
-    lastName: null as string | null,
-    email: null as string | null,
     categoryIris: [] as string[],
     relationType: null as 'distributeur' | 'courtier' | null,
     distributorIri: null as string | null,
@@ -454,17 +477,6 @@ const main = reactive({
     triageService: false,
 })
 
-// Telephones du formulaire principal : 1 par defaut, 2 au maximum (RG-1.02).
-// L'index 0 alimente phonePrimary, l'index 1 phoneSecondary au POST.
-const mainPhones = ref<string[]>([''])
-
-/** Revele le 2e numero (le bouton « + » disparait une fois a 2, RG-1.02). */
-function addMainPhone(): void {
-    if (mainPhones.value.length === 1) {
-        mainPhones.value.push('')
-    }
-}
-
 // Pas d'option « Aucun » : le select est vide par defaut (relationType = null).
 const relationOptions = computed<RefOption[]>(() => [
     { value: 'distributeur', label: t('commercial.clients.form.main.relationDistributor') },
@@ -472,10 +484,11 @@ const relationOptions = computed<RefOption[]>(() => [
 ])
 
 // Validation du formulaire principal (gate le bouton « Valider ») :
-//  - companyName / email / telephone principal / >= 1 categorie obligatoires ;
-//  - RG-1.01 : nom OU prenom du contact principal ;
-//  - relation Distributeur/Courtier obligatoire (un des deux), ET le nom
-//    correspondant obligatoire selon le choix (spec fonctionnelle).
+//  - companyName / >= 1 categorie obligatoires ;
+//  - relation Distributeur/Courtier optionnelle, mais le nom correspondant
+//    devient requis si l'un des deux est choisi (spec fonctionnelle).
+// Les coordonnees de contact ne sont plus saisies ici : elles vivent dans
+// l'onglet Contacts (RG-1.05/1.14 garantissent >= 1 contact valide).
 const isMainValid = computed(() => {
     const filled = (v: string | null | undefined) => v !== null && v !== undefined && v.trim() !== ''
     // Relation Distributeur/Courtier OPTIONNELLE ; mais si « Depend du
@@ -485,9 +498,6 @@ const isMainValid = computed(() => {
         || (main.relationType === 'distributeur' && filled(main.distributorIri))
         || (main.relationType === 'courtier' && filled(main.brokerIri))
     return filled(main.companyName)
-        && filled(main.email)
-        && filled(mainPhones.value[0])
-        && (filled(main.firstName) || filled(main.lastName))
         && main.categoryIris.length >= 1
         && relationValid
 })
@@ -509,14 +519,10 @@ async function onRelationChange(value: string | number | null): Promise<void> {
 async function submitMain(): Promise<void> {
     if (!isMainValid.value || mainSubmitting.value) return
     mainSubmitting.value = true
+    mainErrors.clearErrors()
     try {
         const payload: Record<string, unknown> = {
             companyName: main.companyName,
-            firstName: main.firstName || null,
-            lastName: main.lastName || null,
-            email: main.email,
-            phonePrimary: mainPhones.value[0] || null,
-            phoneSecondary: mainPhones.value[1] || null,
             categories: main.categoryIris,
             distributor: main.relationType === 'distributeur' ? main.distributorIri : null,
             broker: main.relationType === 'courtier' ? main.brokerIri : null,
@@ -528,18 +534,8 @@ async function submitMain(): Promise<void> {
         })
 
         clientId.value = created.id
-        // Reaffiche les valeurs normalisees renvoyees par le serveur.
+        // Reaffiche la valeur normalisee renvoyee par le serveur.
         main.companyName = created.companyName ?? main.companyName
-        main.firstName = created.firstName ?? null
-        main.lastName = created.lastName ?? null
-        main.email = created.email ?? main.email
-        // Reaffiche les telephones normalises (reformates via formatPhoneFR).
-        const normalizedPhones = [formatPhoneFR(created.phonePrimary), formatPhoneFR(created.phoneSecondary)]
-            .filter(p => p !== '')
-        mainPhones.value = normalizedPhones.length > 0 ? normalizedPhones : ['']
-
-        // Pre-remplit le 1er contact a partir du formulaire principal (editable).
-        prefillFirstContact()
 
         mainLocked.value = true
         unlockedIndex.value = 0
@@ -547,15 +543,18 @@ async function submitMain(): Promise<void> {
         toast.success({ title: t('commercial.clients.toast.createSuccess') })
     }
     catch (error) {
-        // 409 = doublon nom de societe (RG d'unicite) → message explicite ;
-        // sinon on remonte le message de validation du serveur (ex: 422).
+        // 409 = doublon nom de societe (RG d'unicite) → erreur inline sur le
+        // champ + toast explicite ; 422 → mapping inline par champ (pas de
+        // toast) ; autre → toast de fallback. Cf. ERP-101.
         const status = (error as { response?: { status?: number } })?.response?.status
-        toast.error({
-            title: t('commercial.clients.toast.error'),
-            message: status === 409
-                ? t('commercial.clients.form.duplicateCompany')
-                : apiErrorMessage(error),
-        })
+        if (status === 409) {
+            const message = t('commercial.clients.form.duplicateCompany')
+            mainErrors.setError('companyName', message)
+            toast.error({ title: t('commercial.clients.toast.error'), message })
+        }
+        else {
+            mainErrors.handleApiError(error, { fallbackMessage: t('commercial.clients.toast.error') })
+        }
     }
     finally {
         mainSubmitting.value = false
@@ -630,6 +629,7 @@ const information = reactive({
 async function submitInformation(): Promise<void> {
     if (clientId.value === null || tabSubmitting.value) return
     tabSubmitting.value = true
+    informationErrors.clearErrors()
     try {
         await api.patch(`/clients/${clientId.value}`, {
             description: information.description || null,
@@ -644,7 +644,7 @@ async function submitInformation(): Promise<void> {
         toast.success({ title: t('commercial.clients.toast.updateSuccess') })
     }
     catch (error) {
-        toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) })
+        informationErrors.handleApiError(error, { fallbackMessage: t('commercial.clients.toast.error') })
     }
     finally {
         tabSubmitting.value = false
@@ -652,18 +652,10 @@ async function submitInformation(): Promise<void> {
 }
 
 // ── Onglet Contact ──────────────────────────────────────────────────────────
+// Au moins un bloc Contact vide au depart : c'est desormais le seul point de
+// saisie des coordonnees (le bloc principal ne porte plus de contact inline).
 const contacts = ref<ContactFormDraft[]>([emptyContact()])
 
-/** Pre-remplit le 1er contact depuis le formulaire principal (apres creation). */
-function prefillFirstContact(): void {
-    const first = contacts.value[0]
-    if (!first) return
-    first.lastName = main.lastName
-    first.firstName = main.firstName
-    first.email = main.email
-    first.phonePrimary = mainPhones.value[0] ?? null
-}
-
 // « + Nouveau contact » desactive tant que le dernier bloc n'a ni nom ni prenom.
 const canAddContact = computed(() => {
     const last = contacts.value[contacts.value.length - 1]
@@ -680,6 +672,7 @@ function addContact(): void {
 function askRemoveContact(index: number): void {
     askConfirm(t('commercial.clients.form.confirmDelete.contact'), () => {
         contacts.value.splice(index, 1)
+        contactErrors.value.splice(index, 1)
     })
 }
 
@@ -688,38 +681,45 @@ async function submitContacts(): Promise<void> {
     if (clientId.value === null || !canValidateContacts.value || tabSubmitting.value) return
     tabSubmitting.value = true
     try {
-        for (const contact of contacts.value) {
-            // On ignore les blocs totalement vides (ni nom ni prenom).
-            if (!isContactNamed(contact)) continue
-
-            const body = {
-                firstName: contact.firstName || null,
-                lastName: contact.lastName || null,
-                jobTitle: contact.jobTitle || null,
-                phonePrimary: contact.phonePrimary || null,
-                phoneSecondary: contact.hasSecondaryPhone ? (contact.phoneSecondary || null) : null,
-                email: contact.email || null,
-            }
-
-            if (contact.id === null) {
-                const created = await api.post<ContactResponse>(
-                    `/clients/${clientId.value}/contacts`,
-                    body,
-                    { headers: { Accept: 'application/ld+json' }, toast: false },
-                )
-                contact.id = created.id
-                contact.iri = created['@id'] ?? null
-            }
-            else {
-                await api.patch(`/client_contacts/${contact.id}`, body, { toast: false })
-            }
-        }
+        // On tente TOUS les blocs (collecte des erreurs par index, ERP-110). Seuls
+        // les blocs TOTALEMENT vides sont ignores : un bloc partiellement rempli
+        // sans nom (email seul) est soumis -> 422 RG-1.05 inline sous le bloc.
+        const hasError = await submitRows(
+            contacts.value,
+            contactErrors,
+            async (contact) => {
+                const body = {
+                    firstName: contact.firstName || null,
+                    lastName: contact.lastName || null,
+                    jobTitle: contact.jobTitle || null,
+                    phonePrimary: contact.phonePrimary || null,
+                    phoneSecondary: contact.hasSecondaryPhone ? (contact.phoneSecondary || null) : null,
+                    email: contact.email || null,
+                }
+                if (contact.id === null) {
+                    const created = await api.post<ContactResponse>(
+                        `/clients/${clientId.value}/contacts`,
+                        body,
+                        { headers: { Accept: 'application/ld+json' }, toast: false },
+                    )
+                    contact.id = created.id
+                    contact.iri = created['@id'] ?? null
+                }
+                else {
+                    await api.patch(`/client_contacts/${contact.id}`, body, { toast: false })
+                }
+            },
+            error => toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) }),
+            // On ne saute QUE les amorces neuves (id null) totalement vides. Un
+            // bloc existant vide est soumis -> 422 RG-1.05 inline (sinon la modif
+            // serait perdue en silence avec un faux toast de succes).
+            contact => contact.id === null && isContactBlank(contact),
+        )
+        // Tant qu'un bloc reste en erreur : pas de validation d'onglet ni de toast succes.
+        if (hasError) return
         completeTab('contact')
         toast.success({ title: t('commercial.clients.toast.updateSuccess') })
     }
-    catch (error) {
-        toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) })
-    }
     finally {
         tabSubmitting.value = false
     }
@@ -750,12 +750,16 @@ const countryOptions: RefOption[] = [
     { value: 'Espagne', label: 'Espagne' },
 ]
 
-// RG-1.10 (>= 1 site) + RG-1.11 (email facturation si Facturation) sur chaque adresse.
+// Type d'adresse (Select) obligatoire + RG-1.10 (>= 1 site) + RG-1.11 (email
+// facturation si Facturation) sur chaque adresse.
 const canValidateAddresses = computed(() =>
     addresses.value.length > 0
     && addresses.value.every((a) => {
         const filledBillingEmail = a.billingEmail !== null && a.billingEmail.trim() !== ''
-        return a.siteIris.length >= 1 && (!isBillingEmailRequired(a) || filledBillingEmail)
+        return addressTypeFromFlags(a) !== null
+            && a.siteIris.length >= 1
+            && a.categoryIris.length >= 1
+            && (!isBillingEmailRequired(a) || filledBillingEmail)
     }),
 )
 
@@ -766,6 +770,7 @@ function addAddress(): void {
 function askRemoveAddress(index: number): void {
     askConfirm(t('commercial.clients.form.confirmDelete.address'), () => {
         addresses.value.splice(index, 1)
+        addressErrors.value.splice(index, 1)
     })
 }
 
@@ -784,40 +789,43 @@ async function submitAddresses(): Promise<void> {
     if (clientId.value === null || !canValidateAddresses.value || tabSubmitting.value) return
     tabSubmitting.value = true
     try {
-        for (const address of addresses.value) {
-            const body = {
-                isProspect: address.isProspect,
-                isDelivery: address.isDelivery,
-                isBilling: address.isBilling,
-                country: address.country,
-                postalCode: address.postalCode || null,
-                city: address.city || null,
-                street: address.street || null,
-                streetComplement: address.streetComplement || null,
-                categories: address.categoryIris,
-                sites: address.siteIris,
-                contacts: address.contactIris,
-                billingEmail: isBillingEmailRequired(address) ? (address.billingEmail || null) : null,
-            }
-
-            if (address.id === null) {
-                const created = await api.post<{ id: number }>(
-                    `/clients/${clientId.value}/addresses`,
-                    body,
-                    { headers: { Accept: 'application/ld+json' }, toast: false },
-                )
-                address.id = created.id
-            }
-            else {
-                await api.patch(`/client_addresses/${address.id}`, body, { toast: false })
-            }
-        }
+        // On tente TOUS les blocs d'adresse (collecte des erreurs par index, ERP-110).
+        const hasError = await submitRows(
+            addresses.value,
+            addressErrors,
+            async (address) => {
+                const body = {
+                    isProspect: address.isProspect,
+                    isDelivery: address.isDelivery,
+                    isBilling: address.isBilling,
+                    country: address.country,
+                    postalCode: address.postalCode || null,
+                    city: address.city || null,
+                    street: address.street || null,
+                    streetComplement: address.streetComplement || null,
+                    categories: address.categoryIris,
+                    sites: address.siteIris,
+                    contacts: address.contactIris,
+                    billingEmail: isBillingEmailRequired(address) ? (address.billingEmail || null) : null,
+                }
+                if (address.id === null) {
+                    const created = await api.post<{ id: number }>(
+                        `/clients/${clientId.value}/addresses`,
+                        body,
+                        { headers: { Accept: 'application/ld+json' }, toast: false },
+                    )
+                    address.id = created.id
+                }
+                else {
+                    await api.patch(`/client_addresses/${address.id}`, body, { toast: false })
+                }
+            },
+            error => toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) }),
+        )
+        if (hasError) return
         completeTab('address')
         toast.success({ title: t('commercial.clients.toast.updateSuccess') })
     }
-    catch (error) {
-        toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) })
-    }
     finally {
         tabSubmitting.value = false
     }
@@ -856,8 +864,11 @@ function ribIsComplete(rib: RibFormDraft): boolean {
     return filled(rib.label) && filled(rib.bic) && filled(rib.iban)
 }
 
+// RG-1.30 : les 6 champs scalaires obligatoires (comme les onglets Contact /
+// Adresse, le bouton reste desactive tant que l'onglet n'est pas complet).
 // RG-1.12 : banque requise si VIREMENT. RG-1.13 : >= 1 RIB complet si LCR.
 const canValidateAccounting = computed(() => {
+    if (!hasAllRequiredAccountingFields(accounting)) return false
     if (isBankRequired.value && (accounting.bankIri === null)) return false
     if (isRibRequired.value && !ribs.value.some(ribIsComplete)) return false
     return true
@@ -870,6 +881,9 @@ function addRib(): void {
 function askRemoveRib(index: number): void {
     askConfirm(t('commercial.clients.form.confirmDelete.rib'), () => {
         ribs.value.splice(index, 1)
+        ribErrors.value.splice(index, 1)
+        // Garde au moins un bloc RIB visible (cf. amorce au montage).
+        if (ribs.value.length === 0) ribs.value.push(emptyRib())
     })
 }
 
@@ -881,38 +895,60 @@ function askRemoveRib(index: number): void {
 async function submitAccounting(): Promise<void> {
     if (clientId.value === null || !canValidateAccounting.value || tabSubmitting.value) return
     tabSubmitting.value = true
+    accountingErrors.clearErrors()
+    // Reset des erreurs RIB des le debut : l'etape 1 (PATCH scalaires) peut
+    // echouer et `return` avant submitRows (qui porte sinon le reset), laissant
+    // des erreurs de RIB obsoletes affichees sous les blocs.
+    ribErrors.value = []
     try {
-        await api.patch(`/clients/${clientId.value}`, {
-            siren: accounting.siren || null,
-            accountNumber: accounting.accountNumber || null,
-            tvaMode: accounting.tvaModeIri,
-            nTva: accounting.nTva || null,
-            paymentDelay: accounting.paymentDelayIri,
-            paymentType: accounting.paymentTypeIri,
-            bank: isBankRequired.value ? accounting.bankIri : null,
-        }, { toast: false })
-
-        for (const rib of ribs.value) {
-            if (!ribIsComplete(rib)) continue
-            if (rib.id === null) {
-                const created = await api.post<{ id: number }>(
-                    `/clients/${clientId.value}/ribs`,
-                    { label: rib.label, bic: rib.bic, iban: rib.iban },
-                    { headers: { Accept: 'application/ld+json' }, toast: false },
-                )
-                rib.id = created.id
-            }
-            else {
-                await api.patch(`/client_ribs/${rib.id}`, { label: rib.label, bic: rib.bic, iban: rib.iban }, { toast: false })
-            }
+        // 1) PATCH des scalaires comptables (erreurs inline sur leurs champs).
+        try {
+            await api.patch(`/clients/${clientId.value}`, {
+                siren: accounting.siren || null,
+                accountNumber: accounting.accountNumber || null,
+                tvaMode: accounting.tvaModeIri,
+                nTva: accounting.nTva || null,
+                paymentDelay: accounting.paymentDelayIri,
+                paymentType: accounting.paymentTypeIri,
+                bank: isBankRequired.value ? accounting.bankIri : null,
+            }, { toast: false })
         }
+        catch (error) {
+            accountingErrors.handleApiError(error, { fallbackMessage: t('commercial.clients.toast.error') })
+            return
+        }
+
+        // 2) POST/PATCH des RIB (erreurs inline par ligne, tous les blocs tentes).
+        // Seuls les blocs RIB TOTALEMENT vides sont ignores : un RIB partiel (ex.
+        // IBAN seul) est soumis -> 422 NotBlank (label / bic / iban) inline.
+        const ribHasError = await submitRows(
+            ribs.value,
+            ribErrors,
+            async (rib) => {
+                const body = { label: rib.label, bic: rib.bic, iban: rib.iban }
+                if (rib.id === null) {
+                    const created = await api.post<{ id: number }>(
+                        `/clients/${clientId.value}/ribs`,
+                        body,
+                        { headers: { Accept: 'application/ld+json' }, toast: false },
+                    )
+                    rib.id = created.id
+                }
+                else {
+                    await api.patch(`/client_ribs/${rib.id}`, body, { toast: false })
+                }
+            },
+            error => toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) }),
+            // On ne saute QUE les amorces neuves (id null) totalement vides. Un
+            // RIB existant vide est soumis -> 422 NotBlank inline (sinon la modif
+            // serait perdue en silence avec un faux toast de succes).
+            rib => rib.id === null && isRibBlank(rib),
+        )
+        if (ribHasError) return
 
         completeTab('accounting')
         toast.success({ title: t('commercial.clients.toast.updateSuccess') })
     }
-    catch (error) {
-        toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) })
-    }
     finally {
         tabSubmitting.value = false
     }
@@ -941,11 +977,6 @@ function runConfirm(): void {
 interface ClientResponse {
     id: number
     companyName: string | null
-    firstName: string | null
-    lastName: string | null
-    email: string | null
-    phonePrimary: string | null
-    phoneSecondary: string | null
 }
 
 interface ContactResponse {
@@ -956,5 +987,8 @@ interface ContactResponse {
 onMounted(() => {
     // Echec du chargement des referentiels non bloquant : les selects restent vides.
     referentials.loadCommon().catch(() => {})
+    // Au moins un bloc RIB toujours visible en creation : on amorce un bloc vide
+    // (non persiste tant qu'incomplet — RG-1.13).
+    if (ribs.value.length === 0) ribs.value.push(emptyRib())
 })
 </script>

frontend/modules/commercial/utils/__tests__/clientEdit.spec.ts

@@ -22,12 +22,6 @@ import type { AddressFormDraft, ContactFormDraft, RibFormDraft } from '~/modules
 function mainDraft(overrides: Partial<MainFormDraft> = {}): MainFormDraft {
     return {
         companyName: 'ACME',
-        firstName: 'Jean',
-        lastName: 'Dupont',
-        email: 'jean@acme.fr',
-        phonePrimary: '05 49 11 22 33',
-        phoneSecondary: null,
-        hasSecondaryPhone: false,
         categoryIris: ['/api/categories/1'],
         relationType: null,
         distributorIri: null,
@@ -64,9 +58,10 @@ function accountingDraft(overrides: Partial<AccountingFormDraft> = {}): Accounti
 }
 
 // Champs de chaque groupe de serialisation (miroir back ClientProcessor).
+// Le contact inline (nom/prenom/telephones/email) ne fait plus partie du groupe
+// main : les coordonnees vivent desormais sur la sous-ressource ClientContact.
 const MAIN_KEYS = [
-    'companyName', 'firstName', 'lastName', 'email', 'phonePrimary',
-    'phoneSecondary', 'categories', 'distributor', 'broker', 'triageService',
+    'companyName', 'categories', 'distributor', 'broker', 'triageService',
 ]
 const INFORMATION_KEYS = [
     'description', 'competitors', 'foundedAt', 'employeesCount',
@@ -104,11 +99,6 @@ describe('buildMainPayload — scoping strict groupe client:write:main', () => {
         expect(payload.distributor).toBeNull()
         expect(payload.broker).toBeNull()
     })
-
-    it('telephone secondaire non revele : envoie null meme si une valeur traine', () => {
-        const payload = buildMainPayload(mainDraft({ hasSecondaryPhone: false, phoneSecondary: '06 00 00 00 00' }))
-        expect(payload.phoneSecondary).toBeNull()
-    })
 })
 
 describe('buildInformationPayload — scoping strict groupe client:write:information', () => {
@@ -168,19 +158,16 @@ describe('buildContactPayload / buildAddressPayload / buildRibPayload', () => {
 })
 
 describe('mapMainDraft — pre-remplissage bloc principal', () => {
-    it('formate les telephones, resout la relation et extrait les IRI', () => {
+    it('resout la relation et extrait les IRI (sans contact inline)', () => {
         const client = {
             '@id': '/api/clients/1', id: 1,
-            companyName: 'ACME', firstName: 'Jean', lastName: 'Dupont', email: 'jean@acme.fr',
-            phonePrimary: '0549112233', phoneSecondary: '0600000000', triageService: true,
+            companyName: 'ACME', triageService: true,
             categories: [{ '@id': '/api/categories/1', code: 'SECTEUR' }],
             distributor: { '@id': '/api/clients/9', companyName: 'DISTRIB' },
         } as ClientDetail
 
         const draft = mapMainDraft(client)
-        expect(draft.phonePrimary).toBe('05 49 11 22 33')
-        expect(draft.phoneSecondary).toBe('06 00 00 00 00')
-        expect(draft.hasSecondaryPhone).toBe(true)
+        expect(draft.companyName).toBe('ACME')
         expect(draft.categoryIris).toEqual(['/api/categories/1'])
         expect(draft.relationType).toBe('distributeur')
         expect(draft.distributorIri).toBe('/api/clients/9')
@@ -191,7 +178,6 @@ describe('mapMainDraft — pre-remplissage bloc principal', () => {
     it('gere les cles omises (skip_null_values) sans planter', () => {
         const draft = mapMainDraft({ '@id': '/api/clients/2', id: 2 } as ClientDetail)
         expect(draft.companyName).toBeNull()
-        expect(draft.hasSecondaryPhone).toBe(false)
         expect(draft.categoryIris).toEqual([])
         expect(draft.relationType).toBeNull()
         expect(draft.triageService).toBe(false)

frontend/modules/commercial/utils/__tests__/clientFormRules.spec.ts

@@ -1,17 +1,36 @@
 import { describe, it, expect } from 'vitest'
 import {
+    addressFlagsFromType,
+    addressTypeFromFlags,
     applyProspectExclusivity,
     buildClientFormTabKeys,
     canSelectDeliveryOrBilling,
     canSelectProspect,
+    hasAllRequiredAccountingFields,
     hasAtLeastOneValidContact,
     isBankRequiredForPaymentType,
     isBillingEmailRequired,
+    isBlankRow,
+    isContactBlank,
     isContactNamed,
+    isRibBlank,
     isRibRequiredForPaymentType,
     type ContactDraft,
+    type ContactFillableDraft,
 } from '../clientFormRules'
 
+/** Bloc contact totalement vide (amorce par defaut). */
+function blankContact(): ContactFillableDraft {
+    return {
+        firstName: null,
+        lastName: null,
+        jobTitle: null,
+        phonePrimary: null,
+        phoneSecondary: null,
+        email: null,
+    }
+}
+
 describe('buildClientFormTabKeys (gating onglet Comptabilite + onglets edit-only)', () => {
     it('inclut l onglet accounting si l utilisateur a accounting.view', () => {
         expect(buildClientFormTabKeys(true)).toContain('accounting')
@@ -59,6 +78,49 @@ describe('isContactNamed (RG-1.05)', () => {
     })
 })
 
+describe('isBlankRow (primitive : toutes les valeurs vides)', () => {
+    it('vrai si toutes les valeurs sont nulles / vides / espaces', () => {
+        expect(isBlankRow([null, undefined, '', '  '])).toBe(true)
+        expect(isBlankRow([])).toBe(true)
+    })
+
+    it('faux des qu une valeur porte un caractere non-espace', () => {
+        expect(isBlankRow([null, 'x', ''])).toBe(false)
+    })
+})
+
+describe('isRibBlank (bloc RIB totalement vide vs partiellement rempli)', () => {
+    it('vrai si label / bic / iban sont tous vides', () => {
+        expect(isRibBlank({ label: null, bic: null, iban: null })).toBe(true)
+        expect(isRibBlank({ label: '  ', bic: '', iban: null })).toBe(true)
+    })
+
+    it('faux si un IBAN seul est saisi (bloc a soumettre -> 422 NotBlank inline)', () => {
+        expect(isRibBlank({ label: null, bic: null, iban: 'FR1420041010050500013M02606' })).toBe(false)
+    })
+
+    it('faux si seul le libelle est saisi', () => {
+        expect(isRibBlank({ label: 'Compte courant', bic: null, iban: null })).toBe(false)
+    })
+})
+
+describe('isContactBlank (bloc totalement vide vs partiellement rempli)', () => {
+    it('vrai si aucun champ saisissable n est rempli', () => {
+        expect(isContactBlank(blankContact())).toBe(true)
+        expect(isContactBlank({ ...blankContact(), firstName: '  ', email: '' })).toBe(true)
+    })
+
+    it('faux si un email seul est saisi (bloc a soumettre -> 422 RG-1.05 inline)', () => {
+        expect(isContactBlank({ ...blankContact(), email: 'jean@acme.fr' })).toBe(false)
+    })
+
+    it('faux si seul un telephone, une fonction ou un nom est saisi', () => {
+        expect(isContactBlank({ ...blankContact(), phonePrimary: '0612345678' })).toBe(false)
+        expect(isContactBlank({ ...blankContact(), jobTitle: 'Directeur' })).toBe(false)
+        expect(isContactBlank({ ...blankContact(), firstName: 'Alice' })).toBe(false)
+    })
+})
+
 describe('hasAtLeastOneValidContact (RG-1.14)', () => {
     it('faux sur une liste vide', () => {
         expect(hasAtLeastOneValidContact([])).toBe(false)
@@ -137,6 +199,32 @@ describe('isBillingEmailRequired (RG-1.11)', () => {
     })
 })
 
+describe('type d\'adresse (Select front) <-> drapeaux back', () => {
+    it('addressFlagsFromType mappe chaque type vers les bons drapeaux', () => {
+        expect(addressFlagsFromType('prospect')).toEqual({ isProspect: true, isDelivery: false, isBilling: false })
+        expect(addressFlagsFromType('delivery')).toEqual({ isProspect: false, isDelivery: true, isBilling: false })
+        expect(addressFlagsFromType('billing')).toEqual({ isProspect: false, isDelivery: false, isBilling: true })
+        expect(addressFlagsFromType('delivery_billing')).toEqual({ isProspect: false, isDelivery: true, isBilling: true })
+    })
+
+    it('addressTypeFromFlags reconstruit le type (Prospect prioritaire, livraison+facturation groupes)', () => {
+        expect(addressTypeFromFlags({ isProspect: true, isDelivery: false, isBilling: false })).toBe('prospect')
+        expect(addressTypeFromFlags({ isProspect: false, isDelivery: true, isBilling: false })).toBe('delivery')
+        expect(addressTypeFromFlags({ isProspect: false, isDelivery: false, isBilling: true })).toBe('billing')
+        expect(addressTypeFromFlags({ isProspect: false, isDelivery: true, isBilling: true })).toBe('delivery_billing')
+    })
+
+    it('addressTypeFromFlags retourne null quand aucun drapeau (amorce vierge -> bouton bloque)', () => {
+        expect(addressTypeFromFlags({ isProspect: false, isDelivery: false, isBilling: false })).toBeNull()
+    })
+
+    it('aller-retour type -> drapeaux -> type stable pour les 4 types', () => {
+        for (const type of ['prospect', 'delivery', 'billing', 'delivery_billing'] as const) {
+            expect(addressTypeFromFlags(addressFlagsFromType(type))).toBe(type)
+        }
+    })
+})
+
 describe('regles type de reglement (RG-1.12 / RG-1.13)', () => {
     it('banque obligatoire si VIREMENT', () => {
         expect(isBankRequiredForPaymentType('VIREMENT')).toBe(true)
@@ -150,3 +238,36 @@ describe('regles type de reglement (RG-1.12 / RG-1.13)', () => {
         expect(isRibRequiredForPaymentType(null)).toBe(false)
     })
 })
+
+describe('hasAllRequiredAccountingFields (RG-1.30)', () => {
+    const complete = {
+        siren: '123456789',
+        accountNumber: '00012345678',
+        nTva: 'FR12345678901',
+        tvaModeIri: '/api/tva_modes/1',
+        paymentDelayIri: '/api/payment_delays/1',
+        paymentTypeIri: '/api/payment_types/1',
+    }
+
+    it('vrai quand les six champs obligatoires sont remplis', () => {
+        expect(hasAllRequiredAccountingFields(complete)).toBe(true)
+    })
+
+    it('faux si un champ est manquant (null ou vide apres trim)', () => {
+        expect(hasAllRequiredAccountingFields({ ...complete, siren: null })).toBe(false)
+        expect(hasAllRequiredAccountingFields({ ...complete, accountNumber: '   ' })).toBe(false)
+        expect(hasAllRequiredAccountingFields({ ...complete, tvaModeIri: null })).toBe(false)
+        expect(hasAllRequiredAccountingFields({ ...complete, paymentTypeIri: null })).toBe(false)
+    })
+
+    it('faux quand tout est vide (onglet non rempli)', () => {
+        expect(hasAllRequiredAccountingFields({
+            siren: null,
+            accountNumber: null,
+            nTva: null,
+            tvaModeIri: null,
+            paymentDelayIri: null,
+            paymentTypeIri: null,
+        })).toBe(false)
+    })
+})

frontend/modules/commercial/utils/clientConsultation.ts

@@ -93,11 +93,6 @@ export interface RelatedClientRead extends HydraRef {
 export interface ClientDetail extends HydraRef {
     id: number
     companyName?: string | null
-    firstName?: string | null
-    lastName?: string | null
-    phonePrimary?: string | null
-    phoneSecondary?: string | null
-    email?: string | null
     triageService?: boolean
     isArchived?: boolean
     categories?: CategoryRead[]

frontend/modules/commercial/utils/clientEdit.ts

@@ -24,23 +24,16 @@ import {
     type ClientDetail,
 } from '~/modules/commercial/utils/clientConsultation'
 import type { AddressFormDraft, ContactFormDraft, RibFormDraft } from '~/modules/commercial/types/clientForm'
-import { formatPhoneFR } from '~/shared/utils/phone'
 
 /**
  * Etat « plat » du bloc principal (groupe client:write:main). Distinct des
  * brouillons Contact : ces champs vivent sur le Client lui-meme (companyName,
- * contact principal, telephones, email, categories, relation, triage), pas sur
- * une sous-ressource ClientContact.
+ * categories, relation, triage), pas sur une sous-ressource ClientContact. Les
+ * coordonnees de contact (nom, prenom, telephones, email) ne sont plus portees
+ * par le Client : elles vivent exclusivement dans l'onglet Contacts.
  */
 export interface MainFormDraft {
     companyName: string | null
-    firstName: string | null
-    lastName: string | null
-    email: string | null
-    phonePrimary: string | null
-    phoneSecondary: string | null
-    /** UI : le 2e numero a ete revele (ou existait deja au chargement). */
-    hasSecondaryPhone: boolean
     /** IRI des categories rattachees (M2M). */
     categoryIris: string[]
     relationType: 'distributeur' | 'courtier' | null
@@ -96,22 +89,15 @@ export interface TabEditability {
 // ── Pre-remplissage (GET detail -> brouillons) ──────────────────────────────
 
 /**
- * Mappe le detail client vers le brouillon du bloc principal. Les telephones
- * sont reformates XX XX XX XX XX (RG d'affichage). La relation Distributeur/
- * Courtier est resolue par exclusivite (RG-1.03) et son IRI extrait de l'embed.
+ * Mappe le detail client vers le brouillon du bloc principal. La relation
+ * Distributeur/Courtier est resolue par exclusivite (RG-1.03) et son IRI extrait
+ * de l'embed.
  */
 export function mapMainDraft(client: ClientDetail): MainFormDraft {
     const relation = relationOf(client)
-    const phoneSecondary = client.phoneSecondary ?? null
 
     return {
         companyName: client.companyName ?? null,
-        firstName: client.firstName ?? null,
-        lastName: client.lastName ?? null,
-        email: client.email ?? null,
-        phonePrimary: client.phonePrimary ? formatPhoneFR(client.phonePrimary) : null,
-        phoneSecondary: phoneSecondary ? formatPhoneFR(phoneSecondary) : null,
-        hasSecondaryPhone: phoneSecondary !== null && phoneSecondary !== '',
         categoryIris: (client.categories ?? []).map(c => c['@id']),
         relationType: relation.type,
         distributorIri: iriOf(client.distributor),
@@ -157,11 +143,6 @@ export function mapAccountingFormDraft(client: ClientDetail): AccountingFormDraf
 export function buildMainPayload(main: MainFormDraft): Record<string, unknown> {
     return {
         companyName: main.companyName,
-        firstName: main.firstName || null,
-        lastName: main.lastName || null,
-        email: main.email,
-        phonePrimary: main.phonePrimary || null,
-        phoneSecondary: main.hasSecondaryPhone ? (main.phoneSecondary || null) : null,
         categories: main.categoryIris,
         distributor: main.relationType === 'distributeur' ? main.distributorIri : null,
         broker: main.relationType === 'courtier' ? main.brokerIri : null,

frontend/modules/commercial/utils/clientFormRules.ts

@@ -86,6 +86,58 @@ export function hasAtLeastOneValidContact(contacts: ContactDraft[]): boolean {
     return contacts.some(isContactNamed)
 }
 
+/**
+ * Primitive reutilisable : vrai si TOUTES les valeurs fournies sont vides (null /
+ * undefined / espaces uniquement). Sert a detecter un bloc de collection
+ * totalement vide (amorce non remplie). Un bloc qui porte la moindre donnee
+ * n'est PAS « blank » : il doit etre soumis pour declencher sa 422 inline plutot
+ * que d'etre saute silencieusement.
+ */
+export function isBlankRow(values: (string | null | undefined)[]): boolean {
+    return values.every(value => !isFilled(value))
+}
+
+/** Champs saisissables d'un bloc contact (pour detecter un bloc totalement vide). */
+export interface ContactFillableDraft extends ContactDraft {
+    jobTitle: string | null
+    phonePrimary: string | null
+    phoneSecondary: string | null
+    email: string | null
+}
+
+/**
+ * Vrai si AUCUN champ saisissable du bloc contact n'est rempli. Distingue un bloc
+ * d'amorce vide (a ignorer au submit) d'un bloc partiellement rempli sans nom
+ * (email / telephone / fonction seul) : ce dernier doit etre soumis pour
+ * declencher la 422 RG-1.05 (« prenom ou nom obligatoire ») affichee inline.
+ */
+export function isContactBlank(contact: ContactFillableDraft): boolean {
+    return isBlankRow([
+        contact.firstName,
+        contact.lastName,
+        contact.jobTitle,
+        contact.phonePrimary,
+        contact.phoneSecondary,
+        contact.email,
+    ])
+}
+
+/** Champs saisissables d'un bloc RIB (pour detecter un bloc totalement vide). */
+export interface RibFillableDraft {
+    label: string | null
+    bic: string | null
+    iban: string | null
+}
+
+/**
+ * Vrai si AUCUN champ du bloc RIB n'est rempli. Un RIB partiellement rempli (ex.
+ * IBAN seul) n'est PAS « blank » : il doit etre soumis pour declencher les 422
+ * NotBlank (label / bic / iban) inline plutot que d'etre saute silencieusement.
+ */
+export function isRibBlank(rib: RibFillableDraft): boolean {
+    return isBlankRow([rib.label, rib.bic, rib.iban])
+}
+
 /**
  * RG-1.06/07/08 : une adresse de prospection est exclusive d'une adresse de
  * livraison/facturation. Prospect n'est selectionnable que si ni Livraison ni
@@ -135,6 +187,45 @@ export function isBillingEmailRequired(flags: AddressFlagsDraft): boolean {
     return flags.isBilling
 }
 
+/**
+ * Type d'adresse expose a l'utilisateur (Select unique remplacant les trois
+ * cases a cocher). Sucre purement front : le back continue de recevoir les
+ * drapeaux isProspect / isDelivery / isBilling (aucune RG modifiee). Les seules
+ * combinaisons proposees respectent l'exclusivite Prospect (RG-1.06/07/08).
+ */
+export type AddressType = 'prospect' | 'delivery' | 'billing' | 'delivery_billing'
+
+/**
+ * Mappe le type d'adresse choisi vers les trois drapeaux back.
+ * « Adresse + Facturation » = livraison ET facturation sur la meme adresse.
+ */
+export function addressFlagsFromType(type: AddressType): AddressFlagsDraft {
+    switch (type) {
+        case 'prospect':
+            return { isProspect: true, isDelivery: false, isBilling: false }
+        case 'delivery':
+            return { isProspect: false, isDelivery: true, isBilling: false }
+        case 'billing':
+            return { isProspect: false, isDelivery: false, isBilling: true }
+        case 'delivery_billing':
+            return { isProspect: false, isDelivery: true, isBilling: true }
+    }
+}
+
+/**
+ * Reconstruit le type d'adresse a partir des drapeaux (consultation / edition
+ * d'une adresse persistee, ou amorce vierge). Retourne null si aucun drapeau
+ * n'est positionne — le Select reste alors a saisir (et bloque la validation).
+ */
+export function addressTypeFromFlags(flags: AddressFlagsDraft): AddressType | null {
+    if (flags.isProspect) return 'prospect'
+    if (flags.isDelivery && flags.isBilling) return 'delivery_billing'
+    if (flags.isDelivery) return 'delivery'
+    if (flags.isBilling) return 'billing'
+
+    return null
+}
+
 /** Code stable du type de reglement « virement » (cf. PaymentType.code, RG-1.12). */
 const PAYMENT_TYPE_TRANSFER = 'VIREMENT'
 
@@ -156,3 +247,32 @@ export function isBankRequiredForPaymentType(code: string | null | undefined): b
 export function isRibRequiredForPaymentType(code: string | null | undefined): boolean {
     return code === PAYMENT_TYPE_LCR
 }
+
+/** Sous-ensemble du brouillon comptable portant les six champs obligatoires. */
+export interface AccountingRequiredDraft {
+    siren: string | null
+    accountNumber: string | null
+    nTva: string | null
+    tvaModeIri: string | null
+    paymentDelayIri: string | null
+    paymentTypeIri: string | null
+}
+
+/**
+ * RG-1.30 : les six champs scalaires de l'onglet Comptabilite sont obligatoires
+ * pour valider l'onglet (SIREN, N de compte, Mode de TVA, N de TVA, Delai de
+ * reglement, Type de reglement). bank / RIB restent conditionnels (RG-1.12 /
+ * RG-1.13) et sont evalues a part. Miroir front du
+ * ClientAccountingCompletenessValidator : meme gate que les onglets Contact /
+ * Adresse (bouton « Valider » desactive tant que l'onglet n'est pas complet).
+ */
+export function hasAllRequiredAccountingFields(accounting: AccountingRequiredDraft): boolean {
+    const filled = (v: string | null): boolean => v !== null && v.trim() !== ''
+
+    return filled(accounting.siren)
+        && filled(accounting.accountNumber)
+        && filled(accounting.nTva)
+        && filled(accounting.tvaModeIri)
+        && filled(accounting.paymentDelayIri)
+        && filled(accounting.paymentTypeIri)
+}

frontend/package-lock.json

@@ -7,7 +7,7 @@
       "name": "starseed-frontend",
       "hasInstallScript": true,
       "dependencies": {
-        "@malio/layer-ui": "^1.7.3",
+        "@malio/layer-ui": "^1.7.4",
         "@nuxt/icon": "^2.2.1",
         "@nuxtjs/i18n": "^10.2.3",
         "@nuxtjs/tailwindcss": "^6.14.0",
@@ -1866,9 +1866,9 @@
       "license": "MIT"
     },
     "node_modules/@malio/layer-ui": {
-      "version": "1.7.3",
-      "resolved": "https://gitea.malio.fr/api/packages/MALIO-DEV/npm/%40malio%2Flayer-ui/-/1.7.3/layer-ui-1.7.3.tgz",
-      "integrity": "sha512-jw3ka0Az6Jf0F9ifsooknkwXph8TNgoe6H3CjF8tbBxl8oND8HLHjlZ04ooUCoOUEIlsQ1Mm2hFFlQRCB04qdA==",
+      "version": "1.7.4",
+      "resolved": "https://gitea.malio.fr/api/packages/MALIO-DEV/npm/%40malio%2Flayer-ui/-/1.7.4/layer-ui-1.7.4.tgz",
+      "integrity": "sha512-JNXwBelj5UQ35Qv5VmnassXKt8niX9jDXjM1vUSukJQiyeUXRxAiZr16QumVgBN9P9YGDyjXVKrwCHltTXvPtQ==",
       "dependencies": {
         "@nuxt/icon": "^2.2.1",
         "@nuxtjs/tailwindcss": "^6.14.0",

frontend/package.json

@@ -17,7 +17,7 @@
     "test:e2e:ui": "playwright test --ui"
   },
   "dependencies": {
-    "@malio/layer-ui": "^1.7.3",
+    "@malio/layer-ui": "^1.7.4",
     "@nuxt/icon": "^2.2.1",
     "@nuxtjs/i18n": "^10.2.3",
     "@nuxtjs/tailwindcss": "^6.14.0",

frontend/shared/components/ui/ComingSoonPlaceholder.vue

@@ -0,0 +1,51 @@
+<template>
+    <!--
+        Placeholder generique « En cours de dev » pour les ecrans / onglets non
+        encore implementes. Composant PARTAGE (shared/components) : auto-importe
+        sans prefixe (`<ComingSoonPlaceholder>`) et reutilisable depuis n'importe
+        quel module. Affiche un gif (asset local par defaut) + un message i18n.
+    -->
+    <div class="flex min-h-[240px] flex-col items-center justify-center gap-4 rounded-md bg-white py-10">
+        <img
+            v-if="!imageFailed"
+            :src="src"
+            :alt="resolvedTitle"
+            class="max-h-[220px] w-auto rounded-md"
+            @error="imageFailed = true"
+        >
+        <!-- Repli si le gif ne charge pas (offline, CSP, asset absent) :
+             illustration emoji, le message reste affiche. -->
+        <div v-else class="text-5xl" aria-hidden="true">🚧 👨‍💻 🚧</div>
+
+        <div class="text-center">
+            <p class="text-xl font-bold text-black">{{ resolvedTitle }}</p>
+            <p class="mt-1 text-black/60">{{ resolvedSubtitle }}</p>
+        </div>
+    </div>
+</template>
+
+<script setup lang="ts">
+const props = withDefaults(
+    defineProps<{
+        /** Source de l'image/gif affichee. Defaut : asset local `/coming-soon.gif`. */
+        src?: string
+        /** Titre. Defaut : i18n `common.comingSoon.title`. */
+        title?: string
+        /** Sous-titre. Defaut : i18n `common.comingSoon.subtitle`. */
+        subtitle?: string
+    }>(),
+    {
+        src: '/coming-soon.gif',
+        title: '',
+        subtitle: '',
+    },
+)
+
+const { t } = useI18n()
+const imageFailed = ref(false)
+
+// Les props priment sur les libelles i18n par defaut (permet a un module
+// d'override le texte sans toucher au composant).
+const resolvedTitle = computed(() => props.title || t('common.comingSoon.title'))
+const resolvedSubtitle = computed(() => props.subtitle || t('common.comingSoon.subtitle'))
+</script>

frontend/shared/composables/__tests__/useAddressAutocomplete.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import {
+    useAddressAutocomplete,
+    AddressAutocompleteUnavailableError,
+} from '../useAddressAutocomplete'
+
+// On mocke le helper d'appel externe : aucun vrai appel reseau a la BAN.
+// vi.mock est hoiste par Vitest au-dessus des imports.
+const mockHttp = vi.hoisted(() => vi.fn())
+vi.mock('~/shared/utils/httpExternal', () => ({ httpExternal: mockHttp }))
+
+const BAN_URL = 'https://api-adresse.data.gouv.fr/search/'
+
+describe('useAddressAutocomplete', () => {
+    beforeEach(() => {
+        mockHttp.mockReset()
+    })
+
+    describe('searchCity', () => {
+        it('interroge la BAN en type=municipality et mappe { city, postalCode }', async () => {
+            mockHttp.mockResolvedValueOnce({
+                type: 'FeatureCollection',
+                features: [
+                    { properties: { city: 'Amiens', postcode: '80000', name: 'Amiens', type: 'municipality' } },
+                    { properties: { city: 'Amiens', postcode: '80080', name: 'Amiens', type: 'municipality' } },
+                ],
+            })
+
+            const { searchCity } = useAddressAutocomplete()
+            const res = await searchCity('80000')
+
+            expect(mockHttp).toHaveBeenCalledWith(
+                BAN_URL,
+                expect.objectContaining({ query: { q: '80000', type: 'municipality' } }),
+            )
+            expect(res).toEqual([
+                { city: 'Amiens', postalCode: '80000' },
+                { city: 'Amiens', postalCode: '80080' },
+            ])
+        })
+
+        it('throw une AddressAutocompleteUnavailableError sur erreur reseau / 5xx', async () => {
+            mockHttp.mockRejectedValueOnce(new Error('500 Server Error'))
+
+            const { searchCity } = useAddressAutocomplete()
+
+            await expect(searchCity('80000')).rejects.toBeInstanceOf(AddressAutocompleteUnavailableError)
+        })
+
+        it('throw une AddressAutocompleteUnavailableError sur timeout', async () => {
+            mockHttp.mockRejectedValueOnce(new Error('The operation was aborted due to timeout'))
+
+            const { searchCity } = useAddressAutocomplete()
+
+            await expect(searchCity('80000')).rejects.toBeInstanceOf(AddressAutocompleteUnavailableError)
+        })
+    })
+
+    describe('searchAddress', () => {
+        it('interroge la BAN avec postcode et mappe la suggestion', async () => {
+            mockHttp.mockResolvedValueOnce({
+                type: 'FeatureCollection',
+                features: [
+                    {
+                        properties: {
+                            label: '8 Boulevard du Port 80000 Amiens',
+                            name: '8 Boulevard du Port',
+                            street: 'Boulevard du Port',
+                            postcode: '80000',
+                            city: 'Amiens',
+                            type: 'housenumber',
+                        },
+                    },
+                ],
+            })
+
+            const { searchAddress } = useAddressAutocomplete()
+            const res = await searchAddress('8 boulevard du port', '80000')
+
+            expect(mockHttp).toHaveBeenCalledWith(
+                BAN_URL,
+                expect.objectContaining({
+                    query: { q: '8 boulevard du port', postcode: '80000' },
+                }),
+            )
+            expect(res).toEqual([
+                {
+                    label: '8 Boulevard du Port 80000 Amiens',
+                    street: '8 Boulevard du Port',
+                    postalCode: '80000',
+                    city: 'Amiens',
+                },
+            ])
+        })
+
+        it('omet le parametre postcode quand aucun code postal n\'est fourni', async () => {
+            mockHttp.mockResolvedValueOnce({ type: 'FeatureCollection', features: [] })
+
+            const { searchAddress } = useAddressAutocomplete()
+            await searchAddress('8 boulevard du port')
+
+            expect(mockHttp).toHaveBeenCalledWith(
+                BAN_URL,
+                expect.objectContaining({
+                    query: { q: '8 boulevard du port' },
+                }),
+            )
+        })
+
+        it('ne restreint PAS la recherche a type=housenumber (sinon la BAN ne renvoie rien tant qu\'aucun numero n\'est saisi)', async () => {
+            // Regression : avec `type=housenumber`, une saisie de nom de rue sans
+            // numero (ex: « boulevard du port ») renvoie 0 resultat cote BAN.
+            mockHttp.mockResolvedValueOnce({ type: 'FeatureCollection', features: [] })
+
+            const { searchAddress } = useAddressAutocomplete()
+            await searchAddress('boulevard du port', '80000')
+
+            const sentQuery = mockHttp.mock.calls[0]?.[1]?.query as Record<string, string>
+            expect(sentQuery.type).toBeUndefined()
+        })
+
+        it('throw une AddressAutocompleteUnavailableError sur erreur reseau', async () => {
+            mockHttp.mockRejectedValueOnce(new Error('network down'))
+
+            const { searchAddress } = useAddressAutocomplete()
+
+            await expect(searchAddress('8 boulevard du port', '80000')).rejects.toBeInstanceOf(
+                AddressAutocompleteUnavailableError,
+            )
+        })
+    })
+})

frontend/shared/composables/__tests__/useFormErrors.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { useFormErrors } from '../useFormErrors'
+
+const mockToastError = vi.hoisted(() => vi.fn())
+vi.stubGlobal('useToast', () => ({ error: mockToastError, success: vi.fn() }))
+// useI18n stub : renvoie la cle telle quelle (pour asserter dessus).
+vi.stubGlobal('useI18n', () => ({ t: (key: string) => key }))
+
+/**
+ * Tests du composable `useFormErrors` — pendant front de la regle « le back
+ * renvoie toutes les violations 422 d'un coup » (ERP-101). Centralise l'etat
+ * d'erreurs par champ (`Record<propertyPath, message>`) et la dispatch d'une
+ * erreur API : 422 mappee inline, sinon toast de fallback.
+ */
+describe('useFormErrors', () => {
+    beforeEach(() => {
+        mockToastError.mockReset()
+    })
+
+    /** Fabrique une erreur ofetch avec status + payload. */
+    function fetchError(status: number, data: unknown) {
+        return { response: { status, _data: data } }
+    }
+
+    it('demarre sans erreur', () => {
+        const { errors, hasErrors } = useFormErrors()
+        expect(errors).toEqual({})
+        expect(hasErrors.value).toBe(false)
+    })
+
+    it('setServerErrors mappe les violations par champ et retourne true', () => {
+        const { errors, hasErrors, setServerErrors } = useFormErrors()
+        const mapped = setServerErrors({
+            violations: [
+                { propertyPath: 'companyName', message: 'Obligatoire.' },
+                { propertyPath: 'siren', message: 'Deja utilise.' },
+            ],
+        })
+        expect(mapped).toBe(true)
+        expect(errors).toEqual({ companyName: 'Obligatoire.', siren: 'Deja utilise.' })
+        expect(hasErrors.value).toBe(true)
+    })
+
+    it('setServerErrors retourne false et ne touche rien sans violation', () => {
+        const { errors, setServerErrors } = useFormErrors()
+        expect(setServerErrors({})).toBe(false)
+        expect(errors).toEqual({})
+    })
+
+    it('setError / clearError / clearErrors manipulent l\'etat finement', () => {
+        const { errors, setError, clearError, clearErrors } = useFormErrors()
+        setError('iban', 'IBAN invalide.')
+        expect(errors.iban).toBe('IBAN invalide.')
+        clearError('iban')
+        expect(errors.iban).toBeUndefined()
+        setError('a', 'x')
+        setError('b', 'y')
+        clearErrors()
+        expect(errors).toEqual({})
+    })
+
+    it('handleApiError : 422 avec violations → mappe inline, pas de toast, retourne true', () => {
+        const { errors, handleApiError } = useFormErrors()
+        const handled = handleApiError(
+            fetchError(422, { violations: [{ propertyPath: 'email', message: 'Invalide.' }] }),
+        )
+        expect(handled).toBe(true)
+        expect(errors.email).toBe('Invalide.')
+        expect(mockToastError).not.toHaveBeenCalled()
+    })
+
+    it('handleApiError : erreur non-422 → toast de fallback, retourne false', () => {
+        const { errors, handleApiError } = useFormErrors()
+        const handled = handleApiError(
+            fetchError(500, { 'hydra:description': 'Erreur serveur.' }),
+            { fallbackMessage: 'Oups.' },
+        )
+        expect(handled).toBe(false)
+        expect(errors).toEqual({})
+        expect(mockToastError).toHaveBeenCalledTimes(1)
+        // Titre via i18n (cle renvoyee telle quelle par le stub).
+        expect(mockToastError.mock.calls[0][0]).toMatchObject({ title: 'errors.title', message: 'Erreur serveur.' })
+    })
+
+    it('handleApiError : 422 sans violation mappable → toast de fallback, retourne false', () => {
+        const { handleApiError } = useFormErrors()
+        const handled = handleApiError(fetchError(422, { 'hydra:description': 'Donnees invalides.' }))
+        expect(handled).toBe(false)
+        expect(mockToastError).toHaveBeenCalledTimes(1)
+    })
+})

frontend/shared/composables/useAddressAutocomplete.ts

@@ -1,27 +1,29 @@
-// STUB ERP-63 — remplacé par l'implémentation BAN d'ERP-66.
+import { httpExternal } from '~/shared/utils/httpExternal'
+
+// Autocompletion d'adresse branchee sur la Base Adresse Nationale (BAN),
+// `api-adresse.data.gouv.fr` — service public francais, gratuit, CORS ouvert.
 //
-// Ce fichier appartient fonctionnellement à ERP-66 (#66). ERP-63 n'en livre
-// qu'un STUB pour ne pas se bloquer : la vraie implémentation (appels
-// api-adresse.data.gouv.fr) viendra remplacer le CORPS des deux méthodes SANS
-// changer leur signature ni l'usage côté composant.
+// Appel HTTP DIRECT depuis le front (pas de proxy back), conformement a la spec
+// M1 (§ API adresse postale). On passe par `httpExternal` et NON `useApi()` :
+// la BAN est un domaine externe, sans cookie de session ni enveloppe Hydra.
 //
-// Contrat figé par ERP-66 (c'est lui qui fait foi) :
+// Contrat (fige) :
 //   searchCity(postalCode)       -> liste { city, postalCode }
 //   searchAddress(query, cp?)    -> liste { label, street, postalCode, city }
-//   En cas d'erreur/timeout, la méthode THROW. Le composant catch l'erreur,
-//   affiche un toast d'avertissement et bascule en saisie libre (MalioInputText).
-//
-// Comportement du stub : les deux méthodes throw systématiquement → l'onglet
-// Adresse part directement en mode dégradé (Ville + Adresse en saisie libre,
-// Code postal saisi manuellement). Aucun appel réseau n'est émis ici.
+//   En cas d'erreur/timeout, la methode THROW une AddressAutocompleteUnavailableError.
+//   Le composant consommateur catch, affiche un toast d'avertissement et bascule
+//   en saisie libre (MalioInputText).
 
-/** Une suggestion de ville renvoyée à partir d'un code postal. */
+/** URL de l'endpoint de recherche BAN. */
+const BAN_SEARCH_URL = 'https://api-adresse.data.gouv.fr/search/'
+
+/** Une suggestion de ville renvoyee a partir d'un code postal. */
 export interface CitySuggestion {
     city: string
     postalCode: string
 }
 
-/** Une suggestion d'adresse complète (saisie assistée du champ « Adresse »). */
+/** Une suggestion d'adresse complete (saisie assistee du champ « Adresse »). */
 export interface AddressSuggestion {
     label: string
     street: string
@@ -34,27 +36,82 @@ export interface AddressAutocomplete {
     searchAddress(query: string, postalCode?: string): Promise<AddressSuggestion[]>
 }
 
-/** Erreur signalant que le service d'autocomplétion BAN n'est pas disponible. */
+/** Erreur signalant que le service d'autocompletion BAN n'est pas disponible. */
 export class AddressAutocompleteUnavailableError extends Error {
     constructor() {
-        // Message technique (non affiché tel quel) : le composant remonte son
-        // propre libellé i18n. Sert au debug / aux logs uniquement.
-        super('Address autocomplete (BAN) is not available yet — ERP-66 stub.')
+        // Message technique (non affiche tel quel) : le composant remonte son
+        // propre libelle i18n. Sert au debug / aux logs uniquement.
+        super('Address autocomplete (BAN) is not available.')
         this.name = 'AddressAutocompleteUnavailableError'
     }
 }
 
-/**
- * STUB : renvoie un composable conforme au contrat ERP-66 dont les méthodes
- * échouent toujours, forçant le mode dégradé côté onglet Adresse.
- */
+/** Proprietes d'une « feature » GeoJSON renvoyee par la BAN (champs utilises). */
+interface BanFeatureProperties {
+    label?: string
+    name?: string
+    street?: string
+    postcode?: string
+    city?: string
+}
+
+/** Reponse GeoJSON FeatureCollection de la BAN. */
+interface BanResponse {
+    features?: { properties?: BanFeatureProperties }[]
+}
+
 export function useAddressAutocomplete(): AddressAutocomplete {
     return {
-        async searchCity(_postalCode: string): Promise<CitySuggestion[]> {
-            throw new AddressAutocompleteUnavailableError()
+        async searchCity(postalCode: string): Promise<CitySuggestion[]> {
+            let res: BanResponse
+            try {
+                res = await httpExternal<BanResponse>(BAN_SEARCH_URL, {
+                    query: { q: postalCode, type: 'municipality' },
+                })
+            } catch {
+                // Reseau coupe, 5xx, timeout... -> mode degrade cote composant.
+                throw new AddressAutocompleteUnavailableError()
+            }
+
+            return (res.features ?? []).map((feature) => {
+                const props = feature.properties ?? {}
+                return {
+                    city: props.city ?? props.name ?? '',
+                    postalCode: props.postcode ?? '',
+                }
+            })
         },
-        async searchAddress(_query: string, _postalCode?: string): Promise<AddressSuggestion[]> {
-            throw new AddressAutocompleteUnavailableError()
+
+        async searchAddress(query: string, postalCode?: string): Promise<AddressSuggestion[]> {
+            // IMPORTANT : pas de `type=housenumber` ici. La BAN ne renvoie un
+            // resultat de ce type qu'une fois un numero saisi → une recherche par
+            // nom de rue (« boulevard du port ») renverrait 0 resultat pendant
+            // toute la frappe. Sans filtre `type`, la BAN classe rues + numeros
+            // par pertinence (comportement d'autocompletion attendu).
+            // On n'ajoute `postcode` que s'il est fourni (sinon recherche large).
+            const banQuery: Record<string, string> = { q: query }
+            if (postalCode) {
+                banQuery.postcode = postalCode
+            }
+
+            let res: BanResponse
+            try {
+                res = await httpExternal<BanResponse>(BAN_SEARCH_URL, { query: banQuery })
+            } catch {
+                throw new AddressAutocompleteUnavailableError()
+            }
+
+            return (res.features ?? []).map((feature) => {
+                const props = feature.properties ?? {}
+                return {
+                    label: props.label ?? '',
+                    // `name` porte la ligne d'adresse complete (numero + voie) ;
+                    // `street` ne contient que la voie. On privilegie `name`.
+                    street: props.name ?? props.street ?? '',
+                    postalCode: props.postcode ?? '',
+                    city: props.city ?? '',
+                }
+            })
         },
     }
 }

frontend/shared/composables/useApi.ts

@@ -44,7 +44,7 @@ export function useApi(): ApiClient {
         const data = responseData ?? (error as FetchError)?.data
         const msg = extractApiErrorMessage(data)
         if (msg) return msg
-        return (error as FetchError)?.message ?? 'Erreur inconnue.'
+        return (error as FetchError)?.message ?? t('errors.unknown')
     }
 
     const methodErrorKeys: Record<string, string> = {
@@ -76,7 +76,7 @@ export function useApi(): ApiClient {
 
             if (successMessage) {
                 toast.success({
-                    title: 'Succes',
+                    title: t('success.title'),
                     message: successMessage
                 })
             }
@@ -98,10 +98,10 @@ export function useApi(): ApiClient {
             apiOptions?.toastErrorMessage ||
             errorMessage ||
             extractedMessage ||
-            'Une erreur est survenue.'
+            t('errors.generic')
 
                     toast.error({
-                        title: apiOptions?.toastTitle ?? 'Erreur',
+                        title: apiOptions?.toastTitle ?? t('errors.title'),
                         message
                     })
                 }
@@ -139,7 +139,7 @@ export function useApi(): ApiClient {
         'Une erreur est survenue.'
 
             toast.error({
-                title: apiOptions?.toastTitle ?? 'Erreur',
+                title: apiOptions?.toastTitle ?? t('errors.title'),
                 message
             })
         }

frontend/shared/composables/useFormErrors.ts

@@ -0,0 +1,113 @@
+/**
+ * Composable d'erreurs de formulaire — convention de mapping erreur→champ pour
+ * tous les forms du projet (ERP-101).
+ *
+ * Le back renvoie TOUTES les violations d'une 422 d'un coup (un `propertyPath`
+ * + `message` par champ fautif). Ce composable centralise leur affichage
+ * inline : il tient un `Record<propertyPath, message>` reactif que le template
+ * branche directement sur la prop `:error` des composants `Malio*` (le nom du
+ * champ cote front = le `propertyPath` cote back, donc aucun mapping manuel).
+ *
+ * Chaque appel cree son propre etat (refs internes a la fonction) — un form =
+ * une instance, pas de singleton partage.
+ *
+ * Convention d'usage : les appels API qui veulent un retour inline doivent
+ * passer `{ toast: false }` a `useApi` (sinon le toast natif masque le mapping
+ * fin), puis router l'erreur via `handleApiError`. Pour les collections (1
+ * appel par ligne), utiliser directement `mapViolationsToRecord` par ligne.
+ */
+import { computed, reactive } from 'vue'
+import { extractApiErrorMessage, mapViolationsToRecord } from '~/shared/utils/api'
+
+/**
+ * Erreur HTTP capturee par ofetch. On n'expose que les champs lus ici (status
+ * + payload) pour eviter de typer toute la lib.
+ */
+interface ApiFetchError {
+    response?: {
+        status?: number
+        _data?: unknown
+    }
+}
+
+/** Options de `handleApiError`. */
+interface HandleApiErrorOptions {
+    /** Message de toast si l'erreur n'est pas une 422 exploitable. */
+    fallbackMessage?: string
+}
+
+export function useFormErrors() {
+    const toast = useToast()
+    const { t } = useI18n()
+
+    // Etat d'erreurs indexe par propertyPath. Reactif : muter une cle suffit a
+    // rafraichir la prop `:error` du champ correspondant.
+    const errors = reactive<Record<string, string>>({})
+
+    const hasErrors = computed(() => Object.keys(errors).length > 0)
+
+    /** Pose une erreur sur un champ. */
+    function setError(field: string, message: string): void {
+        errors[field] = message
+    }
+
+    /** Retire l'erreur d'un champ (no-op si absente). */
+    function clearError(field: string): void {
+        delete errors[field]
+    }
+
+    /** Vide toutes les erreurs (a appeler en debut de submit). */
+    function clearErrors(): void {
+        for (const key of Object.keys(errors)) {
+            delete errors[key]
+        }
+    }
+
+    /**
+     * Mappe les violations 422 d'un payload sur les champs. Retourne true des
+     * qu'au moins une violation a ete posee, false sinon (payload sans
+     * violation exploitable).
+     */
+    function setServerErrors(data: unknown): boolean {
+        const mapped = mapViolationsToRecord(data)
+        const keys = Object.keys(mapped)
+        if (keys.length === 0) return false
+        for (const key of keys) {
+            errors[key] = mapped[key]
+        }
+        return true
+    }
+
+    /**
+     * Route une erreur API : 422 avec violations exploitables → mapping inline
+     * (pas de toast, l'erreur s'affiche sous le champ) ; sinon → toast de
+     * fallback (message serveur extrait, ou `fallbackMessage`).
+     *
+     * Retourne true si l'erreur a ete mappee inline, false si fallback toast.
+     */
+    function handleApiError(e: unknown, opts: HandleApiErrorOptions = {}): boolean {
+        const status = (e as ApiFetchError)?.response?.status
+        const data = (e as ApiFetchError)?.response?._data
+
+        if (status === 422 && setServerErrors(data)) {
+            return true
+        }
+
+        const message
+            = extractApiErrorMessage(data)
+            || opts.fallbackMessage
+            || t('errors.generic')
+        toast.error({ title: t('errors.title'), message })
+        return false
+    }
+
+    return {
+        errors,
+        hasErrors,
+        setError,
+        clearError,
+        clearErrors,
+        setServerErrors,
+        handleApiError,
+    }
+}

frontend/shared/utils/__tests__/api.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest'
+import { mapViolationsToRecord } from '../api'
+
+/**
+ * Tests de `mapViolationsToRecord` — fondation du mapping erreur→champ des
+ * formulaires (ERP-101). Transforme un payload 422 API Platform en
+ * `Record<propertyPath, message>` directement consommable par la prop `:error`
+ * des composants `Malio*`.
+ */
+describe('mapViolationsToRecord', () => {
+    it('mappe chaque violation par son propertyPath (format `violations`)', () => {
+        const data = {
+            violations: [
+                { propertyPath: 'companyName', message: 'Obligatoire.' },
+                { propertyPath: 'siren', message: 'SIREN deja utilise.' },
+            ],
+        }
+        expect(mapViolationsToRecord(data)).toEqual({
+            companyName: 'Obligatoire.',
+            siren: 'SIREN deja utilise.',
+        })
+    })
+
+    it('supporte le format negocie `hydra:violations`', () => {
+        const data = {
+            'hydra:violations': [
+                { propertyPath: 'email', message: 'Adresse invalide.' },
+            ],
+        }
+        expect(mapViolationsToRecord(data)).toEqual({ email: 'Adresse invalide.' })
+    })
+
+    it('renvoie un objet vide quand il n\'y a pas de violation exploitable', () => {
+        expect(mapViolationsToRecord({})).toEqual({})
+        expect(mapViolationsToRecord(null)).toEqual({})
+        expect(mapViolationsToRecord({ violations: [] })).toEqual({})
+    })
+
+    it('ignore les violations sans propertyPath', () => {
+        const data = {
+            violations: [
+                { propertyPath: '', message: 'Erreur globale.' },
+                { propertyPath: 'iban', message: 'IBAN invalide.' },
+            ],
+        }
+        expect(mapViolationsToRecord(data)).toEqual({ iban: 'IBAN invalide.' })
+    })
+
+    it('en cas de doublon de propertyPath, la derniere violation gagne', () => {
+        const data = {
+            violations: [
+                { propertyPath: 'name', message: 'Premier message.' },
+                { propertyPath: 'name', message: 'Second message.' },
+            ],
+        }
+        expect(mapViolationsToRecord(data)).toEqual({ name: 'Second message.' })
+    })
+})

frontend/shared/utils/__tests__/httpExternal.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { httpExternal } from '../httpExternal'
+
+// On mocke ofetch : httpExternal s'appuie sur $fetch sans jamais toucher le
+// reseau pendant les tests. vi.mock est hoiste par Vitest au-dessus des imports.
+const mockFetch = vi.hoisted(() => vi.fn())
+vi.mock('ofetch', () => ({ $fetch: mockFetch }))
+
+describe('httpExternal', () => {
+    beforeEach(() => {
+        mockFetch.mockReset()
+    })
+
+    it('retourne le JSON parse renvoye par $fetch', async () => {
+        mockFetch.mockResolvedValueOnce({ ok: true })
+
+        const res = await httpExternal<{ ok: boolean }>('https://example.test/api')
+
+        expect(res).toEqual({ ok: true })
+    })
+
+    it('transmet la query, coupe le cookie (credentials omit) et pose un timeout par defaut', async () => {
+        mockFetch.mockResolvedValueOnce([])
+
+        await httpExternal('https://example.test/search', {
+            query: { q: '80000', type: 'municipality' },
+        })
+
+        expect(mockFetch).toHaveBeenCalledWith(
+            'https://example.test/search',
+            expect.objectContaining({
+                query: { q: '80000', type: 'municipality' },
+                credentials: 'omit',
+                retry: 0,
+                timeout: 5000,
+            }),
+        )
+    })
+
+    it('permet de surcharger le timeout', async () => {
+        mockFetch.mockResolvedValueOnce(null)
+
+        await httpExternal('https://example.test', { timeoutMs: 1000 })
+
+        expect(mockFetch).toHaveBeenCalledWith(
+            'https://example.test',
+            expect.objectContaining({ timeout: 1000 }),
+        )
+    })
+
+    it('propage l\'erreur reseau / timeout (throw)', async () => {
+        mockFetch.mockRejectedValueOnce(new Error('network down'))
+
+        await expect(httpExternal('https://example.test')).rejects.toThrow('network down')
+    })
+})

frontend/shared/utils/__tests__/phone.test.ts

@@ -20,4 +20,27 @@ describe('formatPhoneFR', () => {
     it('groupe par 2 meme un nombre impair de chiffres (dernier groupe seul)', () => {
         expect(formatPhoneFR('123')).toBe('12 3')
     })
+
+    it('formate une saisie courte (<= 4 chiffres) sans planter', () => {
+        expect(formatPhoneFR('1')).toBe('1')
+        expect(formatPhoneFR('12')).toBe('12')
+        expect(formatPhoneFR('1234')).toBe('12 34')
+    })
+
+    it('strip les caracteres non numeriques (lettres, espaces, ponctuation)', () => {
+        expect(formatPhoneFR('abc')).toBe('')
+        expect(formatPhoneFR('Tel : 06.12')).toBe('06 12')
+        expect(formatPhoneFR('  06 12  ')).toBe('06 12')
+    })
+
+    it('conserve l\'indicatif international (+33) sans le transformer', () => {
+        // Comportement fige : on retire seulement le `+`, on ne deduit pas le
+        // prefixe pays. Le `+33...` est donc groupe brut par paquets de 2.
+        expect(formatPhoneFR('+33612345678')).toBe('33 61 23 45 67 8')
+    })
+
+    it('groupe sans tronquer une saisie plus longue que 10 chiffres', () => {
+        // Aucune troncature silencieuse : on figure tous les chiffres groupes par 2.
+        expect(formatPhoneFR('061234567899')).toBe('06 12 34 56 78 99')
+    })
 })

frontend/shared/utils/api.ts

@@ -66,6 +66,25 @@ export function extractApiViolations(data: unknown): ApiViolation[] {
     return out
 }
 
+/**
+ * Transforme un payload d'erreur 422 d'API Platform en dictionnaire
+ * `{ propertyPath: message }`, directement consommable par la prop `:error`
+ * des composants `Malio*` (le nom du champ cote front = le `propertyPath`
+ * renvoye par le back). Fondation du mapping erreur→champ des formulaires :
+ * utilise par `useFormErrors` (champs scalaires) et par les boucles de submit
+ * de collections (erreur par ligne).
+ *
+ * Les violations sans `propertyPath` (erreur globale) sont ignorees ; en cas
+ * de doublon de `propertyPath`, la derniere violation l'emporte.
+ */
+export function mapViolationsToRecord(data: unknown): Record<string, string> {
+    const out: Record<string, string> = {}
+    for (const v of extractApiViolations(data)) {
+        if (v.propertyPath) out[v.propertyPath] = v.message
+    }
+    return out
+}
+
 /**
  * Extrait un message d'erreur lisible depuis un payload Hydra / JSON
  * d'erreur API Platform. Essaie les champs courants dans l'ordre :

frontend/shared/utils/httpExternal.ts

@@ -0,0 +1,40 @@
+import { $fetch } from 'ofetch'
+
+/**
+ * Options d'un appel HTTP externe.
+ */
+export interface HttpExternalOptions {
+    /** Parametres de query string (encodes par ofetch). */
+    query?: Record<string, string | number | undefined>
+    /** Timeout en millisecondes avant abandon (defaut 5000). */
+    timeoutMs?: number
+}
+
+/**
+ * Petit client HTTP pour les APIs PUBLIQUES EXTERNES (domaine tiers, hors `/api`).
+ *
+ * Pourquoi un helper dedie plutot que `useApi()` : `useApi()` est le client de
+ * l'API interne Starseed (baseURL `/api`, cookie JWT `credentials: 'include'`,
+ * parsing/erreurs Hydra, redirection `/login` sur 401, toasts i18n). Tout cela
+ * est inadapte — voire indesirable — pour un endpoint public externe comme la
+ * Base Adresse Nationale (`api-adresse.data.gouv.fr`).
+ *
+ * Ce helper est donc le SEUL point d'entree autorise pour un `$fetch` brut vers
+ * l'externe (cf. regle frontend n°4 : pas de `$fetch` eparpille dans les
+ * composants). Il :
+ * - cible une URL absolue (pas de baseURL `/api`) ;
+ * - n'envoie PAS le cookie de session (`credentials: 'omit'`) ;
+ * - ne retente pas (`retry: 0`) et applique un timeout ;
+ * - laisse remonter l'erreur (throw) — au consommateur de gerer le mode degrade.
+ */
+export async function httpExternal<T>(
+    url: string,
+    opts: HttpExternalOptions = {},
+): Promise<T> {
+    return $fetch<T>(url, {
+        query: opts.query,
+        credentials: 'omit',
+        retry: 0,
+        timeout: opts.timeoutMs ?? 5000,
+    })
+}

frontend/tests/e2e/_fixtures/personas.ts

@@ -75,6 +75,15 @@ export const personas: Record<PersonaKey, Persona> = {
             'commercial.clients.accounting.view',
             'commercial.clients.accounting.manage',
             'commercial.clients.archive',
+            // Commercial — Repertoire fournisseurs (M2, ERP-90). Meme logique que
+            // les clients : mappe sur le persona "tout", pas de nouveau persona
+            // (regle ABSOLUE n°7). commercial.suppliers.view n'ajoute pas de lien
+            // dans la section Administration, donc expectedAdminLinks reste inchange.
+            'commercial.suppliers.view',
+            'commercial.suppliers.manage',
+            'commercial.suppliers.accounting.view',
+            'commercial.suppliers.accounting.manage',
+            'commercial.suppliers.archive',
         ],
         expectedAdminLinks: ['users', 'roles', 'sites', 'categories', 'audit-log'],
     },

makefile

@@ -229,6 +229,7 @@ test-db-setup:
 	$(SYMFONY_CONSOLE) --env=test dbal:run-sql "CREATE UNIQUE INDEX IF NOT EXISTS uq_category_name_type_active ON category (LOWER(name), category_type_id) WHERE deleted_at IS NULL"
 	$(SYMFONY_CONSOLE) --env=test dbal:run-sql "CREATE UNIQUE INDEX IF NOT EXISTS uq_category_code ON category (code) WHERE deleted_at IS NULL"
 	$(SYMFONY_CONSOLE) --env=test dbal:run-sql "CREATE UNIQUE INDEX IF NOT EXISTS uq_client_company_name_active ON client (LOWER(company_name)) WHERE is_archived = FALSE AND deleted_at IS NULL"
+	$(SYMFONY_CONSOLE) --env=test dbal:run-sql "CREATE UNIQUE INDEX IF NOT EXISTS uq_supplier_company_name_active ON supplier (LOWER(company_name)) WHERE is_archived = FALSE AND deleted_at IS NULL"
 
 fixtures:
 	$(SYMFONY_CONSOLE) --no-interaction doctrine:fixtures:load

migrations/Version20260603120000.php

@@ -0,0 +1,131 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * M1 — Suppression du contact principal inline du `Client` (refonte contact).
+ *
+ * Modele AVANT : le `Client` portait 5 colonnes de contact principal
+ * (first_name, last_name, phone_primary, phone_secondary, email) en doublon
+ * conceptuel de la sous-entite `ClientContact` (onglet Contact).
+ *
+ * Modele APRES (decision produit, README refonte-contact) : les contacts vivent
+ * UNIQUEMENT dans `client_contact`. Les 5 colonnes inline disparaissent du
+ * `client`. RG-1.01 (firstName OU lastName sur Client) et RG-1.02 (max 2
+ * telephones sur Client) sont supprimees : leur equivalent vit deja sur
+ * `client_contact` (RG-1.05 / RG-1.14).
+ *
+ * Le code etant deja en prod, la suppression est precedee d'un BACKFILL : pour
+ * tout client n'ayant encore AUCUN contact, on materialise son contact principal
+ * inline en une ligne `client_contact` (position 0) avant le DROP, afin de ne
+ * perdre aucune donnee.
+ *
+ * Namespace racine `DoctrineMigrations` (regle ABSOLUE n°11) et NON modulaire
+ * Commercial : avec plusieurs migrations_paths, Doctrine Migrations 3.x trie par
+ * FQCN alphabetique (AlphabeticalComparator). Une migration
+ * `App\Module\Commercial\...` trierait AVANT toutes les `DoctrineMigrations\...`
+ * sur base vide -> ce DROP s'executerait avant le CREATE TABLE client
+ * (Version20260601000000). Le namespace racine garantit l'ordre par timestamp.
+ */
+final class Version20260603120000 extends AbstractMigration
+{
+    /** Colonnes de contact inline supprimees du `client`. */
+    private const array INLINE_CONTACT_COLUMNS = [
+        'first_name', 'last_name', 'phone_primary', 'phone_secondary', 'email',
+    ];
+
+    public function getDescription(): string
+    {
+        return 'M1 : suppression du contact inline du Client (backfill vers client_contact puis DROP des 5 colonnes).';
+    }
+
+    public function up(Schema $schema): void
+    {
+        // 1. Backfill : tout client SANS contact recoit une ligne client_contact
+        //    (position 0) reprenant ses champs inline. phone_primary / email du
+        //    client sont NOT NULL -> toujours une donnee a reporter. Le CHECK
+        //    chk_client_contact_name (first_name OU last_name) est garanti par le
+        //    fallback company_name si jamais les deux noms etaient null (cas qui ne
+        //    devrait pas exister, RG-1.01 ayant ete appliquee a l'ecriture).
+        //    created_at/updated_at NOT NULL -> NOW() ; created_by/updated_by null
+        //    (backfill hors contexte HTTP, libelle « Systeme » cote front).
+        $this->addSql(<<<'SQL'
+            INSERT INTO client_contact (
+                client_id, first_name, last_name, phone_primary, phone_secondary,
+                email, position, created_at, updated_at
+            )
+            SELECT
+                c.id,
+                c.first_name,
+                CASE
+                    WHEN c.first_name IS NULL AND c.last_name IS NULL THEN c.company_name
+                    ELSE c.last_name
+                END,
+                c.phone_primary,
+                c.phone_secondary,
+                c.email,
+                0,
+                NOW(),
+                NOW()
+            FROM client c
+            WHERE NOT EXISTS (
+                SELECT 1 FROM client_contact cc WHERE cc.client_id = c.id
+            )
+            SQL);
+
+        // 2. DROP des 5 colonnes inline (rien a documenter : suppression).
+        $this->addSql(<<<'SQL'
+            ALTER TABLE client
+                DROP COLUMN first_name,
+                DROP COLUMN last_name,
+                DROP COLUMN phone_primary,
+                DROP COLUMN phone_secondary,
+                DROP COLUMN email
+            SQL);
+    }
+
+    public function down(Schema $schema): void
+    {
+        // Best-effort : on RECREE les 5 colonnes (en NULLABLE — l'etat NOT NULL
+        // d'origine de phone_primary/email ne peut etre restaure sur une table
+        // peuplee sans risque) et on retro-alimente depuis le contact principal
+        // (position minimale) de chaque client. La donnee n'est pas garantie
+        // identique a l'origine : ce down() sert au rollback technique, pas a une
+        // restauration fidele.
+        $this->addSql('ALTER TABLE client ADD COLUMN first_name VARCHAR(120) DEFAULT NULL');
+        $this->addSql('ALTER TABLE client ADD COLUMN last_name VARCHAR(120) DEFAULT NULL');
+        $this->addSql('ALTER TABLE client ADD COLUMN phone_primary VARCHAR(20) DEFAULT NULL');
+        $this->addSql('ALTER TABLE client ADD COLUMN phone_secondary VARCHAR(20) DEFAULT NULL');
+        $this->addSql('ALTER TABLE client ADD COLUMN email VARCHAR(180) DEFAULT NULL');
+
+        // Retro-alimentation depuis le contact de position la plus basse.
+        $this->addSql(<<<'SQL'
+            UPDATE client c SET
+                first_name      = cc.first_name,
+                last_name       = cc.last_name,
+                phone_primary   = cc.phone_primary,
+                phone_secondary = cc.phone_secondary,
+                email           = cc.email
+            FROM (
+                SELECT DISTINCT ON (client_id)
+                    client_id, first_name, last_name, phone_primary, phone_secondary, email
+                FROM client_contact
+                ORDER BY client_id, position ASC, id ASC
+            ) cc
+            WHERE cc.client_id = c.id
+            SQL);
+
+        // Re-pose des commentaires d'origine (regle ABSOLUE n°12) — dollar-quoting
+        // Postgres pour eviter tout echappement d apostrophe.
+        $this->addSql('COMMENT ON COLUMN client.first_name IS $_$Prenom du contact principal (capitalise serveur, RG-1.19). first_name OU last_name obligatoire (RG-1.01).$_$');
+        $this->addSql('COMMENT ON COLUMN client.last_name IS $_$Nom du contact principal (capitalise serveur, RG-1.19). first_name OU last_name obligatoire (RG-1.01).$_$');
+        $this->addSql('COMMENT ON COLUMN client.phone_primary IS $_$Telephone principal — stocke en chiffres uniquement (RG-1.20). Obligatoire.$_$');
+        $this->addSql('COMMENT ON COLUMN client.phone_secondary IS $_$Telephone secondaire optionnel — chiffres uniquement (RG-1.20).$_$');
+        $this->addSql('COMMENT ON COLUMN client.email IS $_$Email principal (lowercase serveur, RG-1.21). NON unique (RG-1.17 supprimee, Q4).$_$');
+    }
+}

migrations/Version20260605120000.php

@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * ERP-84 — Taxonomie FOURNISSEUR (module Catalog, prerequis M2).
+ *
+ * Contexte : ERP-78 (Version20260602100000) a unifie la taxonomie sur un type
+ * unique CLIENT. Le M2 (fournisseurs) a besoin d'une taxonomie distincte : les
+ * categories clients (Agro-alimentaire...) ne sont pas valides pour un
+ * fournisseur (Negociant, Cooperative...). Decision Matthieu (02/06) : types
+ * distincts CLIENT / FOURNISSEUR (PRESTA a venir), chacun avec sa taxonomie.
+ *
+ * Cette migration :
+ *  1. recree le `category_type` FOURNISSEUR (code FOURNISSEUR, label « Fournisseur ») ;
+ *  2. seede quelques `Category` de demonstration rattachees a ce type.
+ *
+ * Aucune colonne creee/modifiee -> pas de `COMMENT ON COLUMN` (regle ABSOLUE n°12).
+ *
+ * Namespace racine `DoctrineMigrations` (regle ABSOLUE n°11) et NON modulaire
+ * Catalog : avec plusieurs migrations_paths, Doctrine Migrations 3.x trie par
+ * FQCN alphabetique -> une migration `App\Module\Catalog\...` passerait avant les
+ * `DoctrineMigrations\...` sur base vide, donc avant la creation de la table
+ * `category_type`. Le namespace racine garantit l'ordre par timestamp.
+ *
+ * Idempotence : `INSERT ... ON CONFLICT (code) DO NOTHING` pour le type,
+ * `INSERT ... SELECT ... WHERE NOT EXISTS` pour chaque categorie (aligne sur le
+ * pattern ERP-78 etape 4). En prod la table `category` est vide (aucune fixture
+ * metier). En dev/test, le purger Doctrine vide `category`/`category_type` avant
+ * les fixtures qui reproduisent le meme etat final (CategoryTypeFixtures /
+ * CategoryFixtures etendus a FOURNISSEUR).
+ */
+final class Version20260605120000 extends AbstractMigration
+{
+    /**
+     * Categories de demonstration du type FOURNISSEUR : nom => code stable. Le
+     * code est la cle metier (slug MAJUSCULE du nom, miroir du
+     * CategoryCodeGenerator) et reste unique parmi les actifs (uq_category_code,
+     * partage avec les codes CLIENT — aucune collision ici).
+     */
+    private const array SUPPLIER_CATEGORIES = [
+        'Négociant'   => 'NEGOCIANT',
+        'Coopérative' => 'COOPERATIVE',
+        'Producteur'  => 'PRODUCTEUR',
+        'Grossiste'   => 'GROSSISTE',
+        'Importateur' => 'IMPORTATEUR',
+    ];
+
+    public function getDescription(): string
+    {
+        return 'ERP-84 : recree le CategoryType FOURNISSEUR + seed des categories fournisseurs (Negociant, Cooperative...).';
+    }
+
+    public function up(Schema $schema): void
+    {
+        // 1. Type FOURNISSEUR (idempotent via l'index unique uq_category_type_code).
+        $this->addSql(<<<'SQL'
+            INSERT INTO category_type (code, label) VALUES ('FOURNISSEUR', 'Fournisseur')
+            ON CONFLICT (code) DO NOTHING
+            SQL);
+
+        // 2. Categories de demonstration sous FOURNISSEUR (si le code est libre
+        //    parmi les actifs). created_at/updated_at NOT NULL -> NOW() ; le blame
+        //    reste null (seed hors contexte HTTP, libelle « Systeme » cote front).
+        foreach (self::SUPPLIER_CATEGORIES as $name => $code) {
+            $this->addSql(<<<'SQL'
+                INSERT INTO category (name, code, category_type_id, created_at, updated_at)
+                SELECT :name, :code, ct.id, NOW(), NOW()
+                FROM category_type ct
+                WHERE ct.code = 'FOURNISSEUR'
+                  AND NOT EXISTS (
+                      SELECT 1 FROM category c WHERE c.code = :code AND c.deleted_at IS NULL
+                  )
+                SQL, ['name' => $name, 'code' => $code]);
+        }
+    }
+
+    public function down(Schema $schema): void
+    {
+        // Best-effort : on retire d'abord les categories seedees (par code), puis
+        // le type s'il n'est plus reference (guard NOT EXISTS sur la FK RESTRICT).
+        $this->addSql(
+            'DELETE FROM category WHERE code IN (:codes) '
+            ."AND category_type_id = (SELECT id FROM category_type WHERE code = 'FOURNISSEUR')",
+            ['codes' => array_values(self::SUPPLIER_CATEGORIES)],
+            ['codes' => \Doctrine\DBAL\ArrayParameterType::STRING],
+        );
+
+        $this->addSql(<<<'SQL'
+            DELETE FROM category_type
+            WHERE code = 'FOURNISSEUR'
+              AND NOT EXISTS (
+                  SELECT 1 FROM category c WHERE c.category_type_id = category_type.id
+              )
+            SQL);
+    }
+}

migrations/Version20260605130000.php

@@ -0,0 +1,438 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use App\Shared\Infrastructure\Database\ColumnCommentsCatalog;
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * M2 — Repertoire fournisseurs (ERP-85) : creation de toute la structure BDD
+ * des fournisseurs sous le module Commercial (jumeau du M1 client).
+ *
+ * Tables creees :
+ *  - Table principale : supplier (formulaire principal + Information +
+ *    Comptabilite + archive + soft-delete + Timestampable/Blamable).
+ *  - Sous-collections : supplier_category (M2M), supplier_contact (1:n),
+ *    supplier_address (1:n), supplier_rib (1:n).
+ *  - Jointures de supplier_address : supplier_address_site,
+ *    supplier_address_contact, supplier_address_category.
+ *
+ * Differences vs le M1 `client` (cf. spec M2 § 2.4 / § 3.1) :
+ *  - PAS de contact inline sur supplier (first_name / last_name / phone_* /
+ *    email retires en V0.2, refonte-contact ERP-106). Les contacts vivent
+ *    uniquement dans supplier_contact (onglet Contacts).
+ *  - PAS d'auto-reference distributor_id / broker_id (pas de CHECK associe).
+ *  - Ajout du champ Information volume_forecast (entier).
+ *  - supplier_address remplace les 3 booleens M1 (is_prospect / is_delivery /
+ *    is_billing + billing_email) par un seul enum address_type
+ *    (PROSPECT | DEPART | RENDU, radio exclusif, CHECK chk_supplier_address_type)
+ *    et ajoute bennes (int nullable) + triage_provider (bool).
+ *
+ * Referentiels comptables NON recrees : tva_mode / payment_delay / payment_type
+ * / bank sont ceux du M1 (FK partagees, zero duplication — spec § 2.3).
+ *
+ * CategoryType FOURNISSEUR NON re-seede : il est cree par ERP-84
+ * (Version20260605120000) avec ses categories de demonstration. Le M2M
+ * supplier_category / supplier_address_category s'appuie sur ce type existant.
+ *
+ * Namespace racine `DoctrineMigrations` (regle ABSOLUE Starseed n°11) et NON
+ * `App\Module\Commercial\...` : la migration cree un schema avec FK cross-module
+ * (user, category, site, et les referentiels comptables M1). Avec plusieurs
+ * migrations_paths, Doctrine Migrations 3.x trie par FQCN alphabetique — un
+ * namespace modulaire s'executerait avant la creation de user/category/site sur
+ * base vide -> echec des FK. Le namespace racine garantit l'ordre par timestamp.
+ *
+ * Style DDL aligne sur le M1 (Version20260601000000) : `INT GENERATED BY DEFAULT
+ * AS IDENTITY` (et non SERIAL), `TIMESTAMP(0) WITHOUT TIME ZONE` (et non
+ * TIMESTAMPTZ, car le TimestampableBlamableTrait mappe `datetime_immutable`).
+ * Garantit que `schema:update` restera un no-op quand les entites arriveront
+ * (ticket ERP-86).
+ *
+ * Decision unicite (Matthieu 02/06, alignee Q4 du M1) : unicite metier sur le
+ * NOM DE SOCIETE uniquement (uq_supplier_company_name_active, partiel). Pas
+ * d'index unique sur siren ni email.
+ *
+ * Chaque colonne porte un `COMMENT ON COLUMN` (regle ABSOLUE n°12, garde-fou
+ * ColumnsHaveSqlCommentTest). Les tables n'etant pas encore mappees par l'ORM
+ * (entites a ERP-86), ces commentaires survivent au `schema:update --force` du
+ * setup de test (additif, ne drop pas les tables non mappees).
+ */
+final class Version20260605130000 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'ERP-85 (M2) : tables supplier + sous-collections + jointures M2M (referentiels comptables et CategoryType FOURNISSEUR reutilises).';
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->createSupplierTable();
+        $this->createSupplierCategory();
+        $this->createSupplierContact();
+        $this->createSupplierAddress();
+        $this->createSupplierAddressJoinTables();
+        $this->createSupplierRib();
+    }
+
+    public function down(Schema $schema): void
+    {
+        // Ordre inverse des dependances FK : jointures et sous-collections
+        // d'abord, puis supplier. Les referentiels comptables et le
+        // CategoryType FOURNISSEUR ne sont pas touches (crees ailleurs).
+        $this->addSql('DROP TABLE supplier_address_category');
+        $this->addSql('DROP TABLE supplier_address_contact');
+        $this->addSql('DROP TABLE supplier_address_site');
+        $this->addSql('DROP TABLE supplier_rib');
+        $this->addSql('DROP TABLE supplier_address');
+        $this->addSql('DROP TABLE supplier_contact');
+        $this->addSql('DROP TABLE supplier_category');
+        $this->addSql('DROP TABLE supplier');
+    }
+
+    // =================================================================
+    // Table principale `supplier`
+    // =================================================================
+
+    private function createSupplierTable(): void
+    {
+        $this->addSql(<<<'SQL'
+            CREATE TABLE supplier (
+                id INT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
+                company_name VARCHAR(180) NOT NULL,
+                description TEXT DEFAULT NULL,
+                competitors VARCHAR(255) DEFAULT NULL,
+                founded_at DATE DEFAULT NULL,
+                employees_count INT DEFAULT NULL,
+                revenue_amount NUMERIC(15, 2) DEFAULT NULL,
+                director_name VARCHAR(120) DEFAULT NULL,
+                profit_amount NUMERIC(15, 2) DEFAULT NULL,
+                volume_forecast INT DEFAULT NULL,
+                siren VARCHAR(20) DEFAULT NULL,
+                account_number VARCHAR(40) DEFAULT NULL,
+                tva_mode_id INT DEFAULT NULL,
+                n_tva VARCHAR(40) DEFAULT NULL,
+                payment_delay_id INT DEFAULT NULL,
+                payment_type_id INT DEFAULT NULL,
+                bank_id INT DEFAULT NULL,
+                is_archived BOOLEAN DEFAULT FALSE NOT NULL,
+                archived_at TIMESTAMP(0) WITHOUT TIME ZONE DEFAULT NULL,
+                deleted_at TIMESTAMP(0) WITHOUT TIME ZONE DEFAULT NULL,
+                created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL,
+                updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL,
+                created_by INT DEFAULT NULL,
+                updated_by INT DEFAULT NULL,
+                PRIMARY KEY (id),
+                CONSTRAINT fk_supplier_tva_mode
+                    FOREIGN KEY (tva_mode_id) REFERENCES tva_mode (id) ON DELETE RESTRICT,
+                CONSTRAINT fk_supplier_payment_delay
+                    FOREIGN KEY (payment_delay_id) REFERENCES payment_delay (id) ON DELETE RESTRICT,
+                CONSTRAINT fk_supplier_payment_type
+                    FOREIGN KEY (payment_type_id) REFERENCES payment_type (id) ON DELETE RESTRICT,
+                CONSTRAINT fk_supplier_bank
+                    FOREIGN KEY (bank_id) REFERENCES bank (id) ON DELETE RESTRICT,
+                CONSTRAINT fk_supplier_created_by
+                    FOREIGN KEY (created_by) REFERENCES "user" (id) ON DELETE SET NULL,
+                CONSTRAINT fk_supplier_updated_by
+                    FOREIGN KEY (updated_by) REFERENCES "user" (id) ON DELETE SET NULL
+            )
+            SQL);
+
+        $this->addSql('CREATE INDEX idx_supplier_is_archived ON supplier (is_archived)');
+        $this->addSql('CREATE INDEX idx_supplier_deleted_at ON supplier (deleted_at)');
+        $this->addSql('CREATE INDEX idx_supplier_created_by ON supplier (created_by)');
+        $this->addSql('CREATE INDEX idx_supplier_updated_by ON supplier (updated_by)');
+
+        // Index sur les FK des referentiels comptables (Postgres n'indexe pas
+        // automatiquement les colonnes portant une FOREIGN KEY).
+        $this->addSql('CREATE INDEX idx_supplier_tva_mode_id ON supplier (tva_mode_id)');
+        $this->addSql('CREATE INDEX idx_supplier_payment_delay_id ON supplier (payment_delay_id)');
+        $this->addSql('CREATE INDEX idx_supplier_payment_type_id ON supplier (payment_type_id)');
+        $this->addSql('CREATE INDEX idx_supplier_bank_id ON supplier (bank_id)');
+
+        // Unicite metier partielle : nom de societe insensible a la casse, parmi
+        // les non-archives ET non soft-deletes uniquement (spec § 2.6). Pas
+        // d'index unique sur siren ni email.
+        $this->addSql(<<<'SQL'
+            CREATE UNIQUE INDEX uq_supplier_company_name_active
+            ON supplier (LOWER(company_name))
+            WHERE is_archived = FALSE AND deleted_at IS NULL
+            SQL);
+
+        $this->comment('supplier', '_table', 'Repertoire fournisseurs (M2 Commercial) — entites archivables (is_archived) et soft-deletables (deleted_at, HP M3).');
+        $this->comment('supplier', 'id', 'Identifiant interne auto-incremente.');
+        $this->comment('supplier', 'company_name', 'Raison sociale du fournisseur (stockee en MAJUSCULES). Unique case-insensitive parmi les actifs non archives/non supprimes (uq_supplier_company_name_active, § 2.6).');
+        $this->comment('supplier', 'description', 'Onglet Information : description libre. Obligatoire pour le role Commerciale (RG-2.03), optionnel sinon.');
+        $this->comment('supplier', 'competitors', 'Onglet Information : concurrents identifies (texte libre ≤ 255). Obligatoire role Commerciale (RG-2.03).');
+        $this->comment('supplier', 'founded_at', 'Onglet Information : date de creation de l entreprise. Obligatoire role Commerciale (RG-2.03).');
+        $this->comment('supplier', 'employees_count', 'Onglet Information : effectif (entier >= 0). Obligatoire role Commerciale (RG-2.03).');
+        $this->comment('supplier', 'revenue_amount', 'Onglet Information : chiffre d affaires (NUMERIC 15,2). Obligatoire role Commerciale (RG-2.03).');
+        $this->comment('supplier', 'director_name', 'Onglet Information : nom du dirigeant. Obligatoire role Commerciale (RG-2.03).');
+        $this->comment('supplier', 'profit_amount', 'Onglet Information : resultat / benefice (NUMERIC 15,2). Obligatoire role Commerciale (RG-2.03).');
+        $this->comment('supplier', 'volume_forecast', 'Onglet Information : volume previsionnel (entier >= 0) — specifique fournisseur. Obligatoire role Commerciale (RG-2.03).');
+        $this->comment('supplier', 'siren', 'Onglet Comptabilite : SIREN (9 chiffres attendus). NON unique — peut etre partage entre etablissements (§ 2.6).');
+        $this->comment('supplier', 'account_number', 'Onglet Comptabilite : numero de compte comptable du fournisseur.');
+        $this->comment('supplier', 'tva_mode_id', 'Onglet Comptabilite : mode de TVA applique — FK -> tva_mode.id (referentiel partage M1), ON DELETE RESTRICT.');
+        $this->comment('supplier', 'n_tva', 'Onglet Comptabilite : numero de TVA intracommunautaire.');
+        $this->comment('supplier', 'payment_delay_id', 'Onglet Comptabilite : delai de reglement — FK -> payment_delay.id (M1), ON DELETE RESTRICT.');
+        $this->comment('supplier', 'payment_type_id', 'Onglet Comptabilite : type de reglement — FK -> payment_type.id (M1), ON DELETE RESTRICT. Pilote RG-2.07 (Banque si VIREMENT) et RG-2.08 (RIB).');
+        $this->comment('supplier', 'bank_id', 'Onglet Comptabilite : banque — FK -> bank.id (M1), ON DELETE RESTRICT. Obligatoire ssi payment_type = VIREMENT (RG-2.07), null sinon.');
+        $this->comment('supplier', 'is_archived', 'Drapeau fonctionnel d archivage — masque par defaut dans la liste. Bascule via permission commercial.suppliers.archive.');
+        $this->comment('supplier', 'archived_at', 'Horodatage de l archivage — pose quand is_archived passe a vrai, remis a null a la restauration.');
+        $this->comment('supplier', 'deleted_at', 'Horodatage du soft-delete technique (HP M3) — non expose par l API au M2. Null = ligne active.');
+        $this->addTimestampableBlamableComments('supplier');
+    }
+
+    // =================================================================
+    // M2M supplier <-> category (type FOURNISSEUR — RG-2.10)
+    // =================================================================
+
+    private function createSupplierCategory(): void
+    {
+        $this->addSql(<<<'SQL'
+            CREATE TABLE supplier_category (
+                supplier_id INT NOT NULL,
+                category_id INT NOT NULL,
+                PRIMARY KEY (supplier_id, category_id),
+                CONSTRAINT fk_supplier_category_supplier
+                    FOREIGN KEY (supplier_id) REFERENCES supplier (id) ON DELETE CASCADE,
+                CONSTRAINT fk_supplier_category_category
+                    FOREIGN KEY (category_id) REFERENCES category (id) ON DELETE RESTRICT
+            )
+            SQL);
+        $this->addSql('CREATE INDEX idx_supplier_category_category ON supplier_category (category_id)');
+
+        $this->comment('supplier_category', '_table', 'Jointure M2M supplier <-> category (Catalog) — categories de type FOURNISSEUR du fournisseur, au moins une obligatoire (RG-2.10).');
+        $this->comment('supplier_category', 'supplier_id', 'FK -> supplier.id, ON DELETE CASCADE — fournisseur porteur de la categorie.');
+        $this->comment('supplier_category', 'category_id', 'FK -> category.id, ON DELETE RESTRICT — categorie de type FOURNISSEUR rattachee au fournisseur (RG-2.10).');
+    }
+
+    // =================================================================
+    // Sous-collection : contacts (1:n)
+    // =================================================================
+
+    private function createSupplierContact(): void
+    {
+        $this->addSql(<<<'SQL'
+            CREATE TABLE supplier_contact (
+                id INT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
+                supplier_id INT NOT NULL,
+                first_name VARCHAR(120) DEFAULT NULL,
+                last_name VARCHAR(120) DEFAULT NULL,
+                job_title VARCHAR(120) DEFAULT NULL,
+                phone_primary VARCHAR(20) DEFAULT NULL,
+                phone_secondary VARCHAR(20) DEFAULT NULL,
+                email VARCHAR(180) DEFAULT NULL,
+                position INT DEFAULT 0 NOT NULL,
+                created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL,
+                updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL,
+                created_by INT DEFAULT NULL,
+                updated_by INT DEFAULT NULL,
+                PRIMARY KEY (id),
+                CONSTRAINT chk_supplier_contact_name
+                    CHECK (first_name IS NOT NULL OR last_name IS NOT NULL),
+                CONSTRAINT fk_supplier_contact_supplier
+                    FOREIGN KEY (supplier_id) REFERENCES supplier (id) ON DELETE CASCADE,
+                CONSTRAINT fk_supplier_contact_created_by
+                    FOREIGN KEY (created_by) REFERENCES "user" (id) ON DELETE SET NULL,
+                CONSTRAINT fk_supplier_contact_updated_by
+                    FOREIGN KEY (updated_by) REFERENCES "user" (id) ON DELETE SET NULL
+            )
+            SQL);
+        $this->addSql('CREATE INDEX idx_supplier_contact_supplier ON supplier_contact (supplier_id)');
+
+        $this->comment('supplier_contact', '_table', 'Contacts d un fournisseur (1:n) — au moins firstName OU lastName par contact (RG-2.04).');
+        $this->comment('supplier_contact', 'id', 'Identifiant interne auto-incremente.');
+        $this->comment('supplier_contact', 'supplier_id', 'FK -> supplier.id, ON DELETE CASCADE — fournisseur proprietaire du contact.');
+        $this->comment('supplier_contact', 'first_name', 'Prenom du contact (capitalise serveur). first_name OU last_name obligatoire (RG-2.04, chk_supplier_contact_name).');
+        $this->comment('supplier_contact', 'last_name', 'Nom du contact (capitalise serveur). first_name OU last_name obligatoire (RG-2.04, chk_supplier_contact_name).');
+        $this->comment('supplier_contact', 'job_title', 'Fonction / intitule de poste du contact (≤ 120 caracteres).');
+        $this->comment('supplier_contact', 'phone_primary', 'Telephone principal du contact — chiffres uniquement (normalisation serveur).');
+        $this->comment('supplier_contact', 'phone_secondary', 'Telephone secondaire du contact — chiffres uniquement (normalisation serveur).');
+        $this->comment('supplier_contact', 'email', 'Email du contact (lowercase serveur).');
+        $this->comment('supplier_contact', 'position', 'Ordre d affichage du contact dans la liste du fournisseur (croissant).');
+        $this->addTimestampableBlamableComments('supplier_contact');
+    }
+
+    // =================================================================
+    // Sous-collection : adresses (1:n)
+    // =================================================================
+
+    private function createSupplierAddress(): void
+    {
+        $this->addSql(<<<'SQL'
+            CREATE TABLE supplier_address (
+                id INT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
+                supplier_id INT NOT NULL,
+                address_type VARCHAR(20) NOT NULL,
+                country VARCHAR(80) DEFAULT 'France' NOT NULL,
+                postal_code VARCHAR(20) NOT NULL,
+                city VARCHAR(120) NOT NULL,
+                street VARCHAR(255) NOT NULL,
+                street_complement VARCHAR(255) DEFAULT NULL,
+                bennes INT DEFAULT NULL,
+                triage_provider BOOLEAN DEFAULT FALSE NOT NULL,
+                position INT DEFAULT 0 NOT NULL,
+                created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL,
+                updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL,
+                created_by INT DEFAULT NULL,
+                updated_by INT DEFAULT NULL,
+                PRIMARY KEY (id),
+                CONSTRAINT chk_supplier_address_type
+                    CHECK (address_type IN ('PROSPECT', 'DEPART', 'RENDU')),
+                CONSTRAINT fk_supplier_address_supplier
+                    FOREIGN KEY (supplier_id) REFERENCES supplier (id) ON DELETE CASCADE,
+                CONSTRAINT fk_supplier_address_created_by
+                    FOREIGN KEY (created_by) REFERENCES "user" (id) ON DELETE SET NULL,
+                CONSTRAINT fk_supplier_address_updated_by
+                    FOREIGN KEY (updated_by) REFERENCES "user" (id) ON DELETE SET NULL
+            )
+            SQL);
+        $this->addSql('CREATE INDEX idx_supplier_address_supplier ON supplier_address (supplier_id)');
+
+        $this->comment('supplier_address', '_table', 'Adresses d un fournisseur (1:n) — type PROSPECT/DEPART/RENDU exclusif (RG-2.09), >= 1 site rattache (RG-2.06).');
+        $this->comment('supplier_address', 'id', 'Identifiant interne auto-incremente.');
+        $this->comment('supplier_address', 'supplier_id', 'FK -> supplier.id, ON DELETE CASCADE — fournisseur proprietaire de l adresse.');
+        $this->comment('supplier_address', 'address_type', 'Type d adresse : PROSPECT | DEPART | RENDU (radio exclusif par construction — RG-2.09, chk_supplier_address_type).');
+        $this->comment('supplier_address', 'country', 'Pays de l adresse — defaut France.');
+        $this->comment('supplier_address', 'postal_code', 'Code postal (4-5 chiffres attendus).');
+        $this->comment('supplier_address', 'city', 'Ville — preremplie depuis le code postal via API BAN cote front.');
+        $this->comment('supplier_address', 'street', 'Numero et voie de l adresse.');
+        $this->comment('supplier_address', 'street_complement', 'Complement d adresse (etage, batiment...) — optionnel.');
+        $this->comment('supplier_address', 'bennes', 'Nombre de bennes sur le site fournisseur (entier nullable) — specifique fournisseur.');
+        $this->comment('supplier_address', 'triage_provider', 'Le fournisseur est prestataire de triage sur cette adresse. Faux par defaut.');
+        $this->comment('supplier_address', 'position', 'Ordre d affichage de l adresse dans la liste du fournisseur (croissant).');
+        $this->addTimestampableBlamableComments('supplier_address');
+    }
+
+    // =================================================================
+    // Jointures de supplier_address (M2M)
+    // =================================================================
+
+    private function createSupplierAddressJoinTables(): void
+    {
+        $this->addSql(<<<'SQL'
+            CREATE TABLE supplier_address_site (
+                supplier_address_id INT NOT NULL,
+                site_id INT NOT NULL,
+                PRIMARY KEY (supplier_address_id, site_id),
+                CONSTRAINT fk_supplier_address_site_address
+                    FOREIGN KEY (supplier_address_id) REFERENCES supplier_address (id) ON DELETE CASCADE,
+                CONSTRAINT fk_supplier_address_site_site
+                    FOREIGN KEY (site_id) REFERENCES site (id) ON DELETE RESTRICT
+            )
+            SQL);
+        $this->comment('supplier_address_site', '_table', 'Jointure M2M supplier_address <-> site (Sites) — sites rattaches a l adresse (>= 1 obligatoire, RG-2.06).');
+        $this->comment('supplier_address_site', 'supplier_address_id', 'FK -> supplier_address.id, ON DELETE CASCADE — adresse concernee.');
+        $this->comment('supplier_address_site', 'site_id', 'FK -> site.id, ON DELETE RESTRICT — site rattache a l adresse.');
+
+        $this->addSql(<<<'SQL'
+            CREATE TABLE supplier_address_contact (
+                supplier_address_id INT NOT NULL,
+                supplier_contact_id INT NOT NULL,
+                PRIMARY KEY (supplier_address_id, supplier_contact_id),
+                CONSTRAINT fk_supplier_address_contact_address
+                    FOREIGN KEY (supplier_address_id) REFERENCES supplier_address (id) ON DELETE CASCADE,
+                CONSTRAINT fk_supplier_address_contact_contact
+                    FOREIGN KEY (supplier_contact_id) REFERENCES supplier_contact (id) ON DELETE CASCADE
+            )
+            SQL);
+        $this->comment('supplier_address_contact', '_table', 'Jointure M2M supplier_address <-> supplier_contact — contacts associes a une adresse.');
+        $this->comment('supplier_address_contact', 'supplier_address_id', 'FK -> supplier_address.id, ON DELETE CASCADE — adresse concernee.');
+        $this->comment('supplier_address_contact', 'supplier_contact_id', 'FK -> supplier_contact.id, ON DELETE CASCADE — contact associe a l adresse.');
+
+        $this->addSql(<<<'SQL'
+            CREATE TABLE supplier_address_category (
+                supplier_address_id INT NOT NULL,
+                category_id INT NOT NULL,
+                PRIMARY KEY (supplier_address_id, category_id),
+                CONSTRAINT fk_supplier_address_category_address
+                    FOREIGN KEY (supplier_address_id) REFERENCES supplier_address (id) ON DELETE CASCADE,
+                CONSTRAINT fk_supplier_address_category_category
+                    FOREIGN KEY (category_id) REFERENCES category (id) ON DELETE RESTRICT
+            )
+            SQL);
+        $this->comment('supplier_address_category', '_table', 'Jointure M2M supplier_address <-> category — categories d adresse de type FOURNISSEUR (RG-2.10).');
+        $this->comment('supplier_address_category', 'supplier_address_id', 'FK -> supplier_address.id, ON DELETE CASCADE — adresse concernee.');
+        $this->comment('supplier_address_category', 'category_id', 'FK -> category.id, ON DELETE RESTRICT — categorie d adresse de type FOURNISSEUR (RG-2.10).');
+    }
+
+    // =================================================================
+    // Sous-collection : RIB (1:n)
+    // =================================================================
+
+    private function createSupplierRib(): void
+    {
+        $this->addSql(<<<'SQL'
+            CREATE TABLE supplier_rib (
+                id INT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
+                supplier_id INT NOT NULL,
+                label VARCHAR(120) NOT NULL,
+                bic VARCHAR(20) NOT NULL,
+                iban VARCHAR(34) NOT NULL,
+                position INT DEFAULT 0 NOT NULL,
+                created_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL,
+                updated_at TIMESTAMP(0) WITHOUT TIME ZONE NOT NULL,
+                created_by INT DEFAULT NULL,
+                updated_by INT DEFAULT NULL,
+                PRIMARY KEY (id),
+                CONSTRAINT fk_supplier_rib_supplier
+                    FOREIGN KEY (supplier_id) REFERENCES supplier (id) ON DELETE CASCADE,
+                CONSTRAINT fk_supplier_rib_created_by
+                    FOREIGN KEY (created_by) REFERENCES "user" (id) ON DELETE SET NULL,
+                CONSTRAINT fk_supplier_rib_updated_by
+                    FOREIGN KEY (updated_by) REFERENCES "user" (id) ON DELETE SET NULL
+            )
+            SQL);
+        $this->addSql('CREATE INDEX idx_supplier_rib_supplier ON supplier_rib (supplier_id)');
+
+        $this->comment('supplier_rib', '_table', 'Coordonnees bancaires d un fournisseur (1:n) — >= 1 RIB attendu selon le type de reglement (RG-2.08). Tous les champs audites (pas d AuditIgnore).');
+        $this->comment('supplier_rib', 'id', 'Identifiant interne auto-incremente.');
+        $this->comment('supplier_rib', 'supplier_id', 'FK -> supplier.id, ON DELETE CASCADE — fournisseur proprietaire du RIB.');
+        $this->comment('supplier_rib', 'label', 'Libelle du RIB (ex: compte principal).');
+        $this->comment('supplier_rib', 'bic', 'Code BIC/SWIFT de la banque (8 ou 11 caracteres).');
+        $this->comment('supplier_rib', 'iban', 'IBAN du compte (≤ 34 caracteres).');
+        $this->comment('supplier_rib', 'position', 'Ordre d affichage du RIB dans la liste du fournisseur (croissant).');
+        $this->addTimestampableBlamableComments('supplier_rib');
+    }
+
+    // =================================================================
+    // Helpers
+    // =================================================================
+
+    /**
+     * Pose les 4 commentaires standardises Timestampable/Blamable sur une table,
+     * en reutilisant le catalogue partage (source unique, cf. ERP-67).
+     */
+    private function addTimestampableBlamableComments(string $table): void
+    {
+        foreach (ColumnCommentsCatalog::timestampableBlamableComments() as $column => $description) {
+            $this->comment($table, $column, $description);
+        }
+    }
+
+    /**
+     * Emet un `COMMENT ON TABLE` (colonne speciale `_table`) ou
+     * `COMMENT ON COLUMN` en dollar-quoting Postgres ($_$...$_$) pour eviter
+     * tout echappement d apostrophe.
+     */
+    private function comment(string $table, string $column, string $description): void
+    {
+        $quotedTable = '"'.str_replace('"', '""', $table).'"';
+
+        if ('_table' === $column) {
+            $this->addSql(sprintf('COMMENT ON TABLE %s IS $_$%s$_$', $quotedTable, $description));
+
+            return;
+        }
+
+        $this->addSql(sprintf(
+            'COMMENT ON COLUMN %s.%s IS $_$%s$_$',
+            $quotedTable,
+            '"'.str_replace('"', '""', $column).'"',
+            $description,
+        ));
+    }
+}

src/Module/Catalog/Domain/Entity/Category.php

@@ -112,7 +112,7 @@ class Category implements TimestampableInterface, BlamableInterface, CategoryInt
     // persiste, sans contradiction entre l'ordre Validate / Process.
     #[ORM\Column(length: 120)]
     #[Assert\NotBlank(message: 'Le nom est obligatoire.', normalizer: 'trim')]
-    #[Assert\Length(min: 2, max: 120, normalizer: 'trim')]
+    #[Assert\Length(min: 2, max: 120, minMessage: 'Le nom doit comporter au moins {{ limit }} caractères.', maxMessage: 'Le nom ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['category:read', 'category:write'])]
     private ?string $name = null;
 

src/Module/Catalog/Domain/Repository/CategoryRepositoryInterface.php

@@ -23,7 +23,10 @@ interface CategoryRepositoryInterface
     /**
      * Construit un QueryBuilder de liste avec filtre soft-delete et tri par defaut.
      * - $includeDeleted = false : exclut les categories soft-deleted (RG-1.08)
+     * - $typeCode non null : ne garde que les categories dont le CategoryType
+     *   porte ce code (filtre `?typeCode=`, ex. FOURNISSEUR / CLIENT). Sert au
+     *   multi-select Categorie du fournisseur (M2, RG-2.10).
      * - Tri : name ASC (RG-1.10).
      */
-    public function createListQueryBuilder(bool $includeDeleted = false): QueryBuilder;
+    public function createListQueryBuilder(bool $includeDeleted = false, ?string $typeCode = null): QueryBuilder;
 }

src/Module/Catalog/Infrastructure/ApiPlatform/State/Provider/CategoryProvider.php

@@ -40,7 +40,7 @@ final class CategoryProvider implements ProviderInterface
         $includeDeleted = $this->readIncludeDeleted($context);
 
         if ($operation instanceof CollectionOperationInterface) {
-            $qb = $this->repository->createListQueryBuilder($includeDeleted);
+            $qb = $this->repository->createListQueryBuilder($includeDeleted, $this->readTypeCode($context));
 
             // Echappatoire ?pagination=false : retourne la collection complete sans Paginator.
             // Utile pour les drawers Role/Permission/Site/CategoryType qui alimentent un <select>.
@@ -97,4 +97,22 @@ final class CategoryProvider implements ProviderInterface
 
         return false;
     }
+
+    /**
+     * Lit le filtre `?typeCode=` depuis les filtres API Platform. Renvoie le code
+     * normalise (trim) ou null si absent / vide. Ne contraint pas la casse : la
+     * comparaison SQL se fait sur le code exact stocke (ex. FOURNISSEUR, CLIENT).
+     */
+    private function readTypeCode(array $context): ?string
+    {
+        $raw = $context['filters']['typeCode'] ?? null;
+
+        if (!is_string($raw)) {
+            return null;
+        }
+
+        $raw = trim($raw);
+
+        return '' === $raw ? null : $raw;
+    }
 }

src/Module/Catalog/Infrastructure/DataFixtures/CategoryFixtures.php

@@ -14,14 +14,16 @@ use RuntimeException;
 use Symfony\Component\DependencyInjection\Attribute\Autowire;
 
 /**
- * Fixtures dev/test du module Catalog : ~11 categories de demonstration, toutes
- * rattachees au type unique CLIENT (refonte taxonomie ERP-78). Chaque categorie
- * porte un `code` stable. Alimente le repertoire clients (ClientFixtures, module
- * Commercial) avec des donnees realistes couvrant RG-1.03 (codes DISTRIBUTEUR /
- * COURTIER) et RG-1.29 (codes interdits sur adresse).
+ * Fixtures dev/test du module Catalog : categories de demonstration rattachees
+ * a leur CategoryType. Le type CLIENT porte ~11 categories clients (refonte
+ * taxonomie ERP-78) ; le type FOURNISSEUR porte les categories fournisseurs
+ * (ERP-84 : Negociant, Cooperative...). Chaque categorie porte un `code` stable.
+ * Alimente le repertoire clients (ClientFixtures, module Commercial) avec des
+ * donnees realistes couvrant RG-1.03 (codes DISTRIBUTEUR / COURTIER) et RG-1.29
+ * (codes interdits sur adresse), et le multi-select Categorie fournisseur (M2).
  *
- * Depend de CategoryTypeFixtures : le type CLIENT doit etre seede avant de
- * pouvoir y rattacher des Category.
+ * Depend de CategoryTypeFixtures : les types CLIENT et FOURNISSEUR doivent etre
+ * seedes avant de pouvoir y rattacher des Category.
  *
  * Idempotence : lookup par `code` parmi les categories non supprimees (deletedAt
  * null), coherent avec l'index unique partiel uq_category_code (code WHERE
@@ -39,28 +41,36 @@ use Symfony\Component\DependencyInjection\Attribute\Autowire;
  */
 class CategoryFixtures extends Fixture implements DependentFixtureInterface
 {
-    /** Code du type unique (cf. CategoryTypeFixtures, migration ERP-78). */
-    private const string CLIENT_TYPE_CODE = 'CLIENT';
-
     /**
-     * Source unique des categories de demonstration : nom => code stable. Les 4
-     * premieres (Distributeur / Courtier / Secteur / Autre) sont les categories
+     * Categories de demonstration par code de type. Les 4 premieres categories
+     * CLIENT (Distributeur / Courtier / Secteur / Autre) sont les categories
      * « systeme » reportees des anciens types ; leurs codes pilotent les RG.
+     * Les categories FOURNISSEUR (ERP-84) miroir de la migration
+     * Version20260605120000. Chaque valeur : nom => code stable.
      *
-     * @var array<string, string>
+     * @var array<string, array<string, string>>
      */
-    private const CATEGORIES = [
-        'Distributeur'         => 'DISTRIBUTEUR',
-        'Courtier'             => 'COURTIER',
-        'Secteur'              => 'SECTEUR',
-        'Autre'                => 'AUTRE',
-        'BTP'                  => 'BTP',
-        'Industrie'            => 'INDUSTRIE',
-        'Agro-alimentaire'     => 'AGRO_ALIMENTAIRE',
-        'Transport/Logistique' => 'TRANSPORT_LOGISTIQUE',
-        'Services'             => 'SERVICES',
-        'Association'          => 'ASSOCIATION',
-        'Indépendant'          => 'INDEPENDANT',
+    private const CATEGORIES_BY_TYPE = [
+        'CLIENT' => [
+            'Distributeur'         => 'DISTRIBUTEUR',
+            'Courtier'             => 'COURTIER',
+            'Secteur'              => 'SECTEUR',
+            'Autre'                => 'AUTRE',
+            'BTP'                  => 'BTP',
+            'Industrie'            => 'INDUSTRIE',
+            'Agro-alimentaire'     => 'AGRO_ALIMENTAIRE',
+            'Transport/Logistique' => 'TRANSPORT_LOGISTIQUE',
+            'Services'             => 'SERVICES',
+            'Association'          => 'ASSOCIATION',
+            'Indépendant'          => 'INDEPENDANT',
+        ],
+        'FOURNISSEUR' => [
+            'Négociant'   => 'NEGOCIANT',
+            'Coopérative' => 'COOPERATIVE',
+            'Producteur'  => 'PRODUCTEUR',
+            'Grossiste'   => 'GROSSISTE',
+            'Importateur' => 'IMPORTATEUR',
+        ],
     ];
 
     public function __construct(
@@ -84,31 +94,33 @@ class CategoryFixtures extends Fixture implements DependentFixtureInterface
             return;
         }
 
-        $clientType = null;
+        // Index des types presents par code, pour rattacher chaque categorie.
+        $typesByCode = [];
         foreach ($this->categoryTypeRepository->findAllOrderedByLabel() as $type) {
-            if (self::CLIENT_TYPE_CODE === $type->getCode()) {
-                $clientType = $type;
+            $typesByCode[$type->getCode()] = $type;
+        }
 
-                break;
+        foreach (self::CATEGORIES_BY_TYPE as $typeCode => $categories) {
+            $type = $typesByCode[$typeCode] ?? null;
+
+            if (!$type instanceof CategoryType) {
+                // Misconfiguration : CategoryTypeFixtures n'a pas seede ce type.
+                throw new RuntimeException(sprintf(
+                    'CategoryTypeFixtures doit avoir seede le type "%s" avant CategoryFixtures.',
+                    $typeCode,
+                ));
             }
-        }
 
-        if (!$clientType instanceof CategoryType) {
-            // Misconfiguration : CategoryTypeFixtures n'a pas tourne avant.
-            throw new RuntimeException(
-                'CategoryTypeFixtures doit avoir seede le type "CLIENT" avant CategoryFixtures.',
-            );
-        }
-
-        foreach (self::CATEGORIES as $name => $code) {
-            $this->ensureCategory($manager, $name, $code, $clientType);
+            foreach ($categories as $name => $code) {
+                $this->ensureCategory($manager, $name, $code, $type);
+            }
         }
 
         $manager->flush();
     }
 
     /**
-     * Cree la categorie (name, code) sous le type CLIENT si son code n'existe pas
+     * Cree la categorie (name, code) sous le type fourni si son code n'existe pas
      * encore parmi les categories actives, sinon la laisse en place. Lookup
      * aligne sur l'index unique partiel uq_category_code.
      */

src/Module/Catalog/Infrastructure/DataFixtures/CategoryTypeFixtures.php

@@ -12,10 +12,14 @@ use Doctrine\Persistence\ObjectManager;
 /**
  * Fixtures du module Catalog : seed du type de categorie (M1).
  *
- * Refonte taxonomie ERP-78 : le modele n'a plus qu'UN SEUL `category_type`,
- * CLIENT (code CLIENT, label « Client »). Distributeur / Courtier / Secteur /
- * Autre (et les categories metier fines) sont desormais des `Category` codees
- * rattachees a ce type (cf. CategoryFixtures + migration Version20260602100000).
+ * Refonte taxonomie ERP-78 : le type CLIENT (code CLIENT, label « Client »)
+ * porte les categories clients ; Distributeur / Courtier / Secteur / Autre (et
+ * les categories metier fines) sont des `Category` codees rattachees a ce type
+ * (cf. CategoryFixtures + migration Version20260602100000).
+ *
+ * ERP-84 : ajout du type FOURNISSEUR (code FOURNISSEUR, label « Fournisseur »),
+ * taxonomie distincte des fournisseurs (Negociant, Cooperative...). Mirroir de
+ * la migration Version20260605120000.
  *
  * Pourquoi une fixture EN PLUS du seed de la migration : `category_type` est une
  * entite managee par l ORM, donc le purger Doctrine la vide avant chaque
@@ -31,11 +35,13 @@ use Doctrine\Persistence\ObjectManager;
 class CategoryTypeFixtures extends Fixture
 {
     /**
-     * Source unique du type : code technique => libelle FR. Doit rester aligne
-     * sur le seed de la migration Version20260602100000 (type unique CLIENT).
+     * Source unique des types : code technique => libelle FR. Doit rester aligne
+     * sur le seed des migrations Version20260602100000 (CLIENT) et
+     * Version20260605120000 (FOURNISSEUR).
      */
     private const TYPES = [
-        'CLIENT' => 'Client',
+        'CLIENT'      => 'Client',
+        'FOURNISSEUR' => 'Fournisseur',
     ];
 
     public function __construct(

src/Module/Catalog/Infrastructure/Doctrine/DoctrineCategoryRepository.php

@@ -48,7 +48,7 @@ class DoctrineCategoryRepository extends ServiceEntityRepository implements Cate
         return [] !== $qb->getQuery()->getResult();
     }
 
-    public function createListQueryBuilder(bool $includeDeleted = false): QueryBuilder
+    public function createListQueryBuilder(bool $includeDeleted = false, ?string $typeCode = null): QueryBuilder
     {
         $qb = $this->createQueryBuilder('c')
             ->orderBy('c.name', 'ASC')
@@ -58,6 +58,16 @@ class DoctrineCategoryRepository extends ServiceEntityRepository implements Cate
             $qb->andWhere('c.deletedAt IS NULL');
         }
 
+        // Filtre `?typeCode=` : jointure sur le CategoryType pour ne garder que
+        // les categories du type demande (ex. FOURNISSEUR). La jointure reste
+        // compatible avec le Paginator ORM (fetchJoinCollection) du provider.
+        if (null !== $typeCode) {
+            $qb->join('c.categoryType', 'ct')
+                ->andWhere('ct.code = :typeCode')
+                ->setParameter('typeCode', $typeCode)
+            ;
+        }
+
         return $qb;
     }
 }

src/Module/Commercial/Application/Service/SupplierFieldNormalizer.php

@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Application\Service;
+
+/**
+ * Normalisation serveur des champs texte d'un Supplier / SupplierContact,
+ * appliquee par le SupplierProcessor (et les processors de sous-ressources,
+ * ERP-88) AVANT persistance. Cf. spec-back M2 § 2.11 + RG-2.12. Jumeau de
+ * ClientFieldNormalizer (M1) — duplique volontairement (isolation Client /
+ * Fournisseur, decision § 2.1).
+ *
+ * - companyName : UPPERCASE integral (RG-2.12)
+ * - firstName / lastName (personnes, sur SupplierContact) : Title Case (RG-2.12)
+ * - phone* : chiffres uniquement, ex "06.12.34.56.78" -> "0612345678" (RG-2.12).
+ *   Le formatage d'affichage "XX XX XX XX XX" est de la responsabilite du front.
+ * - email : lowercase integral (RG-2.12)
+ *
+ * Toutes les methodes sont null-safe et trim-ent l'entree ; une chaine vide
+ * apres trim devient null (evite de persister "" dans des colonnes nullable).
+ */
+final class SupplierFieldNormalizer
+{
+    /**
+     * Nom de societe en majuscules (RG-2.12). Conserve null tel quel ; une
+     * chaine non vide est trim + upper. Une chaine vide reste "" (champ
+     * obligatoire : c'est l'Assert\NotBlank qui rejette, pas le normalizer).
+     */
+    public function normalizeCompanyName(?string $value): ?string
+    {
+        if (null === $value) {
+            return null;
+        }
+
+        return mb_strtoupper(trim($value), 'UTF-8');
+    }
+
+    /**
+     * Nom/prenom de personne en Title Case (RG-2.12) : "JEAN dupont" ->
+     * "Jean Dupont". Une chaine vide apres trim devient null.
+     */
+    public function normalizePersonName(?string $value): ?string
+    {
+        if (null === $value) {
+            return null;
+        }
+
+        $value = trim($value);
+
+        return '' === $value ? null : mb_convert_case($value, MB_CASE_TITLE, 'UTF-8');
+    }
+
+    /**
+     * Email en minuscules (RG-2.12). Une chaine vide apres trim devient null.
+     */
+    public function normalizeEmail(?string $value): ?string
+    {
+        if (null === $value) {
+            return null;
+        }
+
+        $value = trim($value);
+
+        return '' === $value ? null : mb_strtolower($value, 'UTF-8');
+    }
+
+    /**
+     * Telephone reduit aux chiffres (RG-2.12) : "06.12.34.56.78" ->
+     * "0612345678". Une valeur sans aucun chiffre devient null.
+     */
+    public function normalizePhone(?string $value): ?string
+    {
+        if (null === $value) {
+            return null;
+        }
+
+        $digits = preg_replace('/\D+/', '', $value) ?? '';
+
+        return '' === $digits ? null : $digits;
+    }
+}

src/Module/Commercial/Application/Validator/ClientAccountingCompletenessValidator.php

@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Application\Validator;
+
+use ApiPlatform\Validator\Exception\ValidationException;
+use App\Module\Commercial\Domain\Entity\Client;
+use Symfony\Component\Validator\ConstraintViolation;
+use Symfony\Component\Validator\ConstraintViolationList;
+
+/**
+ * Validator metier (spec-front § Onglet Comptabilite) : a la soumission complete
+ * de l'onglet Comptabilite, les six champs scalaires obligatoires doivent etre
+ * renseignes (SIREN, Numero de compte, Mode de TVA, N de TVA, Delai de reglement,
+ * Type de reglement). La banque reste conditionnelle (RG-1.12) et les RIB aussi
+ * (RG-1.13) : ils ne sont pas couverts ici.
+ *
+ * Calque sur ClientInformationCompletenessValidator (RG-1.04) : colonnes nullable
+ * en base + validateur contextuel, plutot qu'un Assert\NotBlank sur l'entite (qui
+ * casserait le POST de l'onglet principal, lequel n'envoie aucun champ comptable).
+ *
+ * Invoque par le ClientProcessor uniquement quand le payload porte les six champs
+ * (= une validation d'onglet), jamais sur un PATCH ciblant un seul champ comptable.
+ *
+ * Leve une ValidationException (HTTP 422) listant chaque champ manquant, par
+ * coherence avec les violations Symfony rendues par API Platform (mapping inline
+ * front via useFormErrors, ERP-101).
+ */
+final class ClientAccountingCompletenessValidator
+{
+    public function validate(Client $client): void
+    {
+        // Map champ -> valeur courante des champs obligatoires de l'onglet.
+        $fields = [
+            'siren'         => $client->getSiren(),
+            'accountNumber' => $client->getAccountNumber(),
+            'tvaMode'       => $client->getTvaMode(),
+            'nTva'          => $client->getNTva(),
+            'paymentDelay'  => $client->getPaymentDelay(),
+            'paymentType'   => $client->getPaymentType(),
+        ];
+
+        $violations = new ConstraintViolationList();
+
+        foreach ($fields as $property => $value) {
+            if ($this->isMissing($value)) {
+                $violations->add(new ConstraintViolation(
+                    'Ce champ est obligatoire.',
+                    null,
+                    [],
+                    $client,
+                    $property,
+                    $value,
+                ));
+            }
+        }
+
+        if (count($violations) > 0) {
+            throw new ValidationException($violations);
+        }
+    }
+
+    /**
+     * Une valeur est manquante si null ou, pour une chaine, vide apres trim. Les
+     * references (TvaMode / PaymentDelay / PaymentType) ne sont manquantes que
+     * lorsqu'elles valent null.
+     */
+    private function isMissing(mixed $value): bool
+    {
+        if (null === $value) {
+            return true;
+        }
+
+        return is_string($value) && '' === trim($value);
+    }
+}

src/Module/Commercial/Application/Validator/SupplierInformationCompletenessValidator.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Application\Validator;
+
+use ApiPlatform\Validator\Exception\ValidationException;
+use App\Module\Commercial\Domain\Entity\Supplier;
+use Symfony\Component\Validator\ConstraintViolation;
+use Symfony\Component\Validator\ConstraintViolationList;
+
+/**
+ * Validator metier RG-2.03 (jumeau du ClientInformationCompletenessValidator M1) :
+ * pour un utilisateur portant le role metier Commerciale, TOUS les champs de
+ * l'onglet Information sont obligatoires sur POST comme sur tout PATCH,
+ * independamment des champs reellement envoyes.
+ *
+ * Invoque par le SupplierProcessor des que l'utilisateur courant porte le role
+ * Commerciale (detection du role cote back). Pour les autres roles, ces champs
+ * restent optionnels — le validator n'est pas appele.
+ *
+ * NEW vs Client : ajoute le champ `volumeForecast` (volume previsionnel),
+ * specifique fournisseur.
+ *
+ * Leve une ValidationException (HTTP 422) listant chaque champ manquant, chaque
+ * violation portant son propertyPath (consommable par extractApiViolations,
+ * ERP-101), par coherence avec les violations Symfony rendues par API Platform.
+ */
+final class SupplierInformationCompletenessValidator
+{
+    public function validate(Supplier $supplier): void
+    {
+        // Map champ -> valeur courante de l'onglet Information.
+        $fields = [
+            'description'    => $supplier->getDescription(),
+            'competitors'    => $supplier->getCompetitors(),
+            'foundedAt'      => $supplier->getFoundedAt(),
+            'employeesCount' => $supplier->getEmployeesCount(),
+            'revenueAmount'  => $supplier->getRevenueAmount(),
+            'directorName'   => $supplier->getDirectorName(),
+            'profitAmount'   => $supplier->getProfitAmount(),
+            'volumeForecast' => $supplier->getVolumeForecast(),
+        ];
+
+        $violations = new ConstraintViolationList();
+
+        foreach ($fields as $property => $value) {
+            if ($this->isMissing($value)) {
+                $violations->add(new ConstraintViolation(
+                    sprintf('Ce champ est obligatoire pour le rôle Commerciale (champ "%s").', $property),
+                    null,
+                    [],
+                    $supplier,
+                    $property,
+                    $value,
+                ));
+            }
+        }
+
+        if (count($violations) > 0) {
+            throw new ValidationException($violations);
+        }
+    }
+
+    /**
+     * Une valeur est manquante si null ou, pour une chaine, vide apres trim. Les
+     * zeros numeriques (employeesCount = 0, profitAmount = "0.00",
+     * volumeForecast = 0) sont des valeurs valides : on ne les considere pas
+     * manquants.
+     */
+    private function isMissing(mixed $value): bool
+    {
+        if (null === $value) {
+            return true;
+        }
+
+        return is_string($value) && '' === trim($value);
+    }
+}

src/Module/Commercial/CommercialModule.php

@@ -39,6 +39,11 @@ final class CommercialModule
             ['code' => 'commercial.clients.accounting.view', 'label' => 'Voir l\'onglet Comptabilité d\'un client'],
             ['code' => 'commercial.clients.accounting.manage', 'label' => 'Modifier l\'onglet Comptabilité d\'un client'],
             ['code' => 'commercial.clients.archive', 'label' => 'Archiver / restaurer un client'],
+            ['code' => 'commercial.suppliers.view', 'label' => 'Voir les fournisseurs'],
+            ['code' => 'commercial.suppliers.manage', 'label' => 'Créer / modifier les fournisseurs (hors onglet Comptabilité)'],
+            ['code' => 'commercial.suppliers.accounting.view', 'label' => 'Voir l\'onglet Comptabilité d\'un fournisseur'],
+            ['code' => 'commercial.suppliers.accounting.manage', 'label' => 'Modifier l\'onglet Comptabilité d\'un fournisseur'],
+            ['code' => 'commercial.suppliers.archive', 'label' => 'Archiver / restaurer un fournisseur'],
         ];
     }
 }

src/Module/Commercial/Domain/Entity/Bank.php

@@ -20,12 +20,13 @@ use Symfony\Component\Serializer\Attribute\Groups;
  * permission commercial.clients.view ; POST/PATCH/DELETE -> 405. Pas de
  * Timestampable/Blamable (referentiel statique whiteliste dans
  * EntitiesAreTimestampableBlamableTest::EXCLUDED). Le groupe
- * `client:read:accounting` permet l'embarquement dans la reponse Client.
+ * `client:read:accounting` permet l'embarquement dans la reponse Client ;
+ * `supplier:read:accounting` dans la reponse Fournisseur (M2, ERP-92 — § 4.0).
  */
 #[ApiResource(
     operations: [
         new GetCollection(
-            security: "is_granted('commercial.clients.view')",
+            security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
             normalizationContext: ['groups' => ['bank:read']],
             // Tri par defaut spec M1 § 4.7 : position ASC puis label ASC.
             order: ['position' => 'ASC', 'label' => 'ASC'],
@@ -33,11 +34,11 @@ use Symfony\Component\Serializer\Attribute\Groups;
             paginationClientEnabled: true,
         ),
         new Get(
-            security: "is_granted('commercial.clients.view')",
+            security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
             normalizationContext: ['groups' => ['bank:read']],
         ),
     ],
-    security: "is_granted('commercial.clients.view')",
+    security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
 )]
 #[ORM\Entity(repositoryClass: DoctrineBankRepository::class)]
 #[ORM\Table(name: 'bank')]
@@ -47,15 +48,15 @@ class Bank
     #[ORM\Id]
     #[ORM\GeneratedValue]
     #[ORM\Column]
-    #[Groups(['bank:read', 'client:read:accounting'])]
+    #[Groups(['bank:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?int $id = null;
 
     #[ORM\Column(length: 30)]
-    #[Groups(['bank:read', 'client:read:accounting'])]
+    #[Groups(['bank:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?string $code = null;
 
     #[ORM\Column(length: 120)]
-    #[Groups(['bank:read', 'client:read:accounting'])]
+    #[Groups(['bank:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?string $label = null;
 
     #[ORM\Column(options: ['default' => 0])]

src/Module/Commercial/Domain/Entity/Client.php

@@ -147,35 +147,13 @@ class Client implements TimestampableInterface, BlamableInterface
     // === Formulaire principal ===
     #[ORM\Column(length: 180)]
     #[Assert\NotBlank(message: 'Le nom de l\'entreprise est obligatoire.', normalizer: 'trim')]
-    #[Assert\Length(min: 2, max: 180, normalizer: 'trim')]
+    #[Assert\Length(min: 2, max: 180, minMessage: 'Le nom de l\'entreprise doit comporter au moins {{ limit }} caractères.', maxMessage: 'Le nom de l\'entreprise ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client:read', 'client:write:main'])]
     private ?string $companyName = null;
 
-    // RG-1.01 : firstName OU lastName obligatoire (validation au futur Processor).
-    #[ORM\Column(length: 120, nullable: true)]
-    #[Assert\Length(max: 120, normalizer: 'trim')]
-    #[Groups(['client:read', 'client:write:main'])]
-    private ?string $firstName = null;
-
-    #[ORM\Column(length: 120, nullable: true)]
-    #[Assert\Length(max: 120, normalizer: 'trim')]
-    #[Groups(['client:read', 'client:write:main'])]
-    private ?string $lastName = null;
-
-    #[ORM\Column(length: 20)]
-    #[Assert\NotBlank]
-    #[Groups(['client:read', 'client:write:main'])]
-    private ?string $phonePrimary = null;
-
-    #[ORM\Column(length: 20, nullable: true)]
-    #[Groups(['client:read', 'client:write:main'])]
-    private ?string $phoneSecondary = null;
-
-    #[ORM\Column(length: 180)]
-    #[Assert\NotBlank]
-    #[Assert\Email]
-    #[Groups(['client:read', 'client:write:main'])]
-    private ?string $email = null;
+    // Le contact principal n'est plus porte inline par le Client : les contacts
+    // vivent uniquement dans ClientContact (onglet Contact). RG-1.01 / RG-1.02
+    // supprimees du Client (equivalent RG-1.05 / RG-1.14 sur ClientContact).
 
     // RG-1.03 : distributor / broker auto-references mutuellement exclusives
     // (CHECK chk_client_distrib_or_broker en base).
@@ -210,6 +188,7 @@ class Client implements TimestampableInterface, BlamableInterface
     private ?string $description = null;
 
     #[ORM\Column(length: 255, nullable: true)]
+    #[Assert\Length(max: 255, maxMessage: 'Ce champ ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client:read', 'client:write:information'])]
     private ?string $competitors = null;
 
@@ -218,7 +197,7 @@ class Client implements TimestampableInterface, BlamableInterface
     private ?DateTimeImmutable $foundedAt = null;
 
     #[ORM\Column(nullable: true)]
-    #[Assert\PositiveOrZero]
+    #[Assert\PositiveOrZero(message: 'L\'effectif doit être un nombre positif ou nul.')]
     #[Groups(['client:read', 'client:write:information'])]
     private ?int $employeesCount = null;
 
@@ -227,6 +206,7 @@ class Client implements TimestampableInterface, BlamableInterface
     private ?string $revenueAmount = null;
 
     #[ORM\Column(length: 120, nullable: true)]
+    #[Assert\Length(max: 120, maxMessage: 'Le nom du dirigeant ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client:read', 'client:write:information'])]
     private ?string $directorName = null;
 
@@ -239,10 +219,12 @@ class Client implements TimestampableInterface, BlamableInterface
     // futur Provider si l'user a la permission accounting.view). Ecriture via
     // `client:write:accounting` (le futur Processor exige accounting.manage).
     #[ORM\Column(length: 20, nullable: true)]
+    #[Assert\Length(max: 20, maxMessage: 'Le SIREN ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client:read:accounting', 'client:write:accounting'])]
     private ?string $siren = null;
 
     #[ORM\Column(length: 40, nullable: true)]
+    #[Assert\Length(max: 40, maxMessage: 'Le numéro de compte ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client:read:accounting', 'client:write:accounting'])]
     private ?string $accountNumber = null;
 
@@ -252,6 +234,7 @@ class Client implements TimestampableInterface, BlamableInterface
     private ?TvaMode $tvaMode = null;
 
     #[ORM\Column(length: 40, nullable: true)]
+    #[Assert\Length(max: 40, maxMessage: 'Le numéro de TVA ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client:read:accounting', 'client:write:accounting'])]
     private ?string $nTva = null;
 
@@ -326,66 +309,6 @@ class Client implements TimestampableInterface, BlamableInterface
         return $this;
     }
 
-    public function getFirstName(): ?string
-    {
-        return $this->firstName;
-    }
-
-    public function setFirstName(?string $firstName): static
-    {
-        $this->firstName = $firstName;
-
-        return $this;
-    }
-
-    public function getLastName(): ?string
-    {
-        return $this->lastName;
-    }
-
-    public function setLastName(?string $lastName): static
-    {
-        $this->lastName = $lastName;
-
-        return $this;
-    }
-
-    public function getPhonePrimary(): ?string
-    {
-        return $this->phonePrimary;
-    }
-
-    public function setPhonePrimary(string $phonePrimary): static
-    {
-        $this->phonePrimary = $phonePrimary;
-
-        return $this;
-    }
-
-    public function getPhoneSecondary(): ?string
-    {
-        return $this->phoneSecondary;
-    }
-
-    public function setPhoneSecondary(?string $phoneSecondary): static
-    {
-        $this->phoneSecondary = $phoneSecondary;
-
-        return $this;
-    }
-
-    public function getEmail(): ?string
-    {
-        return $this->email;
-    }
-
-    public function setEmail(string $email): static
-    {
-        $this->email = $email;
-
-        return $this;
-    }
-
     public function getDistributor(): ?Client
     {
         return $this->distributor;

src/Module/Commercial/Domain/Entity/ClientAddress.php

@@ -63,6 +63,11 @@ use Symfony\Component\Validator\Context\ExecutionContextInterface;
             uriVariables: [
                 'clientId' => new Link(fromClass: Client::class, toProperty: 'client'),
             ],
+            // read:false : pas de stade lecture du parent. Le Link toProperty
+            // resoudrait l'enfant (SELECT ClientAddress ... WHERE client = :id) et
+            // casse en NonUniqueResult des >= 2 enfants. Le parent est rattache
+            // manuellement par ClientAddressProcessor::linkParent (404 si absent).
+            read: false,
             security: "is_granted('commercial.clients.manage')",
             normalizationContext: ['groups' => ['client_address:read']],
             denormalizationContext: ['groups' => ['client_address:write']],
@@ -125,33 +130,39 @@ class ClientAddress implements TimestampableInterface, BlamableInterface
     private bool $isBilling = false;
 
     #[ORM\Column(length: 80, options: ['default' => 'France'])]
+    #[Assert\Length(max: 80, maxMessage: 'Le pays ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_address:read', 'client_address:write'])]
     private string $country = 'France';
 
     // RG-1.09 : code postal a 4 ou 5 chiffres (pas de controle CP/ville serveur).
+    // Le Regex borne deja la longueur (≤ 5) : pas de Length redondant.
     #[ORM\Column(length: 20)]
-    #[Assert\NotBlank]
+    #[Assert\NotBlank(message: 'Le code postal est obligatoire.', normalizer: 'trim')]
     #[Assert\Regex(pattern: '/^[0-9]{4,5}$/', message: 'Le code postal doit comporter 4 ou 5 chiffres.')]
     #[Groups(['client_address:read', 'client_address:write'])]
     private ?string $postalCode = null;
 
     #[ORM\Column(length: 120)]
-    #[Assert\NotBlank]
+    #[Assert\NotBlank(message: 'La ville est obligatoire.', normalizer: 'trim')]
+    #[Assert\Length(max: 120, maxMessage: 'La ville ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_address:read', 'client_address:write'])]
     private ?string $city = null;
 
     #[ORM\Column(length: 255)]
-    #[Assert\NotBlank]
+    #[Assert\NotBlank(message: 'La rue est obligatoire.', normalizer: 'trim')]
+    #[Assert\Length(max: 255, maxMessage: 'La rue ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_address:read', 'client_address:write'])]
     private ?string $street = null;
 
     #[ORM\Column(length: 255, nullable: true)]
+    #[Assert\Length(max: 255, maxMessage: 'Le complément d\'adresse ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_address:read', 'client_address:write'])]
     private ?string $streetComplement = null;
 
     // RG-1.11 : obligatoire ssi isBilling (validateBillingEmailPresence + CHECK BDD).
     #[ORM\Column(length: 180, nullable: true)]
-    #[Assert\Email]
+    #[Assert\Email(message: 'L\'email de facturation n\'est pas valide.')]
+    #[Assert\Length(max: 180, maxMessage: 'L\'email de facturation ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_address:read', 'client_address:write'])]
     private ?string $billingEmail = null;
 
@@ -177,12 +188,14 @@ class ClientAddress implements TimestampableInterface, BlamableInterface
     #[Groups(['client_address:read', 'client_address:write'])]
     private Collection $contacts;
 
+    // Au moins une categorie est obligatoire sur une adresse (spec-front § Adresse).
     // RG-1.29 : categories de code DISTRIBUTEUR/COURTIER interdites (validateCategoryCodes).
     /** @var Collection<int, CategoryInterface> */
     #[ORM\ManyToMany(targetEntity: CategoryInterface::class)]
     #[ORM\JoinTable(name: 'client_address_category')]
     #[ORM\JoinColumn(name: 'client_address_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
     #[ORM\InverseJoinColumn(name: 'category_id', referencedColumnName: 'id', onDelete: 'RESTRICT')]
+    #[Assert\Count(min: 1, minMessage: 'Au moins une catégorie est obligatoire.')]
     #[Groups(['client_address:read', 'client_address:write'])]
     private Collection $categories;
 

src/Module/Commercial/Domain/Entity/ClientContact.php

@@ -50,6 +50,11 @@ use Symfony\Component\Validator\Constraints as Assert;
             uriVariables: [
                 'clientId' => new Link(fromClass: Client::class, toProperty: 'client'),
             ],
+            // read:false : pas de stade lecture du parent. Le Link toProperty
+            // resoudrait l'enfant (SELECT ClientContact ... WHERE client = :id) et
+            // casse en NonUniqueResult des >= 2 enfants. Le parent est rattache
+            // manuellement par ClientContactProcessor::linkParent (404 si absent).
+            read: false,
             security: "is_granted('commercial.clients.manage')",
             normalizationContext: ['groups' => ['client_contact:read']],
             denormalizationContext: ['groups' => ['client_contact:write']],
@@ -88,30 +93,36 @@ class ClientContact implements TimestampableInterface, BlamableInterface
     // RG-1.05 : firstName OU lastName obligatoire (CHECK BDD + Processor). Les
     // deux restent nullable au niveau ORM.
     #[ORM\Column(length: 120, nullable: true)]
-    #[Assert\Length(max: 120, normalizer: 'trim')]
+    #[Assert\Length(max: 120, maxMessage: 'Le prénom ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_contact:read', 'client_contact:write'])]
     private ?string $firstName = null;
 
     #[ORM\Column(length: 120, nullable: true)]
-    #[Assert\Length(max: 120, normalizer: 'trim')]
+    #[Assert\Length(max: 120, maxMessage: 'Le nom ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_contact:read', 'client_contact:write'])]
     private ?string $lastName = null;
 
     #[ORM\Column(length: 120, nullable: true)]
-    #[Assert\Length(max: 120, normalizer: 'trim')]
+    #[Assert\Length(max: 120, maxMessage: 'La fonction ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_contact:read', 'client_contact:write'])]
     private ?string $jobTitle = null;
 
+    // RG : pas de validation de format telephone (saisie libre), mais une
+    // Assert\Length calee sur la colonne VARCHAR(20) evite l'erreur Postgres
+    // (500 non rattachee au champ) au profit d'une 422 propre (ERP-107).
     #[ORM\Column(length: 20, nullable: true)]
+    #[Assert\Length(max: 20, maxMessage: 'Le téléphone ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_contact:read', 'client_contact:write'])]
     private ?string $phonePrimary = null;
 
     #[ORM\Column(length: 20, nullable: true)]
+    #[Assert\Length(max: 20, maxMessage: 'Le téléphone secondaire ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_contact:read', 'client_contact:write'])]
     private ?string $phoneSecondary = null;
 
     #[ORM\Column(length: 180, nullable: true)]
-    #[Assert\Email]
+    #[Assert\Email(message: 'L\'adresse email n\'est pas valide.')]
+    #[Assert\Length(max: 180, maxMessage: 'L\'email ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_contact:read', 'client_contact:write'])]
     private ?string $email = null;
 

src/Module/Commercial/Domain/Entity/ClientRib.php

@@ -54,6 +54,11 @@ use Symfony\Component\Validator\Constraints as Assert;
             uriVariables: [
                 'clientId' => new Link(fromClass: Client::class, toProperty: 'client'),
             ],
+            // read:false : pas de stade lecture du parent. Le Link toProperty
+            // resoudrait l'enfant (SELECT ClientRib ... WHERE client = :id) et
+            // casse en NonUniqueResult des >= 2 enfants. Le parent est rattache
+            // manuellement par ClientRibProcessor::linkParent (404 si absent).
+            read: false,
             security: "is_granted('commercial.clients.accounting.manage')",
             normalizationContext: ['groups' => ['client_rib:read']],
             denormalizationContext: ['groups' => ['client_rib:write']],
@@ -97,20 +102,22 @@ class ClientRib implements TimestampableInterface, BlamableInterface
     private ?Client $client = null;
 
     #[ORM\Column(length: 120)]
-    #[Assert\NotBlank]
-    #[Assert\Length(max: 120, normalizer: 'trim')]
+    #[Assert\NotBlank(message: 'Le libellé du RIB est obligatoire.', normalizer: 'trim')]
+    #[Assert\Length(max: 120, maxMessage: 'Le libellé ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
     #[Groups(['client_rib:read', 'client:read:accounting', 'client_rib:write'])]
     private ?string $label = null;
 
+    // Bic/Iban bornent deja le format (et donc la longueur) : pas de Length
+    // redondant calee sur la colonne (whitelist du garde-fou ERP-107).
     #[ORM\Column(length: 20)]
-    #[Assert\NotBlank]
-    #[Assert\Bic]
+    #[Assert\NotBlank(message: 'Le BIC est obligatoire.', normalizer: 'trim')]
+    #[Assert\Bic(message: 'Le BIC n\'est pas valide.')]
     #[Groups(['client_rib:read', 'client:read:accounting', 'client_rib:write'])]
     private ?string $bic = null;
 
     #[ORM\Column(length: 34)]
-    #[Assert\NotBlank]
-    #[Assert\Iban]
+    #[Assert\NotBlank(message: 'L\'IBAN est obligatoire.', normalizer: 'trim')]
+    #[Assert\Iban(message: 'L\'IBAN n\'est pas valide.')]
     #[Groups(['client_rib:read', 'client:read:accounting', 'client_rib:write'])]
     private ?string $iban = null;
 

src/Module/Commercial/Domain/Entity/PaymentDelay.php

@@ -20,12 +20,13 @@ use Symfony\Component\Serializer\Attribute\Groups;
  * permission commercial.clients.view ; POST/PATCH/DELETE -> 405. Pas de
  * Timestampable/Blamable (referentiel statique whiteliste dans
  * EntitiesAreTimestampableBlamableTest::EXCLUDED). Le groupe
- * `client:read:accounting` permet l'embarquement dans la reponse Client.
+ * `client:read:accounting` permet l'embarquement dans la reponse Client ;
+ * `supplier:read:accounting` dans la reponse Fournisseur (M2, ERP-92 — § 4.0).
  */
 #[ApiResource(
     operations: [
         new GetCollection(
-            security: "is_granted('commercial.clients.view')",
+            security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
             normalizationContext: ['groups' => ['payment_delay:read']],
             // Tri par defaut spec M1 § 4.7 : position ASC puis label ASC.
             order: ['position' => 'ASC', 'label' => 'ASC'],
@@ -33,11 +34,11 @@ use Symfony\Component\Serializer\Attribute\Groups;
             paginationClientEnabled: true,
         ),
         new Get(
-            security: "is_granted('commercial.clients.view')",
+            security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
             normalizationContext: ['groups' => ['payment_delay:read']],
         ),
     ],
-    security: "is_granted('commercial.clients.view')",
+    security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
 )]
 #[ORM\Entity(repositoryClass: DoctrinePaymentDelayRepository::class)]
 #[ORM\Table(name: 'payment_delay')]
@@ -47,15 +48,15 @@ class PaymentDelay
     #[ORM\Id]
     #[ORM\GeneratedValue]
     #[ORM\Column]
-    #[Groups(['payment_delay:read', 'client:read:accounting'])]
+    #[Groups(['payment_delay:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?int $id = null;
 
     #[ORM\Column(length: 30)]
-    #[Groups(['payment_delay:read', 'client:read:accounting'])]
+    #[Groups(['payment_delay:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?string $code = null;
 
     #[ORM\Column(length: 120)]
-    #[Groups(['payment_delay:read', 'client:read:accounting'])]
+    #[Groups(['payment_delay:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?string $label = null;
 
     #[ORM\Column(options: ['default' => 0])]

src/Module/Commercial/Domain/Entity/PaymentType.php

@@ -23,12 +23,13 @@ use Symfony\Component\Serializer\Attribute\Groups;
  * permission commercial.clients.view ; POST/PATCH/DELETE -> 405. Pas de
  * Timestampable/Blamable (referentiel statique whiteliste dans
  * EntitiesAreTimestampableBlamableTest::EXCLUDED). Le groupe
- * `client:read:accounting` permet l'embarquement dans la reponse Client.
+ * `client:read:accounting` permet l'embarquement dans la reponse Client ;
+ * `supplier:read:accounting` dans la reponse Fournisseur (M2, ERP-92 — § 4.0).
  */
 #[ApiResource(
     operations: [
         new GetCollection(
-            security: "is_granted('commercial.clients.view')",
+            security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
             normalizationContext: ['groups' => ['payment_type:read']],
             // Tri par defaut spec M1 § 4.7 : position ASC puis label ASC.
             order: ['position' => 'ASC', 'label' => 'ASC'],
@@ -36,11 +37,11 @@ use Symfony\Component\Serializer\Attribute\Groups;
             paginationClientEnabled: true,
         ),
         new Get(
-            security: "is_granted('commercial.clients.view')",
+            security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
             normalizationContext: ['groups' => ['payment_type:read']],
         ),
     ],
-    security: "is_granted('commercial.clients.view')",
+    security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
 )]
 #[ORM\Entity(repositoryClass: DoctrinePaymentTypeRepository::class)]
 #[ORM\Table(name: 'payment_type')]
@@ -50,15 +51,15 @@ class PaymentType
     #[ORM\Id]
     #[ORM\GeneratedValue]
     #[ORM\Column]
-    #[Groups(['payment_type:read', 'client:read:accounting'])]
+    #[Groups(['payment_type:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?int $id = null;
 
     #[ORM\Column(length: 30)]
-    #[Groups(['payment_type:read', 'client:read:accounting'])]
+    #[Groups(['payment_type:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?string $code = null;
 
     #[ORM\Column(length: 120)]
-    #[Groups(['payment_type:read', 'client:read:accounting'])]
+    #[Groups(['payment_type:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?string $label = null;
 
     #[ORM\Column(options: ['default' => 0])]

src/Module/Commercial/Domain/Entity/Supplier.php

@@ -0,0 +1,727 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Domain\Entity;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Get;
+use ApiPlatform\Metadata\GetCollection;
+use ApiPlatform\Metadata\Patch;
+use ApiPlatform\Metadata\Post;
+use App\Module\Commercial\Infrastructure\ApiPlatform\State\Processor\SupplierProcessor;
+use App\Module\Commercial\Infrastructure\ApiPlatform\State\Provider\SupplierProvider;
+use App\Module\Commercial\Infrastructure\Doctrine\DoctrineSupplierRepository;
+use App\Shared\Domain\Attribute\Auditable;
+use App\Shared\Domain\Contract\BlamableInterface;
+use App\Shared\Domain\Contract\CategoryInterface;
+use App\Shared\Domain\Contract\SiteInterface;
+use App\Shared\Domain\Contract\TimestampableInterface;
+use App\Shared\Domain\Trait\TimestampableBlamableTrait;
+use DateTimeImmutable;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
+use Symfony\Component\Serializer\Attribute\SerializedName;
+use Symfony\Component\Validator\Constraints as Assert;
+use Symfony\Component\Validator\Context\ExecutionContextInterface;
+
+/**
+ * Fournisseur (M2 Commercial) — entite racine du repertoire fournisseurs,
+ * jumelle du Client (M1). Porte le formulaire principal, l'onglet Information,
+ * l'onglet Comptabilite, le mecanisme d'archivage (is_archived / archived_at) et
+ * le soft-delete technique prepare mais non expose au M2 (deleted_at, HP M3).
+ *
+ * Decisions structurantes (cf. spec M2 § 2 / § 3.3) :
+ *  - Contact inline RETIRE (V0.2, refonte-contact ERP-106) : firstName / lastName
+ *    / phonePrimary / phoneSecondary / email ne sont plus portes par le
+ *    fournisseur — ils vivent uniquement dans SupplierContact (onglet Contacts).
+ *    La garantie « au moins un contact nomme » est portee par RG-2.04 + RG-2.13.
+ *  - PAS d'auto-reference distributor / broker (contrairement au Client).
+ *  - Ajout du champ Information volumeForecast (volume previsionnel, entier),
+ *    specifique fournisseur.
+ *  - Audit complet (#[Auditable]) sur tous les champs (M2M categories audite
+ *    automatiquement). Timestampable / Blamable via le trait Shared.
+ *  - PAS de #[ORM\UniqueConstraint] : l'unicite du nom de societe (RG-2.11) est
+ *    portee par l'index partiel fonctionnel uq_supplier_company_name_active
+ *    (LOWER(company_name) WHERE is_archived = FALSE AND deleted_at IS NULL),
+ *    inexprimable en attribut ORM, donc possede par la seule migration. SIREN et
+ *    email NE SONT PAS uniques (§ 2.6).
+ *  - categories : M2M vers Category (module Catalog) via le contrat
+ *    CategoryInterface + resolve_target_entities (regle n°1, pas d'import direct).
+ *
+ * Contrat de serialisation (RETEX M1, 3 maillons — spec § 4.0) : les read-groups
+ * sont poses ICI (source unique). L'#[ApiResource] (operations + contextes), le
+ * SupplierProvider (liste paginee, exclusion archives, item 404 soft-delete), le
+ * SupplierProcessor (normalisation, archivage, gating accounting/manage en mode
+ * strict, 409 doublon) et le SupplierReadGroupContextBuilder (ajout conditionnel
+ * du groupe supplier:read:accounting selon accounting.view) sont branches ICI
+ * (ERP-87).
+ */
+#[ApiResource(
+    operations: [
+        new GetCollection(
+            security: "is_granted('commercial.suppliers.view')",
+            // La liste embarque les categories (avec leur code/name, groupe
+            // category:read) et les sites agreges des adresses (groupe
+            // site:read) pour alimenter les colonnes « Catégories » et
+            // « Site(s) » du Repertoire (cohérence M1/ERP-62, § 2.12). Cf.
+            // getSites(). Fetch-joins/hydratation deleguee au repository (N+1).
+            normalizationContext: ['groups' => ['supplier:read', 'default:read', 'category:read', 'site:read']],
+            provider: SupplierProvider::class,
+        ),
+        new Get(
+            security: "is_granted('commercial.suppliers.view')",
+            // Detail : fournisseur + sous-collections embarquees (contacts /
+            // adresses + leurs sites/categories/contacts).
+            //  - supplier:read:accounting est ajoute par SupplierReadGroupContextBuilder
+            //    selon la permission (gate les scalaires comptables ET les RIB
+            //    embarques), donc volontairement ABSENT ici (parade bug #4 M1).
+            //  - category:read / site:read indispensables pour embarquer le
+            //    code/name des categories et le name/postalCode des sites (sinon
+            //    stub IRI nu — bugs #1/#2 M1).
+            normalizationContext: ['groups' => [
+                'supplier:read',
+                'supplier:item:read',
+                'category:read',
+                'site:read',
+                'default:read',
+            ]],
+            provider: SupplierProvider::class,
+        ),
+        new Post(
+            security: "is_granted('commercial.suppliers.manage')",
+            normalizationContext: ['groups' => ['supplier:read', 'default:read', 'category:read', 'site:read']],
+            denormalizationContext: ['groups' => ['supplier:write:main']],
+            processor: SupplierProcessor::class,
+        ),
+        new Patch(
+            // Security elargie : `manage` OU `accounting.manage`. Le role Compta
+            // n'a pas `manage` mais doit pouvoir editer l'onglet Comptabilite
+            // d'un fournisseur existant (§ 2.9). Le SupplierProcessor re-gate
+            // ensuite onglet par onglet (mode strict RG-2.16) :
+            //  - champs accounting -> accounting.manage (guardAccounting) ;
+            //  - champs main/information -> manage (guardManage : empeche Compta
+            //    d'editer les autres onglets) ;
+            //  - isArchived -> archive (guardArchive, RG-2.14).
+            security: "is_granted('commercial.suppliers.manage') or is_granted('commercial.suppliers.accounting.manage')",
+            normalizationContext: ['groups' => ['supplier:read', 'default:read', 'category:read', 'site:read']],
+            denormalizationContext: ['groups' => [
+                'supplier:write:main',
+                'supplier:write:information',
+                'supplier:write:accounting',
+                'supplier:write:archive',
+            ]],
+            provider: SupplierProvider::class,
+            processor: SupplierProcessor::class,
+        ),
+        // Pas de Delete au M2 (HP-M3-1). Archivage via PATCH { isArchived: true }.
+    ],
+)]
+#[ORM\Entity(repositoryClass: DoctrineSupplierRepository::class)]
+#[ORM\Table(name: 'supplier')]
+// Index nommes pour matcher la migration (Version20260605130000). L'index unique
+// partiel uq_supplier_company_name_active reste possede par la migration :
+// Doctrine ORM ne sait pas exprimer un index fonctionnel (LOWER) + partiel
+// (WHERE) via attribut. Pas de #[ORM\UniqueConstraint] (§ 2.6).
+#[ORM\Index(name: 'idx_supplier_is_archived', columns: ['is_archived'])]
+#[ORM\Index(name: 'idx_supplier_deleted_at', columns: ['deleted_at'])]
+#[ORM\Index(name: 'idx_supplier_created_by', columns: ['created_by'])]
+#[ORM\Index(name: 'idx_supplier_updated_by', columns: ['updated_by'])]
+#[Auditable]
+class Supplier implements TimestampableInterface, BlamableInterface
+{
+    use TimestampableBlamableTrait;
+
+    /**
+     * RG-2.10 : seules les categories de ce type sont autorisees sur le
+     * fournisseur (entite principale). Miroir de SupplierAddress (ERP-88).
+     * S'appuie sur CategoryInterface::getCategoryTypeCode() (pas d'import du
+     * module Catalog — regle ABSOLUE n°1).
+     */
+    private const string REQUIRED_CATEGORY_TYPE_CODE = 'FOURNISSEUR';
+
+    /** RG-2.07 : code du type de reglement imposant une banque. */
+    private const string PAYMENT_TYPE_VIREMENT = 'VIREMENT';
+
+    /** RG-2.08 : code du type de reglement imposant au moins un RIB. */
+    private const string PAYMENT_TYPE_LCR = 'LCR';
+
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column]
+    #[Groups(['supplier:read'])]
+    private ?int $id = null;
+
+    // === Formulaire principal ===
+    #[ORM\Column(length: 180)]
+    #[Assert\NotBlank(message: 'Le nom du fournisseur est obligatoire.', normalizer: 'trim')]
+    #[Assert\Length(min: 2, max: 180, minMessage: 'Le nom du fournisseur doit comporter au moins {{ limit }} caractères.', maxMessage: 'Le nom du fournisseur ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:read', 'supplier:write:main'])]
+    private ?string $companyName = null;
+
+    // RG : au moins une categorie (Count min 1), de type FOURNISSEUR (RG-2.10,
+    // verifiee au Processor/Validator a ERP-89). M2M vers Category via le contrat
+    // CategoryInterface (resolve_target_entities -> Category). Embarquee en LISTE
+    // ET DETAIL (coherence M1/ERP-62) ; maillon (c) : le contexte inclut
+    // 'category:read' pour exposer id/code/name.
+    /** @var Collection<int, CategoryInterface> */
+    #[ORM\ManyToMany(targetEntity: CategoryInterface::class)]
+    #[ORM\JoinTable(name: 'supplier_category')]
+    #[ORM\JoinColumn(name: 'supplier_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
+    #[ORM\InverseJoinColumn(name: 'category_id', referencedColumnName: 'id', onDelete: 'RESTRICT')]
+    #[Assert\Count(min: 1, minMessage: 'Au moins une catégorie est obligatoire.')]
+    #[Groups(['supplier:read', 'supplier:write:main'])]
+    private Collection $categories;
+
+    // === Onglet Information ===
+    #[ORM\Column(type: 'text', nullable: true)]
+    #[Groups(['supplier:read', 'supplier:write:information'])]
+    private ?string $description = null;
+
+    #[ORM\Column(length: 255, nullable: true)]
+    #[Assert\Length(max: 255, maxMessage: 'Ce champ ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:read', 'supplier:write:information'])]
+    private ?string $competitors = null;
+
+    #[ORM\Column(type: 'date_immutable', nullable: true)]
+    #[Groups(['supplier:read', 'supplier:write:information'])]
+    private ?DateTimeImmutable $foundedAt = null;
+
+    #[ORM\Column(nullable: true)]
+    #[Assert\PositiveOrZero(message: 'L\'effectif doit être un nombre positif ou nul.')]
+    #[Groups(['supplier:read', 'supplier:write:information'])]
+    private ?int $employeesCount = null;
+
+    #[ORM\Column(type: 'decimal', precision: 15, scale: 2, nullable: true)]
+    #[Groups(['supplier:read', 'supplier:write:information'])]
+    private ?string $revenueAmount = null;
+
+    #[ORM\Column(length: 120, nullable: true)]
+    #[Assert\Length(max: 120, maxMessage: 'Le nom du dirigeant ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:read', 'supplier:write:information'])]
+    private ?string $directorName = null;
+
+    #[ORM\Column(type: 'decimal', precision: 15, scale: 2, nullable: true)]
+    #[Groups(['supplier:read', 'supplier:write:information'])]
+    private ?string $profitAmount = null;
+
+    // NEW vs Client : Volume previsionnel (entier).
+    #[ORM\Column(nullable: true)]
+    #[Assert\PositiveOrZero(message: 'Le volume prévisionnel doit être un nombre positif ou nul.')]
+    #[Groups(['supplier:read', 'supplier:write:information'])]
+    private ?int $volumeForecast = null;
+
+    // === Onglet Comptabilite ===
+    // Lecture conditionnee via le groupe `supplier:read:accounting` (ajoute au
+    // contexte par le SupplierReadGroupContextBuilder si l'user a accounting.view,
+    // ERP-87 — un Provider ne peut pas influencer les groupes de serialisation).
+    // Ecriture via `supplier:write:accounting` (le Processor exige accounting.manage).
+    #[ORM\Column(length: 20, nullable: true)]
+    #[Assert\Length(max: 20, maxMessage: 'Le SIREN ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:read:accounting', 'supplier:write:accounting'])]
+    private ?string $siren = null;
+
+    #[ORM\Column(length: 40, nullable: true)]
+    #[Assert\Length(max: 40, maxMessage: 'Le numéro de compte ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:read:accounting', 'supplier:write:accounting'])]
+    private ?string $accountNumber = null;
+
+    #[ORM\ManyToOne(targetEntity: TvaMode::class)]
+    #[ORM\JoinColumn(name: 'tva_mode_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')]
+    #[Groups(['supplier:read:accounting', 'supplier:write:accounting'])]
+    private ?TvaMode $tvaMode = null;
+
+    #[ORM\Column(length: 40, nullable: true)]
+    #[Assert\Length(max: 40, maxMessage: 'Le numéro de TVA ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:read:accounting', 'supplier:write:accounting'])]
+    private ?string $nTva = null;
+
+    #[ORM\ManyToOne(targetEntity: PaymentDelay::class)]
+    #[ORM\JoinColumn(name: 'payment_delay_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')]
+    #[Groups(['supplier:read:accounting', 'supplier:write:accounting'])]
+    private ?PaymentDelay $paymentDelay = null;
+
+    #[ORM\ManyToOne(targetEntity: PaymentType::class)]
+    #[ORM\JoinColumn(name: 'payment_type_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')]
+    #[Groups(['supplier:read:accounting', 'supplier:write:accounting'])]
+    private ?PaymentType $paymentType = null;
+
+    #[ORM\ManyToOne(targetEntity: Bank::class)]
+    #[ORM\JoinColumn(name: 'bank_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')]
+    #[Groups(['supplier:read:accounting', 'supplier:write:accounting'])]
+    private ?Bank $bank = null;
+
+    // === Sous-collections — EMBARQUEES dans le DETAIL (RETEX M1 §2) ===
+    // Maillon (a) : le read-group est porte par le GETTER (getContacts / getAddresses
+    // / getRibs) — sans #[Groups], jamais serialisees. Edition via sous-ressources
+    // POST/PATCH/DELETE (ERP-88).
+    /** @var Collection<int, SupplierContact> */
+    #[ORM\OneToMany(mappedBy: 'supplier', targetEntity: SupplierContact::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
+    private Collection $contacts;
+
+    /** @var Collection<int, SupplierAddress> */
+    #[ORM\OneToMany(mappedBy: 'supplier', targetEntity: SupplierAddress::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
+    private Collection $addresses;
+
+    /** @var Collection<int, SupplierRib> */
+    #[ORM\OneToMany(mappedBy: 'supplier', targetEntity: SupplierRib::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
+    private Collection $ribs;
+
+    // === Archive / Soft delete ===
+    // Groupe d'ECRITURE uniquement sur la propriete (denormalisation PATCH archive).
+    // Le groupe de LECTURE est declare sur le getter isArchived() avec
+    // SerializedName('isArchived') : sans cela, Symfony strip le prefixe "is" et
+    // exposerait la cle JSON "archived" — en pratique la cle est totalement
+    // DROPPEE (piege n°3 du M1). Pattern corrige : Groups + SerializedName sur le getter.
+    #[ORM\Column(name: 'is_archived', options: ['default' => false])]
+    #[Groups(['supplier:write:archive'])]
+    private bool $isArchived = false;
+
+    #[ORM\Column(type: 'datetime_immutable', nullable: true)]
+    #[Groups(['supplier:read'])]
+    private ?DateTimeImmutable $archivedAt = null;
+
+    // Soft delete technique (HP M3) : non expose en lecture/ecriture au M2.
+    #[ORM\Column(type: 'datetime_immutable', nullable: true)]
+    private ?DateTimeImmutable $deletedAt = null;
+
+    public function __construct()
+    {
+        $this->categories = new ArrayCollection();
+        $this->contacts   = new ArrayCollection();
+        $this->addresses  = new ArrayCollection();
+        $this->ribs       = new ArrayCollection();
+    }
+
+    /**
+     * RG-2.10 : toute categorie posee sur le fournisseur doit etre de type
+     * FOURNISSEUR -> sinon 422 avec violation sur le champ `categories`
+     * (propertyPath aligne ERP-101, message FR ERP-107). Miroir de
+     * SupplierAddress::validateCategoryType (ERP-88). S'appuie sur
+     * CategoryInterface::getCategoryTypeCode() (pas d'import du module Catalog —
+     * regle ABSOLUE n°1). Joue avant la base via la validation API Platform, sur
+     * POST (categories ∈ supplier:write:main) comme sur PATCH.
+     */
+    #[Assert\Callback]
+    public function validateCategoryType(ExecutionContextInterface $context): void
+    {
+        foreach ($this->categories as $category) {
+            if ($category instanceof CategoryInterface
+                && self::REQUIRED_CATEGORY_TYPE_CODE !== $category->getCategoryTypeCode()) {
+                $context->buildViolation('Type de catégorie non autorisé (FOURNISSEUR attendu).')
+                    ->atPath('categories')
+                    ->addViolation()
+                ;
+
+                return;
+            }
+        }
+    }
+
+    /**
+     * RG-2.07 / RG-2.08 : coherence du type de reglement comptable. Decision
+     * figee ERP-89 : ces RG inter-champs passent par une contrainte d'entite
+     * (Assert\Callback + ->atPath()) et NON par le SupplierProcessor, afin que
+     * chaque 422 porte un propertyPath exploitable par extractApiViolations
+     * (mapping inline sous le champ, pas un toast — convention ERP-101).
+     *  - RG-2.07 : paymentType = VIREMENT impose une banque -> violation sur `bank`.
+     *  - RG-2.08 : paymentType = LCR impose au moins un RIB -> violation sur `ribs`
+     *    (le 409 sur DELETE du dernier RIB en LCR est porte par ERP-88).
+     *
+     * Ces champs vivant dans le groupe d'ecriture comptable (absent du POST, qui
+     * n'expose que supplier:write:main), la contrainte ne mord en pratique que
+     * sur le PATCH de l'onglet Comptabilite.
+     */
+    #[Assert\Callback]
+    public function validatePaymentTypeConsistency(ExecutionContextInterface $context): void
+    {
+        $paymentCode = $this->paymentType?->getCode();
+
+        if (self::PAYMENT_TYPE_VIREMENT === $paymentCode && null === $this->bank) {
+            $context->buildViolation('La banque est obligatoire pour le type de règlement Virement.')
+                ->atPath('bank')
+                ->addViolation()
+            ;
+        }
+
+        if (self::PAYMENT_TYPE_LCR === $paymentCode && $this->ribs->isEmpty()) {
+            $context->buildViolation('Au moins un RIB est obligatoire pour le type de règlement LCR.')
+                ->atPath('ribs')
+                ->addViolation()
+            ;
+        }
+    }
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getCompanyName(): ?string
+    {
+        return $this->companyName;
+    }
+
+    public function setCompanyName(string $companyName): static
+    {
+        $this->companyName = $companyName;
+
+        return $this;
+    }
+
+    /** @return Collection<int, CategoryInterface> */
+    public function getCategories(): Collection
+    {
+        return $this->categories;
+    }
+
+    public function addCategory(CategoryInterface $category): static
+    {
+        if (!$this->categories->contains($category)) {
+            $this->categories->add($category);
+        }
+
+        return $this;
+    }
+
+    public function removeCategory(CategoryInterface $category): static
+    {
+        $this->categories->removeElement($category);
+
+        return $this;
+    }
+
+    public function getDescription(): ?string
+    {
+        return $this->description;
+    }
+
+    public function setDescription(?string $description): static
+    {
+        $this->description = $description;
+
+        return $this;
+    }
+
+    public function getCompetitors(): ?string
+    {
+        return $this->competitors;
+    }
+
+    public function setCompetitors(?string $competitors): static
+    {
+        $this->competitors = $competitors;
+
+        return $this;
+    }
+
+    public function getFoundedAt(): ?DateTimeImmutable
+    {
+        return $this->foundedAt;
+    }
+
+    public function setFoundedAt(?DateTimeImmutable $foundedAt): static
+    {
+        $this->foundedAt = $foundedAt;
+
+        return $this;
+    }
+
+    public function getEmployeesCount(): ?int
+    {
+        return $this->employeesCount;
+    }
+
+    public function setEmployeesCount(?int $employeesCount): static
+    {
+        $this->employeesCount = $employeesCount;
+
+        return $this;
+    }
+
+    public function getRevenueAmount(): ?string
+    {
+        return $this->revenueAmount;
+    }
+
+    public function setRevenueAmount(?string $revenueAmount): static
+    {
+        $this->revenueAmount = $revenueAmount;
+
+        return $this;
+    }
+
+    public function getDirectorName(): ?string
+    {
+        return $this->directorName;
+    }
+
+    public function setDirectorName(?string $directorName): static
+    {
+        $this->directorName = $directorName;
+
+        return $this;
+    }
+
+    public function getProfitAmount(): ?string
+    {
+        return $this->profitAmount;
+    }
+
+    public function setProfitAmount(?string $profitAmount): static
+    {
+        $this->profitAmount = $profitAmount;
+
+        return $this;
+    }
+
+    public function getVolumeForecast(): ?int
+    {
+        return $this->volumeForecast;
+    }
+
+    public function setVolumeForecast(?int $volumeForecast): static
+    {
+        $this->volumeForecast = $volumeForecast;
+
+        return $this;
+    }
+
+    public function getSiren(): ?string
+    {
+        return $this->siren;
+    }
+
+    public function setSiren(?string $siren): static
+    {
+        $this->siren = $siren;
+
+        return $this;
+    }
+
+    public function getAccountNumber(): ?string
+    {
+        return $this->accountNumber;
+    }
+
+    public function setAccountNumber(?string $accountNumber): static
+    {
+        $this->accountNumber = $accountNumber;
+
+        return $this;
+    }
+
+    public function getTvaMode(): ?TvaMode
+    {
+        return $this->tvaMode;
+    }
+
+    public function setTvaMode(?TvaMode $tvaMode): static
+    {
+        $this->tvaMode = $tvaMode;
+
+        return $this;
+    }
+
+    public function getNTva(): ?string
+    {
+        return $this->nTva;
+    }
+
+    public function setNTva(?string $nTva): static
+    {
+        $this->nTva = $nTva;
+
+        return $this;
+    }
+
+    public function getPaymentDelay(): ?PaymentDelay
+    {
+        return $this->paymentDelay;
+    }
+
+    public function setPaymentDelay(?PaymentDelay $paymentDelay): static
+    {
+        $this->paymentDelay = $paymentDelay;
+
+        return $this;
+    }
+
+    public function getPaymentType(): ?PaymentType
+    {
+        return $this->paymentType;
+    }
+
+    public function setPaymentType(?PaymentType $paymentType): static
+    {
+        $this->paymentType = $paymentType;
+
+        return $this;
+    }
+
+    public function getBank(): ?Bank
+    {
+        return $this->bank;
+    }
+
+    public function setBank(?Bank $bank): static
+    {
+        $this->bank = $bank;
+
+        return $this;
+    }
+
+    /** @return Collection<int, SupplierContact> */
+    #[Groups(['supplier:item:read'])]
+    public function getContacts(): Collection
+    {
+        return $this->contacts;
+    }
+
+    public function addContact(SupplierContact $contact): static
+    {
+        if (!$this->contacts->contains($contact)) {
+            $this->contacts->add($contact);
+            $contact->setSupplier($this);
+        }
+
+        return $this;
+    }
+
+    public function removeContact(SupplierContact $contact): static
+    {
+        if ($this->contacts->removeElement($contact) && $contact->getSupplier() === $this) {
+            $contact->setSupplier(null);
+        }
+
+        return $this;
+    }
+
+    /** @return Collection<int, SupplierAddress> */
+    #[Groups(['supplier:item:read'])]
+    public function getAddresses(): Collection
+    {
+        return $this->addresses;
+    }
+
+    public function addAddress(SupplierAddress $address): static
+    {
+        if (!$this->addresses->contains($address)) {
+            $this->addresses->add($address);
+            $address->setSupplier($this);
+        }
+
+        return $this;
+    }
+
+    public function removeAddress(SupplierAddress $address): static
+    {
+        if ($this->addresses->removeElement($address) && $address->getSupplier() === $this) {
+            $address->setSupplier(null);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Sites distincts rattaches a au moins une adresse du fournisseur (RG-2.06).
+     * Le fournisseur ne porte pas de sites en propre : ils vivent sur les
+     * adresses. Agrege en lecture seule pour la colonne « Site(s) » du Repertoire
+     * (badges colores) — expose en LISTE via le groupe supplier:read (les adresses
+     * completes restent reservees au detail, supplier:item:read). Site n'a pas de
+     * champ `code` : libelle = `name`, prefixe = `postalCode` (§ 2.4 / § 4.0.ter).
+     *
+     * Fetch-join obligatoire (addresses.sites) cote repository pour eviter le N+1
+     * a la serialisation de la liste (cf. DoctrineSupplierRepository, § 2.12).
+     *
+     * @return list<SiteInterface>
+     */
+    #[Groups(['supplier:read'])]
+    public function getSites(): array
+    {
+        $sites = [];
+        foreach ($this->addresses as $address) {
+            foreach ($address->getSites() as $site) {
+                // Deduplication par identite d'objet : un meme site peut etre
+                // rattache a plusieurs adresses du fournisseur.
+                $sites[spl_object_id($site)] = $site;
+            }
+        }
+
+        return array_values($sites);
+    }
+
+    // Embed gate sur le groupe COMPTABLE (et non supplier:item:read comme contacts/
+    // adresses) : supplier:read:accounting n'est ajoute au contexte que si l'user a
+    // accounting.view (SupplierReadGroupContextBuilder, ERP-87). Resultat : la cle `ribs` est
+    // TOTALEMENT ABSENTE du detail pour un user sans accounting.view (ex. Commerciale),
+    // au meme titre que les scalaires comptables — evite la fuite IBAN/BIC (piege n°4 M1).
+    /** @return Collection<int, SupplierRib> */
+    #[Groups(['supplier:read:accounting'])]
+    public function getRibs(): Collection
+    {
+        return $this->ribs;
+    }
+
+    public function addRib(SupplierRib $rib): static
+    {
+        if (!$this->ribs->contains($rib)) {
+            $this->ribs->add($rib);
+            $rib->setSupplier($this);
+        }
+
+        return $this;
+    }
+
+    public function removeRib(SupplierRib $rib): static
+    {
+        if ($this->ribs->removeElement($rib) && $rib->getSupplier() === $this) {
+            $rib->setSupplier(null);
+        }
+
+        return $this;
+    }
+
+    // Groupe de lecture + nom serialise explicite : sans SerializedName, Symfony
+    // exposerait la cle "archived" (strip du prefixe "is" sur les getters) et
+    // droppait silencieusement la cle du JSON (piege n°3 du M1).
+    #[Groups(['supplier:read'])]
+    #[SerializedName('isArchived')]
+    public function isArchived(): bool
+    {
+        return $this->isArchived;
+    }
+
+    public function setIsArchived(bool $isArchived): static
+    {
+        $this->isArchived = $isArchived;
+
+        return $this;
+    }
+
+    public function getArchivedAt(): ?DateTimeImmutable
+    {
+        return $this->archivedAt;
+    }
+
+    public function setArchivedAt(?DateTimeImmutable $archivedAt): static
+    {
+        $this->archivedAt = $archivedAt;
+
+        return $this;
+    }
+
+    public function getDeletedAt(): ?DateTimeImmutable
+    {
+        return $this->deletedAt;
+    }
+
+    public function setDeletedAt(?DateTimeImmutable $deletedAt): static
+    {
+        $this->deletedAt = $deletedAt;
+
+        return $this;
+    }
+}

src/Module/Commercial/Domain/Entity/SupplierAddress.php

@@ -0,0 +1,437 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Domain\Entity;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Delete;
+use ApiPlatform\Metadata\Get;
+use ApiPlatform\Metadata\Link;
+use ApiPlatform\Metadata\Patch;
+use ApiPlatform\Metadata\Post;
+use App\Module\Commercial\Infrastructure\ApiPlatform\State\Processor\SupplierAddressProcessor;
+use App\Module\Commercial\Infrastructure\Doctrine\DoctrineSupplierAddressRepository;
+use App\Shared\Domain\Attribute\Auditable;
+use App\Shared\Domain\Contract\BlamableInterface;
+use App\Shared\Domain\Contract\CategoryInterface;
+use App\Shared\Domain\Contract\SiteInterface;
+use App\Shared\Domain\Contract\TimestampableInterface;
+use App\Shared\Domain\Trait\TimestampableBlamableTrait;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
+use Symfony\Component\Serializer\Attribute\SerializedName;
+use Symfony\Component\Validator\Constraints as Assert;
+use Symfony\Component\Validator\Context\ExecutionContextInterface;
+
+/**
+ * Adresse d'un fournisseur (1:n) — onglet Adresse. Le type d'adresse est un enum
+ * exclusif PROSPECT | DEPART | RENDU (radio cote front — RG-2.09), qui remplace
+ * les 3 booleens prospect/livraison/facturation du Client (M1) ; pas d'email de
+ * facturation au M2. Ajoute deux champs specifiques fournisseur : `bennes`
+ * (entier nullable) et `triageProvider` (prestataire de triage, booleen).
+ *
+ * Relations M2M :
+ *  - sites : SiteInterface (module Sites) via resolve_target_entities — au moins
+ *    un site obligatoire (RG-2.06, Assert\Count). Site n'a pas de `code`.
+ *  - contacts : SupplierContact (meme module).
+ *  - categories : CategoryInterface (module Catalog) via resolve_target_entities —
+ *    type FOURNISSEUR attendu (RG-2.10, Assert\Callback validateCategoryType).
+ *
+ * Embarquee sous `supplier.addresses` au detail (groupe supplier:item:read,
+ * maillon (a)).
+ *
+ * Sous-ressource API (ERP-88, spec § 4.5) :
+ *  - POST /api/suppliers/{supplierId}/addresses : creation rattachee au
+ *    fournisseur parent (Link toProperty 'supplier'), security
+ *    commercial.suppliers.manage.
+ *  - PATCH / DELETE /api/supplier_addresses/{id} : security
+ *    commercial.suppliers.manage.
+ *  - GET /api/supplier_addresses/{id} : lecture unitaire (security view) — la
+ *    lecture courante reste via le parent. Pas de GET collection autonome.
+ * Tout passe par le SupplierAddressProcessor (rattachement parent). Les regles
+ * RG-2.05/2.06/2.09/2.10 sont portees par les contraintes de l'entite (jouees
+ * avant le processor).
+ *
+ * Audite (#[Auditable]) + Timestampable / Blamable.
+ */
+#[ApiResource(
+    operations: [
+        new Get(
+            security: "is_granted('commercial.suppliers.view')",
+            // site:read + category:read : embarquent les Site / Category lies
+            // (maillon (c)) plutot que des IRI nus dans le retour.
+            normalizationContext: ['groups' => ['supplier:item:read', 'site:read', 'category:read', 'default:read']],
+        ),
+        new Post(
+            uriTemplate: '/suppliers/{supplierId}/addresses',
+            uriVariables: [
+                'supplierId' => new Link(fromClass: Supplier::class, toProperty: 'supplier'),
+            ],
+            // read:false : pas de stade lecture du parent. Le Link toProperty
+            // resoudrait l'enfant (SELECT SupplierAddress ... WHERE supplier = :id)
+            // et casse en NonUniqueResult des >= 2 enfants. Le parent est rattache
+            // manuellement par SupplierAddressProcessor::linkParent (404 si absent).
+            read: false,
+            security: "is_granted('commercial.suppliers.manage')",
+            normalizationContext: ['groups' => ['supplier:item:read', 'site:read', 'category:read', 'default:read']],
+            denormalizationContext: ['groups' => ['supplier:write:addresses']],
+            processor: SupplierAddressProcessor::class,
+        ),
+        new Patch(
+            security: "is_granted('commercial.suppliers.manage')",
+            normalizationContext: ['groups' => ['supplier:item:read', 'site:read', 'category:read', 'default:read']],
+            denormalizationContext: ['groups' => ['supplier:write:addresses']],
+            processor: SupplierAddressProcessor::class,
+        ),
+        new Delete(
+            security: "is_granted('commercial.suppliers.manage')",
+            processor: SupplierAddressProcessor::class,
+        ),
+    ],
+)]
+#[ORM\Entity(repositoryClass: DoctrineSupplierAddressRepository::class)]
+#[ORM\Table(name: 'supplier_address')]
+#[ORM\Index(name: 'idx_supplier_address_supplier', columns: ['supplier_id'])]
+#[Auditable]
+class SupplierAddress implements TimestampableInterface, BlamableInterface
+{
+    use TimestampableBlamableTrait;
+
+    /**
+     * Valeurs autorisees de address_type (RG-2.09). Miroir applicatif du CHECK BDD
+     * chk_supplier_address_type : alimente l'Assert\Choice (422 propre rattachee
+     * au champ avant la base) et reste la source des options cote front.
+     */
+    public const array ADDRESS_TYPES = ['PROSPECT', 'DEPART', 'RENDU'];
+
+    /**
+     * RG-2.10 : seules les categories de ce type sont autorisees sur une adresse
+     * fournisseur. S'appuie sur CategoryInterface::getCategoryTypeCode() (pas
+     * d'import du module Catalog — regle ABSOLUE n°1).
+     */
+    private const string REQUIRED_CATEGORY_TYPE_CODE = 'FOURNISSEUR';
+
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column]
+    #[Groups(['supplier:item:read'])]
+    private ?int $id = null;
+
+    #[ORM\ManyToOne(targetEntity: Supplier::class, inversedBy: 'addresses')]
+    #[ORM\JoinColumn(name: 'supplier_id', referencedColumnName: 'id', nullable: false, onDelete: 'CASCADE')]
+    private ?Supplier $supplier = null;
+
+    // RG-2.09 : enum exclusif. La valeur est bornee par Assert\Choice (longueur de
+    // fait <= 8), d'ou la whitelist du miroir Assert\Length == ORM length (ERP-107,
+    // EntityConstraintsHaveFrenchMessageTest::EXCLUDED_LENGTH_MIRROR).
+    #[ORM\Column(length: 20)]
+    #[Assert\NotBlank(message: 'Le type d\'adresse est obligatoire.', normalizer: 'trim')]
+    #[Assert\Choice(choices: self::ADDRESS_TYPES, message: 'Le type d\'adresse doit être Prospect, Départ ou Rendu.')]
+    #[Groups(['supplier:item:read', 'supplier:write:addresses'])]
+    private ?string $addressType = null;
+
+    #[ORM\Column(length: 80, options: ['default' => 'France'])]
+    #[Assert\Length(max: 80, maxMessage: 'Le pays ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:item:read', 'supplier:write:addresses'])]
+    private string $country = 'France';
+
+    // RG-2.05 : code postal a 4 ou 5 chiffres (pas de controle CP/ville serveur).
+    // Le Regex borne deja la longueur (<= 5) : pas de Length redondant (whitelist).
+    #[ORM\Column(length: 20)]
+    #[Assert\NotBlank(message: 'Le code postal est obligatoire.', normalizer: 'trim')]
+    #[Assert\Regex(pattern: '/^[0-9]{4,5}$/', message: 'Le code postal doit comporter 4 ou 5 chiffres.')]
+    #[Groups(['supplier:item:read', 'supplier:write:addresses'])]
+    private ?string $postalCode = null;
+
+    #[ORM\Column(length: 120)]
+    #[Assert\NotBlank(message: 'La ville est obligatoire.', normalizer: 'trim')]
+    #[Assert\Length(max: 120, maxMessage: 'La ville ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:item:read', 'supplier:write:addresses'])]
+    private ?string $city = null;
+
+    #[ORM\Column(length: 255)]
+    #[Assert\NotBlank(message: 'La rue est obligatoire.', normalizer: 'trim')]
+    #[Assert\Length(max: 255, maxMessage: 'La rue ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:item:read', 'supplier:write:addresses'])]
+    private ?string $street = null;
+
+    #[ORM\Column(length: 255, nullable: true)]
+    #[Assert\Length(max: 255, maxMessage: 'Le complément d\'adresse ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:item:read', 'supplier:write:addresses'])]
+    private ?string $streetComplement = null;
+
+    // Specifique fournisseur : nombre de bennes sur le site.
+    #[ORM\Column(nullable: true)]
+    #[Assert\PositiveOrZero(message: 'Le nombre de bennes doit être un nombre positif ou nul.')]
+    #[Groups(['supplier:item:read', 'supplier:write:addresses'])]
+    private ?int $bennes = null;
+
+    // Specifique fournisseur : prestataire de triage sur cette adresse. Groupe
+    // d'ECRITURE uniquement sur la propriete ; le groupe de LECTURE est porte par
+    // le getter isTriageProvider() avec SerializedName('triageProvider') — sinon
+    // Symfony strip le prefixe "is" et droppe la cle (piege n°3 du M1).
+    #[ORM\Column(name: 'triage_provider', options: ['default' => false])]
+    #[Groups(['supplier:write:addresses'])]
+    private bool $triageProvider = false;
+
+    // Ordre d'affichage de l'adresse (gere serveur, non expose au M2).
+    #[ORM\Column(options: ['default' => 0])]
+    private int $position = 0;
+
+    // RG-2.06 : au moins un site rattache a chaque adresse.
+    /** @var Collection<int, SiteInterface> */
+    #[ORM\ManyToMany(targetEntity: SiteInterface::class)]
+    #[ORM\JoinTable(name: 'supplier_address_site')]
+    #[ORM\JoinColumn(name: 'supplier_address_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
+    #[ORM\InverseJoinColumn(name: 'site_id', referencedColumnName: 'id', onDelete: 'RESTRICT')]
+    #[Assert\Count(min: 1, minMessage: 'Au moins un site est obligatoire.')]
+    #[Groups(['supplier:item:read', 'supplier:write:addresses'])]
+    private Collection $sites;
+
+    /** @var Collection<int, SupplierContact> */
+    #[ORM\ManyToMany(targetEntity: SupplierContact::class)]
+    #[ORM\JoinTable(name: 'supplier_address_contact')]
+    #[ORM\JoinColumn(name: 'supplier_address_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
+    #[ORM\InverseJoinColumn(name: 'supplier_contact_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
+    #[Groups(['supplier:item:read', 'supplier:write:addresses'])]
+    private Collection $contacts;
+
+    // RG-2.10 : categories d'adresse de type FOURNISSEUR (controle au Processor).
+    /** @var Collection<int, CategoryInterface> */
+    #[ORM\ManyToMany(targetEntity: CategoryInterface::class)]
+    #[ORM\JoinTable(name: 'supplier_address_category')]
+    #[ORM\JoinColumn(name: 'supplier_address_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
+    #[ORM\InverseJoinColumn(name: 'category_id', referencedColumnName: 'id', onDelete: 'RESTRICT')]
+    #[Groups(['supplier:item:read', 'supplier:write:addresses'])]
+    private Collection $categories;
+
+    public function __construct()
+    {
+        $this->sites      = new ArrayCollection();
+        $this->contacts   = new ArrayCollection();
+        $this->categories = new ArrayCollection();
+    }
+
+    /**
+     * RG-2.10 : toute categorie posee sur une adresse fournisseur doit etre de
+     * type FOURNISSEUR -> sinon 422 avec violation sur le champ `categories`
+     * (propertyPath aligne ERP-101, message FR ERP-107). S'appuie sur
+     * CategoryInterface::getCategoryTypeCode() (pas d'import du module Catalog —
+     * regle ABSOLUE n°1). Joue avant la base via la validation API Platform.
+     */
+    #[Assert\Callback]
+    public function validateCategoryType(ExecutionContextInterface $context): void
+    {
+        foreach ($this->categories as $category) {
+            if ($category instanceof CategoryInterface
+                && self::REQUIRED_CATEGORY_TYPE_CODE !== $category->getCategoryTypeCode()) {
+                $context->buildViolation('Type de catégorie non autorisé (FOURNISSEUR attendu).')
+                    ->atPath('categories')
+                    ->addViolation()
+                ;
+
+                return;
+            }
+        }
+    }
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getSupplier(): ?Supplier
+    {
+        return $this->supplier;
+    }
+
+    public function setSupplier(?Supplier $supplier): static
+    {
+        $this->supplier = $supplier;
+
+        return $this;
+    }
+
+    public function getAddressType(): ?string
+    {
+        return $this->addressType;
+    }
+
+    public function setAddressType(?string $addressType): static
+    {
+        $this->addressType = $addressType;
+
+        return $this;
+    }
+
+    public function getCountry(): string
+    {
+        return $this->country;
+    }
+
+    public function setCountry(string $country): static
+    {
+        $this->country = $country;
+
+        return $this;
+    }
+
+    public function getPostalCode(): ?string
+    {
+        return $this->postalCode;
+    }
+
+    public function setPostalCode(?string $postalCode): static
+    {
+        $this->postalCode = $postalCode;
+
+        return $this;
+    }
+
+    public function getCity(): ?string
+    {
+        return $this->city;
+    }
+
+    public function setCity(?string $city): static
+    {
+        $this->city = $city;
+
+        return $this;
+    }
+
+    public function getStreet(): ?string
+    {
+        return $this->street;
+    }
+
+    public function setStreet(?string $street): static
+    {
+        $this->street = $street;
+
+        return $this;
+    }
+
+    public function getStreetComplement(): ?string
+    {
+        return $this->streetComplement;
+    }
+
+    public function setStreetComplement(?string $streetComplement): static
+    {
+        $this->streetComplement = $streetComplement;
+
+        return $this;
+    }
+
+    public function getBennes(): ?int
+    {
+        return $this->bennes;
+    }
+
+    public function setBennes(?int $bennes): static
+    {
+        $this->bennes = $bennes;
+
+        return $this;
+    }
+
+    // Groupe de lecture + nom serialise explicite (cf. note sur la propriete) :
+    // sans SerializedName, Symfony exposerait la cle "triage" (strip du prefixe
+    // "is") et, le groupe etant sur la propriete `triageProvider`, droppait
+    // silencieusement la cle du JSON.
+    #[Groups(['supplier:item:read'])]
+    #[SerializedName('triageProvider')]
+    public function isTriageProvider(): bool
+    {
+        return $this->triageProvider;
+    }
+
+    public function setTriageProvider(bool $triageProvider): static
+    {
+        $this->triageProvider = $triageProvider;
+
+        return $this;
+    }
+
+    public function getPosition(): int
+    {
+        return $this->position;
+    }
+
+    public function setPosition(int $position): static
+    {
+        $this->position = $position;
+
+        return $this;
+    }
+
+    /** @return Collection<int, SiteInterface> */
+    public function getSites(): Collection
+    {
+        return $this->sites;
+    }
+
+    public function addSite(SiteInterface $site): static
+    {
+        if (!$this->sites->contains($site)) {
+            $this->sites->add($site);
+        }
+
+        return $this;
+    }
+
+    public function removeSite(SiteInterface $site): static
+    {
+        $this->sites->removeElement($site);
+
+        return $this;
+    }
+
+    /** @return Collection<int, SupplierContact> */
+    public function getContacts(): Collection
+    {
+        return $this->contacts;
+    }
+
+    public function addContact(SupplierContact $contact): static
+    {
+        if (!$this->contacts->contains($contact)) {
+            $this->contacts->add($contact);
+        }
+
+        return $this;
+    }
+
+    public function removeContact(SupplierContact $contact): static
+    {
+        $this->contacts->removeElement($contact);
+
+        return $this;
+    }
+
+    /** @return Collection<int, CategoryInterface> */
+    public function getCategories(): Collection
+    {
+        return $this->categories;
+    }
+
+    public function addCategory(CategoryInterface $category): static
+    {
+        if (!$this->categories->contains($category)) {
+            $this->categories->add($category);
+        }
+
+        return $this;
+    }
+
+    public function removeCategory(CategoryInterface $category): static
+    {
+        $this->categories->removeElement($category);
+
+        return $this;
+    }
+}

src/Module/Commercial/Domain/Entity/SupplierContact.php

@@ -0,0 +1,238 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Domain\Entity;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Delete;
+use ApiPlatform\Metadata\Get;
+use ApiPlatform\Metadata\Link;
+use ApiPlatform\Metadata\Patch;
+use ApiPlatform\Metadata\Post;
+use App\Module\Commercial\Infrastructure\ApiPlatform\State\Processor\SupplierContactProcessor;
+use App\Module\Commercial\Infrastructure\Doctrine\DoctrineSupplierContactRepository;
+use App\Shared\Domain\Attribute\Auditable;
+use App\Shared\Domain\Contract\BlamableInterface;
+use App\Shared\Domain\Contract\TimestampableInterface;
+use App\Shared\Domain\Trait\TimestampableBlamableTrait;
+use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
+use Symfony\Component\Validator\Constraints as Assert;
+
+/**
+ * Contact d'un fournisseur (1:n) — onglet Contacts. Au moins firstName OU
+ * lastName doit etre renseigne (RG-2.04) : contrainte portee par un CHECK BDD
+ * (chk_supplier_contact_name) et validee au Processor (ERP-88) ; l'entite reste
+ * permissive (les deux champs sont nullable).
+ *
+ * Embarque sous `supplier.contacts` au detail (groupe supplier:item:read,
+ * maillon (a) du contrat de serialisation).
+ *
+ * Sous-ressource API (ERP-88, spec § 4.5) :
+ *  - POST /api/suppliers/{supplierId}/contacts : creation rattachee au
+ *    fournisseur parent (Link toProperty 'supplier'), security
+ *    commercial.suppliers.manage.
+ *  - PATCH / DELETE /api/supplier_contacts/{id} : security
+ *    commercial.suppliers.manage. Le DELETE est physique et libre (pas de garde
+ *    « dernier contact » au M2 — RG-2.13 front-driven, la collection peut rester
+ *    vide cote back).
+ *  - GET /api/supplier_contacts/{id} : lecture unitaire (security view) — la
+ *    lecture courante reste via le parent (le fournisseur embarque ses contacts).
+ *    Pas de GET collection autonome.
+ * Tout passe par le SupplierContactProcessor (normalisation RG-2.12, RG-2.04).
+ *
+ * Audite (#[Auditable]) + Timestampable / Blamable (pattern Shared standard).
+ */
+#[ApiResource(
+    operations: [
+        new Get(
+            security: "is_granted('commercial.suppliers.view')",
+            normalizationContext: ['groups' => ['supplier:item:read']],
+        ),
+        new Post(
+            uriTemplate: '/suppliers/{supplierId}/contacts',
+            uriVariables: [
+                'supplierId' => new Link(fromClass: Supplier::class, toProperty: 'supplier'),
+            ],
+            // read:false : pas de stade lecture du parent. Le Link toProperty
+            // resoudrait l'enfant (SELECT SupplierContact ... WHERE supplier = :id)
+            // et casse en NonUniqueResult des >= 2 enfants. Le parent est rattache
+            // manuellement par SupplierContactProcessor::linkParent (404 si absent).
+            read: false,
+            security: "is_granted('commercial.suppliers.manage')",
+            normalizationContext: ['groups' => ['supplier:item:read']],
+            denormalizationContext: ['groups' => ['supplier:write:contacts']],
+            processor: SupplierContactProcessor::class,
+        ),
+        new Patch(
+            security: "is_granted('commercial.suppliers.manage')",
+            normalizationContext: ['groups' => ['supplier:item:read']],
+            denormalizationContext: ['groups' => ['supplier:write:contacts']],
+            processor: SupplierContactProcessor::class,
+        ),
+        new Delete(
+            security: "is_granted('commercial.suppliers.manage')",
+            processor: SupplierContactProcessor::class,
+        ),
+    ],
+)]
+#[ORM\Entity(repositoryClass: DoctrineSupplierContactRepository::class)]
+#[ORM\Table(name: 'supplier_contact')]
+#[ORM\Index(name: 'idx_supplier_contact_supplier', columns: ['supplier_id'])]
+#[Auditable]
+class SupplierContact implements TimestampableInterface, BlamableInterface
+{
+    use TimestampableBlamableTrait;
+
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column]
+    #[Groups(['supplier:item:read'])]
+    private ?int $id = null;
+
+    #[ORM\ManyToOne(targetEntity: Supplier::class, inversedBy: 'contacts')]
+    #[ORM\JoinColumn(name: 'supplier_id', referencedColumnName: 'id', nullable: false, onDelete: 'CASCADE')]
+    private ?Supplier $supplier = null;
+
+    // RG-2.04 : firstName OU lastName obligatoire (CHECK BDD + Processor). Les
+    // deux restent nullable au niveau ORM.
+    #[ORM\Column(length: 120, nullable: true)]
+    #[Assert\Length(max: 120, maxMessage: 'Le prénom ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:item:read', 'supplier:write:contacts'])]
+    private ?string $firstName = null;
+
+    #[ORM\Column(length: 120, nullable: true)]
+    #[Assert\Length(max: 120, maxMessage: 'Le nom ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:item:read', 'supplier:write:contacts'])]
+    private ?string $lastName = null;
+
+    #[ORM\Column(length: 120, nullable: true)]
+    #[Assert\Length(max: 120, maxMessage: 'La fonction ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:item:read', 'supplier:write:contacts'])]
+    private ?string $jobTitle = null;
+
+    // RG : pas de validation de format telephone (saisie libre), mais une
+    // Assert\Length calee sur la colonne VARCHAR(20) evite l'erreur Postgres
+    // (500 non rattachee au champ) au profit d'une 422 propre (ERP-107).
+    #[ORM\Column(length: 20, nullable: true)]
+    #[Assert\Length(max: 20, maxMessage: 'Le téléphone ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:item:read', 'supplier:write:contacts'])]
+    private ?string $phonePrimary = null;
+
+    #[ORM\Column(length: 20, nullable: true)]
+    #[Assert\Length(max: 20, maxMessage: 'Le téléphone secondaire ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:item:read', 'supplier:write:contacts'])]
+    private ?string $phoneSecondary = null;
+
+    #[ORM\Column(length: 180, nullable: true)]
+    #[Assert\Email(message: 'L\'adresse email n\'est pas valide.')]
+    #[Assert\Length(max: 180, maxMessage: 'L\'email ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:item:read', 'supplier:write:contacts'])]
+    private ?string $email = null;
+
+    // Ordre d'affichage du contact (gere serveur, non expose au M2).
+    #[ORM\Column(options: ['default' => 0])]
+    private int $position = 0;
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getSupplier(): ?Supplier
+    {
+        return $this->supplier;
+    }
+
+    public function setSupplier(?Supplier $supplier): static
+    {
+        $this->supplier = $supplier;
+
+        return $this;
+    }
+
+    public function getFirstName(): ?string
+    {
+        return $this->firstName;
+    }
+
+    public function setFirstName(?string $firstName): static
+    {
+        $this->firstName = $firstName;
+
+        return $this;
+    }
+
+    public function getLastName(): ?string
+    {
+        return $this->lastName;
+    }
+
+    public function setLastName(?string $lastName): static
+    {
+        $this->lastName = $lastName;
+
+        return $this;
+    }
+
+    public function getJobTitle(): ?string
+    {
+        return $this->jobTitle;
+    }
+
+    public function setJobTitle(?string $jobTitle): static
+    {
+        $this->jobTitle = $jobTitle;
+
+        return $this;
+    }
+
+    public function getPhonePrimary(): ?string
+    {
+        return $this->phonePrimary;
+    }
+
+    public function setPhonePrimary(?string $phonePrimary): static
+    {
+        $this->phonePrimary = $phonePrimary;
+
+        return $this;
+    }
+
+    public function getPhoneSecondary(): ?string
+    {
+        return $this->phoneSecondary;
+    }
+
+    public function setPhoneSecondary(?string $phoneSecondary): static
+    {
+        $this->phoneSecondary = $phoneSecondary;
+
+        return $this;
+    }
+
+    public function getEmail(): ?string
+    {
+        return $this->email;
+    }
+
+    public function setEmail(?string $email): static
+    {
+        $this->email = $email;
+
+        return $this;
+    }
+
+    public function getPosition(): int
+    {
+        return $this->position;
+    }
+
+    public function setPosition(int $position): static
+    {
+        $this->position = $position;
+
+        return $this;
+    }
+}

src/Module/Commercial/Domain/Entity/SupplierRib.php

@@ -0,0 +1,188 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Domain\Entity;
+
+use ApiPlatform\Metadata\ApiResource;
+use ApiPlatform\Metadata\Delete;
+use ApiPlatform\Metadata\Get;
+use ApiPlatform\Metadata\Link;
+use ApiPlatform\Metadata\Patch;
+use ApiPlatform\Metadata\Post;
+use App\Module\Commercial\Infrastructure\ApiPlatform\State\Processor\SupplierRibProcessor;
+use App\Module\Commercial\Infrastructure\Doctrine\DoctrineSupplierRibRepository;
+use App\Shared\Domain\Attribute\Auditable;
+use App\Shared\Domain\Contract\BlamableInterface;
+use App\Shared\Domain\Contract\TimestampableInterface;
+use App\Shared\Domain\Trait\TimestampableBlamableTrait;
+use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Attribute\Groups;
+use Symfony\Component\Validator\Constraints as Assert;
+
+/**
+ * Coordonnees bancaires d'un fournisseur (1:n) — onglet Comptabilite. Au moins un
+ * RIB est obligatoire si le type de reglement est LCR (RG-2.08, verifie au
+ * Processor : refus du DELETE du dernier RIB sous LCR, ERP-88).
+ *
+ * Embarque sous `supplier.ribs` UNIQUEMENT si l'user a accounting.view : le
+ * read-group est `supplier:read:accounting`, retire du contexte par le
+ * SupplierProvider sinon (gating par omission de cle — evite la fuite IBAN/BIC,
+ * piege n°4 du M1). Aucun #[AuditIgnore] sur iban/bic : l'audit etant admin-only,
+ * la tracabilite RIB est conservee (decision M1 reportee, § 2.7).
+ *
+ * Sous-ressource API (ERP-88, spec § 4.5) — gating comptable renforce :
+ *  - POST /api/suppliers/{supplierId}/ribs : creation rattachee au fournisseur
+ *    parent (Link toProperty 'supplier'), security
+ *    commercial.suppliers.accounting.manage.
+ *  - PATCH / DELETE /api/supplier_ribs/{id} : security
+ *    commercial.suppliers.accounting.manage. Le DELETE refuse la suppression du
+ *    dernier RIB sous LCR (RG-2.08, 409).
+ *  - GET /api/supplier_ribs/{id} : lecture unitaire, security
+ *    commercial.suppliers.accounting.view (donnees bancaires sensibles). Pas de
+ *    GET collection autonome.
+ * Tout passe par le SupplierRibProcessor (RG-2.08 sur DELETE).
+ *
+ * Validation IBAN/BIC : Assert\Iban + Assert\Bic standard Symfony (pas de controle
+ * banque reelle). Audite (#[Auditable]) + Timestampable / Blamable.
+ */
+#[ApiResource(
+    operations: [
+        new Get(
+            security: "is_granted('commercial.suppliers.accounting.view')",
+            normalizationContext: ['groups' => ['supplier:read:accounting']],
+        ),
+        new Post(
+            uriTemplate: '/suppliers/{supplierId}/ribs',
+            uriVariables: [
+                'supplierId' => new Link(fromClass: Supplier::class, toProperty: 'supplier'),
+            ],
+            // read:false : pas de stade lecture du parent. Le Link toProperty
+            // resoudrait l'enfant (SELECT SupplierRib ... WHERE supplier = :id) et
+            // casse en NonUniqueResult des >= 2 enfants. Le parent est rattache
+            // manuellement par SupplierRibProcessor::linkParent (404 si absent).
+            read: false,
+            security: "is_granted('commercial.suppliers.accounting.manage')",
+            normalizationContext: ['groups' => ['supplier:read:accounting']],
+            denormalizationContext: ['groups' => ['supplier:write:accounting']],
+            processor: SupplierRibProcessor::class,
+        ),
+        new Patch(
+            security: "is_granted('commercial.suppliers.accounting.manage')",
+            normalizationContext: ['groups' => ['supplier:read:accounting']],
+            denormalizationContext: ['groups' => ['supplier:write:accounting']],
+            processor: SupplierRibProcessor::class,
+        ),
+        new Delete(
+            security: "is_granted('commercial.suppliers.accounting.manage')",
+            processor: SupplierRibProcessor::class,
+        ),
+    ],
+)]
+#[ORM\Entity(repositoryClass: DoctrineSupplierRibRepository::class)]
+#[ORM\Table(name: 'supplier_rib')]
+#[ORM\Index(name: 'idx_supplier_rib_supplier', columns: ['supplier_id'])]
+#[Auditable]
+class SupplierRib implements TimestampableInterface, BlamableInterface
+{
+    use TimestampableBlamableTrait;
+
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column]
+    #[Groups(['supplier:read:accounting'])]
+    private ?int $id = null;
+
+    #[ORM\ManyToOne(targetEntity: Supplier::class, inversedBy: 'ribs')]
+    #[ORM\JoinColumn(name: 'supplier_id', referencedColumnName: 'id', nullable: false, onDelete: 'CASCADE')]
+    private ?Supplier $supplier = null;
+
+    #[ORM\Column(length: 120)]
+    #[Assert\NotBlank(message: 'Le libellé du RIB est obligatoire.', normalizer: 'trim')]
+    #[Assert\Length(max: 120, maxMessage: 'Le libellé ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
+    #[Groups(['supplier:read:accounting', 'supplier:write:accounting'])]
+    private ?string $label = null;
+
+    // Bic/Iban bornent deja le format (et donc la longueur) : pas de Length
+    // redondant calee sur la colonne (auto-exempte du miroir ERP-107).
+    #[ORM\Column(length: 20)]
+    #[Assert\NotBlank(message: 'Le BIC est obligatoire.', normalizer: 'trim')]
+    #[Assert\Bic(message: 'Le BIC n\'est pas valide.')]
+    #[Groups(['supplier:read:accounting', 'supplier:write:accounting'])]
+    private ?string $bic = null;
+
+    #[ORM\Column(length: 34)]
+    #[Assert\NotBlank(message: 'L\'IBAN est obligatoire.', normalizer: 'trim')]
+    #[Assert\Iban(message: 'L\'IBAN n\'est pas valide.')]
+    #[Groups(['supplier:read:accounting', 'supplier:write:accounting'])]
+    private ?string $iban = null;
+
+    // Ordre d'affichage du RIB (gere serveur, non expose au M2).
+    #[ORM\Column(options: ['default' => 0])]
+    private int $position = 0;
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getSupplier(): ?Supplier
+    {
+        return $this->supplier;
+    }
+
+    public function setSupplier(?Supplier $supplier): static
+    {
+        $this->supplier = $supplier;
+
+        return $this;
+    }
+
+    public function getLabel(): ?string
+    {
+        return $this->label;
+    }
+
+    public function setLabel(string $label): static
+    {
+        $this->label = $label;
+
+        return $this;
+    }
+
+    public function getBic(): ?string
+    {
+        return $this->bic;
+    }
+
+    public function setBic(string $bic): static
+    {
+        $this->bic = $bic;
+
+        return $this;
+    }
+
+    public function getIban(): ?string
+    {
+        return $this->iban;
+    }
+
+    public function setIban(string $iban): static
+    {
+        $this->iban = $iban;
+
+        return $this;
+    }
+
+    public function getPosition(): int
+    {
+        return $this->position;
+    }
+
+    public function setPosition(int $position): static
+    {
+        $this->position = $position;
+
+        return $this;
+    }
+}

src/Module/Commercial/Domain/Entity/TvaMode.php

@@ -17,18 +17,20 @@ use Symfony\Component\Serializer\Attribute\Groups;
  * re-seede en dev/test par CommercialReferentialFixtures.
  *
  * Lecture seule au M1 (HP-M2-2) : seules GetCollection et Get sont exposees
- * (ERP-56), sous la permission commercial.clients.view ; aucune ecriture
+ * (ERP-56), sous la permission commercial.clients.view (elargie aux roles
+ * fournisseurs au M2 via commercial.suppliers.view, ERP-90) ; aucune ecriture
  * declaree -> POST/PATCH/DELETE renvoient 405.
  *
  * Referentiel statique : pas de Timestampable/Blamable (whiteliste dans
  * EntitiesAreTimestampableBlamableTest::EXCLUDED, comme CategoryType). Le
  * groupe `client:read:accounting` permet d'embarquer le mode dans la reponse
- * d'un Client (onglet Comptabilite) au lieu d'un IRI.
+ * d'un Client (onglet Comptabilite) au lieu d'un IRI ; `supplier:read:accounting`
+ * fait de meme dans la reponse Fournisseur (M2, ERP-92 — sinon IRI nu, § 4.0).
  */
 #[ApiResource(
     operations: [
         new GetCollection(
-            security: "is_granted('commercial.clients.view')",
+            security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
             normalizationContext: ['groups' => ['tva_mode:read']],
             // Tri par defaut spec M1 § 4.7 : position ASC puis label ASC
             // (ordre des selecteurs comptables) — provider Doctrine par defaut.
@@ -39,11 +41,11 @@ use Symfony\Component\Serializer\Attribute\Groups;
             paginationClientEnabled: true,
         ),
         new Get(
-            security: "is_granted('commercial.clients.view')",
+            security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
             normalizationContext: ['groups' => ['tva_mode:read']],
         ),
     ],
-    security: "is_granted('commercial.clients.view')",
+    security: "is_granted('commercial.clients.view') or is_granted('commercial.suppliers.view')",
 )]
 #[ORM\Entity(repositoryClass: DoctrineTvaModeRepository::class)]
 #[ORM\Table(name: 'tva_mode')]
@@ -53,15 +55,15 @@ class TvaMode
     #[ORM\Id]
     #[ORM\GeneratedValue]
     #[ORM\Column]
-    #[Groups(['tva_mode:read', 'client:read:accounting'])]
+    #[Groups(['tva_mode:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?int $id = null;
 
     #[ORM\Column(length: 30)]
-    #[Groups(['tva_mode:read', 'client:read:accounting'])]
+    #[Groups(['tva_mode:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?string $code = null;
 
     #[ORM\Column(length: 120)]
-    #[Groups(['tva_mode:read', 'client:read:accounting'])]
+    #[Groups(['tva_mode:read', 'client:read:accounting', 'supplier:read:accounting'])]
     private ?string $label = null;
 
     #[ORM\Column(options: ['default' => 0])]

src/Module/Commercial/Domain/Repository/SupplierAddressRepositoryInterface.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Domain\Repository;
+
+use App\Module\Commercial\Domain\Entity\SupplierAddress;
+
+interface SupplierAddressRepositoryInterface
+{
+    public function findById(int $id): ?SupplierAddress;
+
+    public function save(SupplierAddress $address): void;
+}

src/Module/Commercial/Domain/Repository/SupplierContactRepositoryInterface.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Domain\Repository;
+
+use App\Module\Commercial\Domain\Entity\SupplierContact;
+
+interface SupplierContactRepositoryInterface
+{
+    public function findById(int $id): ?SupplierContact;
+
+    public function save(SupplierContact $contact): void;
+}

src/Module/Commercial/Domain/Repository/SupplierRepositoryInterface.php

@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Domain\Repository;
+
+use App\Module\Commercial\Domain\Entity\Supplier;
+use Doctrine\ORM\QueryBuilder;
+
+interface SupplierRepositoryInterface
+{
+    public function findById(int $id): ?Supplier;
+
+    public function save(Supplier $supplier): void;
+
+    /**
+     * Construit un QueryBuilder de liste pour le repertoire fournisseurs.
+     * - Exclut toujours les fournisseurs soft-deletes (deleted_at IS NOT NULL, RG-2.17).
+     * - Archivage (RG-2.17) :
+     *     - $archivedOnly = true  -> uniquement les archives (is_archived = true) ;
+     *     - sinon $includeArchived = true -> actifs + archives (echappatoire) ;
+     *     - sinon (defaut) -> uniquement les actifs (is_archived = false).
+     *   $archivedOnly a la priorite sur $includeArchived.
+     * - Tri par defaut : companyName ASC (RG-2.17).
+     * - $search : recherche fuzzy insensible a la casse sur companyName + les
+     *   contacts lies (firstName / lastName / email) via sous-requete (D1,
+     *   refonte-contact §4.1). Metacaracteres LIKE echappes. Ignore si null/vide.
+     * - $categoryCodes : restreint aux fournisseurs possedant au moins une
+     *   categorie dont le code est dans la liste (OR). Liste vide = pas de filtre.
+     * - $siteIds : restreint aux fournisseurs ayant au moins une adresse rattachee
+     *   a l'un des sites donnes (OR — RG-2.06). Liste vide = pas de filtre.
+     *
+     * Filtrage centralise ICI (et non dans le provider/controller) pour que la
+     * liste paginee (SupplierProvider) et l'export (SupplierExportController)
+     * partagent strictement la meme logique de selection.
+     *
+     * Contrat = SELECTION uniquement (filtres + tri). Aucun fetch-join to-many :
+     * l'hydratation des collections affichees est deleguee a
+     * {@see self::hydrateListCollections()} pour ne pas imposer le cout d'un
+     * produit cartesien aux chemins non pagines (cf. M1/ERP-100).
+     *
+     * @param list<string> $categoryCodes
+     * @param list<int>    $siteIds
+     */
+    public function createListQueryBuilder(
+        bool $includeArchived = false,
+        ?string $search = null,
+        array $categoryCodes = [],
+        array $siteIds = [],
+        bool $archivedOnly = false,
+    ): QueryBuilder;
+
+    /**
+     * Hydrate en lot les collections affichees par le repertoire (categories,
+     * adresses et leurs sites) sur un jeu de fournisseurs DEJA charges, via
+     * l'identity map Doctrine (memes instances). A appeler apres une selection
+     * bornee (page courante ou jeu d'export) pour eviter le N+1 a la
+     * serialisation, sans imposer de fetch-join au QueryBuilder de selection
+     * (anti N+1, § 2.12).
+     *
+     * Charge les categories et les adresses/sites en DEUX requetes distinctes
+     * (et non un triple fetch-join) pour ne pas multiplier categories x adresses
+     * x sites en un seul produit cartesien.
+     *
+     * @param list<Supplier> $suppliers
+     */
+    public function hydrateListCollections(array $suppliers): void;
+
+    /**
+     * Hydrate en lot la collection `contacts` sur un jeu de fournisseurs DEJA
+     * charges (memes instances via l'identity map). Reservee a l'export XLSX
+     * (§ 4.6) qui a besoin du contact principal : la LISTE paginee n'embarque
+     * pas les contacts (§ 2.12), d'ou une methode dediee plutot qu'une passe
+     * supplementaire dans {@see self::hydrateListCollections()} — on n'impose pas
+     * le cout du chargement des contacts au chemin liste.
+     *
+     * @param list<Supplier> $suppliers
+     */
+    public function hydrateContacts(array $suppliers): void;
+}

src/Module/Commercial/Domain/Repository/SupplierRibRepositoryInterface.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Domain\Repository;
+
+use App\Module\Commercial\Domain\Entity\SupplierRib;
+
+interface SupplierRibRepositoryInterface
+{
+    public function findById(int $id): ?SupplierRib;
+
+    public function save(SupplierRib $rib): void;
+}

src/Module/Commercial/Infrastructure/ApiPlatform/Serializer/SupplierReadGroupContextBuilder.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\ApiPlatform\Serializer;
+
+use ApiPlatform\State\SerializerContextBuilderInterface;
+use App\Module\Commercial\Domain\Entity\Supplier;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\DependencyInjection\Attribute\AsDecorator;
+use Symfony\Component\DependencyInjection\Attribute\AutowireDecorated;
+use Symfony\Component\HttpFoundation\Request;
+
+/**
+ * Decore le context builder de serialisation d'API Platform pour ajouter
+ * DYNAMIQUEMENT le groupe de lecture `supplier:read:accounting` sur les
+ * ressources Supplier, uniquement si l'utilisateur courant a la permission
+ * `commercial.suppliers.accounting.view` (cf. spec-back M2 § 2.9 / § 4.1 /
+ * § 4.2). Jumeau de ClientReadGroupContextBuilder (M1).
+ *
+ * Pourquoi un context builder et pas le Provider : un Provider retourne des
+ * donnees mais ne peut pas influencer les groupes de serialisation. Le contexte
+ * de normalisation est construit ici, en amont du serializer — c'est le point
+ * d'extension idiomatique d'API Platform pour conditionner un groupe selon
+ * l'utilisateur. Realise l'intention « gating du groupe accounting » de la spec
+ * (le groupe n'est jamais pose par defaut sur l'operation : il est AJOUTE ici si
+ * la permission est presente — resultat identique au « retrait » decrit en spec).
+ *
+ * S'applique aux operations de LECTURE (normalization) sur Supplier : liste ET
+ * detail. Sans la permission, les champs comptables (siren, accountNumber,
+ * tvaMode, nTva, paymentDelay, paymentType, bank) ET les RIB embarques (groupe
+ * supplier:read:accounting porte par getRibs()) ne sont jamais serialises — la
+ * cle est totalement absente du JSON (gating par omission, parade bug #4 M1).
+ *
+ * Priorite de decoration -10 : on s'empile APRES ClientReadGroupContextBuilder
+ * (priorite par defaut 0) sur le meme service `api_platform.serializer.context_builder`.
+ * Les deux decorateurs passent la main pour toute ressource autre que la leur :
+ * l'ordre de chainage n'a donc aucun effet fonctionnel, la priorite explicite ne
+ * sert qu'a lever l'ambiguite de deux decorateurs sur un meme service.
+ */
+#[AsDecorator(decorates: 'api_platform.serializer.context_builder', priority: -10)]
+final readonly class SupplierReadGroupContextBuilder implements SerializerContextBuilderInterface
+{
+    public function __construct(
+        #[AutowireDecorated]
+        private SerializerContextBuilderInterface $decorated,
+        private Security $security,
+    ) {}
+
+    public function createFromRequest(Request $request, bool $normalization, ?array $extractedAttributes = null): array
+    {
+        $context = $this->decorated->createFromRequest($request, $normalization, $extractedAttributes);
+
+        // Uniquement en lecture, sur la ressource Supplier, avec la permission.
+        if (!$normalization) {
+            return $context;
+        }
+
+        if (Supplier::class !== ($context['resource_class'] ?? null)) {
+            return $context;
+        }
+
+        if (!$this->security->isGranted('commercial.suppliers.accounting.view')) {
+            return $context;
+        }
+
+        $groups = $context['groups'] ?? [];
+        if (!in_array('supplier:read:accounting', $groups, true)) {
+            $groups[] = 'supplier:read:accounting';
+        }
+        $context['groups'] = $groups;
+
+        return $context;
+    }
+}

src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/ClientAddressProcessor.php

@@ -12,6 +12,7 @@ use App\Module\Commercial\Domain\Entity\Client;
 use App\Module\Commercial\Domain\Entity\ClientAddress;
 use Doctrine\ORM\EntityManagerInterface;
 use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 
 /**
  * Processor d'ecriture de la sous-ressource Adresse d'un client (M1, § 4.5).
@@ -75,9 +76,14 @@ final class ClientAddressProcessor implements ProcessorInterface
             ? $clientId
             : $this->em->getRepository(Client::class)->find($clientId);
 
-        if ($client instanceof Client) {
-            $address->setClient($client);
+        // read:false sur le POST : sans stade lecture, un parent introuvable n'est
+        // plus intercepte en amont -> 404 explicite (sinon 500 au persist sur la
+        // contrainte client_id NOT NULL).
+        if (!$client instanceof Client) {
+            throw new NotFoundHttpException('Client introuvable.');
         }
+
+        $address->setClient($client);
     }
 
     /**

src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/ClientContactProcessor.php

@@ -14,6 +14,7 @@ use App\Module\Commercial\Domain\Entity\ClientContact;
 use Doctrine\ORM\EntityManagerInterface;
 use Symfony\Component\DependencyInjection\Attribute\Autowire;
 use Symfony\Component\HttpKernel\Exception\ConflictHttpException;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 use Symfony\Component\Validator\ConstraintViolation;
 use Symfony\Component\Validator\ConstraintViolationList;
 
@@ -88,9 +89,14 @@ final class ClientContactProcessor implements ProcessorInterface
             ? $clientId
             : $this->em->getRepository(Client::class)->find($clientId);
 
-        if ($client instanceof Client) {
-            $contact->setClient($client);
+        // read:false sur le POST : sans stade lecture, un parent introuvable n'est
+        // plus intercepte en amont -> 404 explicite (sinon 500 au persist sur la
+        // contrainte client_id NOT NULL).
+        if (!$client instanceof Client) {
+            throw new NotFoundHttpException('Client introuvable.');
         }
+
+        $contact->setClient($client);
     }
 
     /**

src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/ClientProcessor.php

@@ -8,6 +8,7 @@ use ApiPlatform\Metadata\Operation;
 use ApiPlatform\State\ProcessorInterface;
 use ApiPlatform\Validator\Exception\ValidationException;
 use App\Module\Commercial\Application\Service\ClientFieldNormalizer;
+use App\Module\Commercial\Application\Validator\ClientAccountingCompletenessValidator;
 use App\Module\Commercial\Application\Validator\ClientInformationCompletenessValidator;
 use App\Module\Commercial\Domain\Entity\Client;
 use App\Shared\Domain\Contract\BusinessRoleAwareInterface;
@@ -29,7 +30,7 @@ use Symfony\Component\Validator\ConstraintViolationList;
 
 /**
  * Processor d'ecriture du repertoire clients (M1). Cf. spec-back M1 § 2.8 /
- * § 2.9 / § 4.3 / § 4.4 + RG-1.01 a RG-1.28.
+ * § 2.9 / § 4.3 / § 4.4 + RG-1.03 a RG-1.28 (RG-1.01/1.02 supprimees : contact inline retire).
  *
  * Sequence (POST / PATCH) :
  *  1. Autorisation additionnelle par groupe d'onglet. La security d'operation
@@ -41,7 +42,7 @@ use Symfony\Component\Validator\ConstraintViolationList;
  *     - champ isArchived dans le payload -> exige archive (RG-1.22, 403) et
  *       interdit toute autre modification dans la meme requete (RG-1.22, 422).
  *  2. Normalisation serveur (RG-1.18 a 1.21) via ClientFieldNormalizer.
- *  3. Regles metier : RG-1.01 (prenom/nom), RG-1.03 (distributor/broker
+ *  3. Regles metier : RG-1.03 (distributor/broker
  *     exclusifs + type de categorie), RG-1.12 (Virement -> banque),
  *     RG-1.13 (LCR -> >= 1 RIB), RG-1.04 (completude Information exigee sur POST
  *     et tout PATCH pour le role Commerciale).
@@ -60,8 +61,7 @@ final class ClientProcessor implements ProcessorInterface
 {
     /** Champs de l'onglet principal (groupe client:write:main). */
     private const array MAIN_FIELDS = [
-        'companyName', 'firstName', 'lastName', 'phonePrimary', 'phoneSecondary',
-        'email', 'distributor', 'broker', 'triageService', 'categories',
+        'companyName', 'distributor', 'broker', 'triageService', 'categories',
     ];
 
     /** Champs de l'onglet Information (groupe client:write:information). */
@@ -76,6 +76,14 @@ final class ClientProcessor implements ProcessorInterface
         'paymentType', 'bank',
     ];
 
+    /**
+     * Champs comptables obligatoires a la validation complete de l'onglet
+     * (spec-front § Onglet Comptabilite). bank est exclu : conditionnel (RG-1.12).
+     */
+    private const array ACCOUNTING_REQUIRED_FIELDS = [
+        'siren', 'accountNumber', 'tvaMode', 'nTva', 'paymentDelay', 'paymentType',
+    ];
+
     /** Champ d'archivage (groupe client:write:archive). */
     private const string ARCHIVE_FIELD = 'isArchived';
 
@@ -101,6 +109,7 @@ final class ClientProcessor implements ProcessorInterface
         private readonly ProcessorInterface $persistProcessor,
         private readonly ClientFieldNormalizer $normalizer,
         private readonly ClientInformationCompletenessValidator $informationValidator,
+        private readonly ClientAccountingCompletenessValidator $accountingValidator,
         private readonly Security $security,
         private readonly RequestStack $requestStack,
         private readonly EntityManagerInterface $em,
@@ -124,9 +133,9 @@ final class ClientProcessor implements ProcessorInterface
         // valeurs normalisees des deux cotes (l'etat persiste l'a deja ete).
         $this->guardManage($data);
 
-        $this->validateMainContact($data);
         $this->validateDistributorBroker($data);
         $this->validateAccountingConsistency($data);
+        $this->validateAccountingCompleteness($data);
         $this->validateInformationCompleteness($data);
 
         try {
@@ -274,11 +283,6 @@ final class ClientProcessor implements ProcessorInterface
     {
         $newValues = [
             'companyName'    => $data->getCompanyName(),
-            'firstName'      => $data->getFirstName(),
-            'lastName'       => $data->getLastName(),
-            'phonePrimary'   => $data->getPhonePrimary(),
-            'phoneSecondary' => $data->getPhoneSecondary(),
-            'email'          => $data->getEmail(),
             'distributor'    => $data->getDistributor(),
             'broker'         => $data->getBroker(),
             'triageService'  => $data->isTriageService(),
@@ -420,39 +424,17 @@ final class ClientProcessor implements ProcessorInterface
     }
 
     /**
-     * Normalisation serveur (RG-1.18 a 1.21). Les setters non-nullables
-     * (companyName, email, phonePrimary) ne sont touches que si une valeur est
-     * presente, pour ne jamais ecraser l'existant lors d'un PATCH partiel.
+     * Normalisation serveur du formulaire principal (RG-1.18). Seul companyName
+     * subsiste cote Client depuis la suppression du contact inline (les champs de
+     * contact — noms, telephones, email — sont normalises par ClientContactProcessor).
+     * Le setter non-nullable n'est touche que si une valeur est presente, pour ne
+     * jamais ecraser l'existant lors d'un PATCH partiel.
      */
     private function normalize(Client $data): void
     {
         if (null !== $data->getCompanyName()) {
             $data->setCompanyName((string) $this->normalizer->normalizeCompanyName($data->getCompanyName()));
         }
-        if (null !== $data->getEmail()) {
-            $data->setEmail((string) $this->normalizer->normalizeEmail($data->getEmail()));
-        }
-        if (null !== $data->getPhonePrimary()) {
-            $data->setPhonePrimary((string) $this->normalizer->normalizePhone($data->getPhonePrimary()));
-        }
-
-        $data->setFirstName($this->normalizer->normalizePersonName($data->getFirstName()));
-        $data->setLastName($this->normalizer->normalizePersonName($data->getLastName()));
-        $data->setPhoneSecondary($this->normalizer->normalizePhone($data->getPhoneSecondary()));
-    }
-
-    /**
-     * RG-1.01 : au moins le prenom OU le nom du contact principal.
-     */
-    private function validateMainContact(Client $data): void
-    {
-        if (null === $data->getFirstName() && null === $data->getLastName()) {
-            $this->throwViolation(
-                'firstName',
-                'Le prénom ou le nom du contact principal est obligatoire.',
-                $data,
-            );
-        }
     }
 
     /**
@@ -515,6 +497,29 @@ final class ClientProcessor implements ProcessorInterface
         }
     }
 
+    /**
+     * spec-front § Onglet Comptabilite : a la validation COMPLETE de l'onglet
+     * (les six champs obligatoires presents dans le payload — le front les envoie
+     * toujours ensemble), chacun doit etre renseigne, sinon 422 par champ. On ne
+     * declenche pas sur un PATCH ciblant un sous-ensemble de champs comptables :
+     * ce n'est pas une validation d'onglet (edition ponctuelle preservee). bank /
+     * RIB restent geres par validateAccountingConsistency (RG-1.12 / RG-1.13).
+     *
+     * Colonnes nullable en base + validateur contextuel (meme parti que RG-1.04) :
+     * un Assert\NotBlank sur l'entite casserait le POST de l'onglet principal, qui
+     * n'envoie aucun champ comptable.
+     */
+    private function validateAccountingCompleteness(Client $data): void
+    {
+        // Declenche uniquement si TOUS les champs requis sont presents dans le
+        // payload (= soumission d'onglet, pas un PATCH partiel cible).
+        if ([] !== array_diff(self::ACCOUNTING_REQUIRED_FIELDS, $this->payloadKeys())) {
+            return;
+        }
+
+        $this->accountingValidator->validate($data);
+    }
+
     /**
      * RG-1.04 (durcie ERP-74) : si l'utilisateur porte le role metier
      * Commerciale, TOUS les champs de l'onglet Information sont obligatoires sur

src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/ClientRibProcessor.php

@@ -12,6 +12,7 @@ use App\Module\Commercial\Domain\Entity\ClientRib;
 use Doctrine\ORM\EntityManagerInterface;
 use Symfony\Component\DependencyInjection\Attribute\Autowire;
 use Symfony\Component\HttpKernel\Exception\ConflictHttpException;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 
 /**
  * Processor d'ecriture de la sous-ressource RIB d'un client (M1, § 4.5).
@@ -77,9 +78,14 @@ final class ClientRibProcessor implements ProcessorInterface
             ? $clientId
             : $this->em->getRepository(Client::class)->find($clientId);
 
-        if ($client instanceof Client) {
-            $rib->setClient($client);
+        // read:false sur le POST : sans stade lecture, un parent introuvable n'est
+        // plus intercepte en amont -> 404 explicite (sinon 500 au persist sur la
+        // contrainte client_id NOT NULL).
+        if (!$client instanceof Client) {
+            throw new NotFoundHttpException('Client introuvable.');
         }
+
+        $rib->setClient($client);
     }
 
     /**

src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/SupplierAddressProcessor.php

@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\ApiPlatform\State\Processor;
+
+use ApiPlatform\Metadata\DeleteOperationInterface;
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\Module\Commercial\Domain\Entity\Supplier;
+use App\Module\Commercial\Domain\Entity\SupplierAddress;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+
+/**
+ * Processor d'ecriture de la sous-ressource Adresse d'un fournisseur (M2,
+ * spec-back § 4.5). Jumeau du ClientAddressProcessor (M1), recentre sur le
+ * perimetre ERP-88.
+ *
+ * Sequence :
+ *  - POST / PATCH : rattachement au fournisseur parent. Aucune normalisation
+ *    specifique (pas d'email de facturation au M2). Les regles de l'onglet
+ *    Adresse sont garanties en amont par des contraintes sur l'entite, jouees
+ *    par API Platform avant ce processor : RG-2.05 (code postal, Assert\Regex),
+ *    RG-2.06 (>= 1 site, Assert\Count), RG-2.09 (type d'adresse, Assert\Choice +
+ *    CHECK BDD), RG-2.10 (categorie de type FOURNISSEUR, Assert\Callback
+ *    SupplierAddress::validateCategoryType).
+ *  - DELETE : aucune regle metier specifique (suppression physique directe).
+ *
+ * La security de l'operation (commercial.suppliers.manage) est appliquee par API
+ * Platform en amont, de meme que la validation Symfony des contraintes d'attribut.
+ *
+ * @implements ProcessorInterface<SupplierAddress, null|SupplierAddress>
+ */
+final class SupplierAddressProcessor implements ProcessorInterface
+{
+    public function __construct(
+        #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
+        private readonly ProcessorInterface $persistProcessor,
+        #[Autowire(service: 'api_platform.doctrine.orm.state.remove_processor')]
+        private readonly ProcessorInterface $removeProcessor,
+        private readonly EntityManagerInterface $em,
+    ) {}
+
+    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
+    {
+        if (!$data instanceof SupplierAddress) {
+            return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+        }
+
+        if ($operation instanceof DeleteOperationInterface) {
+            return $this->removeProcessor->process($data, $operation, $uriVariables, $context);
+        }
+
+        $this->linkParent($data, $uriVariables);
+
+        return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+    }
+
+    /**
+     * Rattache l'adresse au fournisseur parent de la sous-ressource POST
+     * (/suppliers/{supplierId}/addresses) : la relation n'est pas peuplee
+     * automatiquement par le Link sur une ecriture. Sur PATCH, no-op.
+     */
+    private function linkParent(SupplierAddress $address, array $uriVariables): void
+    {
+        if (null !== $address->getSupplier()) {
+            return;
+        }
+
+        $supplierId = $uriVariables['supplierId'] ?? null;
+        if (null === $supplierId) {
+            return;
+        }
+
+        $supplier = $supplierId instanceof Supplier
+            ? $supplierId
+            : $this->em->getRepository(Supplier::class)->find($supplierId);
+
+        // read:false sur le POST : sans stade lecture, un parent introuvable n'est
+        // plus intercepte en amont -> 404 explicite (sinon 500 au persist sur la
+        // contrainte supplier_id NOT NULL).
+        if (!$supplier instanceof Supplier) {
+            throw new NotFoundHttpException('Fournisseur introuvable.');
+        }
+
+        $address->setSupplier($supplier);
+    }
+}

src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/SupplierContactProcessor.php

@@ -0,0 +1,135 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\ApiPlatform\State\Processor;
+
+use ApiPlatform\Metadata\DeleteOperationInterface;
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use ApiPlatform\Validator\Exception\ValidationException;
+use App\Module\Commercial\Application\Service\SupplierFieldNormalizer;
+use App\Module\Commercial\Domain\Entity\Supplier;
+use App\Module\Commercial\Domain\Entity\SupplierContact;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+use Symfony\Component\Validator\ConstraintViolation;
+use Symfony\Component\Validator\ConstraintViolationList;
+
+/**
+ * Processor d'ecriture de la sous-ressource Contact d'un fournisseur (M2,
+ * spec-back § 4.5). Jumeau du ClientContactProcessor (M1), recentre sur le
+ * perimetre ERP-88.
+ *
+ * Sequence :
+ *  - POST / PATCH : rattachement au fournisseur parent, normalisation serveur
+ *    (RG-2.12 : prenom/nom Title Case, telephones reduits aux chiffres, email
+ *    lowercase) via le SupplierFieldNormalizer partage, puis validation RG-2.04
+ *    (au moins prenom OU nom) avant persistance.
+ *  - DELETE : aucune garde « dernier contact » au M2 — contrairement au M1, la
+ *    collection peut rester vide cote back (RG-2.13 front-driven, spec § 4.5).
+ *    Suppression physique directe.
+ *
+ * La security de l'operation (commercial.suppliers.manage) est appliquee par API
+ * Platform en amont, de meme que la validation Symfony des contraintes d'attribut
+ * (Assert\Email, Assert\Length...).
+ *
+ * @implements ProcessorInterface<SupplierContact, null|SupplierContact>
+ */
+final class SupplierContactProcessor implements ProcessorInterface
+{
+    public function __construct(
+        #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
+        private readonly ProcessorInterface $persistProcessor,
+        #[Autowire(service: 'api_platform.doctrine.orm.state.remove_processor')]
+        private readonly ProcessorInterface $removeProcessor,
+        private readonly SupplierFieldNormalizer $normalizer,
+        private readonly EntityManagerInterface $em,
+    ) {}
+
+    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
+    {
+        if (!$data instanceof SupplierContact) {
+            return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+        }
+
+        if ($operation instanceof DeleteOperationInterface) {
+            return $this->removeProcessor->process($data, $operation, $uriVariables, $context);
+        }
+
+        $this->linkParent($data, $uriVariables);
+        $this->normalize($data);
+        $this->validateName($data);
+
+        return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+    }
+
+    /**
+     * Rattache le contact au fournisseur parent de la sous-ressource POST
+     * (/suppliers/{supplierId}/contacts). La relation n'est pas peuplee
+     * automatiquement par le Link sur une operation d'ecriture : on resout le
+     * parent depuis l'uri variable. Sur PATCH (entite existante), le fournisseur
+     * est deja present -> no-op.
+     */
+    private function linkParent(SupplierContact $contact, array $uriVariables): void
+    {
+        if (null !== $contact->getSupplier()) {
+            return;
+        }
+
+        $supplierId = $uriVariables['supplierId'] ?? null;
+        if (null === $supplierId) {
+            return;
+        }
+
+        $supplier = $supplierId instanceof Supplier
+            ? $supplierId
+            : $this->em->getRepository(Supplier::class)->find($supplierId);
+
+        // read:false sur le POST : sans stade lecture, un parent introuvable n'est
+        // plus intercepte en amont -> 404 explicite (sinon 500 au persist sur la
+        // contrainte supplier_id NOT NULL).
+        if (!$supplier instanceof Supplier) {
+            throw new NotFoundHttpException('Fournisseur introuvable.');
+        }
+
+        $contact->setSupplier($supplier);
+    }
+
+    /**
+     * Normalisation serveur (RG-2.12). Toutes les methodes du normalizer sont
+     * null-safe : une chaine vide apres trim devient null.
+     */
+    private function normalize(SupplierContact $contact): void
+    {
+        $contact->setFirstName($this->normalizer->normalizePersonName($contact->getFirstName()));
+        $contact->setLastName($this->normalizer->normalizePersonName($contact->getLastName()));
+        $contact->setPhonePrimary($this->normalizer->normalizePhone($contact->getPhonePrimary()));
+        $contact->setPhoneSecondary($this->normalizer->normalizePhone($contact->getPhoneSecondary()));
+        $contact->setEmail($this->normalizer->normalizeEmail($contact->getEmail()));
+    }
+
+    /**
+     * RG-2.04 : au moins le prenom OU le nom est obligatoire (double garde avec le
+     * CHECK BDD chk_supplier_contact_name — leve une 422 propre rattachee au champ
+     * `firstName` plutot qu'une 500 SQL). Joue apres normalisation, donc les
+     * chaines vides sont deja ramenees a null.
+     */
+    private function validateName(SupplierContact $contact): void
+    {
+        if (null === $contact->getFirstName() && null === $contact->getLastName()) {
+            $violations = new ConstraintViolationList();
+            $violations->add(new ConstraintViolation(
+                'Le prénom ou le nom du contact est obligatoire.',
+                null,
+                [],
+                $contact,
+                'firstName',
+                null,
+            ));
+
+            throw new ValidationException($violations);
+        }
+    }
+}

src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/SupplierProcessor.php

@@ -0,0 +1,527 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\ApiPlatform\State\Processor;
+
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\Module\Commercial\Application\Service\SupplierFieldNormalizer;
+use App\Module\Commercial\Application\Validator\SupplierInformationCompletenessValidator;
+use App\Module\Commercial\Domain\Entity\Supplier;
+use App\Shared\Domain\Contract\BusinessRoleAwareInterface;
+use App\Shared\Domain\Security\BusinessRoles;
+use DateTimeImmutable;
+use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\PersistentCollection;
+use JsonException;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\ConflictHttpException;
+use Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException;
+
+/**
+ * Processor d'ecriture du repertoire fournisseurs (M2). Cf. spec-back M2 § 4.3 /
+ * § 4.4 + RG-2.11 / RG-2.12 / RG-2.14 / RG-2.15 / RG-2.16. Jumeau du
+ * ClientProcessor (M1), recentre sur le perimetre ERP-87.
+ *
+ * Sequence (POST / PATCH) :
+ *  1. Autorisation additionnelle par groupe d'onglet (mode strict RG-2.16). La
+ *     security d'operation du PATCH est elargie a `manage` OU `accounting.manage`
+ *     pour laisser entrer le role Compta ; ce processor re-gate alors finement :
+ *     - champ comptable modifie dans le payload -> exige accounting.manage (403) ;
+ *     - champ main/information modifie -> exige manage (guardManage, 403) :
+ *       empeche Compta d'editer un autre onglet que la Comptabilite (§ 2.9) ;
+ *     - champ isArchived dans le payload -> exige archive (RG-2.14, 403) et
+ *       interdit toute autre modification dans la meme requete (RG-2.14, 422).
+ *  2. Normalisation serveur (RG-2.12) via SupplierFieldNormalizer.
+ *  3. Pose / retrait de archivedAt (RG-2.14 true=now, RG-2.15 false=null).
+ *  4. Persistance via le persist_processor Doctrine, avec traduction des
+ *     collisions d'unicite en 409 (RG-2.11 doublon de nom ; RG-2.15 conflit de
+ *     restauration).
+ *
+ * Validators metier (ERP-89). Decision figee : ce processor ne porte QUE
+ * RG-2.03 (completude Information exigee pour le role Commerciale — detection du
+ * role cote back, non exprimable en contrainte d'entite). Les RG inter-champs
+ * RG-2.07 (Virement -> banque), RG-2.08 (LCR -> >= 1 RIB) et RG-2.10 (categorie
+ * de type FOURNISSEUR) sont portees par des Assert\Callback + ->atPath() sur
+ * l'entite Supplier (jouees par API Platform AVANT ce processor), pour que
+ * chaque 422 porte un propertyPath consommable par extractApiViolations
+ * (mapping inline, pas un toast — convention ERP-101).
+ *
+ * Note : la validation Symfony (Assert\NotBlank, Assert\Count sur categories,
+ * les Callback RG-2.07/2.08/2.10...) est jouee par API Platform AVANT ce
+ * processor ; on n'y traite donc que les regles non exprimables en simples
+ * contraintes d'entite (RG-2.03, qui depend du role de l'utilisateur courant).
+ *
+ * @implements ProcessorInterface<Supplier, Supplier>
+ */
+final class SupplierProcessor implements ProcessorInterface
+{
+    /** Champs de l'onglet principal (groupe supplier:write:main). */
+    private const array MAIN_FIELDS = [
+        'companyName', 'categories',
+    ];
+
+    /** Champs de l'onglet Information (groupe supplier:write:information). */
+    private const array INFORMATION_FIELDS = [
+        'description', 'competitors', 'foundedAt', 'employeesCount',
+        'revenueAmount', 'directorName', 'profitAmount', 'volumeForecast',
+    ];
+
+    /** Champs de l'onglet Comptabilite (groupe supplier:write:accounting). */
+    private const array ACCOUNTING_FIELDS = [
+        'siren', 'accountNumber', 'tvaMode', 'nTva', 'paymentDelay',
+        'paymentType', 'bank',
+    ];
+
+    /** Champ d'archivage (groupe supplier:write:archive). */
+    private const string ARCHIVE_FIELD = 'isArchived';
+
+    private const string PERM_MANAGE            = 'commercial.suppliers.manage';
+    private const string PERM_ACCOUNTING_MANAGE = 'commercial.suppliers.accounting.manage';
+    private const string PERM_ARCHIVE           = 'commercial.suppliers.archive';
+
+    /**
+     * Memoisation du dernier corps de requete decode, clos par le contenu brut.
+     * payloadKeys() est appele plusieurs fois par requete (writablePayloadKeys,
+     * categoriesChanged...) : on evite de rejouer json_decode a chaque appel. La
+     * cle etant le contenu lui-meme et le calcul une fonction pure de ce contenu,
+     * aucune fuite n'est possible entre requetes sur ce service partage (un meme
+     * corps redonne les memes cles).
+     */
+    private ?string $decodedContent = null;
+
+    /** @var list<string> Cles de premier niveau correspondant au corps memoise. */
+    private array $decodedPayloadKeys = [];
+
+    public function __construct(
+        #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
+        private readonly ProcessorInterface $persistProcessor,
+        private readonly SupplierFieldNormalizer $normalizer,
+        private readonly SupplierInformationCompletenessValidator $informationValidator,
+        private readonly Security $security,
+        private readonly RequestStack $requestStack,
+        private readonly EntityManagerInterface $em,
+    ) {}
+
+    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
+    {
+        if (!$data instanceof Supplier) {
+            return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+        }
+
+        $writableKeys = $this->writablePayloadKeys();
+
+        $isArchiveRequest = $this->guardArchive($data, $writableKeys);
+        $this->guardAccounting($data);
+
+        $this->normalize($data);
+
+        // guardManage apres normalize : la comparaison « change vs etat
+        // persiste » des champs texte (companyName...) se fait sur des valeurs
+        // normalisees des deux cotes (l'etat persiste l'a deja ete).
+        $this->guardManage($data);
+
+        $this->validateInformationCompleteness($data);
+
+        try {
+            return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+        } catch (UniqueConstraintViolationException $e) {
+            // Le seul index unique partiel est uq_supplier_company_name_active
+            // (LOWER(company_name) parmi non-archives/non-deletes — § 2.6).
+            if ($isArchiveRequest && false === $data->isArchived()) {
+                // RG-2.15 : restauration en conflit avec un homonyme actif.
+                throw new ConflictHttpException(
+                    'Restauration impossible : un autre fournisseur a pris le nom entre-temps.',
+                    $e,
+                );
+            }
+
+            // RG-2.11 : doublon de nom de societe.
+            throw new ConflictHttpException(
+                sprintf('Un fournisseur nommé "%s" existe déjà.', (string) $data->getCompanyName()),
+                $e,
+            );
+        }
+    }
+
+    /**
+     * RG-2.14 / RG-2.15 : si le payload bascule reellement isArchived, exige la
+     * permission archive (403), interdit toute autre modification (422) et
+     * pose/retire archivedAt. Retourne true si la requete est une requete
+     * d'archivage.
+     *
+     * Le gating est restreint a la mise a jour d'un fournisseur existant ET au
+     * seul cas ou isArchived change vraiment : un POST (entite non encore geree
+     * par l'ORM) ou un PATCH « representation complete » renvoyant isArchived
+     * inchange ne doit declencher ni 403 ni 422 parasite.
+     *
+     * @param list<string> $writableKeys cles ecrivables du payload (hors @* et champs inconnus)
+     */
+    private function guardArchive(Supplier $data, array $writableKeys): bool
+    {
+        // POST / entite non geree : l'archivage est une action de mise a jour.
+        if (!$this->em->contains($data)) {
+            return false;
+        }
+
+        // isArchived inchange par rapport a l'etat persiste : pas une requete
+        // d'archivage (cas du PATCH representation complete).
+        if (!$this->fieldChanged($data, 'isArchived', $data->isArchived())) {
+            return false;
+        }
+
+        if (!$this->security->isGranted(self::PERM_ARCHIVE)) {
+            throw new AccessDeniedHttpException(sprintf(
+                'Le champ "%s" requiert la permission "%s".',
+                self::ARCHIVE_FIELD,
+                self::PERM_ARCHIVE,
+            ));
+        }
+
+        // RG-2.14 : une requete d'archivage ne modifie aucun autre champ ecrivable.
+        if ([] !== array_diff($writableKeys, [self::ARCHIVE_FIELD])) {
+            throw new UnprocessableEntityHttpException(
+                'Une requête d\'archivage ne peut modifier aucun autre champ que "isArchived".',
+            );
+        }
+
+        // RG-2.14 (true -> now) / RG-2.15 (false -> null).
+        $data->setArchivedAt($data->isArchived() ? new DateTimeImmutable() : null);
+
+        return true;
+    }
+
+    /**
+     * RG-2.16 : la modification effective d'un champ comptable exige
+     * accounting.manage, sinon 403 sur l'ensemble du payload (mode strict, pas
+     * de filtrage silencieux). On ne gate que si un champ change reellement par
+     * rapport a l'etat persiste : un POST/PATCH renvoyant des champs comptables
+     * inchanges (ou null en creation) ne declenche pas de 403 parasite. Le
+     * message precise le premier champ fautif.
+     */
+    private function guardAccounting(Supplier $data): void
+    {
+        $changed = $this->changedAccountingFields($data);
+
+        if ([] === $changed) {
+            return;
+        }
+
+        if (!$this->security->isGranted(self::PERM_ACCOUNTING_MANAGE)) {
+            throw new AccessDeniedHttpException(sprintf(
+                'Le champ "%s" requiert la permission "%s".',
+                $changed[0],
+                self::PERM_ACCOUNTING_MANAGE,
+            ));
+        }
+    }
+
+    /**
+     * § 2.9 / RG-2.16 : la modification effective d'un champ « metier » (onglets
+     * principal ou Information) exige `commercial.suppliers.manage`. Sans cette
+     * permission -> 403 sur l'ensemble du payload (mode strict, miroir de
+     * guardAccounting). C'est ce qui empeche le role Compta — qui entre dans le
+     * PATCH via `accounting.manage` (security d'operation elargie) — d'editer
+     * autre chose que l'onglet Comptabilite.
+     *
+     * Ne s'applique qu'aux mises a jour (entite geree) : la creation (POST) est
+     * deja gardee par la security d'operation `manage`, donc inutile de la
+     * re-gater ici (et un POST par un porteur de `manage` passerait de toute
+     * facon).
+     */
+    private function guardManage(Supplier $data): void
+    {
+        if (!$this->em->contains($data)) {
+            return;
+        }
+
+        $changed = $this->changedBusinessFields($data);
+
+        if ([] === $changed) {
+            return;
+        }
+
+        if (!$this->security->isGranted(self::PERM_MANAGE)) {
+            throw new AccessDeniedHttpException(sprintf(
+                'Le champ "%s" requiert la permission "%s".',
+                $changed[0],
+                self::PERM_MANAGE,
+            ));
+        }
+    }
+
+    /**
+     * RG-2.03 : si l'utilisateur porte le role metier Commerciale, TOUS les
+     * champs de l'onglet Information sont obligatoires sur POST comme sur TOUT
+     * PATCH — independamment des champs reellement envoyes. Garantit qu'un
+     * fournisseur cree/edite par une Commerciale ne reste jamais avec un onglet
+     * Information incomplet. Pour les autres roles, ces champs restent optionnels.
+     *
+     * Consequence (cf. spec § 7, miroir RG-1.04) : le POST n'exposant que
+     * supplier:write:main, une Commerciale obtient 422 sur tout POST tant que
+     * l'Information n'est pas complete -> la completude se fait via les PATCH
+     * supplier:write:information.
+     */
+    private function validateInformationCompleteness(Supplier $data): void
+    {
+        if ($this->currentUserIsCommerciale()) {
+            $this->informationValidator->validate($data);
+        }
+    }
+
+    /**
+     * Detection du role metier Commerciale cote back (jamais front), via le
+     * contrat BusinessRoleAwareInterface (pas d'import de User — regle ABSOLUE
+     * n°1). Identique au ClientProcessor (M1).
+     */
+    private function currentUserIsCommerciale(): bool
+    {
+        $user = $this->security->getUser();
+
+        return $user instanceof BusinessRoleAwareInterface
+            && $user->hasBusinessRole(BusinessRoles::COMMERCIALE);
+    }
+
+    /**
+     * Champs « metier » (onglets principal + Information, hors comptabilite et
+     * archivage) dont la valeur courante differe de l'etat persiste. Memes
+     * regles de comparaison que changedAccountingFields (scalaires par valeur).
+     *
+     * Cas particulier `categories` (M2M) : non trace par getOriginalEntityData,
+     * compare par valeur via le snapshot de la PersistentCollection (cf.
+     * categoriesChanged) — la simple presence dans le payload ne suffit pas, sous
+     * peine de 403 parasite sur un PATCH representation complete reincluant des
+     * categories inchangees.
+     *
+     * @return list<string>
+     */
+    private function changedBusinessFields(Supplier $data): array
+    {
+        $newValues = [
+            'companyName'    => $data->getCompanyName(),
+            'description'    => $data->getDescription(),
+            'competitors'    => $data->getCompetitors(),
+            'foundedAt'      => $data->getFoundedAt(),
+            'employeesCount' => $data->getEmployeesCount(),
+            'revenueAmount'  => $data->getRevenueAmount(),
+            'directorName'   => $data->getDirectorName(),
+            'profitAmount'   => $data->getProfitAmount(),
+            'volumeForecast' => $data->getVolumeForecast(),
+        ];
+
+        $changed = [];
+        foreach ($newValues as $field => $newValue) {
+            if ($this->fieldChanged($data, $field, $newValue)) {
+                $changed[] = $field;
+            }
+        }
+
+        if ($this->categoriesChanged($data)) {
+            $changed[] = 'categories';
+        }
+
+        return $changed;
+    }
+
+    /**
+     * Vrai si l'ensemble des categories (M2M) differe reellement de l'etat
+     * persiste. La collection n'etant pas tracee par getOriginalEntityData, on
+     * compare par identifiants (independamment de l'ordre) le snapshot de la
+     * PersistentCollection (etat charge depuis la base) a l'etat courant (apres
+     * application du payload). Symetrique de changedAccountingFields : seul un
+     * changement effectif compte, pas la simple presence dans le payload.
+     *
+     * - POST / entite non geree : fournir des categories est un acte metier
+     *   (branche defensive, guardManage ne s'execute de toute facon que sur
+     *   entite geree).
+     * - categories absent du payload (PATCH partiel) : aucun changement.
+     */
+    private function categoriesChanged(Supplier $data): bool
+    {
+        if (!$this->em->contains($data)) {
+            return true;
+        }
+
+        if (!in_array('categories', $this->payloadKeys(), true)) {
+            return false;
+        }
+
+        $collection = $data->getCategories();
+
+        // Hors PersistentCollection (cas limite hors flux PATCH reel) : faute
+        // d'etat persiste comparable, on se rabat sur la presence payload.
+        if (!$collection instanceof PersistentCollection) {
+            return true;
+        }
+
+        return $this->categoryIdSet($collection->toArray())
+            !== $this->categoryIdSet($collection->getSnapshot());
+    }
+
+    /**
+     * Ensemble trie des identifiants d'une liste de categories — pour une
+     * comparaison par valeur independante de l'ordre.
+     *
+     * @param array<int, object> $categories
+     *
+     * @return list<mixed>
+     */
+    private function categoryIdSet(array $categories): array
+    {
+        $ids = array_map(
+            static fn (object $category): mixed => method_exists($category, 'getId')
+                ? $category->getId()
+                : spl_object_id($category),
+            array_values($categories),
+        );
+        sort($ids);
+
+        return $ids;
+    }
+
+    /**
+     * Champs comptables dont la valeur courante differe de l'etat persiste. Les
+     * relations (tvaMode, paymentDelay, paymentType, bank) sont comparees par
+     * identite d'objet : l'identity map Doctrine renvoie la meme instance tant
+     * que la reference est inchangee.
+     *
+     * @return list<string>
+     */
+    private function changedAccountingFields(Supplier $data): array
+    {
+        $changed = [];
+
+        foreach (self::ACCOUNTING_FIELDS as $field) {
+            $newValue = match ($field) {
+                'siren'         => $data->getSiren(),
+                'accountNumber' => $data->getAccountNumber(),
+                'tvaMode'       => $data->getTvaMode(),
+                'nTva'          => $data->getNTva(),
+                'paymentDelay'  => $data->getPaymentDelay(),
+                'paymentType'   => $data->getPaymentType(),
+                'bank'          => $data->getBank(),
+            };
+
+            if ($this->fieldChanged($data, $field, $newValue)) {
+                $changed[] = $field;
+            }
+        }
+
+        return $changed;
+    }
+
+    /**
+     * Vrai si la valeur courante d'un champ differe de l'etat persiste. Pour une
+     * entite non geree (creation/POST), l'etat persiste est vide : toute valeur
+     * non-null est alors un changement.
+     */
+    private function fieldChanged(Supplier $data, string $field, mixed $newValue): bool
+    {
+        $original = $this->originalData($data);
+
+        return $newValue !== ($original[$field] ?? null);
+    }
+
+    /**
+     * Snapshot des valeurs persistees de l'entite (telles que chargees, avant
+     * application du payload). Vide pour une entite non geree (POST).
+     *
+     * @return array<string, mixed>
+     */
+    private function originalData(Supplier $data): array
+    {
+        if (!$this->em->contains($data)) {
+            return [];
+        }
+
+        return $this->em->getUnitOfWork()->getOriginalEntityData($data);
+    }
+
+    /**
+     * Normalisation serveur du formulaire principal (RG-2.12). Seul companyName
+     * subsiste cote Supplier (le contact inline a ete retire en V1 — les champs
+     * de contact sont normalises par SupplierContactProcessor, ERP-88). Le setter
+     * non-nullable n'est touche que si une valeur est presente, pour ne jamais
+     * ecraser l'existant lors d'un PATCH partiel.
+     */
+    private function normalize(Supplier $data): void
+    {
+        if (null !== $data->getCompanyName()) {
+            $data->setCompanyName((string) $this->normalizer->normalizeCompanyName($data->getCompanyName()));
+        }
+    }
+
+    /**
+     * Cles ecrivables effectivement presentes dans le payload : on retire les
+     * cles JSON-LD (@id, @context, @var...) et tout champ non rattache a un
+     * groupe d'ecriture connu. C'est la base du 422 d'archivage (RG-2.14) —
+     * sans elles, un PATCH « representation complete » porteur de @id ferait
+     * croire a une modification multi-onglets.
+     *
+     * @return list<string>
+     */
+    private function writablePayloadKeys(): array
+    {
+        $writable = array_merge(
+            self::MAIN_FIELDS,
+            self::INFORMATION_FIELDS,
+            self::ACCOUNTING_FIELDS,
+            [self::ARCHIVE_FIELD],
+        );
+
+        return array_values(array_intersect($this->payloadKeys(), $writable));
+    }
+
+    /**
+     * Cles de premier niveau effectivement envoyees par le client (payload JSON
+     * brut), filtrage compris. Pour un PATCH merge-patch+json, ce sont les seuls
+     * champs modifies.
+     *
+     * @return list<string>
+     */
+    private function payloadKeys(): array
+    {
+        $request = $this->requestStack->getCurrentRequest();
+        if (null === $request) {
+            return [];
+        }
+
+        $content = $request->getContent();
+
+        // Cache hit : meme corps brut que le dernier decodage -> memes cles.
+        if ($content === $this->decodedContent) {
+            return $this->decodedPayloadKeys;
+        }
+
+        $this->decodedContent     = $content;
+        $this->decodedPayloadKeys = $this->extractPayloadKeys($content);
+
+        return $this->decodedPayloadKeys;
+    }
+
+    /**
+     * Decode le corps brut et en extrait les cles de premier niveau (chaines).
+     * Corps vide ou JSON invalide -> aucune cle.
+     *
+     * @return list<string>
+     */
+    private function extractPayloadKeys(string $content): array
+    {
+        if ('' === $content) {
+            return [];
+        }
+
+        try {
+            $decoded = json_decode($content, true, 512, JSON_THROW_ON_ERROR);
+        } catch (JsonException) {
+            return [];
+        }
+
+        return is_array($decoded) ? array_values(array_filter(array_keys($decoded), 'is_string')) : [];
+    }
+}

src/Module/Commercial/Infrastructure/ApiPlatform/State/Processor/SupplierRibProcessor.php

@@ -0,0 +1,114 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\ApiPlatform\State\Processor;
+
+use ApiPlatform\Metadata\DeleteOperationInterface;
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ProcessorInterface;
+use App\Module\Commercial\Domain\Entity\Supplier;
+use App\Module\Commercial\Domain\Entity\SupplierRib;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpKernel\Exception\ConflictHttpException;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+
+/**
+ * Processor d'ecriture de la sous-ressource RIB d'un fournisseur (M2, spec-back
+ * § 4.5). Jumeau du ClientRibProcessor (M1), recentre sur le perimetre ERP-88.
+ *
+ * Sequence :
+ *  - POST / PATCH : rattachement au fournisseur parent. Aucune normalisation
+ *    specifique ; la validite de l'IBAN et du BIC est garantie par Assert\Iban /
+ *    Assert\Bic sur l'entite (jouees en amont par API Platform). Aucun
+ *    #[AuditIgnore] sur iban/bic : la tracabilite comptable est volontaire
+ *    (decision M1 reportee, spec § 2.7).
+ *  - DELETE : RG-2.08 — si le fournisseur est en reglement LCR, la suppression de
+ *    son DERNIER RIB est refusee (409), car LCR exige au moins un RIB.
+ *
+ * La security de l'operation (commercial.suppliers.accounting.manage) est
+ * appliquee par API Platform en amont : un utilisateur sans cette permission
+ * recoit 403 sur POST/PATCH/DELETE avant d'atteindre ce processor — c'est le
+ * niveau de gating renforce des donnees bancaires (distinct de manage, spec
+ * § 4.5).
+ *
+ * @implements ProcessorInterface<SupplierRib, null|SupplierRib>
+ */
+final class SupplierRibProcessor implements ProcessorInterface
+{
+    public function __construct(
+        #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
+        private readonly ProcessorInterface $persistProcessor,
+        #[Autowire(service: 'api_platform.doctrine.orm.state.remove_processor')]
+        private readonly ProcessorInterface $removeProcessor,
+        private readonly EntityManagerInterface $em,
+    ) {}
+
+    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
+    {
+        if (!$data instanceof SupplierRib) {
+            return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+        }
+
+        if ($operation instanceof DeleteOperationInterface) {
+            $this->guardLastRibDeletionUnderLcr($data);
+
+            return $this->removeProcessor->process($data, $operation, $uriVariables, $context);
+        }
+
+        $this->linkParent($data, $uriVariables);
+
+        return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+    }
+
+    /**
+     * Rattache le RIB au fournisseur parent de la sous-ressource POST
+     * (/suppliers/{supplierId}/ribs) : la relation n'est pas peuplee
+     * automatiquement par le Link sur une ecriture. Sur PATCH, no-op.
+     */
+    private function linkParent(SupplierRib $rib, array $uriVariables): void
+    {
+        if (null !== $rib->getSupplier()) {
+            return;
+        }
+
+        $supplierId = $uriVariables['supplierId'] ?? null;
+        if (null === $supplierId) {
+            return;
+        }
+
+        $supplier = $supplierId instanceof Supplier
+            ? $supplierId
+            : $this->em->getRepository(Supplier::class)->find($supplierId);
+
+        // read:false sur le POST : sans stade lecture, un parent introuvable n'est
+        // plus intercepte en amont -> 404 explicite (sinon 500 au persist sur la
+        // contrainte supplier_id NOT NULL).
+        if (!$supplier instanceof Supplier) {
+            throw new NotFoundHttpException('Fournisseur introuvable.');
+        }
+
+        $rib->setSupplier($supplier);
+    }
+
+    /**
+     * RG-2.08 : un fournisseur dont le type de reglement est LCR doit conserver au
+     * moins un RIB. La collection inclut le RIB en cours de suppression : un
+     * effectif <= 1 signifie qu'il ne resterait aucun RIB -> 409. Pour tout autre
+     * type de reglement, les RIBs sont optionnels (suppression libre).
+     */
+    private function guardLastRibDeletionUnderLcr(SupplierRib $rib): void
+    {
+        $supplier = $rib->getSupplier();
+        if (null === $supplier) {
+            return;
+        }
+
+        if ('LCR' === $supplier->getPaymentType()?->getCode() && $supplier->getRibs()->count() <= 1) {
+            throw new ConflictHttpException(
+                'Impossible de supprimer le dernier RIB : le type de règlement LCR exige au moins un RIB.',
+            );
+        }
+    }
+}

src/Module/Commercial/Infrastructure/ApiPlatform/State/Provider/SupplierProvider.php

@@ -0,0 +1,191 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\ApiPlatform\State\Provider;
+
+use ApiPlatform\Doctrine\Orm\Paginator;
+use ApiPlatform\Metadata\CollectionOperationInterface;
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\Pagination\Pagination;
+use ApiPlatform\State\ProviderInterface;
+use App\Module\Commercial\Domain\Entity\Supplier;
+use App\Module\Commercial\Domain\Repository\SupplierRepositoryInterface;
+use Doctrine\ORM\Tools\Pagination\Paginator as DoctrinePaginator;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+
+/**
+ * Provider du repertoire fournisseurs (M2). Cf. spec-back M2 § 4.1 / § 4.2 +
+ * RG-2.17. Jumeau du ClientProvider (M1).
+ *
+ * Collection (GET /api/suppliers) :
+ *  - exclut par defaut les archives (is_archived = true) ET les soft-deletes
+ *    (deleted_at IS NOT NULL) — RG-2.17 ;
+ *  - ?includeArchived=true reintegre les archives (les soft-deletes restent
+ *    exclus au M2) — RG-2.17 ;
+ *  - tri par defaut companyName ASC — RG-2.17 ;
+ *  - filtres ?search=... (fuzzy companyName + contacts lies : firstName /
+ *    lastName / email — D1 refonte-contact), ?categoryCode=<code> (fournisseurs
+ *    ayant >= 1 categorie de ce code, repetable) et ?siteId=<id> (fournisseurs
+ *    ayant >= 1 adresse rattachee a ce site, repetable) ;
+ *  - pagination obligatoire (regle ABSOLUE n°13) : Paginator ORM ; echappatoire
+ *    ?pagination=false pour alimenter un <select> sans pagination.
+ *
+ * Item (GET /api/suppliers/{id} + provider de PATCH) :
+ *  - 404 si introuvable OU soft-delete (deleted_at non null, jamais expose au
+ *    M2) ; les archives restent consultables/restaurables en detail.
+ *
+ * Le filtrage des champs comptables en lecture (groupe supplier:read:accounting)
+ * n'est PAS fait ici mais dans SupplierReadGroupContextBuilder : un Provider
+ * retourne des donnees mais ne peut pas influencer les groupes de serialisation.
+ * Le contexte de normalisation est construit par le SerializerContextBuilder, en
+ * amont du serializer — c'est le point d'extension idiomatique d'API Platform
+ * pour conditionner le groupe accounting selon la permission de l'utilisateur.
+ *
+ * @implements ProviderInterface<Supplier>
+ */
+final class SupplierProvider implements ProviderInterface
+{
+    public function __construct(
+        #[Autowire(service: 'App\Module\Commercial\Infrastructure\Doctrine\DoctrineSupplierRepository')]
+        private readonly SupplierRepositoryInterface $repository,
+        private readonly Pagination $pagination,
+    ) {}
+
+    public function provide(Operation $operation, array $uriVariables = [], array $context = []): iterable|Paginator|Supplier|null
+    {
+        if ($operation instanceof CollectionOperationInterface) {
+            return $this->provideCollection($operation, $context);
+        }
+
+        return $this->provideItem($uriVariables);
+    }
+
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @return list<Supplier>|Paginator<Supplier>
+     */
+    private function provideCollection(Operation $operation, array $context): array|Paginator
+    {
+        $filters         = $context['filters'] ?? [];
+        $includeArchived = $this->readBool($filters['includeArchived'] ?? false);
+        $archivedOnly    = $this->readBool($filters['archivedOnly'] ?? false);
+        $search          = $filters['search'] ?? null;
+        // categoryCode accepte un code unique (?categoryCode=NEGOCIANT, selects)
+        // OU une liste (?categoryCode[]=A&categoryCode[]=B, drawer multi).
+        $categoryCodes = $this->readStringList($filters['categoryCode'] ?? []);
+        $siteIds       = $this->readIntList($filters['siteId'] ?? []);
+
+        // Filtrage delegue au repository (logique partagee avec l'export XLSX).
+        $qb = $this->repository->createListQueryBuilder(
+            $includeArchived,
+            is_string($search) ? $search : null,
+            $categoryCodes,
+            $siteIds,
+            $archivedOnly,
+        );
+
+        // Echappatoire ?pagination=false : collection complete sans Paginator
+        // (regle n°13 — utile pour un <select> cote front).
+        if (!$this->pagination->isEnabled($operation, $context)) {
+            /** @var list<Supplier> $suppliers */
+            $suppliers = $qb->getQuery()->getResult();
+            // Hydratation batchee des collections affichees (§ 2.12) : evite le
+            // N+1 si la serialisation touche categories/sites, sans cartesien.
+            $this->repository->hydrateListCollections($suppliers);
+
+            return $suppliers;
+        }
+
+        $limit  = $this->pagination->getLimit($operation, $context);
+        $page   = max(1, $this->pagination->getPage($context));
+        $offset = ($page - 1) * $limit;
+
+        $qb->setFirstResult($offset)->setMaxResults($limit);
+
+        // Le QB de selection ne porte pas de fetch-join to-many (§ 2.12) : le
+        // COUNT est simple, fetchJoinCollection inutile. On materialise la page
+        // puis on hydrate ses collections en lot (memes entites managees).
+        $paginator = new Paginator(new DoctrinePaginator($qb->getQuery(), fetchJoinCollection: false));
+        $this->repository->hydrateListCollections(iterator_to_array($paginator));
+
+        return $paginator;
+    }
+
+    /**
+     * @param array<string, mixed> $uriVariables
+     */
+    private function provideItem(array $uriVariables): ?Supplier
+    {
+        $id = $uriVariables['id'] ?? null;
+        if (!is_int($id) && !(is_string($id) && ctype_digit($id))) {
+            return null;
+        }
+
+        $supplier = $this->repository->findById((int) $id);
+        if (null === $supplier) {
+            return null;
+        }
+
+        // Soft-delete : jamais expose au M2 (HP-M3-1) — 404 via retour null.
+        // Les archives restent visibles en detail (consultation + restauration).
+        if (null !== $supplier->getDeletedAt()) {
+            return null;
+        }
+
+        return $supplier;
+    }
+
+    /**
+     * Lit un flag booleen issu des query params. Accepte true / "true" / "1".
+     */
+    private function readBool(mixed $raw): bool
+    {
+        if (is_bool($raw)) {
+            return $raw;
+        }
+
+        return is_string($raw) && in_array(strtolower($raw), ['true', '1'], true);
+    }
+
+    /**
+     * Normalise un filtre en liste de chaines. Tolere un code unique (string)
+     * ou une liste (?key[]=a&key[]=b). Trim + retrait des vides.
+     *
+     * @return list<string>
+     */
+    private function readStringList(mixed $raw): array
+    {
+        $values = is_array($raw) ? $raw : [$raw];
+
+        $out = [];
+        foreach ($values as $value) {
+            if (is_string($value) && '' !== trim($value)) {
+                $out[] = trim($value);
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * Normalise un filtre en liste d'identifiants entiers positifs. Tolere une
+     * valeur unique ou une liste (?key[]=1&key[]=2).
+     *
+     * @return list<int>
+     */
+    private function readIntList(mixed $raw): array
+    {
+        $values = is_array($raw) ? $raw : [$raw];
+
+        $out = [];
+        foreach ($values as $value) {
+            if ((is_int($value) || (is_string($value) && ctype_digit($value))) && (int) $value > 0) {
+                $out[] = (int) $value;
+            }
+        }
+
+        return $out;
+    }
+}

src/Module/Commercial/Infrastructure/Controller/ClientExportController.php

@@ -86,7 +86,9 @@ final class ClientExportController
     }
 
     /**
-     * Colonnes dans l'ordre impose par la spec § 4.6. SIREN inseree avant la
+     * Colonnes de l'export. Depuis la suppression du contact inline (refonte
+     * contact, D2), les colonnes de contact principal sont retirees : l'export
+     * ne porte plus que les donnees propres au Client. SIREN inseree avant la
      * date de creation, uniquement si l'utilisateur a accounting.view.
      *
      * @return list<string>
@@ -95,11 +97,6 @@ final class ClientExportController
     {
         $headers = [
             'Nom entreprise',
-            'Nom contact principal',
-            'Prénom',
-            'Téléphone principal',
-            'Téléphone secondaire',
-            'Email',
             'Catégories',
             'Sites',
         ];
@@ -123,11 +120,6 @@ final class ClientExportController
         foreach ($clients as $client) {
             $row = [
                 $client->getCompanyName(),
-                $client->getLastName(),
-                $client->getFirstName(),
-                $client->getPhonePrimary(),
-                $client->getPhoneSecondary(),
-                $client->getEmail(),
                 $this->formatCategories($client),
                 $this->formatSites($client),
             ];

src/Module/Commercial/Infrastructure/Controller/SupplierExportController.php

@@ -0,0 +1,291 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\Controller;
+
+use App\Module\Commercial\Domain\Entity\Supplier;
+use App\Module\Commercial\Domain\Entity\SupplierContact;
+use App\Module\Commercial\Domain\Repository\SupplierRepositoryInterface;
+use App\Shared\Domain\Contract\CategoryInterface;
+use App\Shared\Domain\Contract\SiteInterface;
+use App\Shared\Domain\Contract\SpreadsheetExporterInterface;
+use DateTimeImmutable;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Attribute\AsController;
+use Symfony\Component\Routing\Attribute\Route;
+use Symfony\Component\Security\Http\Attribute\IsGranted;
+
+/**
+ * Export XLSX du repertoire fournisseurs (M2, spec-back § 4.6). Jumeau du
+ * {@see ClientExportController} (M1).
+ *
+ * Controller Symfony custom (et non operation API Platform) car il produit un
+ * binaire de fichier, pas une representation Hydra. `priority: 1` est
+ * OBLIGATOIRE sur la route : sans cela API Platform capterait
+ * `/api/suppliers/export.xlsx` comme l'item `GET /api/suppliers/{id}.{_format}`
+ * (id="export", _format="xlsx") — cf. CLAUDE.md « controller custom sous /api ».
+ *
+ * Separation des responsabilites :
+ *  - le COMMENT (generation du fichier) est delegue au service Shared
+ *    {@see SpreadsheetExporterInterface} — generique, reutilisable, sans metier ;
+ *  - le QUOI vit ICI : selection des fournisseurs (memes filtres que
+ *    `GET /api/suppliers`, via {@see SupplierRepositoryInterface::createListQueryBuilder()})
+ *    et mapping metier des colonnes.
+ *
+ * Colonnes de contact : depuis la suppression du contact inline (ERP-106), elles
+ * sont alimentees par le CONTACT PRINCIPAL du fournisseur — le SupplierContact de
+ * plus petit `position` (decision D2, spec § 4.6).
+ *
+ * La colonne SIREN n'est ajoutee que si l'utilisateur a la permission
+ * `commercial.suppliers.accounting.view` (gating identique a la lecture).
+ */
+#[AsController]
+final class SupplierExportController
+{
+    public function __construct(
+        #[Autowire(service: 'App\Module\Commercial\Infrastructure\Doctrine\DoctrineSupplierRepository')]
+        private readonly SupplierRepositoryInterface $repository,
+        private readonly SpreadsheetExporterInterface $exporter,
+        private readonly Security $security,
+    ) {}
+
+    #[Route('/api/suppliers/export.xlsx', name: 'commercial_suppliers_export_xlsx', methods: ['GET'], priority: 1)]
+    #[IsGranted('commercial.suppliers.view')]
+    public function __invoke(Request $request): Response
+    {
+        $includeArchived = $this->readBool($request->query->get('includeArchived'));
+        $archivedOnly    = $this->readBool($request->query->get('archivedOnly'));
+        $search          = $request->query->getString('search') ?: null;
+
+        // Memes filtres que la vue liste : categoryCode/siteId tolerent une valeur
+        // unique ou une liste (?categoryCode[]=A&siteId[]=1). On lit via all() pour
+        // ne pas lever d'exception sur une valeur scalaire.
+        $query         = $request->query->all();
+        $categoryCodes = $this->readStringList($query['categoryCode'] ?? []);
+        $siteIds       = $this->readIntList($query['siteId'] ?? []);
+
+        /** @var list<Supplier> $suppliers */
+        $suppliers = $this->repository
+            ->createListQueryBuilder($includeArchived, $search, $categoryCodes, $siteIds, $archivedOnly)
+            ->getQuery()
+            ->getResult()
+        ;
+
+        // Hydratation batchee des collections affichees (§ 2.12) : le QB de
+        // selection ne fetch-join pas les to-many. On remplit categories + sites en
+        // lot (colonnes « Catégories » / « Sites »), puis les contacts (colonnes du
+        // contact principal) — chacune en requetes IN bornees, anti N+1.
+        $this->repository->hydrateListCollections($suppliers);
+        $this->repository->hydrateContacts($suppliers);
+
+        $withSiren = $this->security->isGranted('commercial.suppliers.accounting.view');
+
+        $binary = $this->exporter->export(
+            'Répertoire fournisseurs',
+            $this->buildHeaders($withSiren),
+            $this->buildRows($suppliers, $withSiren),
+        );
+
+        return $this->buildResponse($binary);
+    }
+
+    /**
+     * Colonnes de l'export (spec § 4.6). SIREN inseree avant la date de creation,
+     * uniquement si l'utilisateur a accounting.view.
+     *
+     * @return list<string>
+     */
+    private function buildHeaders(bool $withSiren): array
+    {
+        $headers = [
+            'Nom fournisseur',
+            'Contact principal',
+            'Téléphone principal',
+            'Téléphone secondaire',
+            'Email',
+            'Catégories',
+            'Sites',
+        ];
+
+        if ($withSiren) {
+            $headers[] = 'SIREN';
+        }
+
+        $headers[] = 'Date de création';
+
+        return $headers;
+    }
+
+    /**
+     * @param list<Supplier> $suppliers
+     *
+     * @return iterable<list<null|scalar>>
+     */
+    private function buildRows(array $suppliers, bool $withSiren): iterable
+    {
+        foreach ($suppliers as $supplier) {
+            $contact = $this->principalContact($supplier);
+
+            $row = [
+                $supplier->getCompanyName(),
+                null !== $contact ? $this->formatContactName($contact) : '',
+                $contact?->getPhonePrimary() ?? '',
+                $contact?->getPhoneSecondary() ?? '',
+                $contact?->getEmail() ?? '',
+                $this->formatCategories($supplier),
+                $this->formatSites($supplier),
+            ];
+
+            if ($withSiren) {
+                $row[] = $supplier->getSiren();
+            }
+
+            $row[] = $supplier->getCreatedAt()?->format('d/m/Y');
+
+            yield $row;
+        }
+    }
+
+    /**
+     * Contact principal du fournisseur : le SupplierContact de plus petit
+     * `position` (decision D2, spec § 4.6). Null si le fournisseur n'a aucun
+     * contact (les colonnes contact restent vides).
+     */
+    private function principalContact(Supplier $supplier): ?SupplierContact
+    {
+        $contacts = $supplier->getContacts()->toArray();
+        if ([] === $contacts) {
+            return null;
+        }
+
+        usort(
+            $contacts,
+            static fn (SupplierContact $a, SupplierContact $b): int => $a->getPosition() <=> $b->getPosition(),
+        );
+
+        return $contacts[0];
+    }
+
+    /**
+     * Libelle du contact principal « Nom Prénom » (spec § 4.6). Les deux parties
+     * sont optionnelles (RG-2.04 : au moins l'une des deux), d'ou le trim final.
+     */
+    private function formatContactName(SupplierContact $contact): string
+    {
+        return trim(sprintf('%s %s', $contact->getLastName() ?? '', $contact->getFirstName() ?? ''));
+    }
+
+    /**
+     * Libelles des categories du fournisseur, dedupliques, tries, joints par
+     * virgule.
+     */
+    private function formatCategories(Supplier $supplier): string
+    {
+        $names = [];
+        foreach ($supplier->getCategories() as $category) {
+            // @var CategoryInterface $category
+            $name = $category->getName();
+            if (null !== $name && '' !== $name) {
+                $names[$name] = true;
+            }
+        }
+
+        return $this->joinSorted($names);
+    }
+
+    /**
+     * Le fournisseur ne porte pas de sites en propre : ils sont rattaches aux
+     * adresses (RG-2.06). La colonne « Sites » agrege donc l'union distincte des
+     * sites de toutes les adresses du fournisseur.
+     */
+    private function formatSites(Supplier $supplier): string
+    {
+        $names = [];
+        foreach ($supplier->getAddresses() as $address) {
+            foreach ($address->getSites() as $site) {
+                // @var SiteInterface $site
+                $name = $site->getName();
+                if (null !== $name && '' !== $name) {
+                    $names[$name] = true;
+                }
+            }
+        }
+
+        return $this->joinSorted($names);
+    }
+
+    /**
+     * @param array<string, true> $names ensemble de libelles (cles)
+     */
+    private function joinSorted(array $names): string
+    {
+        $list = array_keys($names);
+        sort($list);
+
+        return implode(', ', $list);
+    }
+
+    private function buildResponse(string $binary): Response
+    {
+        $filename = sprintf('repertoire-fournisseurs-%s.xlsx', new DateTimeImmutable()->format('Ymd'));
+
+        $response = new Response($binary);
+        $response->headers->set('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
+        $response->headers->set('Content-Disposition', sprintf('attachment; filename="%s"', $filename));
+
+        return $response;
+    }
+
+    /**
+     * Lit un flag booleen issu des query params. Accepte true / "true" / "1".
+     * Aligne sur SupplierProvider pour un comportement identique a la liste.
+     */
+    private function readBool(mixed $raw): bool
+    {
+        return is_string($raw) && in_array(strtolower($raw), ['true', '1'], true);
+    }
+
+    /**
+     * Normalise un filtre en liste de chaines (valeur unique ou liste).
+     * Aligne sur SupplierProvider pour un comportement identique a la liste.
+     *
+     * @return list<string>
+     */
+    private function readStringList(mixed $raw): array
+    {
+        $values = is_array($raw) ? $raw : [$raw];
+
+        $out = [];
+        foreach ($values as $value) {
+            if (is_string($value) && '' !== trim($value)) {
+                $out[] = trim($value);
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * Normalise un filtre en liste d'identifiants entiers positifs (valeur unique
+     * ou liste). Aligne sur SupplierProvider.
+     *
+     * @return list<int>
+     */
+    private function readIntList(mixed $raw): array
+    {
+        $values = is_array($raw) ? $raw : [$raw];
+
+        $out = [];
+        foreach ($values as $value) {
+            if ((is_int($value) || (is_string($value) && ctype_digit($value))) && (int) $value > 0) {
+                $out[] = (int) $value;
+            }
+        }
+
+        return $out;
+    }
+}

src/Module/Commercial/Infrastructure/DataFixtures/ClientFixtures.php

@@ -112,10 +112,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$gso, $gsoIsNew] = $this->ensureClient(
             $manager,
             companyName: 'Distrib Grand Sud-Ouest',
-            firstName: 'Paul',
-            lastName: 'Garnier',
-            phonePrimary: '05 56 10 20 30',
-            email: 'contact@distrib-gso.fr',
             categoryNames: ['Distributeur'],
         );
         if ($gsoIsNew) {
@@ -127,10 +123,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$leonard, $leonardIsNew] = $this->ensureClient(
             $manager,
             companyName: 'Cabinet Léonard Assurances',
-            firstName: 'Sophie',
-            lastName: 'Léonard',
-            phonePrimary: '05 49 11 22 33',
-            email: 'contact@cabinet-leonard.fr',
             categoryNames: ['Courtier'],
         );
         if ($leonardIsNew) {
@@ -142,10 +134,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$dubois, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Menuiserie Dubois',
-            firstName: 'Jean',
-            lastName: 'Dubois',
-            phonePrimary: '05 49 00 00 01',
-            email: 'contact@menuiserie-dubois.fr',
             categoryNames: ['BTP'],
         );
         if ($isNew) {
@@ -159,10 +147,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$garage, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Garage Martin',
-            firstName: 'Luc',
-            lastName: 'Martin',
-            phonePrimary: '05 56 44 55 66',
-            email: 'accueil@garage-martin.fr',
             categoryNames: ['Services'],
         );
         if ($isNew) {
@@ -175,10 +159,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$boulangerie, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Boulangerie Lemoine',
-            firstName: 'Marie',
-            lastName: 'Lemoine',
-            phonePrimary: '05 49 77 88 99',
-            email: 'bonjour@boulangerie-lemoine.fr',
             categoryNames: ['Agro-alimentaire'],
         );
         if ($isNew) {
@@ -191,10 +171,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$transports, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Transports Rapides',
-            firstName: null,
-            lastName: 'Bernard',
-            phonePrimary: '05 56 12 13 14',
-            email: 'exploitation@transports-rapides.fr',
             categoryNames: ['Transport/Logistique'],
         );
         if ($isNew) {
@@ -209,10 +185,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$industries, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Industries Vertes',
-            firstName: 'Claire',
-            lastName: 'Moreau',
-            phonePrimary: '05 49 21 22 23',
-            email: 'contact@industries-vertes.fr',
             categoryNames: ['Industrie'],
         );
         if ($isNew) {
@@ -229,12 +201,7 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$agro, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Agro Distribution Sud',
-            firstName: 'Thomas',
-            lastName: 'Petit',
-            phonePrimary: '05 56 31 32 33',
-            email: 'contact@agro-sud.fr',
             categoryNames: ['Agro-alimentaire'],
-            phoneSecondary: '06 01 02 03 04',
         );
         if ($isNew) {
             $this->addContact($agro, 'Thomas', 'Petit', 'Directeur des achats', '05 56 31 32 33', '06 01 02 03 04', 'thomas.petit@agro-sud.fr', 0);
@@ -247,10 +214,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$ancienne, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Ancienne Société Oubliée',
-            firstName: null,
-            lastName: 'Durand',
-            phonePrimary: '05 49 99 99 99',
-            email: 'contact@ancienne-societe.fr',
             categoryNames: ['Association'],
             isArchived: true,
         );
@@ -263,10 +226,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$services, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Services Pro Conseil',
-            firstName: 'Nadia',
-            lastName: 'Benali',
-            phonePrimary: '05 49 41 42 43',
-            email: 'contact@services-pro.fr',
             categoryNames: ['Services'],
         );
         if ($isNew) {
@@ -279,10 +238,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$holding, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Holding Premium Invest',
-            firstName: 'Antoine',
-            lastName: 'Lefèvre',
-            phonePrimary: '05 56 51 52 53',
-            email: 'direction@holding-premium.fr',
             categoryNames: ['Industrie'],
         );
         if ($isNew) {
@@ -301,10 +256,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$conglo, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Conglomérat Multi Activités',
-            firstName: 'Hélène',
-            lastName: 'Faure',
-            phonePrimary: '05 49 61 62 63',
-            email: 'contact@conglomerat-multi.fr',
             categoryNames: ['BTP', 'Industrie', 'Services'],
         );
         if ($isNew) {
@@ -316,10 +267,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$prospect, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Prospect Futur Client',
-            firstName: 'Olivier',
-            lastName: 'Renard',
-            phonePrimary: '05 56 71 72 73',
-            email: 'olivier.renard@prospect-futur.fr',
             categoryNames: ['BTP'],
         );
         if ($isNew) {
@@ -331,10 +278,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
         [$association, $isNew] = $this->ensureClient(
             $manager,
             companyName: 'Association des Riverains',
-            firstName: null,
-            lastName: 'Caron',
-            phonePrimary: '05 49 81 82 83',
-            email: 'contact@asso-riverains.fr',
             categoryNames: ['Association'],
         );
         if ($isNew) {
@@ -350,6 +293,9 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
      * sinon retourne l'existant. Retourne [Client, isNew] : isNew=false bloque la
      * reconstruction des sous-collections (idempotence sans doublon).
      *
+     * Le contact principal n'est plus porte par le Client (refonte contact) : les
+     * coordonnees de contact sont fournies via addContact() dans le bloc isNew.
+     *
      * @param list<string> $categoryNames
      *
      * @return array{0: Client, 1: bool}
@@ -357,12 +303,7 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
     private function ensureClient(
         ObjectManager $manager,
         string $companyName,
-        ?string $firstName,
-        ?string $lastName,
-        string $phonePrimary,
-        string $email,
         array $categoryNames,
-        ?string $phoneSecondary = null,
         bool $isArchived = false,
     ): array {
         $normalizedName = (string) $this->normalizer->normalizeCompanyName($companyName);
@@ -374,11 +315,6 @@ class ClientFixtures extends Fixture implements DependentFixtureInterface
 
         $client = new Client();
         $client->setCompanyName($normalizedName);
-        $client->setFirstName($this->normalizer->normalizePersonName($firstName));
-        $client->setLastName($this->normalizer->normalizePersonName($lastName));
-        $client->setPhonePrimary((string) $this->normalizer->normalizePhone($phonePrimary));
-        $client->setPhoneSecondary($this->normalizer->normalizePhone($phoneSecondary));
-        $client->setEmail((string) $this->normalizer->normalizeEmail($email));
 
         foreach ($categoryNames as $categoryName) {
             $client->addCategory($this->category($manager, $categoryName));

src/Module/Commercial/Infrastructure/DataFixtures/SupplierFixtures.php

@@ -0,0 +1,510 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\DataFixtures;
+
+use App\Module\Catalog\Infrastructure\DataFixtures\CategoryFixtures;
+use App\Module\Commercial\Application\Service\SupplierFieldNormalizer;
+use App\Module\Commercial\Domain\Entity\Bank;
+use App\Module\Commercial\Domain\Entity\PaymentDelay;
+use App\Module\Commercial\Domain\Entity\PaymentType;
+use App\Module\Commercial\Domain\Entity\Supplier;
+use App\Module\Commercial\Domain\Entity\SupplierAddress;
+use App\Module\Commercial\Domain\Entity\SupplierContact;
+use App\Module\Commercial\Domain\Entity\SupplierRib;
+use App\Module\Commercial\Domain\Entity\TvaMode;
+use App\Module\Sites\Infrastructure\DataFixtures\SitesFixtures;
+use App\Shared\Domain\Contract\CategoryInterface;
+use App\Shared\Domain\Contract\SiteInterface;
+use App\Shared\Domain\Contract\SiteProviderInterface;
+use DateTimeImmutable;
+use Doctrine\Bundle\FixturesBundle\Fixture;
+use Doctrine\Common\DataFixtures\DependentFixtureInterface;
+use Doctrine\Persistence\ObjectManager;
+use RuntimeException;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+
+/**
+ * Fixtures dev/test du module Commercial : ~13 fournisseurs de demonstration
+ * couvrant l'ensemble des cas metier RG-2.xx du repertoire fournisseurs (M2),
+ * jumelles des fixtures Client (ERP-68). Theme metier : negoce / recyclage de
+ * metaux (d'ou les champs `bennes` et `triageProvider` sur les adresses).
+ *
+ * Cas pivots couverts (criteres d'acceptation ERP-112) :
+ *  - reglement VIREMENT avec banque renseignee (RG-2.07) ;
+ *  - reglement LCR avec 1 puis 2 RIB (RG-2.08) ; CHEQUE et NON_SOUMISE sans RIB ;
+ *  - adresses multi-types PROSPECT / DEPART / RENDU (RG-2.09) et multi-sites
+ *    (86 / 17 / 82, RG-2.06) ; bennes + prestataire de triage ;
+ *  - 1 a 3 contacts dont un avec telephone secondaire et un nomme par le seul
+ *    nom (RG-2.04) ;
+ *  - 2 fournisseurs archives (isArchived + archivedAt) pour l'exclusion de la
+ *    liste (RG-2.17) ;
+ *  - mono et multi-categories de type FOURNISSEUR (RG-2.10) ;
+ *  - onglet Information complet (dont volumeForecast, specifique fournisseur).
+ *
+ * Resolution inter-modules conforme a la regle n°1 (pas d'import direct) :
+ *  - categories resolues via le contrat Shared CategoryInterface
+ *    (resolve_target_entities -> Category) ;
+ *  - sites resolus via le contrat Shared SiteProviderInterface.
+ *
+ * Normalisation : les valeurs sont fournies BRUTES (casse libre, telephones
+ * formates) et normalisees par SupplierFieldNormalizer avant persist, exactement
+ * comme le ferait le SupplierProcessor via l'API (companyName UPPERCASE,
+ * first/last Capitalize, telephones chiffres seuls, emails lowercase).
+ *
+ * Coherence gating comptable (RG-2.16) : les scalaires comptables (siren,
+ * tvaMode, paymentType, bank...) et les RIB ne sont visibles qu'avec
+ * accounting.view. Les donnees sont posees pour que les roles SANS cette
+ * permission (ex. Commerciale) ne voient pas de compta — support des tests
+ * ERP-92 et du golden path front.
+ *
+ * Idempotence : lookup par companyName normalise (coherent avec l'index unique
+ * partiel uq_supplier_company_name_active). Un fournisseur deja present n'est pas
+ * reconstruit (ses sous-collections ne sont pas redupliquees). Rejouable sans
+ * doublon meme si le purger Doctrine est desactive.
+ *
+ * Audit / Blamable : persist hors contexte HTTP -> created_by / updated_by
+ * restent null (« Systeme » cote front), c'est attendu. Les donnees respectent
+ * les CHECK BDD (chk_supplier_contact_name : firstName OU lastName ;
+ * chk_supplier_address_type : PROSPECT | DEPART | RENDU) ET la coherence des
+ * validators d'entite (RG-2.07/2.08 : VIREMENT => banque, LCR => >= 1 RIB).
+ *
+ * Depend de CategoryFixtures (categories FOURNISSEUR), SitesFixtures (sites) et
+ * CommercialReferentialFixtures (referentiels comptables — REUTILISES de M1,
+ * aucune nouvelle table).
+ *
+ * Portee : DONNEES DE DEMONSTRATION (dev uniquement). En environnement `test`,
+ * la fixture ne charge rien : les tests seedent et nettoient leurs propres
+ * fournisseurs et comptent sur une table `supplier` vierge — y injecter 13
+ * fournisseurs de demo casserait les comptages de liste et les cleanups. Meme
+ * garde-fou que ClientFixtures / CategoryFixtures.
+ */
+class SupplierFixtures extends Fixture implements DependentFixtureInterface
+{
+    /** Cache des categories resolues par nom (evite des requetes repetees). */
+    private array $categoryCache = [];
+
+    /** Cache des sites resolus par nom. */
+    private array $siteCache = [];
+
+    /** ObjectManager courant, capture en debut de load (resolution categories). */
+    private ObjectManager $manager;
+
+    public function __construct(
+        private readonly SupplierFieldNormalizer $normalizer,
+        private readonly SiteProviderInterface $siteProvider,
+        #[Autowire('%kernel.environment%')]
+        private readonly string $environment,
+    ) {}
+
+    /**
+     * @return array<int, class-string>
+     */
+    public function getDependencies(): array
+    {
+        return [
+            CategoryFixtures::class,
+            SitesFixtures::class,
+            CommercialReferentialFixtures::class,
+        ];
+    }
+
+    public function load(ObjectManager $manager): void
+    {
+        // Donnees de demo : dev uniquement. En test, on laisse la table vierge.
+        if ('test' === $this->environment) {
+            return;
+        }
+
+        $this->manager = $manager;
+
+        // === Fournisseur basique — VIREMENT + banque (RG-2.07), compta complete ===
+        [$negoce, $isNew] = $this->ensureSupplier($manager, 'Négoce Métaux Atlantique', ['Négociant']);
+        if ($isNew) {
+            $negoce->setSiren('841611054');
+            $negoce->setAccountNumber('F0001');
+            $negoce->setTvaMode($this->tvaMode($manager, 'FRANCE_VENTES'));
+            $negoce->setNTva('FR12841611054');
+            $negoce->setPaymentDelay($this->paymentDelay($manager, 'J30'));
+            $negoce->setPaymentType($this->paymentType($manager, 'VIREMENT'));
+            $negoce->setBank($this->bank($manager, 'SG'));
+            $this->addContact($negoce, 'Jean', 'Dubois', 'Responsable achats', '05 49 00 00 01', null, 'jean.dubois@negoce-metaux.fr');
+            $this->addAddress($negoce, 'DEPART', ['Chatellerault'], '86100', 'Châtellerault', '12 rue de la Ferraille', bennes: 4, triageProvider: true, categoryNames: ['Négociant']);
+        }
+
+        // === LCR avec 1 RIB (RG-2.08) + 2 contacts ===
+        [$coop, $isNew] = $this->ensureSupplier($manager, 'Coopérative Agricole du Sud-Ouest', ['Coopérative']);
+        if ($isNew) {
+            $coop->setSiren('775680459');
+            $coop->setTvaMode($this->tvaMode($manager, 'FRANCE_VENTES'));
+            $coop->setPaymentDelay($this->paymentDelay($manager, 'J15'));
+            $coop->setPaymentType($this->paymentType($manager, 'LCR'));
+            $this->addContact($coop, 'Sophie', 'Marchand', 'Directrice', '05 56 10 20 30', '06 11 22 33 44', 'sophie.marchand@coop-so.fr', 0);
+            $this->addContact($coop, 'Marc', 'Girard', 'Acheteur', '05 56 10 20 31', null, 'marc.girard@coop-so.fr', 1);
+            $this->addAddress($coop, 'RENDU', ['Pommevic'], '82400', 'Pommevic', '8 route des Cooperateurs', bennes: 2);
+            $this->addRib($coop, 'Compte principal', 'BNPAFRPPXXX', 'FR1420041010050500013M02606', 0);
+        }
+
+        // === Prospect seul (adresse PROSPECT), compta minimale ===
+        [$producteur, $isNew] = $this->ensureSupplier($manager, 'Producteur Bio Charente', ['Producteur']);
+        if ($isNew) {
+            $this->addContact($producteur, 'Claire', 'Moreau', 'Gérante', '05 49 21 22 23', null, 'claire.moreau@bio-charente.fr');
+            $this->addAddress($producteur, 'PROSPECT', ['Saint-Jean'], '17400', 'Fontenet', '1 chemin des Producteurs');
+        }
+
+        // === Multi-categories M2M + LCR avec 2 RIB + 3 contacts ===
+        [$grossiste, $isNew] = $this->ensureSupplier($manager, 'Grossiste Multi-Métaux', ['Grossiste', 'Négociant']);
+        if ($isNew) {
+            $grossiste->setSiren('552081317');
+            $grossiste->setAccountNumber('F0004');
+            $grossiste->setTvaMode($this->tvaMode($manager, 'FRANCE_VENTES'));
+            $grossiste->setNTva('FR45552081317');
+            $grossiste->setPaymentDelay($this->paymentDelay($manager, 'J30'));
+            $grossiste->setPaymentType($this->paymentType($manager, 'LCR'));
+            $this->addContact($grossiste, 'Thomas', 'Petit', 'Directeur des achats', '05 56 31 32 33', '06 01 02 03 04', 'thomas.petit@grossiste-mm.fr', 0);
+            $this->addContact($grossiste, 'Julie', 'Roux', 'Assistante commerciale', '05 56 31 32 34', null, 'julie.roux@grossiste-mm.fr', 1);
+            $this->addContact($grossiste, 'Hélène', 'Faure', 'Logistique', '05 56 31 32 35', null, 'helene.faure@grossiste-mm.fr', 2);
+            $this->addAddress($grossiste, 'DEPART', ['Chatellerault'], '86100', 'Châtellerault', '20 zone des Activités', streetComplement: 'Bâtiment C', bennes: 6, triageProvider: true, categoryNames: ['Grossiste', 'Négociant']);
+            $this->addRib($grossiste, 'Compte principal', 'BNPAFRPPXXX', 'FR7630006000011234567890189', 0);
+            $this->addRib($grossiste, 'Compte secondaire', 'SOGEFRPPXXX', 'FR7630001007941234567890185', 1);
+        }
+
+        // === VIREMENT + banque, TVA intracom (importateur), multi-sites sur l'adresse ===
+        [$import, $isNew] = $this->ensureSupplier($manager, 'Import Recyclage International', ['Importateur']);
+        if ($isNew) {
+            $import->setSiren('409512012');
+            $import->setTvaMode($this->tvaMode($manager, 'INTRACOM_VENTES'));
+            $import->setNTva('FR90409512012');
+            $import->setPaymentDelay($this->paymentDelay($manager, 'J30'));
+            $import->setPaymentType($this->paymentType($manager, 'VIREMENT'));
+            $import->setBank($this->bank($manager, 'CIC'));
+            $this->addContact($import, 'Paul', 'Garnier', 'Import manager', '05 56 44 55 66', null, 'paul.garnier@import-recyclage.fr', 0);
+            $this->addContact($import, null, 'Bernard', 'Douanes', '05 56 44 55 67', null, 'douanes@import-recyclage.fr', 1);
+            $this->addAddress($import, 'RENDU', ['Pommevic', 'Saint-Jean'], '82400', 'Pommevic', '3 quai des Importateurs', bennes: 8);
+        }
+
+        // === Multi-adresses PROSPECT / DEPART / RENDU (RG-2.09) + VIREMENT/banque ===
+        [$ferrailleur, $isNew] = $this->ensureSupplier($manager, 'Ferrailleur Grand Ouest', ['Négociant']);
+        if ($isNew) {
+            $ferrailleur->setSiren('732829320');
+            $ferrailleur->setTvaMode($this->tvaMode($manager, 'FRANCE_VENTES'));
+            $ferrailleur->setPaymentDelay($this->paymentDelay($manager, 'A_RECEPTION'));
+            $ferrailleur->setPaymentType($this->paymentType($manager, 'VIREMENT'));
+            $ferrailleur->setBank($this->bank($manager, 'CA'));
+            $this->addContact($ferrailleur, 'Olivier', 'Renard', 'Responsable site', '05 49 61 62 63', null, 'olivier.renard@ferrailleur-go.fr', 0);
+            $this->addContact($ferrailleur, 'Nadia', 'Benali', 'Pesée', '05 49 61 62 64', null, 'nadia.benali@ferrailleur-go.fr', 1);
+            // Prospect (site en cours de demarchage).
+            $this->addAddress($ferrailleur, 'PROSPECT', ['Chatellerault'], '86100', 'Châtellerault', '5 avenue de la Prospection', position: 0);
+            // Depart (collecte) multi-sites avec bennes + triage.
+            $this->addAddress($ferrailleur, 'DEPART', ['Saint-Jean', 'Pommevic'], '17400', 'Fontenet', '4 rue de la Collecte', bennes: 5, triageProvider: true, categoryNames: ['Négociant'], position: 1);
+            // Rendu (livraison).
+            $this->addAddress($ferrailleur, 'RENDU', ['Pommevic'], '82400', 'Pommevic', '7 boulevard du Rendu', bennes: 3, position: 2);
+        }
+
+        // === Onglet Information complet (dont volumeForecast) + VIREMENT/banque ===
+        [$holding, $isNew] = $this->ensureSupplier($manager, 'Holding Recyclage Premium', ['Importateur']);
+        if ($isNew) {
+            $holding->setDescription('Holding de recyclage diversifiée, présente sur le Grand Sud-Ouest.');
+            $holding->setCompetitors('Groupe Atlantique Recyclage, Sud Métaux');
+            $holding->setFoundedAt(new DateTimeImmutable('2008-09-01'));
+            $holding->setEmployeesCount(180);
+            $holding->setRevenueAmount('24500000.00');
+            $holding->setDirectorName('Antoine Lefèvre');
+            $holding->setProfitAmount('1850000.00');
+            $holding->setVolumeForecast(120000);
+            $holding->setSiren('318471925');
+            $holding->setAccountNumber('F0007');
+            $holding->setTvaMode($this->tvaMode($manager, 'FRANCE_VENTES'));
+            $holding->setNTva('FR33318471925');
+            $holding->setPaymentDelay($this->paymentDelay($manager, 'J30'));
+            $holding->setPaymentType($this->paymentType($manager, 'VIREMENT'));
+            $holding->setBank($this->bank($manager, 'SG'));
+            $this->addContact($holding, 'Antoine', 'Lefèvre', 'PDG', '05 56 51 52 53', null, 'antoine.lefevre@holding-recyclage.fr');
+            $this->addAddress($holding, 'DEPART', ['Chatellerault'], '86100', 'Châtellerault', '1 allée des Investisseurs', bennes: 5, triageProvider: true, categoryNames: ['Importateur']);
+        }
+
+        // === Coop minimale — contact par le seul nom (RG-2.04), sans compta ===
+        [$coopMin, $isNew] = $this->ensureSupplier($manager, 'Coop Métaux Réunis', ['Coopérative']);
+        if ($isNew) {
+            $this->addContact($coopMin, null, 'Caron', 'Président', '05 49 81 82 83', null, 'president@coop-metaux-reunis.fr');
+            $this->addAddress($coopMin, 'DEPART', ['Saint-Jean'], '17400', 'Fontenet', '6 chemin du Village');
+        }
+
+        // === Reglement CHEQUE (sans banque ni RIB requis) ===
+        [$petit, $isNew] = $this->ensureSupplier($manager, 'Petit Négoce Local', ['Négociant']);
+        if ($isNew) {
+            $petit->setTvaMode($this->tvaMode($manager, 'FRANCE_VENTES'));
+            $petit->setPaymentDelay($this->paymentDelay($manager, 'A_RECEPTION'));
+            $petit->setPaymentType($this->paymentType($manager, 'CHEQUE'));
+            $this->addContact($petit, 'Luc', 'Martin', 'Gérant', '05 56 71 72 73', null, 'luc.martin@petit-negoce.fr');
+            $this->addAddress($petit, 'RENDU', ['Chatellerault'], '86100', 'Châtellerault', '15 rue du Commerce');
+        }
+
+        // === Reglement NON_SOUMISE + adresse multi-sites avec triage ===
+        [$recup, $isNew] = $this->ensureSupplier($manager, 'Récupération Métaux Express', ['Grossiste']);
+        if ($isNew) {
+            $recup->setSiren('490212019');
+            $recup->setTvaMode($this->tvaMode($manager, 'FRANCE_VENTES'));
+            $recup->setPaymentDelay($this->paymentDelay($manager, 'J15'));
+            $recup->setPaymentType($this->paymentType($manager, 'NON_SOUMISE'));
+            $this->addContact($recup, 'Marie', 'Lemoine', 'Responsable', '05 49 77 88 99', null, 'marie.lemoine@recup-express.fr', 0);
+            $this->addContact($recup, 'Pierre', 'Durand', 'Chauffeur', '05 49 77 88 98', null, 'pierre.durand@recup-express.fr', 1);
+            $this->addAddress($recup, 'DEPART', ['Saint-Jean', 'Chatellerault'], '17400', 'Fontenet', '10 zone industrielle', bennes: 7, triageProvider: true, categoryNames: ['Grossiste']);
+        }
+
+        // === Centre de tri — focus bennes/triage + multi-categories ===
+        [$centre, $isNew] = $this->ensureSupplier($manager, 'Centre de Tri Sud', ['Producteur', 'Coopérative']);
+        if ($isNew) {
+            $centre->setPaymentDelay($this->paymentDelay($manager, 'A_RECEPTION'));
+            $this->addContact($centre, 'Camille', 'Faure', 'Chef de centre', '05 56 91 92 93', null, 'camille.faure@centre-tri-sud.fr');
+            $this->addAddress($centre, 'DEPART', ['Pommevic'], '82400', 'Pommevic', '2 route du Tri', bennes: 12, triageProvider: true, categoryNames: ['Producteur']);
+        }
+
+        // === Fournisseur archive #1 (RG-2.17) ===
+        [$ancien, $isNew] = $this->ensureSupplier($manager, 'Ancien Fournisseur Fermé', ['Producteur'], isArchived: true);
+        if ($isNew) {
+            $this->addContact($ancien, null, 'Lambert', 'Ancien contact', '05 49 99 99 99', null, 'contact@ancien-fournisseur.fr');
+            $this->addAddress($ancien, 'DEPART', ['Chatellerault'], '86100', 'Châtellerault', '99 rue Fermée');
+        }
+
+        // === Fournisseur archive #2 (RG-2.17) ===
+        [$disparu, $isNew] = $this->ensureSupplier($manager, 'Négoce Disparu', ['Grossiste'], isArchived: true);
+        if ($isNew) {
+            $this->addContact($disparu, 'Gérard', 'Blanc', 'Ex-gérant', '05 56 00 00 00', null, 'gerard.blanc@negoce-disparu.fr');
+            $this->addAddress($disparu, 'RENDU', ['Saint-Jean'], '17400', 'Fontenet', '0 impasse Oubliée');
+        }
+
+        $manager->flush();
+    }
+
+    /**
+     * Cree un fournisseur (base normalisee + categories de type FOURNISSEUR)
+     * s'il n'existe pas encore, sinon retourne l'existant. Retourne
+     * [Supplier, isNew] : isNew=false bloque la reconstruction des
+     * sous-collections (idempotence sans doublon).
+     *
+     * @param list<string> $categoryNames categories de type FOURNISSEUR (RG-2.10)
+     *
+     * @return array{0: Supplier, 1: bool}
+     */
+    private function ensureSupplier(
+        ObjectManager $manager,
+        string $companyName,
+        array $categoryNames,
+        bool $isArchived = false,
+    ): array {
+        $normalizedName = (string) $this->normalizer->normalizeCompanyName($companyName);
+
+        $existing = $manager->getRepository(Supplier::class)->findOneBy(['companyName' => $normalizedName]);
+        if ($existing instanceof Supplier) {
+            return [$existing, false];
+        }
+
+        $supplier = new Supplier();
+        $supplier->setCompanyName($normalizedName);
+
+        foreach ($categoryNames as $categoryName) {
+            $supplier->addCategory($this->category($manager, $categoryName));
+        }
+
+        if ($isArchived) {
+            $supplier->setIsArchived(true);
+            $supplier->setArchivedAt(new DateTimeImmutable());
+        }
+
+        $manager->persist($supplier);
+
+        return [$supplier, true];
+    }
+
+    /**
+     * Ajoute un contact normalise au fournisseur (cascade persist via
+     * Supplier.contacts). Au moins firstName OU lastName est toujours fourni
+     * (RG-2.04, chk_supplier_contact_name).
+     */
+    private function addContact(
+        Supplier $supplier,
+        ?string $firstName,
+        ?string $lastName,
+        ?string $jobTitle,
+        ?string $phonePrimary,
+        ?string $phoneSecondary,
+        ?string $email,
+        int $position = 0,
+    ): void {
+        $contact = new SupplierContact();
+        $contact->setFirstName($this->normalizer->normalizePersonName($firstName));
+        $contact->setLastName($this->normalizer->normalizePersonName($lastName));
+        $contact->setJobTitle($jobTitle);
+        $contact->setPhonePrimary($this->normalizer->normalizePhone($phonePrimary));
+        $contact->setPhoneSecondary($this->normalizer->normalizePhone($phoneSecondary));
+        $contact->setEmail($this->normalizer->normalizeEmail($email));
+        $contact->setPosition($position);
+
+        $supplier->addContact($contact);
+    }
+
+    /**
+     * Ajoute une adresse au fournisseur (cascade persist via Supplier.addresses).
+     * Le type d'adresse est exclusif (PROSPECT | DEPART | RENDU — RG-2.09,
+     * chk_supplier_address_type) ; au moins un site est rattache (RG-2.06) ; les
+     * categories d'adresse sont de type FOURNISSEUR (RG-2.10).
+     *
+     * @param list<string> $siteNames     au moins un site (RG-2.06)
+     * @param list<string> $categoryNames categories de type FOURNISSEUR (RG-2.10)
+     */
+    private function addAddress(
+        Supplier $supplier,
+        string $addressType,
+        array $siteNames,
+        string $postalCode,
+        string $city,
+        string $street,
+        ?string $streetComplement = null,
+        ?int $bennes = null,
+        bool $triageProvider = false,
+        array $categoryNames = [],
+        int $position = 0,
+    ): void {
+        $address = new SupplierAddress();
+        $address->setAddressType($addressType);
+        $address->setPostalCode($postalCode);
+        $address->setCity($city);
+        $address->setStreet($street);
+        $address->setStreetComplement($streetComplement);
+        $address->setBennes($bennes);
+        $address->setTriageProvider($triageProvider);
+        $address->setPosition($position);
+
+        foreach ($siteNames as $siteName) {
+            $address->addSite($this->site($siteName));
+        }
+
+        foreach ($categoryNames as $categoryName) {
+            $address->addCategory($this->category($this->manager, $categoryName));
+        }
+
+        $supplier->addAddress($address);
+    }
+
+    /**
+     * Ajoute un RIB au fournisseur (cascade persist via Supplier.ribs). IBAN/BIC
+     * valides (Assert\Iban/Bic non rejouee sur persist direct mais donnees
+     * coherentes pour le golden path / les tests).
+     */
+    private function addRib(Supplier $supplier, string $label, string $bic, string $iban, int $position = 0): void
+    {
+        $rib = new SupplierRib();
+        $rib->setLabel($label);
+        $rib->setBic($bic);
+        $rib->setIban($iban);
+        $rib->setPosition($position);
+
+        $supplier->addRib($rib);
+    }
+
+    /**
+     * Resout une categorie par son nom via le contrat Shared CategoryInterface
+     * (resolve_target_entities -> Category), sans importer le module Catalog
+     * (regle n°1). Mise en cache par nom.
+     */
+    private function category(ObjectManager $manager, string $name): CategoryInterface
+    {
+        if (isset($this->categoryCache[$name])) {
+            return $this->categoryCache[$name];
+        }
+
+        $category = $manager->getRepository(CategoryInterface::class)->findOneBy([
+            'name'      => $name,
+            'deletedAt' => null,
+        ]);
+
+        if (!$category instanceof CategoryInterface) {
+            throw new RuntimeException(sprintf(
+                'Categorie "%s" introuvable : CategoryFixtures doit tourner avant SupplierFixtures.',
+                $name,
+            ));
+        }
+
+        return $this->categoryCache[$name] = $category;
+    }
+
+    /**
+     * Resout un site par son nom via le contrat Shared SiteProviderInterface,
+     * sans importer le module Sites (regle n°1). Mise en cache par nom.
+     */
+    private function site(string $name): SiteInterface
+    {
+        if (isset($this->siteCache[$name])) {
+            return $this->siteCache[$name];
+        }
+
+        $site = $this->siteProvider->findByName($name);
+
+        if (!$site instanceof SiteInterface) {
+            throw new RuntimeException(sprintf(
+                'Site "%s" introuvable : SitesFixtures doit tourner avant SupplierFixtures.',
+                $name,
+            ));
+        }
+
+        return $this->siteCache[$name] = $site;
+    }
+
+    private function tvaMode(ObjectManager $manager, string $code): TvaMode
+    {
+        $mode = $manager->getRepository(TvaMode::class)->findOneBy(['code' => $code]);
+
+        if (!$mode instanceof TvaMode) {
+            throw new RuntimeException(sprintf(
+                'TvaMode "%s" introuvable : CommercialReferentialFixtures doit tourner avant SupplierFixtures.',
+                $code,
+            ));
+        }
+
+        return $mode;
+    }
+
+    private function paymentDelay(ObjectManager $manager, string $code): PaymentDelay
+    {
+        $delay = $manager->getRepository(PaymentDelay::class)->findOneBy(['code' => $code]);
+
+        if (!$delay instanceof PaymentDelay) {
+            throw new RuntimeException(sprintf(
+                'PaymentDelay "%s" introuvable : CommercialReferentialFixtures doit tourner avant SupplierFixtures.',
+                $code,
+            ));
+        }
+
+        return $delay;
+    }
+
+    private function paymentType(ObjectManager $manager, string $code): PaymentType
+    {
+        $type = $manager->getRepository(PaymentType::class)->findOneBy(['code' => $code]);
+
+        if (!$type instanceof PaymentType) {
+            throw new RuntimeException(sprintf(
+                'PaymentType "%s" introuvable : CommercialReferentialFixtures doit tourner avant SupplierFixtures.',
+                $code,
+            ));
+        }
+
+        return $type;
+    }
+
+    private function bank(ObjectManager $manager, string $code): Bank
+    {
+        $bank = $manager->getRepository(Bank::class)->findOneBy(['code' => $code]);
+
+        if (!$bank instanceof Bank) {
+            throw new RuntimeException(sprintf(
+                'Bank "%s" introuvable : CommercialReferentialFixtures doit tourner avant SupplierFixtures.',
+                $code,
+            ));
+        }
+
+        return $bank;
+    }
+}

src/Module/Commercial/Infrastructure/Doctrine/DoctrineClientRepository.php

@@ -103,9 +103,11 @@ class DoctrineClientRepository extends ServiceEntityRepository implements Client
     }
 
     /**
-     * Recherche fuzzy insensible a la casse sur companyName + lastName + email.
-     * Les metacaracteres LIKE (%, _, \) saisis sont echappes pour rester
-     * litteraux.
+     * Recherche fuzzy insensible a la casse sur companyName (D1, refonte contact).
+     * Depuis la suppression du contact inline du Client, la recherche ne porte
+     * plus que sur le nom d'entreprise (les anciens criteres lastName / email
+     * vivaient sur les colonnes inline disparues). Les metacaracteres LIKE
+     * (%, _, \) saisis sont echappes pour rester litteraux.
      */
     private function applySearch(QueryBuilder $qb, ?string $search): void
     {
@@ -116,11 +118,9 @@ class DoctrineClientRepository extends ServiceEntityRepository implements Client
         $escaped = str_replace(['\\', '%', '_'], ['\\\\', '\%', '\_'], trim($search));
         $pattern = '%'.mb_strtolower($escaped, 'UTF-8').'%';
 
-        $qb->andWhere(
-            'LOWER(c.companyName) LIKE :search '
-            .'OR LOWER(c.lastName) LIKE :search '
-            .'OR LOWER(c.email) LIKE :search',
-        )->setParameter('search', $pattern);
+        $qb->andWhere('LOWER(c.companyName) LIKE :search')
+            ->setParameter('search', $pattern)
+        ;
     }
 
     /**

src/Module/Commercial/Infrastructure/Doctrine/DoctrineSupplierAddressRepository.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\Doctrine;
+
+use App\Module\Commercial\Domain\Entity\SupplierAddress;
+use App\Module\Commercial\Domain\Repository\SupplierAddressRepositoryInterface;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @extends ServiceEntityRepository<SupplierAddress>
+ */
+class DoctrineSupplierAddressRepository extends ServiceEntityRepository implements SupplierAddressRepositoryInterface
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, SupplierAddress::class);
+    }
+
+    public function findById(int $id): ?SupplierAddress
+    {
+        return $this->find($id);
+    }
+
+    public function save(SupplierAddress $address): void
+    {
+        $this->getEntityManager()->persist($address);
+        $this->getEntityManager()->flush();
+    }
+}

src/Module/Commercial/Infrastructure/Doctrine/DoctrineSupplierContactRepository.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\Doctrine;
+
+use App\Module\Commercial\Domain\Entity\SupplierContact;
+use App\Module\Commercial\Domain\Repository\SupplierContactRepositoryInterface;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @extends ServiceEntityRepository<SupplierContact>
+ */
+class DoctrineSupplierContactRepository extends ServiceEntityRepository implements SupplierContactRepositoryInterface
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, SupplierContact::class);
+    }
+
+    public function findById(int $id): ?SupplierContact
+    {
+        return $this->find($id);
+    }
+
+    public function save(SupplierContact $contact): void
+    {
+        $this->getEntityManager()->persist($contact);
+        $this->getEntityManager()->flush();
+    }
+}

src/Module/Commercial/Infrastructure/Doctrine/DoctrineSupplierRepository.php

@@ -0,0 +1,264 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Module\Commercial\Infrastructure\Doctrine;
+
+use App\Module\Commercial\Domain\Entity\Supplier;
+use App\Module\Commercial\Domain\Repository\SupplierRepositoryInterface;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\ORM\QueryBuilder;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @extends ServiceEntityRepository<Supplier>
+ */
+class DoctrineSupplierRepository extends ServiceEntityRepository implements SupplierRepositoryInterface
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, Supplier::class);
+    }
+
+    public function findById(int $id): ?Supplier
+    {
+        return $this->find($id);
+    }
+
+    public function save(Supplier $supplier): void
+    {
+        $this->getEntityManager()->persist($supplier);
+        $this->getEntityManager()->flush();
+    }
+
+    public function createListQueryBuilder(
+        bool $includeArchived = false,
+        ?string $search = null,
+        array $categoryCodes = [],
+        array $siteIds = [],
+        bool $archivedOnly = false,
+    ): QueryBuilder {
+        // SELECTION uniquement (filtres + tri) : pas de fetch-join to-many ici.
+        // L'hydratation des collections affichees (Catégories / Site(s)) est
+        // deleguee a hydrateListCollections() une fois le jeu borne, pour ne pas
+        // imposer un produit cartesien aux chemins non pagines (export,
+        // ?pagination=false) — § 2.12 (cf. M1/ERP-100).
+        $qb = $this->createQueryBuilder('s')
+            ->andWhere('s.deletedAt IS NULL')
+            ->orderBy('s.companyName', 'ASC')
+        ;
+
+        // Perimetre d'archivage : archivedOnly prioritaire sur includeArchived.
+        if ($archivedOnly) {
+            $qb->andWhere('s.isArchived = true');
+        } elseif (!$includeArchived) {
+            $qb->andWhere('s.isArchived = false');
+        }
+
+        $this->applySearch($qb, $search);
+        $this->applyCategoryCodes($qb, $categoryCodes);
+        $this->applySiteIds($qb, $siteIds);
+
+        return $qb;
+    }
+
+    public function hydrateListCollections(array $suppliers): void
+    {
+        if ([] === $suppliers) {
+            return;
+        }
+
+        // Ids des fournisseurs deja charges (entites managees). Les requetes
+        // ci-dessous renvoient les MEMES instances Supplier (identity map), dont
+        // les collections sont alors remplies — anti N+1 a la serialisation.
+        $ids = [];
+        foreach ($suppliers as $supplier) {
+            $id = $supplier->getId();
+            if (null !== $id) {
+                $ids[] = $id;
+            }
+        }
+        if ([] === $ids) {
+            return;
+        }
+
+        // 1re passe : categories (colonne « Catégories »). Produit s x cat seul.
+        $this->createQueryBuilder('s')
+            ->leftJoin('s.categories', 'cat')->addSelect('cat')
+            ->where('s.id IN (:ids)')->setParameter('ids', $ids)
+            ->getQuery()
+            ->getResult()
+        ;
+
+        // 2e passe : adresses + sites (colonne « Site(s) », sites portes par les
+        // adresses — RG-2.06). Le join addr -> site reste imbrique mais n'est plus
+        // multiplie par les categories : le cartesien global est casse.
+        $this->createQueryBuilder('s')
+            ->leftJoin('s.addresses', 'addr')->addSelect('addr')
+            ->leftJoin('addr.sites', 'site')->addSelect('site')
+            ->where('s.id IN (:ids)')->setParameter('ids', $ids)
+            ->getQuery()
+            ->getResult()
+        ;
+    }
+
+    public function hydrateContacts(array $suppliers): void
+    {
+        $ids = [];
+        foreach ($suppliers as $supplier) {
+            $id = $supplier->getId();
+            if (null !== $id) {
+                $ids[] = $id;
+            }
+        }
+        if ([] === $ids) {
+            return;
+        }
+
+        // Une seule requete IN bornee : remplit la collection `contacts` des MEMES
+        // instances Supplier (identity map). Tri par position pour que le « contact
+        // principal » (plus petit position) soit deterministe a l'export (§ 4.6).
+        $this->createQueryBuilder('s')
+            ->leftJoin('s.contacts', 'sc')->addSelect('sc')
+            ->where('s.id IN (:ids)')->setParameter('ids', $ids)
+            ->orderBy('sc.position', 'ASC')
+            ->getQuery()
+            ->getResult()
+        ;
+    }
+
+    /**
+     * Recherche fuzzy insensible a la casse sur companyName ET sur les contacts
+     * lies (firstName / lastName / email) — decision D1, refonte-contact (§ 4.1).
+     * Les deux criteres sont unis par OR : un fournisseur matche si son nom de
+     * societe OU l'un de ses contacts matche. Le critere contact passe par une
+     * sous-requete IN (plutot qu'un JOIN sur la collection) pour ne pas perturber
+     * le DISTINCT / ORDER BY / pagination principal. Les metacaracteres LIKE
+     * (%, _, \) saisis sont echappes pour rester litteraux.
+     */
+    private function applySearch(QueryBuilder $qb, ?string $search): void
+    {
+        if (null === $search || '' === trim($search)) {
+            return;
+        }
+
+        $escaped = str_replace(['\\', '%', '_'], ['\\\\', '\%', '\_'], trim($search));
+        $pattern = '%'.mb_strtolower($escaped, 'UTF-8').'%';
+
+        $contactSub = $this->getEntityManager()->createQueryBuilder()
+            ->select('s2.id')
+            ->from(Supplier::class, 's2')
+            ->join('s2.contacts', 'sc2')
+            ->where('LOWER(sc2.firstName) LIKE :search')
+            ->orWhere('LOWER(sc2.lastName) LIKE :search')
+            ->orWhere('LOWER(sc2.email) LIKE :search')
+        ;
+
+        $qb->andWhere(
+            $qb->expr()->orX(
+                'LOWER(s.companyName) LIKE :search',
+                $qb->expr()->in('s.id', $contactSub->getDQL()),
+            ),
+        )->setParameter('search', $pattern);
+    }
+
+    /**
+     * Restreint aux fournisseurs possedant au moins une categorie dont le code
+     * figure dans la liste (OR). Alimente le filtre « Catégories » du drawer.
+     * Sous-requete IN (plutot qu'un JOIN sur la collection M2M) pour ne pas
+     * perturber le DISTINCT / ORDER BY principal.
+     *
+     * @param list<string> $categoryCodes
+     */
+    private function applyCategoryCodes(QueryBuilder $qb, array $categoryCodes): void
+    {
+        $codes = $this->normalizeStringList($categoryCodes);
+        if ([] === $codes) {
+            return;
+        }
+
+        $sub = $this->getEntityManager()->createQueryBuilder()
+            ->select('s3.id')
+            ->from(Supplier::class, 's3')
+            ->join('s3.categories', 'cat3')
+            ->where('cat3.code IN (:categoryCodes)')
+        ;
+
+        $qb->andWhere($qb->expr()->in('s.id', $sub->getDQL()))
+            ->setParameter('categoryCodes', $codes)
+        ;
+    }
+
+    /**
+     * Restreint aux fournisseurs ayant au moins une adresse rattachee a l'un des
+     * sites donnes (OR — RG-2.06 : les sites vivent sur les adresses). Sous-requete
+     * IN pour ne pas perturber le tri/pagination principal.
+     *
+     * @param list<int> $siteIds
+     */
+    private function applySiteIds(QueryBuilder $qb, array $siteIds): void
+    {
+        $ids = $this->normalizeIntList($siteIds);
+        if ([] === $ids) {
+            return;
+        }
+
+        $sub = $this->getEntityManager()->createQueryBuilder()
+            ->select('s4.id')
+            ->from(Supplier::class, 's4')
+            ->join('s4.addresses', 'addr4')
+            ->join('addr4.sites', 'site4')
+            ->where('site4.id IN (:siteIds)')
+        ;
+
+        $qb->andWhere($qb->expr()->in('s.id', $sub->getDQL()))
+            ->setParameter('siteIds', $ids)
+        ;
+    }
+
+    /**
+     * Nettoie une liste de chaines : trim, retrait des vides, reindexation.
+     * Defensive : tolere des elements scalaires non-string (cast) et ignore le
+     * reste sans lever de TypeError, le contrat etant de normaliser une entree
+     * potentiellement brute (query params).
+     *
+     * @param array<mixed> $values
+     *
+     * @return list<string>
+     */
+    private function normalizeStringList(array $values): array
+    {
+        $out = [];
+        foreach ($values as $value) {
+            if (is_string($value) || is_int($value) || is_float($value)) {
+                $trimmed = trim((string) $value);
+                if ('' !== $trimmed) {
+                    $out[] = $trimmed;
+                }
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * Nettoie une liste d'identifiants : cast int, retrait des <= 0, reindexation.
+     * Defensive (cf. normalizeStringList) : accepte des entiers ou des chaines
+     * numeriques ('1', '2') sans TypeError, ignore le reste.
+     *
+     * @param array<mixed> $values
+     *
+     * @return list<int>
+     */
+    private function normalizeIntList(array $values): array
+    {
+        $out = [];
+        foreach ($values as $value) {
+            if (is_numeric($value) && (int) $value > 0) {
+                $out[] = (int) $value;
+            }
+        }
+
+        return $out;
+    }
+}