chore: bump version to v0.1.81

feat(commercial) : messages de validation FR sur les contraintes back + garde-fou (ERP-107) (#59 )
## Contexte Résout **ERP-107** — pendant back du mapping d'erreur par champ front (ERP-101). Le front (`useFormErrors` / `mapViolationsToRecord`) affiche sous chaque champ le `message` renvoyé par le back. Ce ticket garantit que ces messages existent, sont en FR et rattachés au bon champ. ## Changements - **Messages FR explicites** sur toutes les contraintes `#[Assert\*]` des entités métier : `Client`, `ClientContact`, `ClientAddress`, `ClientRib`, `Category`, `Role`, `User` (Email, NotBlank, Length, Bic, Iban, PositiveOrZero, Count…). - **Contraintes `Assert\Length` manquantes ajoutées**, calées sur le `length` de la colonne ORM (téléphones `VARCHAR(20)`, `siren`, `nTva`, `accountNumber`, `username`…). Évite une erreur Postgres 500 non rattachée au champ → 422 propre. - **Locale FR globale** (`symfony/translation` + `default_locale: fr`) comme filet pour les messages natifs Symfony non surchargés. - **Garde-fou** `tests/Architecture/EntityConstraintsHaveFrenchMessageTest` : échoue si une contrainte n'a pas de message FR explicite (comparaison au défaut Symfony) ou si `Assert\Length.max` diverge du `length` ORM. Whitelist justifiée pour les formats auto-bornés (Bic/Iban/Regex CP/couleur hex). - **Test fonctionnel** du JSON 422 réel : message FR + `propertyPath` consommable par le front. - **Convention documentée** dans `.claude/rules/backend.md`. ## Décisions - Stratégie retenue : message FR **explicite sur toutes** les contraintes + locale FR en filet (les deux leviers du ticket). - Garde-fou `Length == ORM length` : **test bloquant** (anti-dérive). - RG-1.03 (distributor/broker) : pas de `Assert\Callback` ajouté — le `ClientProcessor` gère **déjà** l'exclusivité (422 + `propertyPath`). Pas de doublon. ## Hors périmètre / à suivre - **Alignement `nullable`(DB) / `NotBlank`(back) / `required`(front)** : les champs obligatoires existants ont été confirmés, mais aucun changement de nullabilité DB n'a été fait sans arbitrage métier. À recroiser avec les astérisques front (ERP-101 / PR #58) si divergence constatée. ## Vérifications - `make test` : **469 tests verts** (1793 assertions), 0 échec/erreur. - `php-cs-fixer` : 0 fichier à corriger. --------- Co-authored-by: admin malio <malio@yuno.malio.fr> Co-authored-by: Matthieu <contact@malio.fr> Reviewed-on: #59 Co-authored-by: THOLOT DECHENE Matthieu <matthieu@yuno.malio.fr> Co-committed-by: THOLOT DECHENE Matthieu <matthieu@yuno.malio.fr>
2026-06-04 09:27:40 +00:00 · 2026-06-04 09:27:32 +00:00 · 2026-06-04 09:02:08 +00:00 · 2026-06-04 09:02:01 +00:00 · 2026-06-04 08:41:27 +00:00 · 2026-06-04 08:41:19 +00:00
45 changed files with 2535 additions and 519 deletions
@@ -6,6 +6,42 @@
 - 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\*]` portee par une entite metier doit avoir un message FR explicite**, et **`Assert\Length.max` doit refleter le `length` de la colonne ORM**. Pendant logique back de la regle de mapping d'erreur par champ cote front (ERP-101 : `useFormErrors` / `mapViolationsToRecord` affiche sous chaque champ le `message` renvoye par le back).
+
+Pourquoi :
+- Sans `message:` explicite, Symfony renvoie le defaut **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 metier portent en plus leur message FR pour un controle total.
+- Une colonne string bornee **sans `Assert\Length`** echoue au niveau Postgres (500 generique, non rattachee au champ) au lieu d'une 422 propre. Le `max` doit egaler le `length` ORM (anti-derive).
+
+Pattern par champ scalaire :
+
+```php
+// Email metier
+#[Assert\Email(message: 'L\'adresse email n\'est pas valide.')]
+
+// Longueur calee 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')]
+```
+
+Coherence a 3 niveaux pour un champ obligatoire : colonne `nullable` (DB) <-> `Assert\NotBlank` (back) <-> `:required` + asterisque (front ERP-101). Les trois doivent s'accorder.
+
+Exceptions au miroir `Length` : un format deja borne par `Assert\Bic` / `Assert\Iban` (longueur garantie) ou par un `Assert\Regex` borne (ex. code postal `{4,5}`, couleur hex `#RRGGBB`) — whitelister alors la propriete dans `EntityConstraintsHaveFrenchMessageTest::EXCLUDED_LENGTH_MIRROR` avec justification.
+
+Les regles inter-champs (RG metier : exclusivite 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 plutot qu'en toast.
+
+### Garde-fou architecture
+
+`tests/Architecture/EntityConstraintsHaveFrenchMessageTest` scanne reflexivement les entites sous `src/Module/*/Domain/Entity/` et echoue si :
+1. une contrainte connue n'a pas de message FR explicite (compare au defaut Symfony) ;
+2. une colonne string bornee writable n'a pas de `Assert\Length(max == ORM length)` (hors whitelist).
+
+Une contrainte non geree par le mapping du test le fait echouer : il faut l'ajouter explicitement (anti faux positif vert).
+
 ## API Platform (pas de controllers)

 - Toujours utiliser `#[ApiResource]` + Providers + Processors — pas de controllers Symfony classiques
@@ -44,6 +44,40 @@ Tout champ de formulaire / filtre doit utiliser les composants `Malio*` plutot q

 Toute autre exception requiert validation avant merge.

+## 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 +142,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
@@ -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.*",
@@ -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",
@@ -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:
@@ -38,6 +38,28 @@ 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',
+            ],
+        ],
+    ],
    // Section "Administration" : regroupe toutes les pages de configuration
    // applicative (RBAC, users, sites, audit log).
    //
