@mostajs/flotte 0.0.0-stage → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog — @mostajs/flotte
+
+Format [Keep a Changelog](https://keepachangelog.com/fr/1.0.0/) · [SemVer](https://semver.org/lang/fr/).
+Auteur : Dr Hamid MADANI <drmdh@msn.com>
+
+## [0.3.0] — non publiée
+### Added
+- `vehicules({ statut?, type?, site?, q?, reformes? })` : la liste du parc, rangée par code ; `statut` est un code
+  ou une liste ; `q` est cherché dans le code, la plaque, la marque et le modèle, sans casse, espaces et tirets
+  indifférents ; les réformés n'y sont que sur demande. Demandé par le tableau de bord ECR-16 de Guerway, que
+  `@mostajs/flotte-ui` construit sans accéder aux dépôts. Essai T-FLO-17.
+
+## [0.2.0] — non publiée
+### Added
+- `prochainsEntretiens(v, { date? })` et `prochainEntretien(v)` : pour chaque plan, l'échéance de chaque pas (km,
+  jours) et la date du premier atteint, rangés du plus urgent au moins urgent. Un pas en km devient une date au rythme
+  relevé (`estime: true`). Demandé par l'écran ECR-16 de Guerway (« Prochain entretien : date, dans N jours »).
+- Règles pures `regles.prochainEntretien` et `regles.kmParJour` (rythme sur les 90 derniers jours). Essai T-FLO-16.
+
+## [0.1.0] — 2026-10-24
+### Added
+- `createFlotte` : registre par types déclarés, cycle en service / immobilisé / à l'atelier / réformé
+  (`@mostajs/statemachine`), échéances typées, plans d'entretien au km et à la date, interventions numérotées,
+  relevés avec correction motivée, pleins et consommation, affectations, `peutPartir`, `disponibles`, `cout`.
+- Port `habilitations` facultatif (`@mostajs/staff`) ; numérotation injectée (`@mostajs/numbering`).
+- Codes et libellés français canoniques, `libelle(famille, code, t)` pour les sept langues de Guerway.
+- Sept tables déclarées par `register` ; permissions `flotte:domaine:action` ; événements.
+- Essais T-FLO-1 à 15 ; exemple `examples/verifier.mjs`. Premier consommateur prévu : Guerway.

package/LICENSE

@@ -0,0 +1,15 @@
+@mostajs/flotte
+Copyright (C) 2026 Dr Hamid MADANI <drmdh@msn.com>
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU Affero General Public License as published by the Free
+Software Foundation, either version 3 of the License, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/agpl-3.0.html>.

package/README.md

@@ -1,3 +1,56 @@
-# Temporary Holding Version
+# @mostajs/flotte
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · Licence AGPL-3.0-or-later
+
+Le carnet du parc. Il répond à une question : **ce véhicule peut-il partir aujourd'hui, avec ce conducteur, et
+combien coûte-t-il ?**
+
+- un registre de véhicules, chacun d'un **type déclaré** par l'application (fourgon, moto, autocar…), et sa liste
+  filtrée par statut, type, site ou texte ;
+- un cycle : en service, immobilisé, à l'atelier, réformé ; chaque passage est tracé, avec son motif ;
+- des échéances (assurance, contrôle technique…) ; la plus récente fait foi, les anciennes restent lisibles ;
+- l'entretien au kilométrage **et** à la date, dû au premier des deux atteint, avec une tolérance ; le prochain
+  entretien est daté, et un pas en km devient une date au rythme relevé ;
+- des relevés de compteur : un recul est refusé, sauf correction motivée ; un saut anormal est signalé ;
+- des pleins, et la consommation mesurée entre deux pleins complets ;
+- des affectations de conducteurs (identifiant opaque) ;
+- `peutPartir` rend **tous** les motifs de refus, pas seulement le premier ;
+- `cout` rend le coût sur une période et au km, et dit ce qu'il ne compte pas.
+
+```js
+import { createFlotte, createMemoryRepositories, libelle } from '@mostajs/flotte';
+
+const flotte = createFlotte({
+  repositories: createMemoryRepositories(),          // en production : les dépôts data-plug de l'application
+  declarations: {
+    types: { fourgon: { categoriePermis: 'B', attributs: { chargeUtileKg: 'nombre' } } },
+    echeances: { assurance: { bloquante: true, obligatoire: true, periodiciteJours: 365 } },
+    immatriculation: [/^\d{5,6}-\d{3}-\d{2}$/],
+  },
+  numeroter: async ({ nature }) => `INT-${Date.now()}`, // en production : @mostajs/numbering
+});
+const v = await flotte.inscrire({ code: 'GW-F01', immatriculation: '12345-116-16', type: 'fourgon' }, { agent: 'chef-parc' });
+const r = await flotte.peutPartir(v.id);
+r.motifs.map((m) => libelle('motif', m.code, t, m));   // t : la traduction de l'application
+```
+
+## Langues
+
+Le module rend des **codes** (`r.motifs = [{ code: 'ECHEANCE_ABSENTE', type: 'assurance' }]`) et un libellé
+français canonique. L'application traduit la clé `flotte.<famille>.<code>`. Guerway le fait dans ses sept
+catalogues. Sans traduction, le libellé du module s'affiche. Le motif saisi par un agent reste tel quel.
+
+## Ce que le module ne fait pas
+
+Position (`geo-tracker`), réservation (`booking`), déplacement de billets ou de colis (`tournees`), personne du
+conducteur et permis (`staff`, par le port `habilitations`), pièces en stock (`stocks`), comptabilité (`compta`),
+alertes (`notifications`), fichiers scannés (`blob-store`). `peutPartir` dit **apte**, jamais **libre**.
+
+## Vérifier
+
+```bash
+npm test                    # T-FLO-1 à 16 (@mostajs/mjs-unit)
+node examples/verifier.mjs  # un fourgon, de l'inscription au coût au km
+```
+
+Plan : `docs/03-PLAN-DEV-FLOTTE.md`. Fiche pour les assistants : `llms.txt`.

package/llms.txt

