Merge branch 'feat/erp-164-carriers-list' into feat/erp-165-carrier-new

config/sidebar.php

@@ -78,23 +78,6 @@ return [
             ],
         ],
     ],
-    // Section "Transport" (M4, ERP-153) : pole logistique, porte le repertoire
-    // transporteurs. L'item est gate par `transport.carriers.view` ; la section
-    // disparait automatiquement (SidebarProvider) si le module `transport` est
-    // desactive ou si l'user n'a pas la permission (Compta / Usine).
-    [
-        'label' => 'sidebar.transport.section',
-        'icon'  => 'mdi:truck-outline',
-        'items' => [
-            [
-                'label'      => 'sidebar.transport.carriers',
-                'to'         => '/carriers',
-                'icon'       => 'mdi:truck-outline',
-                'module'     => 'transport',
-                'permission' => 'transport.carriers.view',
-            ],
-        ],
-    ],
     // Section "Administration" : regroupe toutes les pages de configuration
     // applicative (RBAC, users, sites, audit log).
     //
@@ -117,8 +100,20 @@ return [
     // individuelles"), ajouter : 'permission' => 'core.admin.access'.
     [
         'label' => 'sidebar.administration.section',
-        'icon'  => 'mdi:cog-outline',
+        'icon'  => 'mdi:file-settings-cog-outline',
         'items' => [
+            // Transport — Repertoire transporteurs (M4, ERP-164). Rattache a
+            // l'Administration (premier item) plutot qu'a une section dediee :
+            // referentiel global de configuration applicative, sans cloisonnement
+            // par site. Reste gate par sa propre permission `transport.carriers.view`
+            // (Admin / Bureau / Commerciale) et son module owner `transport`.
+            [
+                'label'      => 'sidebar.transport.carriers',
+                'to'         => '/carriers',
+                'icon'       => 'mdi:truck-outline',
+                'module'     => 'transport',
+                'permission' => 'transport.carriers.view',
+            ],
             [
                 'label'      => 'sidebar.core.roles',
                 'to'         => '/admin/roles',

config/version.yaml

@@ -1,2 +1,2 @@
 parameters:
-    app.version: '0.1.130'
+    app.version: '0.1.129'

frontend/i18n/locales/fr.json

@@ -495,6 +495,62 @@
             }
         }
     },
+    "transport": {
+        "carriers": {
+            "title": "Répertoire transporteurs",
+            "add": "Ajouter",
+            "export": "Exporter",
+            "empty": "Aucun transporteur pour l'instant.",
+            "column": {
+                "name": "Nom",
+                "certification": "Certification",
+                "validityDate": "Date de validité",
+                "lastActivity": "Dernière activité"
+            },
+            "certification": {
+                "QUALIMAT": "QUALIMAT",
+                "GMP_PLUS": "GMP+",
+                "OVOCOM": "OVOCOM",
+                "COMPTE_PROPRE": "Compte-propre",
+                "AUTRE": "Autre"
+            },
+            "filters": {
+                "title": "Filtres",
+                "search": "Recherche",
+                "certification": "Certification",
+                "status": "Statut",
+                "archivedOnly": "Voir les archivés",
+                "apply": "Voir les résultats",
+                "reset": "Réinitialiser"
+            },
+            "toast": {
+                "error": "Une erreur est survenue. Réessayez.",
+                "exportError": "L'export du répertoire transporteurs a échoué. Réessayez.",
+                "createSuccess": "Transporteur créé avec succès"
+            },
+            "tab": {
+                "qualimat": "Qualimat",
+                "addresses": "Adresses",
+                "contacts": "Contacts",
+                "prices": "Prix"
+            },
+            "form": {
+                "title": "Ajouter un transporteur",
+                "back": "Retour au répertoire",
+                "submit": "Valider",
+                "comingSoon": "À venir",
+                "duplicateName": "Un transporteur actif portant ce nom existe déjà.",
+                "main": {
+                    "name": "Nom",
+                    "certificationType": "Certification transport",
+                    "isChartered": "Affréter"
+                },
+                "errors": {
+                    "nameRequired": "Le nom du transporteur est obligatoire."
+                }
+            }
+        }
+    },
     "auth": {
         "login": "Connexion",
         "logout": "Deconnexion",

frontend/modules/commercial/composables/useSuppliersRepository.ts

@@ -41,9 +41,10 @@ export interface Supplier {
  * sur la ressource `/suppliers` (RG-13 : pagination serveur obligatoire ; jamais
  * de chargement integral en memoire). Miroir de `useClientsRepository` (M1).
  *
- * Les filtres (recherche, categories, sites, inclusion des archives) sont pilotes
+ * Les filtres (recherche, categories, sites, archives) sont pilotes par la page
- * par la page via `setFilters` du composable partage — la remise en page 1 est
+ * via `setFilters` du composable partage — la remise en page 1 est garantie.
- * garantie.
+ * Cocher « Voir les archivés » envoie `archivedOnly=true` → seules les archives
+ * sont listees (aligne sur Client).
  *
  * Volontairement PAR INSTANCE (pas de singleton module-level) : l'etat tableau
  * est propre a l'ecran Repertoire et meurt avec lui, comme tout consommateur de

frontend/modules/transport/composables/__tests__/useCarrierForm.test.ts

@@ -0,0 +1,191 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+/**
+ * Tests du workflow « Ajouter un transporteur » (M4 Transport, ERP-165).
+ *
+ * `useCarrierForm` porte le formulaire principal (Nom + Certification + Affréter)
+ * et l'orchestration des onglets de création. On vérifie ici le CONTRAT propre à
+ * la création :
+ *  - pré-check front : nom requis → POST bloqué, erreur inline, aucun appel réseau ;
+ *  - POST /carriers (groupe carrier:write:main) : payload + Accept ld+json +
+ *    toast:false ; au succès, verrouillage + bascule sur l'onglet Qualimat +
+ *    réaffichage du nom normalisé ;
+ *  - 409 doublon (RG-4.12) → erreur inline dédiée sur `name` ;
+ *  - 422 → mapping inline par champ (propertyPath) ;
+ *  - onglets : 4 onglets (Qualimat/Adresses/Contacts/Prix), completeTab
+ *    déverrouille/avance et signale le dernier onglet ;
+ *  - patchCarrier : PATCH partiel, no-op avant création.
+ */
+
+const mockPost = vi.hoisted(() => vi.fn())
+const mockPatch = vi.hoisted(() => vi.fn())
+
+vi.stubGlobal('useApi', () => ({
+    get: vi.fn(),
+    post: mockPost,
+    put: vi.fn(),
+    patch: mockPatch,
+    delete: vi.fn(),
+}))
+vi.stubGlobal('useI18n', () => ({ t: (key: string) => key }))
+vi.stubGlobal('useToast', () => ({
+    success: vi.fn(),
+    error: vi.fn(),
+    warning: vi.fn(),
+    info: vi.fn(),
+}))
+
+const { useCarrierForm, CARRIER_TAB_KEYS } = await import('../useCarrierForm')
+
+describe('useCarrierForm', () => {
+    beforeEach(() => {
+        mockPost.mockReset()
+        mockPatch.mockReset()
+    })
+
+    it('front : nom vide → erreur inline sur name, pas de POST', async () => {
+        const form = useCarrierForm()
+
+        const created = await form.submitMain()
+
+        expect(created).toBe(false)
+        expect(mockPost).not.toHaveBeenCalled()
+        expect(form.mainErrors.errors.name).toBe('transport.carriers.form.errors.nameRequired')
+        expect(form.mainLocked.value).toBe(false)
+    })
+
+    it('front : nom en espaces uniquement → erreur inline, pas de POST', async () => {
+        const form = useCarrierForm()
+        form.main.name = '   '
+
+        const created = await form.submitMain()
+
+        expect(created).toBe(false)
+        expect(mockPost).not.toHaveBeenCalled()
+        expect(form.mainErrors.errors.name).toBe('transport.carriers.form.errors.nameRequired')
+    })
+
+    it('POST /carriers avec Accept ld+json, verrouille et bascule sur Qualimat', async () => {
+        mockPost.mockResolvedValueOnce({ id: 42, name: 'TRANSPORTS ACME', certificationType: 'GMP_PLUS' })
+        const form = useCarrierForm()
+        form.main.name = 'Transports Acme'
+        form.main.certificationType = 'GMP_PLUS'
+        form.main.isChartered = true
+
+        const created = await form.submitMain()
+
+        expect(created).toBe(true)
+        expect(mockPost).toHaveBeenCalledTimes(1)
+        const [url, body, opts] = mockPost.mock.calls[0] ?? []
+        expect(url).toBe('/carriers')
+        expect(body).toEqual({
+            name: 'Transports Acme',
+            certificationType: 'GMP_PLUS',
+            isChartered: true,
+        })
+        expect(opts).toMatchObject({ toast: false, headers: { Accept: 'application/ld+json' } })
+
+        expect(form.carrierId.value).toBe(42)
+        // RG-4.13 : réaffiche le nom normalisé (UPPERCASE) renvoyé par le serveur.
+        expect(form.main.name).toBe('TRANSPORTS ACME')
+        expect(form.mainLocked.value).toBe(true)
+        expect(form.activeTab.value).toBe('qualimat')
+        expect(form.unlockedIndex.value).toBe(0)
+    })
+
+    it('payload : omet name et certificationType vides, garde isChartered', async () => {
+        mockPost.mockRejectedValueOnce({ response: { status: 422, _data: { violations: [] } } })
+        const form = useCarrierForm()
+        form.main.name = 'X' // nom présent pour passer le pré-check front
+        // certificationType laissé null → omis pour que la 422 « obligatoire » porte.
+
+        await form.submitMain()
+
+        const body = mockPost.mock.calls[0]?.[1] as Record<string, unknown>
+        expect(body).toEqual({ name: 'X', isChartered: false })
+        expect('certificationType' in body).toBe(false)
+    })
+
+    it('409 doublon (RG-4.12) : erreur inline dédiée sur name, pas de verrouillage', async () => {
+        mockPost.mockRejectedValueOnce({ response: { status: 409 } })
+        const form = useCarrierForm()
+        form.main.name = 'Doublon'
+        form.main.certificationType = 'AUTRE'
+
+        const created = await form.submitMain()
+
+        expect(created).toBe(false)
+        expect(form.mainErrors.errors.name).toBe('transport.carriers.form.duplicateName')
+        expect(form.mainLocked.value).toBe(false)
+    })
+
+    it('422 : mappe les violations serveur inline par champ', async () => {
+        mockPost.mockRejectedValueOnce({
+            response: {
+                status: 422,
+                _data: { violations: [{ propertyPath: 'certificationType', message: 'Le type de certification est obligatoire.' }] },
+            },
+        })
+        const form = useCarrierForm()
+        form.main.name = 'Sans Certif'
+
+        const created = await form.submitMain()
+
+        expect(created).toBe(false)
+        expect(form.mainErrors.errors.certificationType).toBe('Le type de certification est obligatoire.')
+        expect(form.mainLocked.value).toBe(false)
+    })
+
+    it('onglets : 4 clés Qualimat/Adresses/Contacts/Prix', () => {
+        expect(CARRIER_TAB_KEYS).toEqual(['qualimat', 'addresses', 'contacts', 'prices'])
+        const form = useCarrierForm()
+        expect(form.tabKeys.value).toEqual(['qualimat', 'addresses', 'contacts', 'prices'])
+        // Tous verrouillés tant que le formulaire principal n'est pas validé.
+        expect(form.unlockedIndex.value).toBe(-1)
+    })
+
+    it('completeTab : déverrouille/avance, et signale le dernier onglet du flux', () => {
+        const form = useCarrierForm()
+
+        // Qualimat → Adresses (pas le dernier).
+        expect(form.completeTab('qualimat')).toBe(false)
+        expect(form.isValidated('qualimat')).toBe(true)
+        expect(form.activeTab.value).toBe('addresses')
+        expect(form.unlockedIndex.value).toBe(1)
+
+        expect(form.completeTab('addresses')).toBe(false)
+        expect(form.activeTab.value).toBe('contacts')
+
+        expect(form.completeTab('contacts')).toBe(false)
+        expect(form.activeTab.value).toBe('prices')
+
+        // Prix = dernier onglet → true (création terminée).
+        expect(form.completeTab('prices')).toBe(true)
+        expect(form.isValidated('prices')).toBe(true)
+    })
+
+    it('editMode : completeTab ne verrouille pas et ne bascule pas d\'onglet', () => {
+        const form = useCarrierForm()
+        form.editMode.value = true
+        form.activeTab.value = 'qualimat'
+
+        expect(form.completeTab('qualimat')).toBe(false)
+        expect(form.isValidated('qualimat')).toBe(false)
+        expect(form.activeTab.value).toBe('qualimat')
+    })
+
+    it('patchCarrier : PATCH /carriers/{id} en mode strict, no-op avant création', async () => {
+        const form = useCarrierForm()
+
+        await form.patchCarrier({ liotPlates: 'AA-123-BB' })
+        expect(mockPatch).not.toHaveBeenCalled()
+
+        mockPost.mockResolvedValueOnce({ id: 9, name: 'ACME', certificationType: 'OVOCOM' })
+        form.main.name = 'Acme'
+        form.main.certificationType = 'OVOCOM'
+        await form.submitMain()
+
+        await form.patchCarrier({ liotPlates: 'AA-123-BB' })
+        expect(mockPatch).toHaveBeenCalledWith('/carriers/9', { liotPlates: 'AA-123-BB' }, { toast: false })
+    })
+})

frontend/modules/transport/composables/__tests__/useCarriersRepository.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { useCarriersRepository, type Carrier } from '../useCarriersRepository'
+
+const mockApiGet = vi.hoisted(() => vi.fn())
+vi.stubGlobal('useApi', () => ({ get: mockApiGet }))
+
+/**
+ * Tests du repertoire transporteurs (ERP-164).
+ *
+ * `useCarriersRepository` est une fine enveloppe de `usePaginatedList<Carrier>`
+ * sur `/carriers`. Les invariants generiques de pagination sont deja couverts par
+ * `usePaginatedList.test.ts` ; on verifie ici le CONTRAT propre au repertoire :
+ *  - la ressource ciblee est bien `/carriers` ;
+ *  - l'enveloppe Hydra (member / totalItems) est consommee ;
+ *  - le header `Accept: application/ld+json` est envoye (sinon API Platform 4
+ *    renvoie un tableau plat sans pagination) ;
+ *  - EXCLUSION DES ARCHIVES PAR DEFAUT : aucun `archivedOnly` n'est envoye
+ *    tant que l'utilisateur ne coche pas le filtre (le back masque alors les
+ *    archives) ; le filtre « Voir les archivés » est bien transmis une fois
+ *    applique (aligne sur Client / Fournisseur / Prestataire).
+ */
+describe('useCarriersRepository', () => {
+    beforeEach(() => {
+        mockApiGet.mockReset()
+    })
+
+    /** Une page de transporteurs Hydra, avec qualimatCarrier embarque (RG-4.04). */
+    const PAGE: Carrier[] = [
+        {
+            id: 1,
+            name: 'TRANSPORTS ACME',
+            certificationType: 'QUALIMAT',
+            qualimatCarrier: {
+                id: '42',
+                name: 'TRANSPORTS ACME',
+                validityDate: '2027-01-15',
+                status: 'VALIDE',
+            },
+            updatedAt: '2026-06-15T08:12:01+02:00',
+            isArchived: false,
+        },
+    ]
+
+    it('cible /carriers, consomme l\'enveloppe Hydra et envoie l\'Accept ld+json', async () => {
+        mockApiGet.mockResolvedValueOnce({ member: PAGE, totalItems: 1 })
+        const repo = useCarriersRepository()
+
+        await repo.fetch()
+
+        expect(mockApiGet).toHaveBeenCalledTimes(1)
+        const [url, query, opts] = mockApiGet.mock.calls[0]
+        expect(url).toBe('/carriers')
+        expect(query).toMatchObject({ page: 1, itemsPerPage: 10 })
+        expect(opts).toMatchObject({
+            toast: false,
+            headers: { Accept: 'application/ld+json' },
+        })
+        expect(repo.items.value).toEqual(PAGE)
+        expect(repo.totalItems.value).toBe(1)
+    })
+
+    it('exclut les archives par defaut : aucun archivedOnly au premier fetch', async () => {
+        mockApiGet.mockResolvedValueOnce({ member: PAGE, totalItems: 1 })
+        const repo = useCarriersRepository()
+
+        await repo.fetch()
+
+        const query = mockApiGet.mock.calls[0][1] as Record<string, unknown>
+        expect(query.archivedOnly).toBeUndefined()
+    })
+
+    it('transmet archivedOnly une fois le filtre applique (retour page 1)', async () => {
+        mockApiGet.mockResolvedValueOnce({ member: PAGE, totalItems: 1 })
+        const repo = useCarriersRepository()
+        await repo.fetch()
+
+        mockApiGet.mockResolvedValueOnce({ member: PAGE, totalItems: 1 })
+        await repo.setFilters({ archivedOnly: true })
+
+        expect(repo.currentPage.value).toBe(1)
+        const query = mockApiGet.mock.calls.at(-1)?.[1] as Record<string, unknown>
+        expect(query.archivedOnly).toBe(true)
+    })
+
+    it('transmet les certifications multiples + la recherche', async () => {
+        mockApiGet.mockResolvedValueOnce({ member: PAGE, totalItems: 1 })
+        const repo = useCarriersRepository()
+        await repo.fetch()
+
+        mockApiGet.mockResolvedValueOnce({ member: PAGE, totalItems: 1 })
+        await repo.setFilters({ search: 'acme', 'certificationType[]': ['QUALIMAT', 'AUTRE'] })
+
+        const query = mockApiGet.mock.calls.at(-1)?.[1] as Record<string, unknown>
+        expect(query.search).toBe('acme')
+        expect(query['certificationType[]']).toEqual(['QUALIMAT', 'AUTRE'])
+    })
+})

frontend/modules/transport/composables/useCarrierForm.ts

@@ -0,0 +1,207 @@
+import { reactive, ref } from 'vue'
+import { useFormErrors } from '~/shared/composables/useFormErrors'
+import {
+    emptyCarrierMain,
+    type CarrierMainDraft,
+    type CarrierMainResponse,
+} from '~/modules/transport/types/carrierForm'
+
+/**
+ * Workflow de l'écran « Ajouter un transporteur » (M4 Transport, ERP-165) —
+ * miroir conceptuel de `useSupplierForm` (M2) / `useProviderForm` (M3).
+ *
+ * Périmètre ERP-165 : le formulaire PRINCIPAL (pré-onglets) et l'orchestration de
+ * la barre d'onglets. La création est INCRÉMENTALE (spec-front § Écran Ajouter) :
+ *  - on POST d'abord le formulaire principal (`POST /api/carriers`) ;
+ *  - au succès le bloc principal passe en lecture seule, le 1er onglet (Qualimat)
+ *    se déverrouille et devient actif ;
+ *  - chaque onglet validé déverrouille le suivant (PATCH partiels par groupe de
+ *    sérialisation) et passe en lecture seule.
+ *
+ * Les champs conditionnels du formulaire principal (indexation / benne / volume
+ * si affrété, décharge si AUTRE, cas LIOT) et la saisie assistée QUALIMAT arrivent
+ * à ERP-166 ; le contenu des onglets Adresses / Contacts / Prix aux tickets
+ * suivants. Ce composable pose le POST principal, le PATCH partiel et le gating
+ * des onglets.
+ *
+ * État 100 % local à l'instance (refs / reactive) — aucune persistance URL.
+ */
+
+/**
+ * Clés des onglets du flux de création, dans l'ordre de la barre (spec-front
+ * § Écran Ajouter). Toujours les 4 (pas de gating par permission au M4, ≠ l'onglet
+ * Comptabilité du M3).
+ */
+export const CARRIER_TAB_KEYS = ['qualimat', 'addresses', 'contacts', 'prices'] as const
+
+export function useCarrierForm() {
+    const api = useApi()
+    const { t } = useI18n()
+    const toast = useToast()
+
+    // Erreurs de validation par champ (ERP-101) du formulaire principal.
+    const mainErrors = useFormErrors()
+
+    // ── État du transporteur créé ─────────────────────────────────────────────
+    const carrierId = ref<number | null>(null)
+    const mainLocked = ref(false)
+    const mainSubmitting = ref(false)
+
+    // ── Formulaire principal ──────────────────────────────────────────────────
+    const main = reactive<CarrierMainDraft>(emptyCarrierMain())
+
+    // ── Onglets : ordre + gating progressif ───────────────────────────────────
+    const tabKeys = ref<string[]>([...CARRIER_TAB_KEYS])
+    // Index du dernier onglet déverrouillé (-1 tant que le transporteur n'est pas créé).
+    const unlockedIndex = ref(-1)
+    const activeTab = ref<string>(CARRIER_TAB_KEYS[0])
+    // Onglets validés (passent en lecture seule).
+    const validated = reactive<Record<string, boolean>>({})
+    // Mode MODIFICATION (ticket ultérieur) : navigation libre, pas de verrouillage
+    // ni de bascule automatique d'onglet à la validation (cf. completeTab).
+    const editMode = ref(false)
+
+    function isValidated(key: string): boolean {
+        return validated[key] === true
+    }
+
+    function tabIndex(key: string): number {
+        return tabKeys.value.indexOf(key)
+    }
+
+    /**
+     * Validation FRONT du formulaire principal : seul le nom est requis côté front
+     * (RG-4.01). Le back reste la couche autoritaire (ERP-101) — la certification
+     * obligatoire (sauf LIOT) et les RG conditionnelles sont re-validées serveur et
+     * remontées en 422 inline, sans pré-check front (qui devrait connaître le cas
+     * LIOT, hors périmètre ERP-165).
+     */
+    function validateMainFront(): boolean {
+        let valid = true
+        if (!main.name?.trim()) {
+            mainErrors.setError('name', t('transport.carriers.form.errors.nameRequired'))
+            valid = false
+        }
+        return valid
+    }
+
+    /**
+     * Payload du POST principal (groupe `carrier:write:main`). `name` et
+     * `certificationType` sont omis s'ils sont vides afin que la 422 porte la
+     * violation métier (NotBlank sur le nom, « certification obligatoire » sur la
+     * certification) sur le champ plutôt qu'une erreur de type.
+     */
+    function buildMainPayload(): Record<string, unknown> {
+        const payload: Record<string, unknown> = {
+            isChartered: main.isChartered,
+        }
+        if (main.name?.trim()) {
+            payload.name = main.name
+        }
+        if (main.certificationType) {
+            payload.certificationType = main.certificationType
+        }
+        return payload
+    }
+
+    /**
+     * POST /carriers (groupe `carrier:write:main`). Pré-check front (nom), puis
+     * création. Au succès : verrouille le bloc principal, déverrouille le 1er onglet
+     * et bascule sur « Qualimat ». Retourne true si créé, false sinon.
+     */
+    async function submitMain(): Promise<boolean> {
+        if (mainSubmitting.value) return false
+        mainErrors.clearErrors()
+        if (!validateMainFront()) return false
+
+        mainSubmitting.value = true
+        try {
+            const created = await api.post<CarrierMainResponse>('/carriers', buildMainPayload(), {
+                headers: { Accept: 'application/ld+json' },
+                toast: false,
+            })
+
+            carrierId.value = created.id
+            // Réaffiche les valeurs normalisées renvoyées par le serveur (nom en
+            // UPPERCASE — RG-4.13 ; certification éventuellement forcée).
+            main.name = created.name ?? main.name
+            main.certificationType = created.certificationType ?? main.certificationType
+
+            mainLocked.value = true
+            unlockedIndex.value = 0
+            activeTab.value = tabKeys.value[0] ?? CARRIER_TAB_KEYS[0]
+            toast.success({ title: t('transport.carriers.toast.createSuccess') })
+            return true
+        }
+        catch (error) {
+            // 409 = doublon de nom (RG-4.12) → erreur inline dédiée + toast ;
+            // 422 → mapping inline par champ ; autre → toast de fallback (ERP-101).
+            const status = (error as { response?: { status?: number } })?.response?.status
+            if (status === 409) {
+                const message = t('transport.carriers.form.duplicateName')
+                mainErrors.setError('name', message)
+                toast.error({ title: t('transport.carriers.toast.error'), message })
+            }
+            else {
+                mainErrors.handleApiError(error, { fallbackMessage: t('transport.carriers.toast.error') })
+            }
+            return false
+        }
+        finally {
+            mainSubmitting.value = false
+        }
+    }
+
+    /**
+     * PATCH partiel du transporteur (mode strict : un seul groupe de sérialisation
+     * par appel — spec-back § 2.9). Servira les onglets à champs scalaires des
+     * tickets suivants. No-op tant que le transporteur n'existe pas.
+     */
+    async function patchCarrier(payload: Record<string, unknown>): Promise<void> {
+        if (carrierId.value === null) return
+        await api.patch(`/carriers/${carrierId.value}`, payload, { toast: false })
+    }
+
+    /**
+     * Marque un onglet validé (passe en lecture seule), déverrouille et avance à
+     * l'onglet suivant. Retourne true si c'était le dernier onglet du flux (création
+     * terminée), false sinon.
+     */
+    function completeTab(key: string): boolean {
+        // En modification : navigation libre, l'onglet reste éditable après validation.
+        if (editMode.value) {
+            return false
+        }
+        validated[key] = true
+        const index = tabIndex(key)
+        const next = tabKeys.value[index + 1]
+        if (next === undefined) {
+            return true
+        }
+        unlockedIndex.value = Math.max(unlockedIndex.value, index + 1)
+        activeTab.value = next
+        return false
+    }
+
+    return {
+        // état
+        main,
+        carrierId,
+        mainLocked,
+        mainSubmitting,
+        mainErrors,
+        // onglets
+        tabKeys,
+        activeTab,
+        unlockedIndex,
+        validated,
+        editMode,
+        isValidated,
+        // actions
+        validateMainFront,
+        buildMainPayload,
+        submitMain,
+        patchCarrier,
+        completeTab,
+    }
+}

frontend/modules/transport/composables/useCarriersRepository.ts

@@ -0,0 +1,70 @@
+import { usePaginatedList } from '~/shared/composables/usePaginatedList'
+
+/**
+ * Vue MINIMALE du referentiel QUALIMAT embarque (groupe `qualimat:read`) dans la
+ * LISTE des transporteurs. Seuls les champs consommes par le Repertoire sont
+ * types : `validityDate` alimente la colonne « Date de validité » (fond rouge si
+ * perimee — RG-4.04). L'id QUALIMAT est une chaine (colonne BIGINT cote back).
+ */
+export interface CarrierQualimat {
+    id: string
+    name: string | null
+    /** Date ISO de validite de l'agrement QUALIMAT (date_immutable) — RG-4.04. */
+    validityDate: string | null
+    status: string | null
+}
+
+/**
+ * Vue MINIMALE d'un transporteur pour le Repertoire (datatable). Volontairement
+ * partielle : seuls les champs des colonnes + l'id (navigation) sont types ici.
+ * Le detail complet (onglets Adresses / Contacts / Prix) est hors perimetre de
+ * cet ecran (ERP-164, ticket #9).
+ *
+ * `certificationType` : QUALIMAT | GMP_PLUS | OVOCOM | COMPTE_PROPRE | AUTRE, ou
+ * `null` dans le cas LIOT (compte-propre interne sans certification — RG-4.01).
+ * Le libelle affiche est resolu cote front (cle i18n `transport.carriers.certification.*`).
+ */
+export interface Carrier {
+    id: number
+    name: string | null
+    certificationType: string | null
+    /** Lien editable vers le referentiel QUALIMAT (null si transporteur non QUALIMAT). */
+    qualimatCarrier: CarrierQualimat | null
+    /** Date ISO de derniere modification (default:read) — colonne « Dernière activité ». */
+    updatedAt: string | null
+    isArchived: boolean
+}
+
+/**
+ * Filtres du Repertoire transporteurs, branches sur les query params de
+ * `GET /api/carriers` (spec-back § 4.1). Pilotes par la page via `setFilters` :
+ *  - `search` : recherche fuzzy sur le nom ;
+ *  - `certificationType[]` : multi-valeurs (OR cote back) ;
+ *  - `archivedOnly` : n'affiche QUE les archives (toggle « Voir les archivés »,
+ *    aligne sur les autres repertoires M1/M2/M3).
+ */
+export interface CarrierFilters {
+    search?: string
+    'certificationType[]'?: string[]
+    archivedOnly?: boolean
+}
+
+/**
+ * Repertoire transporteurs (M4, ERP-164) — simple enveloppe de
+ * `usePaginatedList<Carrier>` sur la ressource `/carriers` (regle ABSOLUE n°13 :
+ * pagination serveur obligatoire ; jamais de chargement integral en memoire).
+ * Miroir de `useSuppliersRepository` (M2) / `useProvidersRepository` (M3).
+ *
+ * Les filtres (recherche, certifications, archives) sont pilotes par la page via
+ * `setFilters` du composable partage — la remise en page 1 est garantie. Par
+ * defaut AUCUN `archivedOnly` n'est envoye : le back masque alors les archives
+ * (§ 2.4). Cocher « Voir les archivés » envoie `archivedOnly=true` (seules les
+ * archives sont listees, aligne sur Client / Fournisseur / Prestataire).
+ *
+ * Volontairement PAR INSTANCE (pas de singleton module-level) : l'etat tableau
+ * est propre a l'ecran Repertoire et meurt avec lui, comme tout consommateur de
+ * `usePaginatedList`. Aucun reset au logout a gerer.
+ */
+export function useCarriersRepository() {
+    return usePaginatedList<Carrier, CarrierFilters>({ url: '/carriers' })
+}

frontend/modules/transport/pages/__tests__/carriersIndex.spec.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { mount, flushPromises } from '@vue/test-utils'
+import { defineComponent, h, ref } from 'vue'
+
+// ── Auto-imports Nuxt stubbes globalement ───────────────────────────────────
+// La page ne les importe pas (auto-import) : on les expose en globals pour le
+// runtime de test (happy-dom). Meme philosophie que les specs M1/M2/M3.
+const mockPush = vi.hoisted(() => vi.fn())
+const mockApiGet = vi.hoisted(() => vi.fn())
+const mockCan = vi.hoisted(() => vi.fn())
+const mockSetFilters = vi.hoisted(() => vi.fn())
+const mockFetch = vi.hoisted(() => vi.fn())
+const mockToastError = vi.hoisted(() => vi.fn())
+
+vi.stubGlobal('useI18n', () => ({ t: (key: string) => key }))
+vi.stubGlobal('useHead', () => undefined)
+vi.stubGlobal('useApi', () => ({ get: mockApiGet }))
+vi.stubGlobal('useRouter', () => ({ push: mockPush }))
+vi.stubGlobal('useToast', () => ({ error: mockToastError, success: vi.fn() }))
+vi.stubGlobal('usePermissions', () => ({ can: mockCan }))
+
+// Le repository est lui aussi un auto-import : on controle items + setFilters.
+vi.stubGlobal('useCarriersRepository', () => ({
+    items: ref([
+        {
+            id: 7,
+            name: 'TRANSPORTS ACME',
+            certificationType: 'QUALIMAT',
+            qualimatCarrier: { id: '42', name: 'TRANSPORTS ACME', validityDate: '2027-01-15', status: 'VALIDE' },
+            updatedAt: '2026-01-15T10:00:00+00:00',
+            isArchived: false,
+        },
+    ]),
+    totalItems: ref(1),
+    currentPage: ref(1),
+    itemsPerPage: ref(10),
+    itemsPerPageOptions: ref([10, 25, 50]),
+    fetch: mockFetch,
+    goToPage: vi.fn(),
+    setItemsPerPage: vi.fn(),
+    setFilters: mockSetFilters,
+}))
+
+// happy-dom n'implemente pas createObjectURL : on ajoute les methodes statiques
+// sur la classe URL existante (sans la remplacer — sinon `new URL()` casse).
+globalThis.URL.createObjectURL = vi.fn(() => 'blob:fake')
+globalThis.URL.revokeObjectURL = vi.fn()
+
+// Import APRES les stubs (la page resout les auto-imports au top-level du module).
+const CarriersIndex = (await import('../carriers/index.vue')).default
+
+// ── Stubs de composants ──────────────────────────────────────────────────────
+const ButtonStub = defineComponent({
+    props: { label: { type: String, default: '' }, disabled: { type: Boolean, default: false } },
+    emits: ['click'],
+    setup(props, { emit }) {
+        return () => h('button', { 'data-label': props.label, onClick: () => emit('click') }, props.label)
+    },
+})
+
+const DataTableStub = defineComponent({
+    props: { items: { type: Array, default: () => [] } },
+    emits: ['row-click', 'update:page', 'update:per-page'],
+    setup(props, { emit }) {
+        return () => h('div', { 'data-testid': 'datatable' },
+            (props.items as Array<{ id: number }>).map(it =>
+                h('tr', { 'data-row-id': it.id, onClick: () => emit('row-click', it) }),
+            ),
+        )
+    },
+})
+
+const DrawerStub = defineComponent({
+    props: { modelValue: { type: Boolean, default: false } },
+    setup(_, { slots }) {
+        return () => h('div', {}, [slots.header?.(), slots.default?.(), slots.footer?.()])
+    },
+})
+
+const SlotStub = defineComponent({ setup(_, { slots }) { return () => h('div', {}, slots.default?.()) } })
+
+const PageHeaderStub = defineComponent({
+    setup(_, { slots }) { return () => h('div', {}, [slots.default?.(), slots.actions?.()]) },
+})
+
+const CheckboxStub = defineComponent({
+    props: { id: { type: String, default: '' }, modelValue: { type: Boolean, default: false } },
+    emits: ['update:model-value'],
+    setup(props, { emit }) {
+        return () => h('input', {
+            'type': 'checkbox',
+            'data-id': props.id,
+            'onChange': (e: Event) => emit('update:model-value', (e.target as HTMLInputElement).checked),
+        })
+    },
+})
+
+const InputTextStub = defineComponent({ setup() { return () => h('input') } })
+
+function mountPage() {
+    return mount(CarriersIndex, {
+        global: {
+            stubs: {
+                PageHeader: PageHeaderStub,
+                MalioButton: ButtonStub,
+                MalioDataTable: DataTableStub,
+                MalioDrawer: DrawerStub,
+                MalioAccordion: SlotStub,
+                MalioAccordionItem: SlotStub,
+                MalioInputText: InputTextStub,
+                MalioCheckbox: CheckboxStub,
+            },
+        },
+    })
+}
+
+describe('Répertoire transporteurs (page /carriers)', () => {
+    beforeEach(() => {
+        mockPush.mockReset()
+        mockApiGet.mockReset().mockResolvedValue({ member: [] })
+        mockCan.mockReset().mockReturnValue(true)
+        mockSetFilters.mockReset()
+        mockFetch.mockReset()
+        mockToastError.mockReset()
+    })
+
+    it('charge la liste au montage', async () => {
+        mountPage()
+        await flushPromises()
+        expect(mockFetch).toHaveBeenCalled()
+    })
+
+    it('affiche « + Ajouter » uniquement avec la permission manage', async () => {
+        mockCan.mockImplementation((perm: string) => perm === 'transport.carriers.manage')
+        const wrapper = mountPage()
+        await flushPromises()
+        expect(wrapper.find('[data-label="transport.carriers.add"]').exists()).toBe(true)
+    })
+
+    it('masque « + Ajouter » sans la permission manage (view seul)', async () => {
+        mockCan.mockImplementation((perm: string) => perm === 'transport.carriers.view')
+        const wrapper = mountPage()
+        await flushPromises()
+        expect(wrapper.find('[data-label="transport.carriers.add"]').exists()).toBe(false)
+    })
+
+    it('navigue vers la consultation au clic sur une ligne', async () => {
+        const wrapper = mountPage()
+        await flushPromises()
+        await wrapper.find('tr[data-row-id="7"]').trigger('click')
+        expect(mockPush).toHaveBeenCalledWith('/carriers/7')
+    })
+
+    it('appelle l\'export XLSX sur /carriers/export.xlsx en blob', async () => {
+        const wrapper = mountPage()
+        await flushPromises()
+        await wrapper.find('[data-label="transport.carriers.export"]').trigger('click')
+        await flushPromises()
+        expect(mockApiGet).toHaveBeenCalledWith(
+            '/carriers/export.xlsx',
+            expect.any(Object),
+            expect.objectContaining({ responseType: 'blob', toast: false }),
+        )
+    })
+
+    it('repercute le filtre « Voir les archivés » dans setFilters sans toucher l\'URL', async () => {
+        const wrapper = mountPage()
+        await flushPromises()
+
+        // Coche « Voir les archivés » puis applique les filtres.
+        await wrapper.find('input[data-id="filter-archived-only"]').setValue(true)
+        await wrapper.find('[data-label="transport.carriers.filters.apply"]').trigger('click')
+
+        expect(mockSetFilters).toHaveBeenLastCalledWith(
+            { archivedOnly: true },
+            { replace: true },
+        )
+        // Etat 100 % local (regle n°6) : aucune navigation/query string declenchee.
+        expect(mockPush).not.toHaveBeenCalled()
+    })
+
+    it('repercute les certifications cochees dans setFilters (filtre multi)', async () => {
+        const wrapper = mountPage()
+        await flushPromises()
+
+        // Coche deux certifications via les cases a cocher (pattern repertoire clients).
+        await wrapper.find('input[data-id="filter-certification-QUALIMAT"]').setValue(true)
+        await wrapper.find('input[data-id="filter-certification-AUTRE"]').setValue(true)
+        await wrapper.find('[data-label="transport.carriers.filters.apply"]').trigger('click')
+
+        expect(mockSetFilters).toHaveBeenLastCalledWith(
+            { 'certificationType[]': ['QUALIMAT', 'AUTRE'] },
+            { replace: true },
+        )
+    })
+
+    it('badge filtres actifs + Réinitialiser vide l\'etat applique', async () => {
+        const wrapper = mountPage()
+        await flushPromises()
+
+        await wrapper.find('input[data-id="filter-archived-only"]').setValue(true)
+        await wrapper.find('[data-label="transport.carriers.filters.apply"]').trigger('click')
+
+        // Le libelle du bouton Filtrer porte le compteur (1 filtre actif).
+        expect(wrapper.find('[data-label="transport.carriers.filters.title (1)"]').exists()).toBe(true)
+
+        // Réinitialiser → query propre (setFilters avec objet vide).
+        await wrapper.find('[data-label="transport.carriers.filters.reset"]').trigger('click')
+        expect(mockSetFilters).toHaveBeenLastCalledWith({}, { replace: true })
+    })
+})

frontend/modules/transport/pages/carriers/index.vue

@@ -0,0 +1,389 @@
+<template>
+    <div>
+        <PageHeader>
+            {{ t('transport.carriers.title') }}
+            <template #actions>
+                <!-- gap-8 = 32px d'espacement entre Filtrer et Ajouter. -->
+                <div class="flex items-center gap-8">
+                    <!-- Bouton Filtrer a GAUCHE d'Ajouter. Le compteur reflete les filtres actifs. -->
+                    <MalioButton
+                        v-if="canView"
+                        variant="tertiary"
+                        :label="filterButtonLabel"
+                        icon-name="mdi:tune"
+                        icon-position="left"
+                        icon-size="24"
+                        @click="openFilters"
+                    />
+                    <MalioButton
+                        v-if="canManage"
+                        variant="secondary"
+                        :label="t('transport.carriers.add')"
+                        icon-name="mdi:add-bold"
+                        icon-position="left"
+                        @click="goToCreate"
+                    />
+                </div>
+            </template>
+        </PageHeader>
+
+        <!-- Datatable branchee sur usePaginatedList via useCarriersRepository :
+             pagination serveur, tri name ASC par defaut (cote back). -->
+        <MalioDataTable
+            :columns="columns"
+            :items="rows"
+            :total-items="totalItems"
+            :page="currentPage"
+            :per-page="itemsPerPage"
+            :per-page-options="itemsPerPageOptions"
+            row-clickable
+            :empty-message="t('transport.carriers.empty')"
+            @row-click="onRowClick"
+            @update:page="goToPage"
+            @update:per-page="setItemsPerPage"
+        >
+            <!-- Certification : libelle i18n (le back renvoie le code enum). -->
+            <template #cell-certificationType="{ item }">
+                {{ formatCertification(item) }}
+            </template>
+
+            <!-- Date de validite QUALIMAT : fond rouge si perimee (< aujourd'hui — RG-4.04). -->
+            <template #cell-validityDate="{ item }">
+                <span
+                    v-if="getValidityDate(item)"
+                    :class="isValidityExpired(item) ? 'inline-block rounded px-2 py-0.5 bg-m-danger text-white' : ''"
+                >
+                    {{ formatDateFr(getValidityDate(item)) }}
+                </span>
+            </template>
+
+            <!-- Derniere activite : date de derniere modification (updatedAt). -->
+            <template #cell-lastActivity="{ item }">
+                {{ formatDateFr(item.updatedAt as string | null) }}
+            </template>
+        </MalioDataTable>
+
+        <div class="flex justify-center mt-4">
+            <MalioButton
+                v-if="canView"
+                variant="primary"
+                :label="t('transport.carriers.export')"
+                :disabled="exporting"
+                @click="exportXlsx"
+            />
+        </div>
+
+        <!-- Drawer de filtres : etat BROUILLON, applique uniquement au clic sur
+             « Voir les résultats ». Meme pattern que les repertoires M1/M2/M3.
+             Etat 100 % local, jamais dans l'URL (regle ABSOLUE n°6). -->
+        <MalioDrawer
+            v-model="filterDrawerOpen"
+            drawer-class="max-w-[450px]"
+            body-class="p-0"
+            footer-class="justify-between border-t border-black p-6"
+        >
+            <template #header>
+                <h2 class="text-[24px] font-bold uppercase">{{ t('transport.carriers.filters.title') }}</h2>
+            </template>
+
+            <MalioAccordion>
+                <!-- Recherche : nom du transporteur (param `search`). -->
+                <MalioAccordionItem :title="t('transport.carriers.filters.search')" value="search">
+                    <MalioInputText
+                        v-model="draftSearch"
+                        icon-name="mdi:magnify"
+                    />
+                </MalioAccordionItem>
+
+                <!-- Certification : cases a cocher (multi). Valeur = code enum.
+                     Meme pattern que le filtre Categories du repertoire clients. -->
+                <MalioAccordionItem :title="t('transport.carriers.filters.certification')" value="certification">
+                    <div class="flex flex-col">
+                        <MalioCheckbox
+                            v-for="opt in certificationOptions"
+                            :id="`filter-certification-${opt.value}`"
+                            :key="opt.value"
+                            :label="opt.label"
+                            :model-value="draftCertificationTypes.includes(opt.value)"
+                            @update:model-value="(val: boolean) => toggleCertification(opt.value, val)"
+                        />
+                    </div>
+                </MalioAccordionItem>
+
+                <!-- Statut : voir uniquement les archives (sinon actifs uniquement). -->
+                <MalioAccordionItem :title="t('transport.carriers.filters.status')" value="status">
+                    <MalioCheckbox
+                        id="filter-archived-only"
+                        :label="t('transport.carriers.filters.archivedOnly')"
+                        :model-value="draftArchivedOnly"
+                        @update:model-value="(val: boolean) => draftArchivedOnly = val"
+                    />
+                </MalioAccordionItem>
+            </MalioAccordion>
+
+            <template #footer>
+                <MalioButton
+                    variant="tertiary"
+                    :label="t('transport.carriers.filters.reset')"
+                    button-class="w-m-btn-action"
+                    @click="resetFilters"
+                />
+                <MalioButton
+                    variant="primary"
+                    :label="t('transport.carriers.filters.apply')"
+                    button-class="w-[170px]"
+                    @click="applyFilters"
+                />
+            </template>
+        </MalioDrawer>
+    </div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, ref } from 'vue'
+
+interface FilterOption {
+    value: string
+    label: string
+}
+
+const { t } = useI18n()
+const api = useApi()
+const router = useRouter()
+const toast = useToast()
+const { can } = usePermissions()
+
+useHead({ title: t('transport.carriers.title') })
+
+// Bouton « Ajouter » reserve a `manage` (Admin + Bureau). « Exporter » et
+// « Filtrer » suivent `view` (Admin / Bureau / Commerciale). Compta et Usine
+// n'ont aucun acces (item sidebar masque cote back).
+const canManage = computed(() => can('transport.carriers.manage'))
+const canView = computed(() => can('transport.carriers.view'))
+
+const {
+    items: carriers,
+    totalItems,
+    currentPage,
+    itemsPerPage,
+    itemsPerPageOptions,
+    fetch: loadCarriers,
+    goToPage,
+    setItemsPerPage,
+    setFilters,
+} = useCarriersRepository()
+
+// Mappe les transporteurs en objets « plats » pour MalioDataTable (items typees
+// Record<string, unknown>[]) : un objet litteral porte une signature d'index
+// implicite, contrairement a l'interface Carrier. Meme pattern que M1/M2/M3.
+const rows = computed(() => carriers.value.map(carrier => ({
+    id: carrier.id,
+    name: carrier.name,
+    certificationType: carrier.certificationType,
+    validityDate: carrier.qualimatCarrier?.validityDate ?? null,
+    updatedAt: carrier.updatedAt,
+})))
+
+const columns = [
+    { key: 'name', label: t('transport.carriers.column.name') },
+    { key: 'certificationType', label: t('transport.carriers.column.certification') },
+    { key: 'validityDate', label: t('transport.carriers.column.validityDate') },
+    { key: 'lastActivity', label: t('transport.carriers.column.lastActivity') },
+]
+
+// Codes de certification (miroir de l'enum back) + cas LIOT (null). Le libelle
+// est resolu par i18n ; un code inconnu retombe sur le code brut.
+const CERTIFICATION_CODES = ['QUALIMAT', 'GMP_PLUS', 'OVOCOM', 'COMPTE_PROPRE', 'AUTRE'] as const
+
+const certificationOptions = computed<FilterOption[]>(() =>
+    CERTIFICATION_CODES.map(code => ({
+        value: code,
+        label: t(`transport.carriers.certification.${code}`),
+    })),
+)
+
+/** Libelle i18n de la certification (vide en cas LIOT — certificationType null). */
+function formatCertification(item: Record<string, unknown>): string {
+    const code = item.certificationType as string | null | undefined
+    if (!code) {
+        return ''
+    }
+    return t(`transport.carriers.certification.${code}`)
+}
+
+/** Date de validite QUALIMAT de la ligne (null si transporteur non QUALIMAT). */
+function getValidityDate(item: Record<string, unknown>): string | null {
+    return (item.validityDate as string | null | undefined) ?? null
+}
+
+/**
+ * RG-4.04 : un agrement QUALIMAT est perime si sa date de validite est anterieure
+ * a la date du jour (comparaison jour a jour, sans l'heure).
+ */
+function isValidityExpired(item: Record<string, unknown>): boolean {
+    const value = getValidityDate(item)
+    if (!value) {
+        return false
+    }
+    const date = new Date(value)
+    if (Number.isNaN(date.getTime())) {
+        return false
+    }
+    const today = new Date()
+    today.setHours(0, 0, 0, 0)
+    date.setHours(0, 0, 0, 0)
+    return date.getTime() < today.getTime()
+}
+
+/** Format court francais JJ-MM-AAAA (spec M4). Chaine vide si date absente / invalide. */
+function formatDateFr(value: string | null | undefined): string {
+    if (!value) {
+        return ''
+    }
+    const date = new Date(value)
+    if (Number.isNaN(date.getTime())) {
+        return ''
+    }
+    const day = String(date.getDate()).padStart(2, '0')
+    const month = String(date.getMonth() + 1).padStart(2, '0')
+    return `${day}-${month}-${date.getFullYear()}`
+}
+
+/** Clic sur une ligne → ecran Consultation (route a plat /carriers/{id}). */
+function onRowClick(item: Record<string, unknown>): void {
+    router.push(`/carriers/${item.id}`)
+}
+
+function goToCreate(): void {
+    router.push('/carriers/new')
+}
+
+// ── Filtres (drawer) ────────────────────────────────────────────────────────
+// Deux niveaux d'etat (pattern repertoires M1/M2/M3) :
+//  - APPLIED : pilote la liste/l'export + le compteur du bouton. Modifie
+//    uniquement au clic « Voir les résultats » / « Réinitialiser ».
+//  - DRAFT : edite librement dans le drawer ; recopie vers applied a la validation.
+const filterDrawerOpen = ref(false)
+
+const draftSearch = ref('')
+const draftCertificationTypes = ref<string[]>([])
+const draftArchivedOnly = ref(false)
+
+const appliedSearch = ref('')
+const appliedCertificationTypes = ref<string[]>([])
+const appliedArchivedOnly = ref(false)
+
+const activeFilterCount = computed(() => {
+    let count = 0
+    if (appliedSearch.value.trim() !== '') count++
+    if (appliedCertificationTypes.value.length > 0) count++
+    if (appliedArchivedOnly.value) count++
+    return count
+})
+
+const filterButtonLabel = computed(() => {
+    const base = t('transport.carriers.filters.title')
+    return activeFilterCount.value > 0 ? `${base} (${activeFilterCount.value})` : base
+})
+
+// Recopie l'etat applique vers le brouillon puis ouvre le drawer : la reouverture
+// reflete les filtres actifs.
+function openFilters(): void {
+    draftSearch.value = appliedSearch.value
+    draftCertificationTypes.value = [...appliedCertificationTypes.value]
+    draftArchivedOnly.value = appliedArchivedOnly.value
+    filterDrawerOpen.value = true
+}
+
+/** Coche / decoche une certification dans le brouillon (filtre multi). */
+function toggleCertification(code: string, selected: boolean): void {
+    draftCertificationTypes.value = selected
+        ? [...draftCertificationTypes.value, code]
+        : draftCertificationTypes.value.filter(c => c !== code)
+}
+
+/**
+ * Construit le payload de filtres serveur a partir de l'etat applique. Cle
+ * `certificationType[]` pour que PHP la parse en tableau (OR cote back). Les
+ * filtres vides sont omis pour une query propre.
+ */
+function buildFilterPayload(): Record<string, string | string[] | boolean> {
+    const payload: Record<string, string | string[] | boolean> = {}
+    if (appliedSearch.value.trim() !== '') payload.search = appliedSearch.value.trim()
+    if (appliedCertificationTypes.value.length > 0) payload['certificationType[]'] = [...appliedCertificationTypes.value]
+    if (appliedArchivedOnly.value) payload.archivedOnly = true
+    return payload
+}
+
+// « Voir les résultats » : recopie brouillon → applied, pousse les filtres
+// (retombe en page 1 via usePaginatedList) et ferme le drawer.
+function applyFilters(): void {
+    appliedSearch.value = draftSearch.value.trim()
+    appliedCertificationTypes.value = [...draftCertificationTypes.value]
+    appliedArchivedOnly.value = draftArchivedOnly.value
+
+    setFilters(buildFilterPayload(), { replace: true })
+    filterDrawerOpen.value = false
+}
+
+// « Réinitialiser » : vide brouillon ET applied, recharge la liste complete.
+// Le drawer reste ouvert pour montrer le formulaire vide.
+function resetFilters(): void {
+    draftSearch.value = ''
+    draftCertificationTypes.value = []
+    draftArchivedOnly.value = false
+
+    appliedSearch.value = ''
+    appliedCertificationTypes.value = []
+    appliedArchivedOnly.value = false
+
+    setFilters({}, { replace: true })
+}
+
+// ── Export XLSX ─────────────────────────────────────────────────────────────
+// Memes filtres que la vue : l'export reflete exactement ce que l'utilisateur voit.
+const exporting = ref(false)
+
+async function exportXlsx(): Promise<void> {
+    if (exporting.value) {
+        return
+    }
+    exporting.value = true
+    try {
+        // useApi type ses options en JSON ; l'export renvoie un binaire, donc on
+        // force responseType:'blob' (transmis tel quel a ofetch au runtime). Cast
+        // contenu faute d'overload blob sur le client partage (meme pattern M2/M3).
+        const blob = await api.get<Blob>('/carriers/export.xlsx', buildFilterPayload(), {
+            responseType: 'blob',
+            toast: false,
+        } as unknown as Parameters<typeof api.get>[2])
+
+        triggerDownload(blob, 'repertoire-transporteurs.xlsx')
+    }
+    catch {
+        toast.error({
+            title: t('transport.carriers.toast.error'),
+            message: t('transport.carriers.toast.exportError'),
+        })
+    }
+    finally {
+        exporting.value = false
+    }
+}
+
+/** Declenche le telechargement d'un blob via un lien temporaire. */
+function triggerDownload(blob: Blob, filename: string): void {
+    const url = URL.createObjectURL(blob)
+    const link = document.createElement('a')
+    link.href = url
+    link.download = filename
+    document.body.appendChild(link)
+    link.click()
+    link.remove()
+    URL.revokeObjectURL(url)
+}
+
+onMounted(() => {
+    loadCarriers()
+})
+</script>

frontend/modules/transport/pages/carriers/new.vue

@@ -0,0 +1,152 @@
+<template>
+    <div>
+        <!-- En-tete : retour vers le repertoire + titre. -->
+        <div class="flex items-center gap-3 pt-11">
+            <MalioButtonIcon
+                icon="mdi:arrow-left-bold"
+                icon-size="24"
+                variant="ghost"
+                v-bind="{ ariaLabel: t('transport.carriers.form.back') }"
+                @click="goBack"
+            />
+            <h1 class="text-[30px] font-semibold text-m-primary">{{ t('transport.carriers.form.title') }}</h1>
+        </div>
+
+        <!-- ── Formulaire principal (pre-onglets) ─────────────────────────────
+             Sans validation de ce bloc, les onglets restent inaccessibles. Au
+             succes du POST, les champs passent en lecture seule et on bascule
+             automatiquement sur l'onglet Qualimat. Les champs conditionnels
+             (indexation / benne / volume si affrete, decharge si AUTRE, cas LIOT)
+             et la saisie assistee QUALIMAT arrivent a ERP-166. -->
+        <div class="mt-[48px] grid grid-cols-3 xl:grid-cols-4 gap-x-[44px] gap-y-4">
+            <MalioInputText
+                v-model="main.name"
+                :label="t('transport.carriers.form.main.name')"
+                :required="true"
+                :readonly="mainLocked"
+                :error="mainErrors.errors.name"
+            />
+            <MalioSelect
+                :model-value="main.certificationType"
+                :options="certificationOptions"
+                :label="t('transport.carriers.form.main.certificationType')"
+                empty-option-label=""
+                :required="true"
+                :readonly="mainLocked"
+                :error="mainErrors.errors.certificationType"
+                @update:model-value="(v: string | number | null) => main.certificationType = v === null ? null : String(v)"
+            />
+            <!-- Wrapper h-12 + centrage vertical : aligne la case a cocher sur la
+                 ligne de champ des inputs/selects (qui posent un h-12 items-center
+                 en interne). reserve-message-space=false pour un centrage exact. -->
+            <div class="flex h-12 items-center">
+                <MalioCheckbox
+                    id="carrier-is-chartered"
+                    :label="t('transport.carriers.form.main.isChartered')"
+                    :model-value="main.isChartered"
+                    :readonly="mainLocked"
+                    :reserve-message-space="false"
+                    @update:model-value="(val: boolean) => main.isChartered = val"
+                />
+            </div>
+        </div>
+
+        <div v-if="!mainLocked" class="mt-12 flex justify-center">
+            <MalioButton
+                variant="primary"
+                :label="t('transport.carriers.form.submit')"
+                :disabled="mainSubmitting"
+                @click="onSubmitMain"
+            />
+        </div>
+
+        <!-- ── Onglets a validation incrementale ─────────────────────────────
+             Barre Qualimat · Adresses · Contacts · Prix. Onglets verrouilles tant
+             que le formulaire principal n'est pas valide (unlockedIndex = -1) puis
+             deverrouilles progressivement. Le contenu de chaque onglet arrive aux
+             tickets suivants (ERP-166+) : placeholders « A venir » pour l'instant. -->
+        <MalioTabList v-model="activeTab" :tabs="tabs" class="mt-[60px]">
+            <template
+                v-for="key in tabKeys"
+                :key="key"
+                #[key]
+            >
+                <div class="mt-12 flex justify-center text-m-muted">
+                    {{ t('transport.carriers.form.comingSoon') }}
+                </div>
+            </template>
+        </MalioTabList>
+    </div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import { useCarrierForm } from '~/modules/transport/composables/useCarrierForm'
+
+interface SelectOption {
+    value: string
+    label: string
+}
+
+const { t } = useI18n()
+const router = useRouter()
+const { can } = usePermissions()
+
+useHead({ title: t('transport.carriers.form.title') })
+
+// Gating de la route : la creation est reservee a `manage` (Admin / Bureau).
+// Commerciale (consultation seule), Compta et Usine sont rediriges vers le repertoire.
+if (!can('transport.carriers.manage')) {
+    await navigateTo('/carriers')
+}
+
+const {
+    main,
+    mainLocked,
+    mainSubmitting,
+    mainErrors,
+    tabKeys,
+    activeTab,
+    unlockedIndex,
+    submitMain,
+} = useCarrierForm()
+
+// Certifications selectionnables manuellement (spec § Formulaire principal).
+// QUALIMAT n'est PAS dans cette liste : il est pose par la saisie assistee QUALIMAT
+// (ERP-166), pas choisi a la main.
+const SELECTABLE_CERTIFICATIONS = ['GMP_PLUS', 'OVOCOM', 'COMPTE_PROPRE', 'AUTRE'] as const
+
+const certificationOptions = computed<SelectOption[]>(() =>
+    SELECTABLE_CERTIFICATIONS.map(code => ({
+        value: code,
+        label: t(`transport.carriers.certification.${code}`),
+    })),
+)
+
+// Icone (Iconify) affichee dans chaque onglet, par cle.
+const TAB_ICONS: Record<string, string> = {
+    qualimat: 'mdi:truck-check-outline',
+    addresses: 'mdi:map-marker-outline',
+    contacts: 'mdi:account-box-plus-outline',
+    prices: 'mdi:currency-eur',
+}
+
+// Onglets desactives tant que le formulaire principal n'est pas valide
+// (unlockedIndex = -1 au depart) ; deverrouillage progressif ensuite.
+const tabs = computed(() => tabKeys.value.map((key, index) => ({
+    key,
+    label: t(`transport.carriers.tab.${key}`),
+    icon: TAB_ICONS[key],
+    disabled: index > unlockedIndex.value,
+})))
+
+/** Retour vers le repertoire transporteurs (fleche d'en-tete). */
+function goBack(): void {
+    router.push('/carriers')
+}
+
+/** Valide le formulaire principal (POST /carriers ; bascule gerée par le composable). */
+async function onSubmitMain(): Promise<void> {
+    await submitMain()
+}
+</script>

frontend/modules/transport/types/carrierForm.ts

@@ -0,0 +1,40 @@
+/**
+ * Types du workflow « Ajouter un transporteur » (M4 Transport, ERP-165).
+ *
+ * Périmètre ERP-165 = formulaire PRINCIPAL (pré-onglets) uniquement : Nom +
+ * Certification + Affréter. Les champs conditionnels (indexation / benne / volume
+ * si affrété, décharge si AUTRE, immatriculations LIOT) et la saisie assistée
+ * QUALIMAT arrivent à ERP-166 ; les onglets Adresses / Contacts / Prix aux tickets
+ * suivants. On garde donc volontairement ce draft minimal — il s'étendra.
+ */
+
+/**
+ * Brouillon du formulaire principal. `certificationType` est un code enum back
+ * (GMP_PLUS | OVOCOM | COMPTE_PROPRE | AUTRE ; QUALIMAT sera posé par la saisie
+ * assistée à ERP-166) ou `null` tant que rien n'est choisi.
+ */
+export interface CarrierMainDraft {
+    name: string
+    certificationType: string | null
+    isChartered: boolean
+}
+
+/** Brouillon principal vide (état initial du formulaire de création). */
+export function emptyCarrierMain(): CarrierMainDraft {
+    return {
+        name: '',
+        certificationType: null,
+        isChartered: false,
+    }
+}
+
+/**
+ * Réponse du POST / PATCH principal (groupe `carrier:read`). Le serveur renvoie
+ * le nom normalisé (UPPERCASE, RG-4.13) que l'UI réaffiche tel quel.
+ */
+export interface CarrierMainResponse {
+    id: number
+    name: string | null
+    certificationType: string | null
+    '@id'?: string
+}

frontend/package-lock.json

@@ -7,7 +7,7 @@
       "name": "starseed-frontend",
       "hasInstallScript": true,
       "dependencies": {
-        "@malio/layer-ui": "^1.7.10",
+        "@malio/layer-ui": "^1.7.12",
         "@nuxt/icon": "^2.2.1",
         "@nuxtjs/i18n": "^10.2.3",
         "@nuxtjs/tailwindcss": "^6.14.0",
@@ -583,9 +583,9 @@
       "license": "MIT"
     },
     "node_modules/@emnapi/core": {
-      "version": "1.11.0",
+      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.0.tgz",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.1.tgz",
-      "integrity": "sha512-l9Oo58x0HOP5znGzVhYW9U3e5wVuA4LAZU2AGezTmkhO1CgQRFDhDg4nneHsu/t3WniXg9QrG2nIXL/ZS8ln8Q==",
+      "integrity": "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ==",
       "license": "MIT",
       "optional": true,
       "dependencies": {
@@ -594,9 +594,9 @@
       }
     },
     "node_modules/@emnapi/runtime": {
-      "version": "1.11.0",
+      "version": "1.11.1",
-      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.0.tgz",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.1.tgz",
-      "integrity": "sha512-55coeOFKHv1ywEcUXJtWU5f+Jr/W5tZDvZig8DLKSwUN1JpROQ4rk/SNOQiFWmaR/VKF4zuFyW1B8JduOSv6Pg==",
+      "integrity": "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw==",
       "license": "MIT",
       "optional": true,
       "dependencies": {
@@ -1866,9 +1866,9 @@
       "license": "MIT"
     },
     "node_modules/@malio/layer-ui": {
-      "version": "1.7.10",
+      "version": "1.7.12",
-      "resolved": "https://gitea.malio.fr/api/packages/MALIO-DEV/npm/%40malio%2Flayer-ui/-/1.7.10/layer-ui-1.7.10.tgz",
+      "resolved": "https://gitea.malio.fr/api/packages/MALIO-DEV/npm/%40malio%2Flayer-ui/-/1.7.12/layer-ui-1.7.12.tgz",
-      "integrity": "sha512-ZWYaKvl+VpGAqeTE+4xdyKOmuRd4zwjlUYVppeIBZwGeNAK16kZnrztR+4eQmnzUqPZVybBhEBdKP9weqWHSUg==",
+      "integrity": "sha512-ezQLqi19K2ogI3XwSMsUyluU9x5C4W0tu1muxFbL3foKjibRYRg/FdvySivEhEsalAAt1E88V6Sv/06xPqyYTw==",
       "dependencies": {
         "@nuxt/icon": "^2.2.1",
         "@nuxtjs/tailwindcss": "^6.14.0",

frontend/package.json

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

frontend/tests/e2e/_fixtures/personas.ts

@@ -95,10 +95,11 @@ export const personas: Record<PersonaKey, Persona> = {
             'technique.providers.accounting.view',
             'technique.providers.accounting.manage',
             'technique.providers.archive',
-            // Transport — Repertoire transporteurs (M4, ERP-153). Meme logique :
+            // Transport — Repertoire transporteurs (M4, ERP-164). Meme logique :
             // mappe sur le persona "tout", pas de nouveau persona (regle ABSOLUE
-            // n°7). transport.carriers.view n'ajoute pas de lien dans la section
+            // n°7). L'item transporteurs vit desormais dans la section Administration
-            // Administration, donc expectedAdminLinks reste inchange.
+            // (1er item, ERP-164) mais sur la route `/carriers` (hors `/admin/<slug>`),
+            // donc il n'entre pas dans ALL_ADMIN_LINKS : expectedAdminLinks reste inchange.
             'transport.carriers.view',
             'transport.carriers.manage',
             'transport.carriers.archive',