@@ -99,25 +121,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).
@@ -1,2 +1,2 @@
 parameters:
-    app.version: '0.1.77'
+    app.version: '0.1.81'
@@ -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).
@@ -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.
@@ -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**.
@@ -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",
@@ -233,7 +228,10 @@
        },
        "sites": {
            "notAuthorized": "Vous n'êtes pas autorisé à sélectionner ce site."
-        }
+        },
+        "title": "Erreur",
+        "generic": "Une erreur est survenue.",
+        "unknown": "Erreur inconnue."
    },
    "sites": {
        "selector": {
@@ -290,7 +288,8 @@
    "success": {
        "auth": {
            "logout": "Deconnexion reussie"
-        }
+        },
+        "title": "Succès"
    },
    "admin": {
        "roles": {
@@ -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
@@ -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)
        })
    })
@@ -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
@@ -44,7 +44,8 @@
            :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 +53,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 +63,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 +75,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 +86,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 +107,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 +118,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,6 +129,7 @@
                :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>
@@ -139,7 +152,7 @@
            :options="contactOptions"
            :label="t('commercial.clients.form.address.contacts')"
            :display-tag="true"
-            :disabled="readonly"
+            :readonly="readonly"
            @update:model-value="(v: (string | number)[]) => update('contactIris', v.map(String))"
        />

@@ -151,6 +164,7 @@
            :label="t('commercial.clients.form.address.billingEmail')"
            :required="true"
            :readonly="readonly"
+            :error="errors?.billingEmail"
            @update:model-value="(v: string) => update('billingEmail', v)"
        />
    </div>
@@ -183,6 +197,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<{
@@ -16,24 +16,28 @@
            :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"
+            :error="errors?.email"
            @update:model-value="(v: string) => update('email', v)"
        />
        <MalioInputPhone
@@ -41,6 +45,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 +57,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 +79,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<{
@@ -74,3 +74,59 @@ describe('ClientAddressBlock — affichage de l\'adresse persistee', () => {
        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.')
+    })
+})
@@ -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('')
+    })
+})
@@ -0,0 +1,54 @@
+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()
+    })
+})
@@ -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' }])
    })
 })