@@ -0,0 +1,53 @@
+# @mostajs/flotte — fiche LLM
+
+RÔLE
+  Le carnet du parc (N3, forme annuaire) : registre des véhicules par TYPE DÉCLARÉ, cycle d'état, échéances
+  (assurance, contrôle technique…), entretien au km ET à la date, relevés de compteur, pleins, affectations de
+  conducteurs, coût au km, et la réponse « ce véhicule peut-il partir aujourd'hui, avec ce conducteur ? ».
+  NE FAIT PAS : position (→ geo-tracker) ; réservation (→ booking) ; déplacer billets ou colis (→ tournees) ;
+  personne du conducteur et permis (→ staff, par le PORT habilitations) ; stock de pièces (→ stocks) ; écriture
+  comptable (→ compta) ; alerte (→ notifications) ; fichier scanné (→ blob-store, on garde sa référence) ;
+  numéroter (→ numbering, INJECTÉ). `peutPartir` dit APTE, jamais LIBRE.
+
+EXPORTS
+  createFlotte({ repositories, declarations, numeroter({ vehicule, nature, date }), habilitations?, audit?,
+                 plusieursVehiculesParConducteur?, exigerAffectation?, maintenant? }) -> api
+  declarations = { types: { <type>: { categoriePermis?, attributs: { <nom>: 'nombre'|'booleen'|'texte' } } },
+                   echeances: { <type>: { bloquante?, obligatoire?, periodiciteJours } },
+                   immatriculation: [RegExp…], alerteJours? (30), sautAnormalKmParJour? (2000) }
+  PORT habilitations : peutConduire(conducteur, categorie, date) -> booléen
+  createMemoryRepositories()   7 dépôts : vehicules, echeances, plans, interventions, releves, pleins, affectations
+  ErreurFlotte { code, statut } (400 donnée, 404 inconnu, 409 doublon/recul/close/ouverte/occupé, 422 transition)
+  CODES, LIBELLES, libelle(famille, code, t?, vars?) ; STATUTS, MOTIFS ; PERMISSIONS (flotte:domaine:action)
+  regles (pur) : etatEntretien, prochainEntretien, kmParJour, consommation, evaluerDepart, cout, echeanceCourante, jours, ajouterJours
+  register (7 tables ; aussi './register'), SCHEMAS, validerDeclarations
+
+API (async ; ctx = { agent })
+  inscrire({ code, immatriculation, type, attributs, marque?, site?, mode? }, ctx) ; lire(id)
+  vehicules({ statut?, type?, site?, q?, reformes? })  (0.3.0) -> copies rangées par code ; réformés exclus sauf demande
+  changerStatut(id, 'immobiliser'|'atelier'|'remettre'|'reformer', { agent, motif })   motif requis : immobiliser, reformer
+  poserEcheance({ vehicule, type, debut, fin?, cout?, piece? }, ctx)   fin absente = debut + periodiciteJours
+  echeances(v) ; aEcheance({ dans?, date? }) -> [{ id, vehicule, type, fin, n, expiree }]
+  planifierEntretien({ vehicule, libelle, tousLesKm?, tousLesJours?, toleranceKm?, toleranceJours? }, ctx) ; plans(v) ; entretiensDus({ date? })
+  prochainsEntretiens(v, { date? }) / prochainEntretien(v)  (0.2.0) -> { plan, libelle, etat, km: { echeance, restant },
+    jours: { echeance, restant }, le, dans, estime }  le pas en km devient une date au rythme relevé (estime: true)
+  ouvrirIntervention({ vehicule, nature, plan?, description?, ouverteLe? }, ctx)   corrective => a_l_atelier
+  cloreIntervention(id, { km?, cout?, le? }, ctx)   recale le plan ; km => relevé ; close => immuable
+  relever(v, { km, le?, source?, correction?: { motif, agent } }, ctx) -> relevé + avertissements (SAUT_ANORMAL)
+  saisirPlein({ vehicule, le, litres, montant, km, complet }, ctx)   vaut relevé ; consommation(v)
+  affecter(v, conducteur, ctx) ; liberer(v, ctx) ; affectations(v) ; affectationCourante(v)
+  peutPartir(v, { date?, conducteur?, km? }) -> { ok, motifs[], avertissements[] }   TOUS les motifs, en OBJETS
+  disponibles({ date?, type?, attributs? }) ; cout(v, { du, au }) -> { carburant, entretien, echeances, total, km, parKm, nonComptes }
+  onEvenement((type, donnees) => …) -> désabonnement
+
+LANGUES
+  Le module rend des CODES et un libellé français canonique. L'application traduit `flotte.<famille>.<code>`
+  (Guerway : ses 7 catalogues) et passe son `t` à libelle(). Le motif saisi par un agent n'est jamais traduit.
+
+PIÈGES
+  - Dates en jours 'AAAA-MM-JJ'. Un relevé doit être cohérent avec ceux qui l'entourent dans le temps.
+  - L'entité de relevé s'appelle ReleveCompteur (Releve appartient à @mostajs/recette).
+  - L'échéance qui fait foi est la plus récente par début ; les anciennes restent lisibles.
+
+ESSAIS  test-scripts/unit/flotte.test.mjs — T-FLO-1 à 16 ; exemple : node examples/verifier.mjs
+LICENCE AGPL-3.0-or-later · Auteur Dr Hamid MADANI <drmdh@msn.com>

package/package.json

@@ -1,6 +1,89 @@
 {
   "name": "@mostajs/flotte",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "Le carnet du parc : registre des véhicules par type déclaré, cycle d'état, échéances, entretien au kilométrage et à la date, relevés, pleins, affectations de conducteurs, coût au km, et la réponse « ce véhicule peut-il partir ? ».",
+  "license": "AGPL-3.0-or-later",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./register": "./src/schemas.js"
+  },
+  "files": [
+    "src",
+    "llms.txt",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "bash test-scripts/run-tests.sh"
+  },
+  "keywords": [
+    "mostajs",
+    "flotte",
+    "fleet",
+    "vehicule",
+    "entretien",
+    "maintenance",
+    "carburant",
+    "echeances",
+    "parc-automobile"
+  ],
+  "dependencies": {
+    "@mostajs/statemachine": "0.0.1"
+  },
+  "devDependencies": {
+    "@mostajs/mjs-unit": "0.10.0"
+  },
+  "mostajs": {
+    "niveau": "N3",
+    "nature": "metier",
+    "reutilisabilite": "mono-domaine",
+    "depend_de": [
+      "@mostajs/statemachine"
+    ],
+    "question": "Ce véhicule peut-il partir aujourd'hui, avec ce conducteur, et combien coûte-t-il ?",
+    "forme": "annuaire",
+    "entites": [
+      "Vehicule",
+      "Echeance",
+      "PlanEntretien",
+      "Intervention",
+      "ReleveCompteur",
+      "Plein",
+      "Affectation"
+    ],
+    "verbes": [
+      "inscrire",
+      "vehicules",
+      "changerStatut",
+      "peutPartir",
+      "prochainEntretien",
+      "aEcheance",
+      "entretiensDus",
+      "saisirPlein",
+      "affecter",
+      "cout"
+    ],
+    "interop": [
+      "ISO/TS 15143-3 (forme des relevés cumulés)",
+      "ISO 39001 (indicateurs d'exposition)"
+    ],
+    "ne_fait_pas": {
+      "suivre une position": "@mostajs/geo-tracker",
+      "réserver un véhicule sur un créneau": "@mostajs/booking",
+      "déplacer billets ou colis d'un véhicule à un autre": "@mostajs/tournees",
+      "tenir la personne du conducteur et ses permis": "@mostajs/staff",
+      "tenir le stock de pièces": "@mostajs/stocks",
+      "passer l'écriture comptable": "@mostajs/compta",
+      "envoyer une alerte": "@mostajs/notifications",
+      "ranger les pièces scannées": "@mostajs/blob-store",
+      "numéroter": "@mostajs/numbering"
+    }
+  }
+}

package/src/cycle.js

@@ -0,0 +1,22 @@
+// @mostajs/flotte — le cycle du véhicule, par @mostajs/statemachine (plan de dev §3.3).
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { defineMachine } from '@mostajs/statemachine';
+
+/** Les transitions : `motif` requis ou non ; `remettre` est gardée (aucune intervention ouverte). */
+export const TRANSITIONS = Object.freeze([
+  { id: 'immobiliser', from: ['en_service', 'a_l_atelier'], to: 'immobilise', motif: true },
+  { id: 'atelier', from: ['en_service', 'immobilise'], to: 'a_l_atelier', motif: false },
+  { id: 'remettre', from: ['a_l_atelier', 'immobilise'], to: 'en_service', motif: false, guard: (c) => c.data?.interventionsOuvertes === 0 },
+  { id: 'reformer', from: ['en_service', 'immobilise', 'a_l_atelier'], to: 'reforme', motif: true },
+]);
+
+/**
+ * La machine d'une instance. `audit` (AuditSink de statemachine) est celui de l'application quand elle en
+ * fournit un ; sinon la machine garde son journal en mémoire.
+ */
+export function creerCycle({ audit, maintenant }) {
+  return defineMachine({
+    states: [{ id: 'en_service', initial: true }, { id: 'immobilise' }, { id: 'a_l_atelier' }, { id: 'reforme', terminal: true }],
+    transitions: TRANSITIONS.map(({ id, from, to, guard }) => (guard ? { id, from, to, guard } : { id, from, to })),
+  }, { ...(audit ? { audit } : {}), now: () => new Date(`${maintenant()}T00:00:00Z`) });
+}

package/src/declarations.js