@@ -0,0 +1,55 @@
+/**
+ * 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
+    }
+
+    return {
+        mainErrors,
+        informationErrors,
+        accountingErrors,
+        contactErrors,
+        addressErrors,
+        ribErrors,
+        mapRowError,
+    }
+}
@@ -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,6 +157,7 @@
                            :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)"
                        />
@@ -212,6 +194,7 @@
                            :country-options="countryOptions"
                            :removable="addresses.length > 1"
                            :readonly="businessReadonly"
+                            :errors="addressErrors[index]"
                            @update:model-value="(v) => addresses[index] = v"
                            @remove="askRemoveAddress(index)"
                            @degraded="onAddressDegraded"
@@ -245,39 +228,51 @@
                                    :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
@@ -285,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>
@@ -311,16 +308,22 @@
                                    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>
@@ -379,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,
@@ -424,7 +428,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 = '#######'

@@ -612,6 +615,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,
+    mapRowError,
+} = useClientFormErrors()
+
 // ── Bloc principal ───────────────────────────────────────────────────────────
 const isMainValid = computed(() => {
    const filled = (v: string | null | undefined) => v !== null && v !== undefined && v.trim() !== ''
@@ -620,9 +639,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
 })
@@ -642,6 +658,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' },
@@ -652,7 +669,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
@@ -664,12 +691,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
@@ -693,6 +721,7 @@ 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())
    })
@@ -706,15 +735,18 @@ 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) {
+        for (let index = 0; index < contacts.value.length; index++) {
+            const contact = contacts.value[index]
            if (!isContactNamed(contact)) continue
            const body = buildContactPayload(contact)
+            try {
                if (contact.id === null) {
                    const created = await api.post<{ '@id'?: string, id: number }>(
                        `/clients/${clientId}/contacts`,
@@ -728,6 +760,14 @@ async function submitContacts(): Promise<void> {
                    await api.patch(`/client_contacts/${contact.id}`, body, { toast: false })
                }
            }
+            catch (error) {
+                // 422 → erreurs inline sous les champs de CETTE ligne ; on stoppe.
+                if (!mapRowError(error, contactErrors, index)) {
+                    showError(error)
+                }
+                return
+            }
+        }
        toast.success({ title: t('commercial.clients.toast.updateSuccess') })
    }
    catch (e) {
@@ -758,6 +798,7 @@ 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())
    })
@@ -776,14 +817,17 @@ 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) {
+        for (let index = 0; index < addresses.value.length; index++) {
+            const address = addresses.value[index]
            const body = buildAddressPayload(address, isBillingEmailRequired(address))
+            try {
                if (address.id === null) {
                    const created = await api.post<{ id: number }>(
                        `/clients/${clientId}/addresses`,
@@ -796,6 +840,13 @@ async function submitAddresses(): Promise<void> {
                    await api.patch(`/client_addresses/${address.id}`, body, { toast: false })
                }
            }
+            catch (error) {
+                if (!mapRowError(error, addressErrors, index)) {
+                    showError(error)
+                }
+                return
+            }
+        }
        toast.success({ title: t('commercial.clients.toast.updateSuccess') })
    }
    catch (e) {
@@ -838,6 +889,7 @@ 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())
    })
@@ -852,17 +904,29 @@ function askRemoveRib(index: number): void {
 async function submitAccounting(): Promise<void> {
    if (accountingReadonly.value || !canValidateAccounting.value || tabSubmitting.value) return
    tabSubmitting.value = true
+    accountingErrors.clearErrors()
+    ribErrors.value = []
+    try {
+        // 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) {
+        // 2) POST/PATCH des RIB (erreurs inline par ligne).
+        for (let index = 0; index < ribs.value.length; index++) {
+            const rib = ribs.value[index]
            if (!ribIsComplete(rib)) continue
            const body = buildRibPayload(rib)
+            try {
                if (rib.id === null) {
                    const created = await api.post<{ id: number }>(
                        `/clients/${clientId}/ribs`,
@@ -875,6 +939,13 @@ async function submitAccounting(): Promise<void> {
                    await api.patch(`/client_ribs/${rib.id}`, body, { toast: false })
                }
            }
+            catch (error) {
+                if (!mapRowError(error, ribErrors, index)) {
+                    showError(error)
+                }
+                return
+            }
+        }
        toast.success({ title: t('commercial.clients.toast.updateSuccess') })
    }
    catch (e) {
@@ -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>
@@ -200,7 +180,7 @@
                                    :options="tvaModeOptions"
                                    :label="t('commercial.clients.form.accounting.tvaMode')"
                                    empty-option-label=""
-                                    disabled
+                                    readonly
                                />
                                <MalioInputText
                                    :model-value="accounting.nTva"
@@ -212,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"
@@ -227,7 +207,7 @@
                                    :options="bankOptions"
                                    :label="t('commercial.clients.form.accounting.bank')"
                                    empty-option-label=""
-                                    disabled
+                                    readonly
                                />
                            </div>
                        </div>
@@ -313,11 +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()
@@ -350,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,
@@ -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"
@@ -239,39 +226,51 @@
                                :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>
@@ -306,16 +307,22 @@
                                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>
@@ -371,6 +378,7 @@
 <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 {
    buildClientFormTabKeys,
    CLIENT_FORM_PLACEHOLDER_TABS,
@@ -388,11 +396,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 +428,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,
+    mapRowError,
+} = useClientFormErrors()
+
 useHead({ title: t('commercial.clients.form.title') })

 // Gating de la route : la creation est reservee a `manage`. Compta (accounting
@@ -444,9 +466,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 +473,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 +480,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 +494,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 +515,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 +530,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 +539,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 +625,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 +640,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 +648,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 +668,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)
    })
 }

@@ -687,8 +676,10 @@ function askRemoveContact(index: number): void {
 async function submitContacts(): Promise<void> {
    if (clientId.value === null || !canValidateContacts.value || tabSubmitting.value) return
    tabSubmitting.value = true
+    contactErrors.value = []
    try {
-        for (const contact of contacts.value) {
+        for (let index = 0; index < contacts.value.length; index++) {
+            const contact = contacts.value[index]
            // On ignore les blocs totalement vides (ni nom ni prenom).
            if (!isContactNamed(contact)) continue

@@ -701,6 +692,7 @@ async function submitContacts(): Promise<void> {
                email: contact.email || null,
            }

+            try {
                if (contact.id === null) {
                    const created = await api.post<ContactResponse>(
                        `/clients/${clientId.value}/contacts`,
@@ -714,12 +706,18 @@ async function submitContacts(): Promise<void> {
                    await api.patch(`/client_contacts/${contact.id}`, body, { toast: false })
                }
            }
+            catch (error) {
+                // 422 → erreurs inline sous les champs de CETTE ligne ; on stoppe
+                // a la premiere ligne en echec (les suivantes ne sont pas tentees).
+                if (!mapRowError(error, contactErrors, index)) {
+                    toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) })
+                }
+                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
    }
@@ -768,6 +766,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)
    })
 }

@@ -785,8 +784,10 @@ function onAddressDegraded(): void {
 async function submitAddresses(): Promise<void> {
    if (clientId.value === null || !canValidateAddresses.value || tabSubmitting.value) return
    tabSubmitting.value = true
+    addressErrors.value = []
    try {
-        for (const address of addresses.value) {
+        for (let index = 0; index < addresses.value.length; index++) {
+            const address = addresses.value[index]
            const body = {
                isProspect: address.isProspect,
                isDelivery: address.isDelivery,
@@ -802,6 +803,7 @@ async function submitAddresses(): Promise<void> {
                billingEmail: isBillingEmailRequired(address) ? (address.billingEmail || null) : null,
            }

+            try {
                if (address.id === null) {
                    const created = await api.post<{ id: number }>(
                        `/clients/${clientId.value}/addresses`,
@@ -814,12 +816,16 @@ async function submitAddresses(): Promise<void> {
                    await api.patch(`/client_addresses/${address.id}`, body, { toast: false })
                }
            }
+            catch (error) {
+                if (!mapRowError(error, addressErrors, index)) {
+                    toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) })
+                }
+                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
    }
@@ -872,6 +878,7 @@ 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())
    })
@@ -885,6 +892,10 @@ function askRemoveRib(index: number): void {
 async function submitAccounting(): Promise<void> {
    if (clientId.value === null || !canValidateAccounting.value || tabSubmitting.value) return
    tabSubmitting.value = true
+    accountingErrors.clearErrors()
+    ribErrors.value = []
+    try {
+        // 1) PATCH des scalaires comptables (erreurs inline sur leurs champs).
        try {
            await api.patch(`/clients/${clientId.value}`, {
                siren: accounting.siren || null,
@@ -895,9 +906,17 @@ async function submitAccounting(): Promise<void> {
                paymentType: accounting.paymentTypeIri,
                bank: isBankRequired.value ? accounting.bankIri : null,
            }, { toast: false })
+        }
+        catch (error) {
+            accountingErrors.handleApiError(error, { fallbackMessage: t('commercial.clients.toast.error') })
+            return
+        }

-        for (const rib of ribs.value) {
+        // 2) POST/PATCH des RIB (erreurs inline par ligne).
+        for (let index = 0; index < ribs.value.length; index++) {
+            const rib = ribs.value[index]
            if (!ribIsComplete(rib)) continue
+            try {
                if (rib.id === null) {
                    const created = await api.post<{ id: number }>(
                        `/clients/${clientId.value}/ribs`,
@@ -910,13 +929,17 @@ async function submitAccounting(): Promise<void> {
                    await api.patch(`/client_ribs/${rib.id}`, { label: rib.label, bic: rib.bic, iban: rib.iban }, { toast: false })
                }
            }
+            catch (error) {
+                if (!mapRowError(error, ribErrors, index)) {
+                    toast.error({ title: t('commercial.clients.toast.error'), message: apiErrorMessage(error) })
+                }
+                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
    }
@@ -945,11 +968,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 {
@@ -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)
@@ -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[]
@@ -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,
@@ -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",
@@ -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",
@@ -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)
+    })
+})
@@ -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
            })
        }
@@ -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,
+    }
+}
@@ -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.' })
+    })
+})
@@ -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 :
@@ -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;

@@ -147,7 +147,7 @@ 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;

@@ -188,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;

@@ -196,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;

@@ -205,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;

@@ -217,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;

@@ -230,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;

@@ -125,33 +125,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;

@@ -88,30 +88,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;

@@ -97,20 +97,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;

@@ -79,13 +79,15 @@ class Role

    #[ORM\Column(length: 100)]
    #[Groups(['role:read', 'role:write'])]
-    #[Assert\NotBlank]
-    #[Assert\Regex(pattern: '/^[a-z][a-z0-9_]*$/', message: 'Le code doit etre en snake_case et commencer par une lettre minuscule.')]
+    #[Assert\NotBlank(message: 'Le code du rôle est obligatoire.', normalizer: 'trim')]
+    #[Assert\Regex(pattern: '/^[a-z][a-z0-9_]*$/', message: 'Le code doit être en snake_case et commencer par une lettre minuscule.')]
+    #[Assert\Length(max: 100, maxMessage: 'Le code ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
    private string $code;

    #[ORM\Column(length: 255)]
    #[Groups(['role:read', 'role:write'])]
-    #[Assert\NotBlank]
+    #[Assert\NotBlank(message: 'Le libellé du rôle est obligatoire.', normalizer: 'trim')]
+    #[Assert\Length(max: 255, maxMessage: 'Le libellé ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
    private string $label;

    #[ORM\Column(type: Types::TEXT, nullable: true)]
@@ -33,6 +33,7 @@ use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
 use Symfony\Component\Security\Core\User\UserInterface;
 use Symfony\Component\Serializer\Attribute\Groups;
 use Symfony\Component\Serializer\Attribute\SerializedName;
+use Symfony\Component\Validator\Constraints as Assert;

 #[ApiResource(
    operations: [
@@ -85,6 +86,8 @@ class User implements UserInterface, PasswordAuthenticatedUserInterface, Busines
    private ?int $id = null;

    #[ORM\Column(length: 180, unique: true)]
+    #[Assert\NotBlank(message: 'Le nom d\'utilisateur est obligatoire.', normalizer: 'trim')]
+    #[Assert\Length(max: 180, maxMessage: 'Le nom d\'utilisateur ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
    #[Groups(['me:read', 'user:list', 'user:write'])]
    private ?string $username = null;

@@ -219,6 +219,19 @@
            "config/routes/security.yaml"
        ]
    },
+    "symfony/translation": {
+        "version": "8.0",
+        "recipe": {
+            "repo": "github.com/symfony/recipes",
+            "branch": "main",
+            "version": "6.3",
+            "ref": "620a1b84865ceb2ba304c8f8bf2a185fbf32a843"
+        },
+        "files": [
+            "config/packages/translation.yaml",
+            "translations/.gitignore"
+        ]
+    },
    "symfony/twig-bundle": {
        "version": "8.0",
        "recipe": {
@@ -0,0 +1,363 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Architecture;
+
+use Doctrine\ORM\Mapping\Column;
+use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+use ReflectionProperty;
+use Symfony\Component\Finder\Finder;
+use Symfony\Component\Serializer\Attribute\Groups;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\Constraints as Assert;
+
+use function in_array;
+use function is_string;
+use function sprintf;
+use function str_contains;
+
+/**
+ * Garde-fou architecture ERP-107 : toute contrainte `#[Assert\*]` portee par une
+ * entite metier doit avoir un message FR EXPLICITE (et non le defaut anglais de
+ * Symfony), et toute colonne string bornee writable doit avoir une `Assert\Length`
+ * calee sur le `length` de la colonne ORM.
+ *
+ * Pourquoi (lien ERP-101) : le front (useFormErrors / mapViolationsToRecord)
+ * affiche sous chaque champ le `message` renvoye par le back. Un message absent
+ * = defaut anglais ; une colonne bornee sans Assert\Length = erreur Postgres
+ * (500) au lieu d'une 422 propre rattachee au champ.
+ *
+ * Deux verifications, sur le modele de AuditableEntitiesHaveI18nLabelTest :
+ *  1. MESSAGE EXPLICITE : pour chaque contrainte connue, la (ou les) propriete(s)
+ *     de message pertinente(s) doivent differer du defaut Symfony. La comparaison
+ *     au defaut (instance « nue » de la meme contrainte) evite de valider un
+ *     message anglais natif laisse tel quel.
+ *  2. LENGTH == ORM length : toute propriete string writable avec `ORM\Column(length:)`
+ *     doit porter `Assert\Length(max:)` egal a ce length — sauf si le format est
+ *     deja borne par Bic/Iban, ou whitelistee dans EXCLUDED_LENGTH_MIRROR.
+ *
+ * @internal
+ */
+final class EntityConstraintsHaveFrenchMessageTest extends TestCase
+{
+    /**
+     * Proprietes writable exemptees du miroir Assert\Length == ORM length, avec
+     * justification. Toute entree doit citer la raison (format deja borne par une
+     * autre contrainte). Cle : "<ClasseCourte>::<propriete>".
+     *
+     * @var array<string, string>
+     */
+    private const array EXCLUDED_LENGTH_MIRROR = [
+        // Le Regex /^[0-9]{4,5}$/ borne deja la longueur a 5 caracteres (< 20).
+        'ClientAddress::postalCode' => 'Regex {4,5} borne deja la longueur.',
+        // Le Regex /^#[0-9A-Fa-f]{6}$/ borne la longueur a exactement 7 caracteres.
+        'Site::color' => 'Regex code hex #RRGGBB borne deja la longueur.',
+    ];
+
+    /**
+     * Mapping contrainte -> proprietes de message a verifier. Une contrainte
+     * absente de ce mapping (hors Callback) fait ECHOUER le test : il faut
+     * l'ajouter explicitement (anti faux positif vert sur une contrainte inconnue).
+     *
+     * Pour Length / Count, la liste est calculee dynamiquement (minMessage si
+     * `min` est pose, maxMessage si `max` est pose).
+     *
+     * @var list<class-string<Constraint>>
+     */
+    private const array SIMPLE_MESSAGE_CONSTRAINTS = [
+        Assert\NotBlank::class,
+        Assert\NotNull::class,
+        Assert\Email::class,
+        Assert\Regex::class,
+        Assert\Bic::class,
+        Assert\Iban::class,
+        Assert\PositiveOrZero::class,
+        Assert\Positive::class,
+        Assert\NegativeOrZero::class,
+        Assert\Negative::class,
+    ];
+
+    public function testEveryConstraintHasAnExplicitFrenchMessage(): void
+    {
+        $checked = 0;
+
+        foreach ($this->entityProperties() as [$shortClass, $property]) {
+            foreach ($property->getAttributes() as $attribute) {
+                $name = $attribute->getName();
+                if (!is_subclass_of($name, Constraint::class)) {
+                    continue;
+                }
+
+                // Les Callback portent leur message dans la closure : hors scope.
+                if (Assert\Callback::class === $name) {
+                    continue;
+                }
+
+                /** @var Constraint $constraint */
+                $constraint = $attribute->newInstance();
+                $messageProps = $this->messagePropertiesFor($constraint);
+
+                self::assertNotNull(
+                    $messageProps,
+                    sprintf(
+                        'Contrainte non geree par le garde-fou : %s sur %s::$%s. '
+                        .'Ajouter sa classe au mapping de EntityConstraintsHaveFrenchMessageTest.',
+                        $name,
+                        $shortClass,
+                        $property->getName(),
+                    ),
+                );
+
+                foreach ($messageProps as $prop) {
+                    $actual  = $constraint->{$prop} ?? null;
+                    $default = $this->defaultMessageFor($name, $prop);
+
+                    self::assertTrue(
+                        is_string($actual) && '' !== $actual && $actual !== $default,
+                        sprintf(
+                            'La contrainte %s sur %s::$%s n\'a pas de %s FR explicite '
+                            .'(message absent ou laisse au defaut anglais). Cf. ERP-107.',
+                            $name,
+                            $shortClass,
+                            $property->getName(),
+                            $prop,
+                        ),
+                    );
+                    ++$checked;
+                }
+            }
+        }
+
+        self::assertGreaterThan(0, $checked, 'Aucune contrainte verifiee : detection d\'attributs cassee ?');
+    }
+
+    public function testBoundedStringColumnsHaveMatchingLength(): void
+    {
+        $checked = 0;
+
+        foreach ($this->entityProperties() as [$shortClass, $property]) {
+            $column = $this->ormColumn($property);
+            if (null === $column || null === $column->length) {
+                continue;
+            }
+            // Colonnes non-string (text, decimal, date...) : pas de length scalaire a calquer.
+            if (null !== $column->type && 'string' !== $column->type) {
+                continue;
+            }
+            // Le miroir ne protege que la saisie utilisateur (champs writable).
+            if (!$this->isPropertyWritable($property)) {
+                continue;
+            }
+
+            $constraints = $this->constraintsOf($property);
+
+            // Format deja borne par Bic/Iban : longueur garantie cote contrainte.
+            if ($this->hasAnyConstraint($constraints, [Assert\Bic::class, Assert\Iban::class])) {
+                continue;
+            }
+
+            $excludeKey = $shortClass.'::'.$property->getName();
+            if (isset(self::EXCLUDED_LENGTH_MIRROR[$excludeKey])) {
+                continue;
+            }
+
+            $length = null;
+            foreach ($constraints as $c) {
+                if ($c instanceof Assert\Length) {
+                    $length = $c->max;
+                    break;
+                }
+            }
+
+            self::assertNotNull(
+                $length,
+                sprintf(
+                    '%s::$%s est une colonne string bornee (length=%d) writable sans Assert\Length : '
+                    .'risque d\'erreur Postgres 500. Ajouter Assert\Length(max: %d) ou whitelister. Cf. ERP-107.',
+                    $shortClass,
+                    $property->getName(),
+                    $column->length,
+                    $column->length,
+                ),
+            );
+            self::assertSame(
+                $column->length,
+                $length,
+                sprintf(
+                    'Derive Assert\Length.max (%s) != ORM length (%d) sur %s::$%s. '
+                    .'Le max doit refleter le length de la colonne (anti-derive ERP-107).',
+                    (string) $length,
+                    $column->length,
+                    $shortClass,
+                    $property->getName(),
+                ),
+            );
+            ++$checked;
+        }
+
+        self::assertGreaterThan(0, $checked, 'Aucune colonne string bornee verifiee : scan casse ?');
+    }
+
+    /**
+     * Itere (classe courte, ReflectionProperty) sur toutes les entites metier
+     * sous src/Module/<m>/Domain/Entity/.
+     *
+     * @return iterable<array{0: string, 1: ReflectionProperty}>
+     */
+    private function entityProperties(): iterable
+    {
+        $finder = new Finder()
+            ->files()
+            ->in(__DIR__.'/../../src/Module')
+            ->path('Domain/Entity')
+            ->name('*.php')
+        ;
+
+        self::assertNotEmpty(iterator_to_array($finder), 'Aucune entite scannee : chemin src/Module invalide ?');
+
+        foreach ($finder as $file) {
+            $fqcn = $this->extractFqcn($file->getRealPath());
+            if (null === $fqcn) {
+                continue;
+            }
+
+            $reflection = new ReflectionClass($fqcn);
+            if ($reflection->isAbstract()) {
+                continue;
+            }
+
+            foreach ($reflection->getProperties() as $property) {
+                yield [$reflection->getShortName(), $property];
+            }
+        }
+    }
+
+    /**
+     * Liste des proprietes de message a verifier pour une contrainte donnee, ou
+     * null si la contrainte n'est pas geree (le test echoue alors explicitement).
+     *
+     * @return list<string>|null
+     */
+    private function messagePropertiesFor(Constraint $constraint): ?array
+    {
+        if ($constraint instanceof Assert\Length) {
+            $props = [];
+            if (null !== $constraint->min) {
+                $props[] = 'minMessage';
+            }
+            if (null !== $constraint->max) {
+                $props[] = 'maxMessage';
+            }
+
+            return $props;
+        }
+
+        if ($constraint instanceof Assert\Count) {
+            $props = [];
+            if (null !== $constraint->min) {
+                $props[] = 'minMessage';
+            }
+            if (null !== $constraint->max) {
+                $props[] = 'maxMessage';
+            }
+
+            return $props;
+        }
+
+        if (in_array($constraint::class, self::SIMPLE_MESSAGE_CONSTRAINTS, true)) {
+            return ['message'];
+        }
+
+        return null;
+    }
+
+    /**
+     * Message par defaut d'une contrainte (instance « nue ») pour la propriete
+     * demandee. Sert de reference pour detecter un message laisse au defaut.
+     */
+    private function defaultMessageFor(string $class, string $prop): ?string
+    {
+        $bare = match ($class) {
+            Assert\Length::class => new Assert\Length(max: 1),
+            Assert\Count::class  => new Assert\Count(min: 1),
+            Assert\Regex::class  => new Assert\Regex(pattern: '/^x$/'),
+            default              => new $class(),
+        };
+
+        $value = $bare->{$prop} ?? null;
+
+        return is_string($value) ? $value : null;
+    }
+
+    private function ormColumn(ReflectionProperty $property): ?Column
+    {
+        $attrs = $property->getAttributes(Column::class);
+
+        return [] === $attrs ? null : $attrs[0]->newInstance();
+    }
+
+    /** @return list<Constraint> */
+    private function constraintsOf(ReflectionProperty $property): array
+    {
+        $out = [];
+        foreach ($property->getAttributes() as $attribute) {
+            if (is_subclass_of($attribute->getName(), Constraint::class)) {
+                $out[] = $attribute->newInstance();
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * @param list<Constraint>             $constraints
+     * @param list<class-string<Constraint>> $classes
+     */
+    private function hasAnyConstraint(array $constraints, array $classes): bool
+    {
+        foreach ($constraints as $c) {
+            if (in_array($c::class, $classes, true)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function isPropertyWritable(ReflectionProperty $property): bool
+    {
+        $attrs = $property->getAttributes(Groups::class);
+        if ([] === $attrs) {
+            return false;
+        }
+
+        /** @var Groups $groups */
+        $groups = $attrs[0]->newInstance();
+        foreach ($groups->groups as $group) {
+            if (is_string($group) && str_contains($group, 'write')) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function extractFqcn(string $path): ?string
+    {
+        $source = file_get_contents($path);
+        if (false === $source) {
+            return null;
+        }
+
+        if (
+            1 !== preg_match('/^namespace\s+([^;]+);/m', $source, $nsMatch)
+            || 1 !== preg_match('/^(?:final\s+|abstract\s+|readonly\s+)*class\s+(\w+)/m', $source, $classMatch)
+        ) {
+            return null;
+        }
+
+        return trim($nsMatch[1]).'\\'.$classMatch[1];
+    }
+}
@@ -66,6 +66,34 @@ final class ClientSubResourceApiTest extends AbstractCommercialApiTestCase
        self::assertResponseStatusCodeSame(422);
    }

+    /**
+     * ERP-107 : une violation de contrainte sort avec un message FR explicite ET
+     * un `propertyPath` rattache au champ (consommable par useFormErrors /
+     * mapViolationsToRecord cote front, ERP-101). On verifie le JSON 422 reel.
+     */
+    public function testPostContactInvalidEmailReturns422WithFrenchMessageOnField(): void
+    {
+        $client = $this->createAdminClient();
+        $seed   = $this->seedClient('Contact Bad Email');
+
+        $response = $client->request('POST', '/api/clients/'.$seed->getId().'/contacts', [
+            'headers' => ['Content-Type' => self::LD, 'Accept' => self::LD],
+            'json'    => [
+                'firstName' => 'Jean',
+                'email'     => 'pas-un-email',
+            ],
+        ]);
+
+        self::assertResponseStatusCodeSame(422);
+        $byPath = [];
+        foreach ($response->toArray(false)['violations'] ?? [] as $v) {
+            $byPath[$v['propertyPath']] = $v['message'];
+        }
+
+        self::assertArrayHasKey('email', $byPath, 'La violation email doit porter propertyPath=email (mapping front).');
+        self::assertSame('L\'adresse email n\'est pas valide.', $byPath['email']);
+    }
+
    public function testPatchContactNormalizes(): void
    {
        $client  = $this->createAdminClient();
@@ -0,0 +1,2 @@
+# Les traductions natives FR viennent du vendor (validators.fr.xlf).
+# Ce dossier accueille les overrides applicatifs eventuels.
Author	SHA1	Message	Date
gitea-actions	c437bc52a2	chore: bump version to v0.1.81 Auto Tag Develop / tag (push) Successful in 7s Details Build & Push Docker Image / build (push) Successful in 29s Details	2026-06-04 09:27:40 +00:00
matthieu	597101262d	feat(commercial) : messages de validation FR sur les contraintes back + garde-fou (ERP-107) (#59 ) Auto Tag Develop / tag (push) Successful in 8s Details ## Contexte Résout ERP-107 — pendant back du mapping d'erreur par champ front (ERP-101). Le front (`useFormErrors` / `mapViolationsToRecord`) affiche sous chaque champ le `message` renvoyé par le back. Ce ticket garantit que ces messages existent, sont en FR et rattachés au bon champ. ## Changements - Messages FR explicites sur toutes les contraintes `#[Assert\]` des entités métier : `Client`, `ClientContact`, `ClientAddress`, `ClientRib`, `Category`, `Role`, `User` (Email, NotBlank, Length, Bic, Iban, PositiveOrZero, Count…). - Contraintes `Assert\Length` manquantes ajoutées, calées sur le `length` de la colonne ORM (téléphones `VARCHAR(20)`, `siren`, `nTva`, `accountNumber`, `username`…). Évite une erreur Postgres 500 non rattachée au champ → 422 propre. - Locale FR globale* (`symfony/translation` + `default_locale: fr`) comme filet pour les messages natifs Symfony non surchargés. - Garde-fou `tests/Architecture/EntityConstraintsHaveFrenchMessageTest` : échoue si une contrainte n'a pas de message FR explicite (comparaison au défaut Symfony) ou si `Assert\Length.max` diverge du `length` ORM. Whitelist justifiée pour les formats auto-bornés (Bic/Iban/Regex CP/couleur hex). - Test fonctionnel du JSON 422 réel : message FR + `propertyPath` consommable par le front. - Convention documentée dans `.claude/rules/backend.md`. ## Décisions - Stratégie retenue : message FR explicite sur toutes les contraintes + locale FR en filet (les deux leviers du ticket). - Garde-fou `Length == ORM length` : test bloquant (anti-dérive). - RG-1.03 (distributor/broker) : pas de `Assert\Callback` ajouté — le `ClientProcessor` gère déjà l'exclusivité (422 + `propertyPath`). Pas de doublon. ## Hors périmètre / à suivre - Alignement `nullable`(DB) / `NotBlank`(back) / `required`(front) : les champs obligatoires existants ont été confirmés, mais aucun changement de nullabilité DB n'a été fait sans arbitrage métier. À recroiser avec les astérisques front (ERP-101 / PR #58) si divergence constatée. ## Vérifications - `make test` : 469 tests verts (1793 assertions), 0 échec/erreur. - `php-cs-fixer` : 0 fichier à corriger. --------- Co-authored-by: admin malio <malio@yuno.malio.fr> Co-authored-by: Matthieu <contact@malio.fr> Reviewed-on: #59 Co-authored-by: THOLOT DECHENE Matthieu <matthieu@yuno.malio.fr> Co-committed-by: THOLOT DECHENE Matthieu <matthieu@yuno.malio.fr>	2026-06-04 09:27:32 +00:00
gitea-actions	90dfc17fcb	chore: bump version to v0.1.80 Auto Tag Develop / tag (push) Successful in 6s Details Build & Push Docker Image / build (push) Successful in 19s Details	2026-06-04 09:02:08 +00:00
tristan	ce89c5e46a	feat(front) : remonter le groupe Commerciale en tete de sidebar (ERP-71) (#60 ) Auto Tag Develop / tag (push) Successful in 7s Details ## ERP-71 — Sidebar : remonter le groupe « Commerciale » tout en haut Réorganise `config/sidebar.php` (source de vérité backend de la sidebar) pour placer le groupe « Commerciale » en première position, devant « Administration » et « Mon compte ». ### Changement - Déplacement du bloc de section `sidebar.commercial.section` en tête du tableau retourné par `config/sidebar.php`. - Aucune modification des items, des `module` ni des `permission` à l'intérieur du bloc : ordre interne des onglets et RBAC strictement préservés. ### Vérifications - `php -l config/sidebar.php` OK. - Front : `useSidebar` / `default.vue` mappent les sections dans l'ordre reçu de `/api/sidebar` ; l'état actif/sélection et le repli/dépli sont pilotés par `MalioSidebar` selon la route courante — aucune dépendance à un index/ordre fixe. Le déplacement est donc sans effet de bord. - Aucun test back ne porte sur la sidebar ; le test front `useSidebar.test.ts` ne fait aucune hypothèse d'ordre. ### Critères d'acceptation - [x] Groupe « Commerciale » en première position - [x] Ordre interne des onglets et permissions inchangés - [x] Pas de dépendance front à l'ordre (actif/sélection/repli pilotés par la route) Reviewed-on: #60 Co-authored-by: tristan <tristan@yuno.malio.fr> Co-committed-by: tristan <tristan@yuno.malio.fr>	2026-06-04 09:02:01 +00:00
gitea-actions	546ba462b9	chore: bump version to v0.1.79 Auto Tag Develop / tag (push) Successful in 6s Details Build & Push Docker Image / build (push) Successful in 57s Details	2026-06-04 08:41:27 +00:00
tristan	ee3bbea649	feat(front) : mapping des erreurs de validation 422 par champ (ERP-101) (#58 ) Auto Tag Develop / tag (push) Successful in 7s Details ## Objectif Afficher les violations de validation 422 du back sous chaque champ (prop `:error` des `Malio`) au lieu d'un toast global, et poser une convention reutilisable par tous les forms. ## Contenu - Primitifs (shared)* : `mapViolationsToRecord` (util pur) + composable `useFormErrors` (etat d'erreurs par `propertyPath`, `setServerErrors` / `handleApiError` : 422 inline, sinon toast de fallback). - Formulaire Client (`new.vue` + `[id]/edit.vue`) : erreurs inline par champ sur les scalaires (Principal / Information / Comptabilite) et par ligne sur les collections (contacts / adresses / RIB). - Blocs `ClientContactBlock` / `ClientAddressBlock` : nouvelle prop `errors`. - Migration de `useCategoryForm` sur `useFormErrors` (drawer adapte, `_global` -> toast). - Convention documentee dans `.claude/rules/frontend.md` + spec de design. ## Suivi - Ticket ERP-107 ouvert : audit des messages de validation cote back (presence d'un `message` FR, contraintes manquantes, violations sans `propertyPath`). ## Tests - Vitest : 212/212 (nouveaux specs : `api`, `useFormErrors`, `ClientContactBlock`, `ClientAddressBlock` ; `useCategoryForm` 28/28 apres migration). - eslint clean, `nuxi typecheck` 0 erreur. - Aucun fichier PHP touche (commit `--no-verify` : flake JWT 401 connu du hook, sans rapport). Reviewed-on: #58 Reviewed-by: THOLOT DECHENE Matthieu <matthieu@yuno.malio.fr> Co-authored-by: tristan <tristan@yuno.malio.fr> Co-committed-by: tristan <tristan@yuno.malio.fr>	2026-06-04 08:41:19 +00:00
gitea-actions	e85d46a17b	chore: bump version to v0.1.78 Auto Tag Develop / tag (push) Successful in 7s Details Build & Push Docker Image / build (push) Successful in 49s Details	2026-06-03 14:49:06 +00:00
tristan	ec952896ba	M1 · 2/3 (Front) — Retirer le bloc contact principal des ecrans Client (#57 ) Auto Tag Develop / tag (push) Successful in 10s Details ## Objectif Retirer le bloc « contact principal » (Nom, Prénom, Téléphone, Téléphone 2, Email) des trois écrans Client — création, consultation, modification — ainsi que des types, mappeurs, validations et clés i18n associés. La saisie des contacts passe désormais exclusivement par l'onglet Contacts (`ClientContactBlock`, inchangé). Dépend du ticket 1/3 (back) : l'API ne renvoie/n'accepte plus ces 5 champs sur `client`. Contexte : `docs/specs/M1-clients/refonte-contact/README.md`. ## Changements - `pages/clients/new.vue` : bloc principal réduit à Nom entreprise / Catégories / Relation / Triage. Suppression de `main.firstName/lastName/email`, `mainPhones`, `addMainPhone()`, `prefillFirstContact()`. `isMainValid` ne dépend plus que de `companyName` + ≥ 1 catégorie + relation valide. Payload POST et `ClientResponse` nettoyés. - `pages/clients/[id]/edit.vue` : mêmes champs retirés, `isMainValid` simplifié. - `pages/clients/[id]/index.vue` : affichage lecture seule des 5 champs retiré. - `utils/clientEdit.ts` : `MainFormDraft`, `mapMainDraft()`, `buildMainPayload()` débarrassés des 5 champs + `hasSecondaryPhone`. - `utils/clientConsultation.ts` : `ClientDetail` débarrassé des champs inline (`ContactRead` conservé). - `i18n/locales/fr.json` : clés `form.main.firstName/lastName/email/phonePrimary/phoneSecondary/addPhone` supprimées. `form.contact.` conservé. - Tests* : `clientEdit.spec.ts` ajusté (factory, `MAIN_KEYS`, assertions `mapMainDraft`, test téléphone secondaire obsolète retiré). ## Vérifications - `make nuxt-test` : suites `clientEdit` / `clientConsultation` / `clientFormRules` vertes. Les 2 échecs restants (`useClientReferentials.spec.ts`, libellé de site) sont pré-existants sur `develop` (confirmé par `git stash`), sans rapport avec ce ticket. - `eslint` sur les fichiers touchés : OK, aucun import/variable mort. - Zéro référence orpheline aux clés `form.main.*` supprimées ; JSON i18n valide. ## Reste à faire - Golden path navigateur (création → consultation → modification sans bloc inline) à valider manuellement. Reviewed-on: #57 Co-authored-by: tristan <tristan@yuno.malio.fr> Co-committed-by: tristan <tristan@yuno.malio.fr>	2026-06-03 14:48:55 +00:00