@@ -0,0 +1,65 @@
+// @mostajs/flotte — validation des déclarations de l'application : types, échéances, motifs d'immatriculation.
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+//
+// Les déclarations sont des DONNÉES (R-K) : Guerway les tient dans son paramétrage. Une déclaration invalide
+// refuse la création de l'instance : mieux vaut ne pas démarrer que bloquer une tournée à tort.
+
+export const FORMES = Object.freeze(['nombre', 'booleen', 'texte']);
+
+export class ErreurFlotte extends Error {
+  /** @param {string} code  un code de LIBELLES.erreur ; @param {number} statut 400, 404, 409 ou 422 */
+  constructor(code, message, statut = 400) { super(message); this.name = 'ErreurFlotte'; this.code = code; this.statut = statut; }
+}
+export const refus = (code, message, statut = 400) => { throw new ErreurFlotte(code, message, statut); };
+
+const objet = (x) => x !== null && typeof x === 'object' && !Array.isArray(x);
+const decl = (message) => refus('DECLARATION', `flotte : déclaration invalide — ${message}`, 400);
+
+/** Valide et normalise les déclarations ; rend une copie figée. */
+export function validerDeclarations(d = {}) {
+  if (!objet(d)) decl('un objet est attendu');
+  const types = d.types ?? {};
+  if (!objet(types)) decl('types doit être un objet');
+  for (const [nom, t] of Object.entries(types)) {
+    if (!objet(t)) decl(`type ${nom} : un objet est attendu`);
+    if (t.categoriePermis !== undefined && typeof t.categoriePermis !== 'string') decl(`type ${nom} : categoriePermis doit être un texte`);
+    if (t.attributs !== undefined && !objet(t.attributs)) decl(`type ${nom} : attributs doit être un objet`);
+    for (const [a, forme] of Object.entries(t.attributs || {})) {
+      if (!FORMES.includes(forme)) decl(`type ${nom}, attribut ${a} : forme « ${forme} » inconnue (${FORMES.join(', ')})`);
+    }
+  }
+  const echeances = d.echeances ?? {};
+  if (!objet(echeances)) decl('echeances doit être un objet');
+  for (const [nom, e] of Object.entries(echeances)) {
+    if (!objet(e)) decl(`échéance ${nom} : un objet est attendu`);
+    if (!(Number.isInteger(e.periodiciteJours) && e.periodiciteJours > 0)) decl(`échéance ${nom} : periodiciteJours (entier > 0) requis`);
+    for (const b of ['bloquante', 'obligatoire']) if (e[b] !== undefined && typeof e[b] !== 'boolean') decl(`échéance ${nom} : ${b} doit être un booléen`);
+  }
+  const immatriculation = d.immatriculation ?? [];
+  if (!Array.isArray(immatriculation) || !immatriculation.every((m) => m instanceof RegExp)) {
+    decl('immatriculation doit être une liste de RegExp fournies par l’application (jamais construites depuis une saisie)');
+  }
+  for (const k of ['alerteJours', 'sautAnormalKmParJour']) {
+    if (d[k] !== undefined && !(Number.isFinite(d[k]) && d[k] > 0)) decl(`${k} doit être un nombre > 0`);
+  }
+  return Object.freeze({
+    types: structuredClone(types),
+    echeances: structuredClone(echeances),
+    immatriculation: [...immatriculation],
+    alerteJours: d.alerteJours ?? 30,
+    sautAnormalKmParJour: d.sautAnormalKmParJour ?? 2000,
+  });
+}
+
+/** Valide les attributs d'un véhicule selon son type ; rend une copie. */
+export function validerAttributs(declarations, type, attributs = {}) {
+  const t = declarations.types[type] || refus('TYPE', `type non déclaré : ${type}`, 400);
+  if (!objet(attributs)) refus('ATTRIBUT', 'attributs : un objet est attendu', 400);
+  for (const [a, v] of Object.entries(attributs)) {
+    const forme = t.attributs?.[a];
+    if (!forme) refus('ATTRIBUT', `attribut ${a} non déclaré pour le type ${type}`, 400);
+    const bon = forme === 'nombre' ? Number.isFinite(v) : forme === 'booleen' ? typeof v === 'boolean' : typeof v === 'string';
+    if (!bon) refus('ATTRIBUT', `attribut ${a} : ${forme} attendu`, 400);
+  }
+  return { ...attributs };
+}

package/src/flotte.js

@@ -0,0 +1,355 @@
+// @mostajs/flotte — le carnet du parc : registre, cycle, échéances, entretien, relevés, pleins, affectations, coût,
+// et la réponse « ce véhicule peut-il partir ? ».
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+//
+// NE FAIT PAS : suivre une position (→ geo-tracker), réserver (→ booking), déplacer billets ou colis (→ tournees),
+// tenir la personne du conducteur et ses permis (→ staff, par le PORT `habilitations`), envoyer une alerte
+// (→ notifications), ranger une pièce scannée (→ blob-store : on garde sa référence), numéroter (→ numbering, INJECTÉ).
+// Couche service PURE (R-A, R-L) : dépôts, déclarations, ports et horloge sont injectés.
+import { randomUUID } from 'node:crypto';
+import { ErreurFlotte, refus, validerDeclarations, validerAttributs } from './declarations.js';
+import { TRANSITIONS, creerCycle } from './cycle.js';
+import { CODES } from './libelles.js';
+import * as R from './regles.js';
+
+const TABLES = ['vehicules', 'echeances', 'plans', 'interventions', 'releves', 'pleins', 'affectations'];
+const jourDe = (x) => (x instanceof Date ? x.toISOString().slice(0, 10) : String(x).slice(0, 10));
+const texte = (x) => typeof x === 'string' && x.trim().length > 0;
+const exigerJour = (d, quoi) => { if (!R.estJour(d)) refus('DONNEE', `${quoi} : date AAAA-MM-JJ attendue`, 400); return d; };
+const exigerNombre = (n, quoi, { min = 0, strict = false } = {}) => {
+  if (!Number.isFinite(n) || (strict ? n <= min : n < min)) refus('DONNEE', `${quoi} : nombre ${strict ? '>' : '≥'} ${min} attendu`, 400);
+  return n;
+};
+const correspond = (motif, valeur) => new RegExp(motif.source, motif.flags.replace(/[gy]/g, '')).test(valeur);
+
+/**
+ * repositories : { vehicules, echeances, plans, interventions, releves, pleins, affectations } — chacun
+ *   { find(prédicat), create(doc), update(id, champs) } (data-plug en production, createMemoryRepositories en essai).
+ * declarations : { types, echeances, immatriculation, alerteJours?, sautAnormalKmParJour? } (plan §3.2).
+ * numeroter({ vehicule, nature, date }) → numéro d'intervention (injecté : @mostajs/numbering).
+ * habilitations : PORT facultatif { peutConduire(conducteur, categorie, date) → booléen } (@mostajs/staff).
+ * plusieursVehiculesParConducteur, exigerAffectation : options (faux par défaut).
+ * audit : AuditSink de @mostajs/statemachine, facultatif. maintenant() → 'AAAA-MM-JJ' ou Date.
+ */
+export function createFlotte({
+  repositories, declarations, numeroter, habilitations, audit,
+  plusieursVehiculesParConducteur = false, exigerAffectation = false,
+  maintenant = () => new Date(),
+} = {}) {
+  const D = validerDeclarations(declarations);
+  for (const t of TABLES) if (!repositories?.[t]) throw new Error(`flotte : repositories.${t} requis`);
+  if (typeof numeroter !== 'function') throw new Error('flotte : numeroter() requis (@mostajs/numbering)');
+  if (habilitations !== undefined && typeof habilitations?.peutConduire !== 'function') throw new Error('flotte : habilitations.peutConduire() requis');
+  const P = repositories;
+  const aujourdhui = () => jourDe(maintenant());
+  const cycle = creerCycle({ audit, maintenant: aujourdhui });
+
+  const abonnes = new Set();
+  const emettre = (type, d) => { for (const f of abonnes) { try { f(type, d); } catch (e) { console.error('[flotte] abonné :', e.message); } } };
+  const creer = async (table, doc) => { await P[table].create(doc); return structuredClone(doc); };
+  const maj = async (table, doc, champs) => { await P[table].update(doc.id, champs); return { ...doc, ...structuredClone(champs) }; };
+  const de = (table, vehicule) => P[table].find((x) => x.vehicule === vehicule);
+
+  async function lire(id) {
+    return (await P.vehicules.find((v) => v.id === id))[0] || refus('INCONNU', `véhicule inconnu : ${id}`, 404);
+  }
+  async function intervention(id) {
+    return (await P.interventions.find((i) => i.id === id))[0] || refus('INCONNU', `intervention inconnue : ${id}`, 404);
+  }
+  const releves = async (vehicule) => (await de('releves', vehicule)).sort((a, b) => (a.le < b.le ? -1 : a.le > b.le ? 1 : 0));
+  const ouvertes = async (vehicule) => (await de('interventions', vehicule)).filter((i) => !i.closeLe);
+  const courante = async (vehicule) => (await de('affectations', vehicule)).find((a) => !a.au) || null;
+
+  // ── Relevés : vérifier AVANT d'écrire quoi que ce soit (un plein refusé ne laisse pas de plein orphelin) ──
+  async function verifierReleve(vehicule, { km, le, correction }) {
+    exigerNombre(km, 'km'); exigerJour(le, 'le');
+    if (correction !== undefined) {
+      if (!texte(correction?.motif)) refus('MOTIF', 'une correction de compteur exige un motif', 400);
+      if (!texte(correction?.agent)) refus('DONNEE', 'une correction de compteur exige un agent', 400);
+      return [];
+    }
+    const tous = await releves(vehicule);
+    const avant = tous.filter((r) => r.le <= le).at(-1), apres = tous.find((r) => r.le > le);
+    if (avant && km < avant.km) refus('RECUL', `le compteur recule : ${km} km après ${avant.km} km`, 409);
+    if (apres && km > apres.km) refus('RECUL', `le compteur dépasse le relevé suivant : ${km} km avant ${apres.km} km`, 409);
+    if (avant) {
+      const j = Math.max(1, R.jours(avant.le, le)), n = km - avant.km;
+      if (n / j > D.sautAnormalKmParJour) return [{ code: 'SAUT_ANORMAL', n, jours: j }];
+    }
+    return [];
+  }
+  async function ecrireReleve(vehicule, { km, le, source, correction }, avertissements, agent) {
+    const r = await creer('releves', { id: randomUUID(), vehicule, km, le, source, correction: correction ? { motif: correction.motif, agent: correction.agent } : null, saisiPar: agent ?? null });
+    emettre('releve.saisi', { vehicule, releve: r.id, km, source });
+    return { ...r, avertissements };
+  }
+
+  async function transiter(v, transition, { motif, agent } = {}) {
+    const def = TRANSITIONS.find((t) => t.id === transition);
+    if (!def || !def.from.includes(v.statut)) refus('TRANSITION', `« ${transition} » est impossible depuis ${v.statut}`, 422);
+    if (def.motif && !texte(motif)) refus('MOTIF', `« ${transition} » exige un motif`, 400);
+    const data = { interventionsOuvertes: (await ouvertes(v.id)).length };
+    const ok = await cycle.canTransition(v.statut, def.to, { actorId: agent, data });
+    if (!ok.allowed) {
+      if (ok.reason === 'guard') refus('INTERVENTION_OUVERTE', 'une intervention est encore ouverte : la clore avant de remettre en service', 409);
+      refus('TRANSITION', `« ${transition} » refusée (${ok.reason})`, 422);
+    }
+    await cycle.transition({ entityType: 'vehicule', entityId: v.id }, v.statut, def.to, { actorId: agent, data, comment: motif ?? undefined });
+    // Le motif est écrit TEL QUEL : il est saisi par un agent, il ne se traduit pas.
+    const pas = { de: v.statut, vers: def.to, motif: def.motif ? motif : (texte(motif) ? motif : null), agent: agent ?? null, le: aujourdhui() };
+    const r = await maj('vehicules', v, { statut: def.to, historique: [...v.historique, pas] });
+    emettre('vehicule.statut', { vehicule: v.id, transition, ...pas });
+    return r;
+  }
+
+  /** Les prochains entretiens d'un véhicule, du plus urgent au moins urgent (sans date : en dernier). */
+  async function prochainsEntretiens(vehicule, { date } = {}) {
+    await lire(vehicule);
+    const jour = date ? exigerJour(date, 'date') : aujourdhui();
+    const tous = await releves(vehicule);
+    const km = R.dernierReleve(tous, jour)?.km, rythme = R.kmParJour(tous, jour);
+    return (await de('plans', vehicule)).map((p) => R.prochainEntretien(p, { km, date: jour, kmParJour: rythme }))
+      .sort((a, b) => (a.le === b.le ? 0 : a.le === null ? 1 : b.le === null ? -1 : a.le < b.le ? -1 : 1));
+  }
+
+  async function peutPartir(id, { date, conducteur, km } = {}) {
+    const v = await lire(id);
+    const jour = date ? exigerJour(date, 'date') : aujourdhui();
+    const kmActuel = Number.isFinite(km) ? km : R.dernierReleve(await releves(id), jour)?.km;
+    let habilitation;
+    if (conducteur && habilitations) {
+      habilitation = Boolean(await habilitations.peutConduire(conducteur, D.types[v.type]?.categoriePermis ?? null, jour));
+    }
+    return R.evaluerDepart({
+      vehicule: v, declarations: D, echeances: await de('echeances', id), plans: await de('plans', id), km: kmActuel, date: jour,
+      conducteur, affectation: await courante(id), exigerAffectation, habilitation,
+    });
+  }
+
+  return {
+    CODES,
+    onEvenement(f) { abonnes.add(f); return () => abonnes.delete(f); },
+    lire,
+
+    /** Inscrire un véhicule d'un type déclaré. */
+    async inscrire(d = {}, { agent } = {}) {
+      if (!texte(d.code)) refus('DONNEE', 'code requis', 400);
+      if (!texte(d.immatriculation)) refus('DONNEE', 'immatriculation requise', 400);
+      if (!texte(d.type)) refus('DONNEE', 'type requis', 400);
+      const attributs = validerAttributs(D, d.type, d.attributs);
+      const code = d.code.trim(), immatriculation = d.immatriculation.trim().toUpperCase();
+      if (D.immatriculation.length && !D.immatriculation.some((m) => correspond(m, immatriculation))) {
+        refus('IMMATRICULATION', `immatriculation hors des motifs déclarés : ${immatriculation}`, 400);
+      }
+      const mode = d.mode ?? 'propre';
+      if (!CODES.mode.includes(mode)) refus('DONNEE', `mode inconnu : ${mode}`, 400);
+      if ((await P.vehicules.find((v) => v.code === code || v.immatriculation === immatriculation)).length) {
+        refus('DOUBLON', `code ou immatriculation déjà pris : ${code} / ${immatriculation}`, 409);
+      }
+      const v = await creer('vehicules', {
+        id: randomUUID(), code, immatriculation, type: d.type, marque: d.marque ?? null, modele: d.modele ?? null, annee: d.annee ?? null,
+        couleur: d.couleur ?? null, energie: d.energie ?? null, attributs, site: d.site ?? null, detenteur: d.detenteur ?? null, mode,
+        acquisition: d.acquisition ?? null, statut: cycle.initial, historique: [], inscritLe: aujourdhui(), inscritPar: agent ?? null,
+      });
+      emettre('vehicule.inscrit', { vehicule: v.id, code, type: v.type });
+      return v;
+    },
+
+    /**
+     * La liste du parc, rangée par code : `statut` (un code ou une liste), `type`, `site`, et `q` cherché dans le code,
+     * la plaque, la marque et le modèle (sans casse ; espaces et tirets indifférents). Sans `statut`, les réformés
+     * n'y sont que si `reformes` est vrai.
+     */
+    async vehicules({ statut, type, site, q, reformes = false } = {}) {
+      const statuts = statut === undefined ? null : [statut].flat();
+      for (const s of statuts || []) if (!CODES.statut.includes(s)) refus('DONNEE', `statut inconnu : ${s}`, 400);
+      const plat = (s) => String(s ?? '').toLowerCase().replace(/[\s-]+/g, '');
+      const cherche = texte(q) ? plat(q) : null;
+      return (await P.vehicules.find((v) => (statuts ? statuts.includes(v.statut) : reformes || v.statut !== 'reforme')
+        && (!type || v.type === type) && (!site || v.site === site)
+        && (!cherche || [v.code, v.immatriculation, v.marque, v.modele].some((c) => plat(c).includes(cherche)))))
+        .sort((a, b) => (a.code < b.code ? -1 : a.code > b.code ? 1 : 0)).map((v) => structuredClone(v));
+    },
+
+    /** Passer une transition du cycle : immobiliser, atelier, remettre, reformer. */
+    async changerStatut(id, transition, ctx = {}) { return transiter(await lire(id), transition, ctx); },
+
+    // ── Échéances ──
+    async poserEcheance({ vehicule, type, debut, fin, piece, cout } = {}, { agent } = {}) {
+      await lire(vehicule);
+      const d = D.echeances[type] || refus('TYPE', `type d'échéance non déclaré : ${type}`, 400);
+      exigerJour(debut, 'debut');
+      const f = fin === undefined ? R.ajouterJours(debut, d.periodiciteJours) : exigerJour(fin, 'fin');
+      if (f <= debut) refus('DONNEE', 'la fin doit suivre le début', 400);
+      if (cout !== undefined) exigerNombre(cout, 'cout');
+      const e = await creer('echeances', { id: randomUUID(), vehicule, type, debut, fin: f, piece: piece ?? null, cout: cout ?? null, poseePar: agent ?? null, poseeLe: aujourdhui() });
+      emettre('echeance.posee', { vehicule, echeance: e.id, type, fin: f });
+      return e;
+    },
+    async echeances(vehicule) { await lire(vehicule); return de('echeances', vehicule); },
+    /** Les échéances qui font foi et finissent au plus tard dans `dans` jours (les expirées comprises). */
+    async aEcheance({ dans = D.alerteJours, date } = {}) {
+      const jour = date ? exigerJour(date, 'date') : aujourdhui(), limite = R.ajouterJours(jour, dans);
+      const sortie = [];
+      for (const v of await P.vehicules.find((x) => x.statut !== 'reforme')) {
+        const toutes = await de('echeances', v.id);
+        for (const type of new Set(toutes.map((e) => e.type))) {
+          const e = R.echeanceCourante(toutes, type);
+          if (e.fin <= limite) sortie.push({ id: e.id, vehicule: v.id, code: v.code, type, fin: e.fin, n: R.jours(jour, e.fin), expiree: e.fin < jour });
+        }
+      }
+      return sortie.sort((a, b) => (a.fin < b.fin ? -1 : a.fin > b.fin ? 1 : 0));
+    },
+
+    // ── Entretien ──
+    async planifierEntretien({ vehicule, libelle, tousLesKm, tousLesJours, toleranceKm = 0, toleranceJours = 0, dernierKm, dernierLe } = {}, { agent } = {}) {
+      await lire(vehicule);
+      if (!texte(libelle)) refus('DONNEE', 'libelle requis', 400);
+      if (!(tousLesKm > 0) && !(tousLesJours > 0)) refus('DONNEE', 'un plan exige un pas en km, en jours, ou les deux', 400);
+      for (const [n, q] of [[tousLesKm, 'tousLesKm'], [tousLesJours, 'tousLesJours']]) if (n !== undefined) exigerNombre(n, q, { strict: true });
+      exigerNombre(toleranceKm, 'toleranceKm'); exigerNombre(toleranceJours, 'toleranceJours');
+      const km = dernierKm ?? R.dernierReleve(await releves(vehicule))?.km ?? 0;
+      const p = await creer('plans', {
+        id: randomUUID(), vehicule, libelle: libelle.trim(), tousLesKm: tousLesKm ?? null, tousLesJours: tousLesJours ?? null, toleranceKm, toleranceJours,
+        dernierKm: exigerNombre(km, 'dernierKm'), dernierLe: dernierLe ? exigerJour(dernierLe, 'dernierLe') : aujourdhui(), creePar: agent ?? null,
+      });
+      emettre('entretien.planifie', { vehicule, plan: p.id });
+      return p;
+    },
+    async plans(vehicule) { await lire(vehicule); return de('plans', vehicule); },
+    prochainsEntretiens,
+    /** Le plus urgent des prochains entretiens, ou null sans plan (ECR-16.17 : « Prochain entretien »). */
+    async prochainEntretien(vehicule, opts = {}) { return (await prochainsEntretiens(vehicule, opts))[0] || null; },
+    /** Les plans dus ou dépassés à `date`, sur les véhicules non réformés. */
+    async entretiensDus({ date } = {}) {
+      const jour = date ? exigerJour(date, 'date') : aujourdhui();
+      const sortie = [];
+      for (const v of await P.vehicules.find((x) => x.statut !== 'reforme')) {
+        const km = R.dernierReleve(await releves(v.id), jour)?.km;
+        for (const p of await de('plans', v.id)) {
+          const s = R.etatEntretien(p, { km, date: jour });
+          if (s.etat === 'du' || s.etat === 'depasse') sortie.push({ plan: p.id, vehicule: v.id, code: v.code, libelle: p.libelle, ...s });
+        }
+      }
+      return sortie;
+    },
+
+    // ── Interventions ──
+    async ouvrirIntervention({ vehicule, nature, plan, description, prestataire, ouverteLe } = {}, { agent } = {}) {
+      const v = await lire(vehicule);
+      if (!CODES.nature.includes(nature)) refus('DONNEE', `nature inconnue : ${nature}`, 400);
+      if (v.statut === 'reforme') refus('TRANSITION', 'un véhicule réformé ne reçoit plus d’intervention', 422);
+      if (plan !== undefined && !(await de('plans', vehicule)).some((p) => p.id === plan)) refus('INCONNU', `plan inconnu pour ce véhicule : ${plan}`, 404);
+      const jour = ouverteLe ? exigerJour(ouverteLe, 'ouverteLe') : aujourdhui();   // une saisie a posteriori garde sa date
+      const i = await creer('interventions', {
+        id: randomUUID(), numero: await numeroter({ vehicule, nature, date: jour }), vehicule, nature, plan: plan ?? null, ouverteLe: jour, closeLe: null,
+        km: null, cout: null, prestataire: prestataire ?? null, description: description ?? '', ouvertePar: agent ?? null,
+      });
+      emettre('intervention.ouverte', { vehicule, intervention: i.id, numero: i.numero, nature });
+      // Une corrective arrête le véhicule : règle du service (MostaGare le faisait dans une route).
+      if (nature === 'corrective' && v.statut === 'en_service') await transiter(v, 'atelier', { agent });
+      return i;
+    },
+    async modifierIntervention(id, champs = {}, { agent } = {}) {
+      const i = await intervention(id);
+      if (i.closeLe) refus('CLOSE', `intervention ${i.numero} close : elle ne se modifie plus`, 409);
+      const permis = {};
+      for (const k of ['description', 'prestataire']) if (champs[k] !== undefined) permis[k] = champs[k];
+      if (champs.cout !== undefined) permis.cout = exigerNombre(champs.cout, 'cout');
+      const r = await maj('interventions', i, { ...permis, modifieePar: agent ?? null });
+      emettre('intervention.modifiee', { vehicule: i.vehicule, intervention: i.id });
+      return r;
+    },
+    /** Clore : recale le plan lié, et le kilométrage vaut relevé. */
+    async cloreIntervention(id, { km, cout, le } = {}, { agent } = {}) {
+      const i = await intervention(id);
+      if (i.closeLe) refus('CLOSE', `intervention ${i.numero} déjà close`, 409);
+      const jour = le ? exigerJour(le, 'le') : aujourdhui();
+      if (jour < i.ouverteLe) refus('DONNEE', 'la clôture précède l’ouverture', 400);
+      if (cout !== undefined) exigerNombre(cout, 'cout');
+      const avert = km !== undefined ? await verifierReleve(i.vehicule, { km, le: jour }) : [];
+      const r = await maj('interventions', i, { closeLe: jour, km: km ?? null, cout: cout ?? null, closePar: agent ?? null });
+      emettre('intervention.close', { vehicule: i.vehicule, intervention: i.id, numero: i.numero });
+      if (km !== undefined) await ecrireReleve(i.vehicule, { km, le: jour, source: 'intervention' }, avert, agent);
+      if (i.plan) {
+        const p = (await de('plans', i.vehicule)).find((x) => x.id === i.plan);
+        if (p) await maj('plans', p, { dernierKm: km ?? p.dernierKm, dernierLe: jour });
+      }
+      return r;
+    },
+    async interventions(vehicule) { await lire(vehicule); return de('interventions', vehicule); },
+
+    // ── Relevés et pleins ──
+    async relever(vehicule, { km, le, source = 'saisie', correction } = {}, { agent } = {}) {
+      await lire(vehicule);
+      if (!CODES.source.includes(source)) refus('DONNEE', `source inconnue : ${source}`, 400);
+      const jour = le ?? aujourdhui();
+      const avert = await verifierReleve(vehicule, { km, le: jour, correction });
+      return ecrireReleve(vehicule, { km, le: jour, source, correction }, avert, agent);
+    },
+    async releves(vehicule) { await lire(vehicule); return releves(vehicule); },
+    async saisirPlein({ vehicule, le, litres, montant, km, complet = false, carte } = {}, { agent } = {}) {
+      await lire(vehicule);
+      const jour = le ?? aujourdhui();
+      exigerNombre(litres, 'litres', { strict: true }); exigerNombre(montant, 'montant');
+      const avert = await verifierReleve(vehicule, { km, le: jour });
+      const p = await creer('pleins', { id: randomUUID(), vehicule, le: jour, litres, montant, km, complet: Boolean(complet), carte: carte ?? null, saisiPar: agent ?? null });
+      emettre('plein.saisi', { vehicule, plein: p.id, litres, montant });
+      const r = await ecrireReleve(vehicule, { km, le: jour, source: 'plein' }, avert, agent);
+      return { ...p, avertissements: r.avertissements };
+    },
+    async consommation(vehicule) { await lire(vehicule); return R.consommation(await de('pleins', vehicule)); },
+
+    // ── Affectations ──
+    async affecter(vehicule, conducteur, { agent } = {}) {
+      const v = await lire(vehicule);
+      if (!texte(conducteur)) refus('DONNEE', 'conducteur requis (identifiant opaque)', 400);
+      if (v.statut === 'reforme') refus('TRANSITION', 'un véhicule réformé ne s’affecte plus', 422);
+      const actuelle = await courante(vehicule);
+      if (actuelle?.conducteur === conducteur) return actuelle;
+      if (!plusieursVehiculesParConducteur) {
+        const ailleurs = (await P.affectations.find((a) => a.conducteur === conducteur && !a.au && a.vehicule !== vehicule))[0];
+        if (ailleurs) refus('CONDUCTEUR_OCCUPE', `le conducteur ${conducteur} tient déjà un autre véhicule`, 409);
+      }
+      const jour = aujourdhui();
+      if (actuelle) {
+        await maj('affectations', actuelle, { au: jour, closePar: agent ?? null });
+        emettre('affectation.fin', { vehicule, affectation: actuelle.id, conducteur: actuelle.conducteur });
+      }
+      const a = await creer('affectations', { id: randomUUID(), vehicule, conducteur, du: jour, au: null, parAgent: agent ?? null });
+      emettre('affectation.debut', { vehicule, affectation: a.id, conducteur });
+      return a;
+    },
+    async liberer(vehicule, { agent } = {}) {
+      await lire(vehicule);
+      const actuelle = await courante(vehicule);
+      if (!actuelle) return null;
+      const r = await maj('affectations', actuelle, { au: aujourdhui(), closePar: agent ?? null });
+      emettre('affectation.fin', { vehicule, affectation: actuelle.id, conducteur: actuelle.conducteur });
+      return r;
+    },
+    async affectations(vehicule) { await lire(vehicule); return (await de('affectations', vehicule)).sort((a, b) => (a.du < b.du ? -1 : a.du > b.du ? 1 : 0)); },
+    async affectationCourante(vehicule) { await lire(vehicule); return courante(vehicule); },
+
+    // ── Décisions ──
+    peutPartir,
+    /** Les véhicules aptes à `date`, d'un type, avec des attributs minimaux (nombre : au moins ; sinon : égal). */
+    async disponibles({ date, type, attributs = {} } = {}) {
+      const jour = date ? exigerJour(date, 'date') : aujourdhui();
+      const sortie = [];
+      for (const v of await P.vehicules.find((x) => x.statut !== 'reforme' && (!type || x.type === type))) {
+        const assez = Object.entries(attributs).every(([k, min]) => (typeof min === 'number' ? v.attributs?.[k] >= min : v.attributs?.[k] === min));
+        if (assez && (await peutPartir(v.id, { date: jour })).ok) sortie.push(v);
+      }
+      return sortie.sort((a, b) => (a.code < b.code ? -1 : a.code > b.code ? 1 : 0));
+    },
+    async cout(vehicule, { du, au } = {}) {
+      await lire(vehicule);
+      exigerJour(du, 'du'); exigerJour(au, 'au');
+      if (au < du) refus('DONNEE', 'la période finit avant de commencer', 400);
+      return R.cout({ pleins: await de('pleins', vehicule), interventions: await de('interventions', vehicule), echeances: await de('echeances', vehicule), releves: await releves(vehicule), du, au });
+    },
+  };
+}
+
+export { ErreurFlotte };

package/src/index.js

@@ -0,0 +1,15 @@
+// @mostajs/flotte — point d'entrée. Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+import { CODES } from './libelles.js';
+export { createFlotte, ErreurFlotte } from './flotte.js';
+export { createMemoryRepositories } from './memoire.js';
+export { CODES, LIBELLES, libelle } from './libelles.js';
+export { register, SCHEMAS } from './schemas.js';
+export { validerDeclarations, FORMES } from './declarations.js';
+export * as regles from './regles.js';
+export const STATUTS = CODES.statut;
+export const MOTIFS = CODES.motif;
+/** Les permissions, au format domaine:action (§10 #5) : le module les nomme, rbac-tenant les vérifie. */
+export const PERMISSIONS = Object.freeze([
+  'flotte:vehicules:inscrire', 'flotte:vehicules:statut', 'flotte:vehicules:reformer', 'flotte:echeances:gerer',
+  'flotte:entretien:saisir', 'flotte:carburant:saisir', 'flotte:affectations:gerer', 'flotte:couts:lire',
+]);

package/src/libelles.js

@@ -0,0 +1,69 @@
+// @mostajs/flotte — les codes de tout ce qui s'affiche, et leur libellé français canonique.
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+//
+// Règle des libellés d'un module (mosta-i18n, méthode §7) : le module POSSÈDE les codes et le libellé canonique ;
+// la langue d'affichage appartient à l'application. Guerway traduit la clé `flotte.<famille>.<code>` dans ses
+// sept catalogues ; sans traduction, le libellé ci-dessous s'affiche. Les codes sont une API publique (SemVer).
+
+export const LIBELLES = Object.freeze({
+  statut: { en_service: 'En service', immobilise: 'Immobilisé', a_l_atelier: 'À l’atelier', reforme: 'Réformé' },
+  transition: { immobiliser: 'Immobiliser', atelier: 'Envoyer à l’atelier', remettre: 'Remettre en service', reformer: 'Réformer' },
+  motif: {
+    STATUT: 'Le véhicule n’est pas en service ({statut})',
+    ECHEANCE_ABSENTE: 'Échéance absente : {type}',
+    ECHEANCE_EXPIREE: 'Échéance expirée : {type}, le {date}',
+    ENTRETIEN_DEPASSE: 'Entretien « {plan} » dépassé de {n} {unite}',
+    CONDUCTEUR: 'Le conducteur {conducteur} n’est pas affecté à ce véhicule',
+    HABILITATION: 'Le conducteur {conducteur} n’est pas habilité (catégorie {categorie})',
+  },
+  avertissement: {
+    ECHEANCE_PROCHE: 'Échéance proche : {type}, le {date}, dans {n} jours',
+    ENTRETIEN_PROCHE: 'Entretien « {plan} » dû dans {n} {unite}',
+    ENTRETIEN_DU: 'Entretien « {plan} » dû depuis {n} {unite}, dans la tolérance',
+    SAUT_ANORMAL: 'Saut anormal du compteur : {n} km en {jours} jours',
+  },
+  erreur: {
+    DECLARATION: 'Déclaration invalide',
+    DONNEE: 'Donnée invalide',
+    TYPE: 'Type non déclaré',
+    ATTRIBUT: 'Attribut invalide pour ce type',
+    IMMATRICULATION: 'Immatriculation hors des motifs déclarés',
+    DOUBLON: 'Code ou immatriculation déjà pris',
+    INCONNU: 'Élément inconnu',
+    MOTIF: 'Motif requis',
+    TRANSITION: 'Changement d’état refusé',
+    INTERVENTION_OUVERTE: 'Une intervention est encore ouverte',
+    CLOSE: 'Intervention close : elle ne se modifie plus',
+    RECUL: 'Le compteur recule',
+    CONDUCTEUR_OCCUPE: 'Le conducteur tient déjà un autre véhicule',
+  },
+  nature: { preventive: 'Préventive', corrective: 'Corrective', inspection: 'Inspection' },
+  source: { saisie: 'Saisie', plein: 'Plein', intervention: 'Intervention', gps: 'GPS', constructeur: 'Constructeur' },
+  mode: { propre: 'En propre', location: 'En location', sous_traitant: 'Sous-traitant' },
+  unite: { km: 'km', jours: 'jours' },
+  poste: { carburant: 'Carburant', entretien: 'Entretien', echeances: 'Échéances', amortissement: 'Amortissement', sinistres: 'Sinistres', pieces_hors_intervention: 'Pièces hors intervention' },
+});
+
+/** Les codes de chaque famille, dans l'ordre des libellés. */
+export const CODES = Object.freeze(Object.fromEntries(Object.entries(LIBELLES).map(([f, l]) => [f, Object.freeze(Object.keys(l))])));
+
+const remplir = (texte, vars) => texte.replace(/\{(\w+)\}/g, (m, k) => (vars && vars[k] !== undefined && vars[k] !== null ? String(vars[k]) : m));
+
+/**
+ * Le libellé à afficher. `t` est la fonction de traduction de la requête (Guerway : `t(cle, vars)`) ; si elle ne
+ * connaît pas la clé (elle rend la clé nue, ou rien), on se replie sur le libellé du module. Une FONCTION, appelée
+ * dans la requête : jamais une constante évaluée hors contexte de langue.
+ * @param {string} famille  statut, transition, motif, avertissement, erreur, nature, source, mode, unite, poste
+ * @param {string} code
+ * @param {(cle: string, vars?: object) => string} [t]
+ * @param {object} [vars]   les valeurs d'un motif ou d'un avertissement ({ plan, n, unite… })
+ */
+export function libelle(famille, code, t, vars) {
+  const cle = `flotte.${famille}.${code}`;
+  if (typeof t === 'function') {
+    const tr = t(cle, vars);
+    if (typeof tr === 'string' && tr && tr !== cle) return tr;
+  }
+  const canon = LIBELLES[famille]?.[code];
+  return canon === undefined ? code : remplir(canon, vars);
+}

package/src/memoire.js

@@ -0,0 +1,16 @@
+// @mostajs/flotte — dépôts en mémoire, pour les essais et la démonstration (en production : data-plug, §10.bis).
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+const TABLES = ['vehicules', 'echeances', 'plans', 'interventions', 'releves', 'pleins', 'affectations'];
+
+/** Un dépôt par table : { find(prédicat), create(doc), update(id, champs) }, copies à l'entrée et à la sortie. */
+export function createMemoryRepositories() {
+  const depot = () => {
+    const m = new Map();
+    return {
+      async create(d) { m.set(d.id, structuredClone(d)); return structuredClone(d); },
+      async update(id, p) { if (!m.has(id)) throw new Error(`flotte (mémoire) : ${id} inconnu`); Object.assign(m.get(id), structuredClone(p)); return structuredClone(m.get(id)); },
+      async find(f = () => true) { return [...m.values()].map((r) => structuredClone(r)).filter(f); },
+    };
+  };
+  return Object.fromEntries(TABLES.map((t) => [t, depot()]));
+}

package/src/regles.js

@@ -0,0 +1,157 @@
+// @mostajs/flotte — le cœur PUR : des valeurs en entrée, une réponse en sortie, aucun dépôt, aucune horloge.
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+//
+// Les dates sont des jours 'AAAA-MM-JJ'. Motifs et avertissements sont des OBJETS { code, … } : la phrase
+// appartient au catalogue de l'application (libelles.js), jamais au calcul.
+
+const JOUR = 86_400_000;
+const t0 = (d) => Date.parse(`${d}T00:00:00Z`);
+/** Nombre de jours de `a` à `b` (négatif si `b` précède `a`). */
+export const jours = (a, b) => Math.round((t0(b) - t0(a)) / JOUR);
+export const ajouterJours = (d, n) => new Date(t0(d) + n * JOUR).toISOString().slice(0, 10);
+export const estJour = (d) => typeof d === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(d) && !Number.isNaN(t0(d)) && ajouterJours(d, 0) === d;
+const arrondi = (x) => Math.round(x * 100) / 100;
+const parDate = (a, b) => (a.le < b.le ? -1 : a.le > b.le ? 1 : 0);   // stable : l'ordre d'entrée départage
+
+const RANG = { ok: 0, proche: 1, du: 2, depasse: 3 };
+function selonPas(pas, tolerance, ecart) {   // ecart = valeur atteinte − échéance du pas
+  if (ecart > tolerance) return { etat: 'depasse', n: ecart };
+  if (ecart >= 0) return { etat: 'du', n: ecart };
+  if (-ecart <= pas * 0.1) return { etat: 'proche', n: -ecart };
+  return { etat: 'ok', n: -ecart };
+}
+
+/**
+ * L'état d'un plan d'entretien : dû au PREMIER atteint du kilométrage ou de la date.
+ * `proche` : moins de 10 % du pas avant l'échéance ; `du` : échéance passée, dans la tolérance ;
+ * `depasse` : au-delà de la tolérance. À gravité égale, le kilométrage l'emporte.
+ * @returns {{ etat: 'ok'|'proche'|'du'|'depasse', unite?: 'km'|'jours', n?: number }}
+ */
+export function etatEntretien(plan, { km, date }) {
+  const cands = [];
+  if (plan.tousLesKm > 0 && Number.isFinite(km)) {
+    cands.push({ unite: 'km', ...selonPas(plan.tousLesKm, plan.toleranceKm || 0, km - ((plan.dernierKm || 0) + plan.tousLesKm)) });
+  }
+  if (plan.tousLesJours > 0 && plan.dernierLe && date) {
+    cands.push({ unite: 'jours', ...selonPas(plan.tousLesJours, plan.toleranceJours || 0, jours(plan.dernierLe, date) - plan.tousLesJours) });
+  }
+  const pire = cands.reduce((m, c) => (!m || RANG[c.etat] > RANG[m.etat] ? c : m), null);
+  if (!pire || pire.etat === 'ok') return { etat: 'ok' };
+  return { etat: pire.etat, unite: pire.unite, n: pire.n };
+}
+
+/**
+ * Le rythme du véhicule, en km par jour, mesuré sur les relevés des `fenetre` derniers jours avant `date`.
+ * Null sans deux relevés de dates différentes, ou si le compteur n'a pas avancé.
+ */
+export function kmParJour(releves, date, fenetre = 90) {
+  const debut = ajouterJours(date, -fenetre);
+  const dans = [...releves].sort(parDate).filter((r) => r.le >= debut && r.le <= date);
+  if (dans.length < 2) return null;
+  const a = dans[0], b = dans.at(-1), j = jours(a.le, b.le);
+  return j > 0 && b.km > a.km ? arrondi((b.km - a.km) / j) : null;
+}
+
+/**
+ * Le PROCHAIN entretien d'un plan : l'échéance de chaque pas (km, jours), et la date du premier atteint. Un pas en
+ * km devient une date au rythme relevé (`kmParJour`) : la date est alors ESTIMÉE. Sans rythme, un plan au km seul
+ * n'a pas de date (`le: null`), seulement ses km restants. `dans` est négatif quand l'échéance est passée.
+ */
+export function prochainEntretien(plan, { km, date, kmParJour: rythme = null }) {
+  const etat = etatEntretien(plan, { km, date });
+  const parKm = plan.tousLesKm > 0 && Number.isFinite(km)
+    ? { echeance: (plan.dernierKm || 0) + plan.tousLesKm, restant: (plan.dernierKm || 0) + plan.tousLesKm - km } : null;
+  const parJours = plan.tousLesJours > 0 && plan.dernierLe
+    ? { echeance: ajouterJours(plan.dernierLe, plan.tousLesJours), restant: jours(date, ajouterJours(plan.dernierLe, plan.tousLesJours)) } : null;
+  const leKm = parKm && rythme > 0 ? ajouterJours(date, Math.ceil(parKm.restant / rythme)) : null;
+  const le = [leKm, parJours?.echeance].filter(Boolean).sort()[0] || null;
+  return { plan: plan.id, libelle: plan.libelle, ...etat, km: parKm, jours: parJours, le, dans: le ? jours(date, le) : null, estime: Boolean(le && le === leKm && le !== parJours?.echeance) };
+}
+
+/** L'échéance qui fait foi pour un type : la plus récente par début (à début égal, la dernière posée). */
+export function echeanceCourante(echeances, type) {
+  return echeances.filter((e) => e.type === type).sort((a, b) => (a.debut < b.debut ? -1 : a.debut > b.debut ? 1 : 0)).at(-1) || null;
+}
+
+/** Le dernier relevé au plus tard à `date` (tous si `date` est absente). */
+export function dernierReleve(releves, date) {
+  return [...releves].sort(parDate).filter((r) => !date || r.le <= date).at(-1) || null;
+}
+
+/**
+ * La consommation, mesurée entre deux pleins COMPLETS : les litres des pleins qui suivent le premier, jusqu'au
+ * second inclus, sur les kilomètres parcourus entre les deux. Un plein partiel seul ne mesure rien.
+ */
+export function consommation(pleins) {
+  const tries = [...pleins].sort((a, b) => a.km - b.km);
+  const mesures = [];
+  let depart = null, litres = 0;
+  for (const p of tries) {
+    if (depart) litres += p.litres;
+    if (p.complet) {
+      if (depart && p.km > depart.km) {
+        const km = p.km - depart.km;
+        mesures.push({ du: depart.km, au: p.km, litres: arrondi(litres), km, lPour100Km: arrondi((litres / km) * 100) });
+      }
+      depart = p; litres = 0;
+    }
+  }
+  const L = mesures.reduce((s, m) => s + m.litres, 0), K = mesures.reduce((s, m) => s + m.km, 0);
+  return { lPour100Km: K > 0 ? arrondi((L / K) * 100) : null, mesures };
+}
+
+/**
+ * « Ce véhicule peut-il partir ? » : TOUS les motifs bloquants, et les avertissements.
+ * L'habilitation est résolue avant (le port est asynchrone) et arrive ici en valeur : `habilitation` vaut
+ * `true`, `false`, ou `undefined` quand elle n'est pas vérifiée.
+ */
+export function evaluerDepart({ vehicule, declarations, echeances, plans, km, date, conducteur, affectation, exigerAffectation, habilitation }) {
+  const motifs = [], avertissements = [];
+  if (vehicule.statut !== 'en_service') motifs.push({ code: 'STATUT', statut: vehicule.statut });
+  for (const [type, d] of Object.entries(declarations.echeances || {})) {
+    const e = echeanceCourante(echeances, type);
+    if (!e) { if (d.obligatoire) motifs.push({ code: 'ECHEANCE_ABSENTE', type }); continue; }
+    if (!d.bloquante) continue;
+    if (e.fin < date) motifs.push({ code: 'ECHEANCE_EXPIREE', type, date: e.fin });
+    else if (jours(date, e.fin) < (declarations.alerteJours ?? 30)) avertissements.push({ code: 'ECHEANCE_PROCHE', type, date: e.fin, n: jours(date, e.fin) });
+  }
+  for (const p of plans) {
+    const s = etatEntretien(p, { km, date });
+    if (s.etat === 'depasse') motifs.push({ code: 'ENTRETIEN_DEPASSE', plan: p.libelle, n: s.n, unite: s.unite });
+    else if (s.etat === 'du') avertissements.push({ code: 'ENTRETIEN_DU', plan: p.libelle, n: s.n, unite: s.unite });
+    else if (s.etat === 'proche') avertissements.push({ code: 'ENTRETIEN_PROCHE', plan: p.libelle, n: s.n, unite: s.unite });
+  }
+  if (conducteur && exigerAffectation && affectation?.conducteur !== conducteur) motifs.push({ code: 'CONDUCTEUR', conducteur });
+  if (conducteur && habilitation === false) {
+    motifs.push({ code: 'HABILITATION', conducteur, categorie: declarations.types?.[vehicule.type]?.categoriePermis ?? null });
+  }
+  return { ok: motifs.length === 0, motifs, avertissements };
+}
+
+/** Les postes que `cout` ne compte pas en 0.1.0 : le coût ne se lit pas comme complet. */
+export const NON_COMPTES = Object.freeze(['amortissement', 'sinistres', 'pieces_hors_intervention']);
+
+/**
+ * Le coût d'un véhicule sur [du, au] : carburant et entretien de la période, échéances au prorata de leur
+ * recouvrement avec la période, kilomètres entre le dernier relevé ≤ du (ou le premier de la période) et le
+ * dernier relevé ≤ au.
+ */
+export function cout({ pleins, interventions, echeances, releves, du, au }) {
+  const dans = (d) => d && d >= du && d <= au;
+  const carburant = pleins.filter((p) => dans(p.le)).reduce((s, p) => s + (p.montant || 0), 0);
+  const entretien = interventions.filter((i) => dans(i.closeLe)).reduce((s, i) => s + (i.cout || 0), 0);
+  let ech = 0;
+  for (const e of echeances) {
+    if (!e.cout) continue;
+    const duree = jours(e.debut, e.fin);
+    const recouvre = jours(e.debut > du ? e.debut : du, e.fin < au ? e.fin : au);
+    if (duree > 0 && recouvre > 0) ech += (e.cout * recouvre) / duree;
+  }
+  const echeancesPeriode = arrondi(ech);
+  const tries = [...releves].sort(parDate);
+  const fin = tries.filter((r) => r.le <= au).at(-1);
+  const debut = tries.filter((r) => r.le <= du).at(-1) || tries.find((r) => dans(r.le));
+  const km = fin && debut ? Math.max(0, fin.km - debut.km) : 0;
+  const total = arrondi(carburant + entretien + echeancesPeriode);
+  return { du, au, carburant, entretien, echeances: echeancesPeriode, total, km, parKm: km > 0 ? total / km : null, nonComptes: [...NON_COMPTES] };
+}

package/src/schemas.js

@@ -0,0 +1,37 @@
+// @mostajs/flotte — les sept tables, déclarées au socle par register (R-P). Author: Dr Hamid MADANI <drmdh@msn.com>
+const s = (name, collection, fields, indexes = []) => ({ name, collection, timestamps: false, relations: {}, fields, indexes });
+const T = { type: 'string' }, TR = { type: 'string', required: true }, N = { type: 'number' }, NR = { type: 'number', required: true }, J = { type: 'json' }, B = { type: 'boolean' };
+
+export const VehiculeSchema = s('Vehicule', 'flotte_vehicules', {
+  code: { ...TR, unique: true }, immatriculation: { ...TR, unique: true }, type: TR, marque: T, modele: T, annee: N, couleur: T, energie: T,
+  attributs: J, site: T, detenteur: T, mode: TR, acquisition: J, statut: TR, historique: J, inscritLe: T, inscritPar: T,
+}, [{ fields: { code: 'asc' }, unique: true }, { fields: { immatriculation: 'asc' }, unique: true }, { fields: { statut: 'asc', type: 'asc' } }]);
+export const EcheanceSchema = s('Echeance', 'flotte_echeances', {
+  vehicule: TR, type: TR, debut: TR, fin: TR, piece: T, cout: N, poseePar: T, poseeLe: T,
+}, [{ fields: { vehicule: 'asc', type: 'asc' } }, { fields: { fin: 'asc' } }]);
+export const PlanEntretienSchema = s('PlanEntretien', 'flotte_plans', {
+  vehicule: TR, libelle: TR, tousLesKm: N, tousLesJours: N, toleranceKm: N, toleranceJours: N, dernierKm: N, dernierLe: T, creePar: T,
+}, [{ fields: { vehicule: 'asc' } }]);
+export const InterventionSchema = s('Intervention', 'flotte_interventions', {
+  numero: { ...TR, unique: true }, vehicule: TR, nature: TR, plan: T, ouverteLe: TR, closeLe: T, km: N, cout: N, prestataire: T, description: T,
+  ouvertePar: T, closePar: T, modifieePar: T,
+}, [{ fields: { numero: 'asc' }, unique: true }, { fields: { vehicule: 'asc', closeLe: 'asc' } }]);
+export const ReleveCompteurSchema = s('ReleveCompteur', 'flotte_releves', {
+  vehicule: TR, km: NR, le: TR, source: TR, correction: J, saisiPar: T,
+}, [{ fields: { vehicule: 'asc', le: 'asc' } }]);
+export const PleinSchema = s('Plein', 'flotte_pleins', {
+  vehicule: TR, le: TR, litres: NR, montant: NR, km: NR, complet: B, carte: T, saisiPar: T,
+}, [{ fields: { vehicule: 'asc', le: 'asc' } }]);
+export const AffectationSchema = s('Affectation', 'flotte_affectations', {
+  vehicule: TR, conducteur: TR, du: TR, au: T, parAgent: T, closePar: T,
+}, [{ fields: { vehicule: 'asc', au: 'asc' } }, { fields: { conducteur: 'asc', au: 'asc' } }]);
+
+export const SCHEMAS = Object.freeze([VehiculeSchema, EcheanceSchema, PlanEntretienSchema, InterventionSchema, ReleveCompteurSchema, PleinSchema, AffectationSchema]);
+
+export function register(registry) {
+  registry.register({
+    manifest: { name: 'flotte', package: '@mostajs/flotte', version: '0.2.0', type: 'business', priority: 45, displayName: 'Flotte (carnet du parc)',
+      description: 'Registre des véhicules, cycle, échéances, entretien, relevés, pleins, affectations, coût au km, peutPartir.', register: './src/schemas.js' },
+    schemas: SCHEMAS.map((x) => ({ name: x.name, schema: x })),
+  });
+}