@mostajs/allocations 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog — @mostajs/allocations
+
+Format : Keep a Changelog · SemVer.
+
+## [0.1.0] — 2026-06-18
+### Added
+- Schémas `Unit`/`Allocation`/`AllocationEvent` (EntitySchema @mostajs/orm), généralisés du casier SecuAccessPro.
+- `createAllocations()` : `units` (create/list/findAvailable/maintenance/retire), `alloc` (assign/release/renew/markOverdue/findByHolder/history/countByStatus). `guard` d'éligibilité + hook `onEvent`.
+- `createMemoryRepositories()` ; profils `allocationsProfile()` (locker/bike/gare-locker/gym-locker/book-loan/rental).
+- Exemples §12 exécutables : **velos**, **casiers-gare**, **casiers-salle-sport**, **showcase-3-modules** (+ tests `test-scripts/unit`, 10 verts).
+
+### Notes
+- Détenteur = `@mostajs/users` (holderId). Compose `booking`/`payment`/`subscriptions-plan`/`notifications` (injectés).
+- Extraction depuis `SolutionCh/SecuAccessPro` (locker.schema/locker-event.schema/locker.repository).

package/README.md

@@ -0,0 +1,29 @@
+# @mostajs/allocations
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Licence** : AGPL-3.0-or-later
+**Statut** : 0.1.0 (extraction exécutable — exemples §12 verts)
+
+> Unités **assignables** à un détenteur (état occupé/libre + historique) — **générique** : casiers, prêts de livres,
+> locations. Détenteur = **`@mostajs/users`**. Généralisé du module casier de `SecuAccessPro`.
+
+## Install / Exemple minimal
+```js
+import { createAllocations, createMemoryRepositories, allocationsProfile } from '@mostajs/allocations';
+const a = createAllocations({ repositories: createMemoryRepositories() });
+const u = await a.units.create({ code: 'V-07', group: 'Vestiaire', resourceType: allocationsProfile('gym-locker').resourceType });
+await a.alloc.assign(u.id, memberId);     // occupe
+await a.alloc.release(u.id);              // libère
+```
+
+## Exemples (`examples/`, exécutables)
+- `velos/` — vélo-partage (compose payment/booking)
+- `casiers-gare/` — consigne Gare (QR + échéance + notifications)
+- `casiers-salle-sport/` — vestiaire gym (guard abonnement)
+- `showcase-3-modules/` — **users + users-ui + allocations** ensemble
+
+```bash
+node examples/casiers-salle-sport/run.mjs
+node test-scripts/unit/allocations.test.mjs
+```
+
+API & types : voir `llms.txt`. Plan/audit : `docs/`.

package/docs/00-AUDIT-EXTRACTION-ALLOCATIONS-18062026.md

@@ -0,0 +1,94 @@
+# 00 — Audit d'extraction & proposition (cas C §4) — `@mostajs/allocations`
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com>
+**Date** : 2026-06-18
+**Statut** : **proposition à discuter** (audit §9 #2 + proposition §4 — précède le scaffold).
+**Principe** : **EXTRACTION de l'existant — NE PAS redévelopper.** Généralisation du module **casiers** de `SecuAccessPro`.
+**Source** : `SolutionCh/SecuAccessPro` — `locker.schema.ts`, `locker-event.schema.ts`, `locker.repository.ts`, `locker-event.repository.ts`.
+**Nom proposé** : `@mostajs/allocations` *(alternatives à valider : `lending`, `assignables`, `lockers`-generic — cf. §8)*.
+
+> Besoin exprimé : « gestion des **casiers** d'une façon **générique** pour servir à la gestion d'autre chose :
+> des **livres** (prêts), des **locations**, … ». → un module générique d'**unités assignables à un détenteur**.
+
+---
+
+## 1. Audit de l'existant (SecuAccessPro — modèle « casier »)
+
+Modèle **déjà `@mostajs/orm`-natif**, propre et générique dans sa forme :
+- **Locker** : `number, zone(A/B/C), status(available|occupied|maintenance|out_of_order), rfidLockId, lastAssignedAt` + relations `currentClient`, `currentTag`.
+- **LockerEvent** : `eventType(assigned|released|tag_lost|maintenance_start|maintenance_end), notes, timestamp` + relations `locker, client, rfidTag, performedBy`.
+- **LockerRepository** : `findAllWithOccupants`, `findByClient`, `countOccupied/Total`, `assign(id, clientId, tagId)`, `release(id)`, `setMaintenance/endMaintenance`.
+
+**Constat** : c'est **déjà** le patron générique « **unité ↔ détenteur + cycle d'état + historique d'événements** ». Seuls les noms (`Locker`, `zone`, `currentClient`, `rfidLockId`) sont spécifiques. → **généraliser**, pas réécrire.
+
+---
+
+## 2. Application de la règle d'or (§0)
+
+| Proche | Couvre | Ne couvre PAS |
+|---|---|---|
+| `@mostajs/booking-stack` | **créneaux/agenda/réservation** (temps) | l'**unité physique ↔ détenteur**, l'état occupé/libre **persistant**, l'historique d'affectation |
+| `@mostajs/secu` | contrôle d'accès (clients, badges, **casiers spécifiques**) | une gestion **générique** d'unités réutilisable hors accès (livres, locations) |
+| `@mostajs/subscriptions-plan` | abonnement/facturation | l'affectation d'une unité concrète |
+
+→ **cas A/B écartés** (aucun ne porte l'unité assignable générique) → **cas C**. (Et `secu` **consommera** `allocations` pour ses casiers — extraction propre.)
+
+**Frontière** : `booking` = *quand* (créneau) ; `allocations` = *quelle unité, à qui, dans quel état*. Une **location** compose les deux (booking pour la période + allocations pour l'unité + `payment` pour le prix). Un **prêt de livre** = allocations + `dueAt` + `notifications` (rappel).
+
+---
+
+## 3. Périmètre `@mostajs/allocations` (généralisation)
+
+| Entité | Champs (généralisés depuis Locker/LockerEvent) | Rôle |
+|---|---|---|
+| **Unit** | `code, group?(ex-zone), resourceType(locker\|book\|rental\|…), status(available\|assigned\|maintenance\|retired), lastAssignedAt, externalRef?(ex-rfidLockId), meta?` + rel `currentHolder?(User)` | l'unité assignable |
+| **Allocation** *(état courant)* | `unitId, holderId(User), since, dueAt?, status(active\|returned\|overdue), price?` | l'affectation en cours (prêt/location/occupation) |
+| **AllocationEvent** *(historique)* | `unitId, holderId?, action(assigned\|released\|renewed\|overdue\|maintenance_*), at, performedBy(User), notes` | journal immuable |
+
+> **Détenteur = `@mostajs/users`** (ou une entité **dérivée** de `User` : Client, Élève, Patient…) — réutilise le socle personne (`currentClient`→`currentHolder:User`).
+
+**API (extraite/généralisée)** : `createAllocations({repositories, users?, booking?, payment?, now?})` → `units.{create,list,findAvailable(group?),setMaintenance,retire}`, `alloc.{assign(unitId,holderId,{dueAt?,price?}), release(unitId), renew(unitId,dueAt)}`, `alloc.{findByHolder, history(unitId), countByStatus}`. *(← `assign/release/findByClient/countOccupied/findAllWithOccupants`)*.
+
+**Composition (§10)** : `repository`/`orm` (persistance) · **`users`** (détenteur) · `booking-stack` (période de location) · `payment`/`subscriptions-plan` (prix/abonnement) · `notifications` (rappels d'échéance) · `audit` (traçabilité). **Profils** d'usage livrés : `locker`, `book-loan`, `rental`.
+
+---
+
+## 4. Carte d'extraction (source → cible — *lift/adapt/generalize*)
+
+| # | Source SecuAccessPro | Cible `mosta-allocations/` | Action |
+|---|---|---|---|
+| A1 | `locker.schema.ts` | `src/schemas/unit.schema.ts` | **GENERALIZE** : `number`→`code`, `zone`→`group`, +`resourceType`, `currentClient`→`currentHolder:User`, `rfidLockId`→`externalRef` |
+| A2 | `locker-event.schema.ts` | `src/schemas/allocation-event.schema.ts` | **ADAPT** : `client`→`holder:User` ; +actions `renewed/overdue` |
+| A3 | *(nouveau, mince)* état courant | `src/schemas/allocation.schema.ts` | **ADD** (dérivé du couple status+lastAssignedAt + `dueAt/price`) |
+| A4 | `locker.repository.ts` (`assign/release/findAvailable/count`) | `src/repositories/allocations.repository.ts` | **LIFT** + renommer générique + `renew`/`overdue` |
+| A5 | profils concrets | `src/profiles/{locker,book-loan,rental}.ts` | **ADD** (presets de `resourceType` + champs meta) |
+
+> Aucune ligne « réécrire de zéro » : tout est **GENERALIZE/ADAPT/LIFT** depuis le code casier éprouvé.
+
+## 5. Versions (jalons)
+| Version | Contenu | Extraction |
+|---|---|---|
+| 0.1.0 | `Unit` + `AllocationEvent` + repo (`assign/release/findAvailable`) + repos mémoire + profil `locker` | A1,A2,A4 |
+| 0.2.0 | `Allocation` (dueAt/status) + `renew/overdue` + profil `book-loan` (compose `notifications`) | A3,A5 |
+| 0.3.0 | profil `rental` (compose `booking-stack`+`payment`) + adaptateurs `@mostajs/repository` | A5 |
+| 1.0.0 | 14 livrables §9 + portes §11 + exemple §12 + article #17 + **migration SecuAccessPro `secu`→`allocations`** | — |
+
+## 6. Réutilisabilité (§4.4)
+SecuAccessPro (casiers) **+** bibliothèque/prêts (livres) **+** locations **+** tout pool d'unités (matériel, salles-clés, véhicules) → **≥ 2 consommateurs**, générique transverse.
+
+**3 exemples ciblés** (mêmes API/entités, profil différent — cf. plan de dev §8, exemples §12) :
+- **Vélos** (vélo-partage) : `resourceType='bike'`, station=`group`, compose `payment`+`booking`.
+- **Casiers de la Gare** (MostaGare) : `resourceType='gare-locker'`, consigne court terme, compose `qrpanel`/`scan`+`payment`+`notifications` (échéance).
+- **Casiers de salle de sport** (gym) : `resourceType='gym-locker'`, détenteur=membre abonné, compose `subscriptions-plan`+`scan`/`face`.
+
+## 7. Portes §11
+§11.1 qualité (bloquante) ; §11.2/§11.3 **informatives** (données détenteur via `users`). SemVer strict §11.8.
+
+## 8. Questions ouvertes (validation)
+1. **Nom** : `@mostajs/allocations` (recommandé) vs `lending` / `assignables` / `lockers`-generic ?
+2. `Allocation` (état courant) séparé de `Unit.status`, ou dérivé du dernier `AllocationEvent` ?
+3. `secu` consomme `allocations` pour ses casiers (migration), ou garde un alias ?
+
+---
+
+**Fin de l'audit d'extraction `@mostajs/allocations`.**

package/docs/03-PLAN-DEV-ALLOCATIONS.md

@@ -0,0 +1,82 @@
+# 03 — Plan de développement (EXTRACTION) — `@mostajs/allocations`
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com>
+**Date** : 2026-06-18
+**Statut** : proposition à discuter (livrable §9 #3). **Précède le scaffold code.**
+**Principe** : **EXTRAIRE & GÉNÉRALISER, NE PAS REDÉVELOPPER.** Généralisation du module *casiers* de `SecuAccessPro`.
+**Amont** : `00-AUDIT-EXTRACTION-ALLOCATIONS-18062026.md` (carte A1–A5)
+**Source** : `SolutionCh/SecuAccessPro` (`locker.schema.ts`, `locker-event.schema.ts`, `locker.repository.ts` — déjà `@mostajs/orm`).
+
+> Module générique d'**unités assignables à un détenteur** (état occupé/libre + historique). Le **détenteur = `@mostajs/users`** (ou entité dérivée). Couvre **casiers, prêts de livres, locations** — et les **3 exemples ciblés : vélos, casiers de Gare, casiers de salle de sport** (§8).
+
+---
+
+## 1. Périmètre & responsabilité unique
+**Unité ↔ détenteur ↔ état ↔ historique**, **DB-agnostique** (repos injectés). **Hors périmètre (délégué)** : détenteur (`users`), créneau/agenda (`booking-stack`), prix/abonnement (`payment`/`subscriptions-plan`), rappels (`notifications`), badge/QR (`qrpanel`/`scan`), traçabilité (`audit`).
+
+## 2. Carte d'extraction (source → cible — *generalize/adapt/lift*)
+| # | Source SecuAccessPro | Cible `mosta-allocations/src/` | Action |
+|---|---|---|---|
+| A1 | `locker.schema.ts` | `schemas/unit.schema.ts` | **GENERALIZE** : `number`→`code`, `zone`→`group`, +`resourceType`, `currentClient`→`currentHolder:User`, `rfidLockId`→`externalRef` |
+| A2 | `locker-event.schema.ts` | `schemas/allocation-event.schema.ts` | **ADAPT** : `client`→`holder:User` ; +actions `renewed/overdue` |
+| A3 | (dérivé status+lastAssignedAt) | `schemas/allocation.schema.ts` | **ADD** mince : `unitId,holderId,since,dueAt?,price?,status(active/returned/overdue)` |
+| A4 | `locker.repository.ts` (`assign/release/findAvailable/count`) | `repositories/allocations.repository.ts` | **LIFT** + générique + `renew`/`markOverdue` |
+| A5 | (nouveau) presets | `profiles/{locker,bike,book-loan,rental}.ts` | **ADD** (resourceType + champs meta + règles par profil) |
+
+> Aucune ligne « réécrire de zéro » : GENERALIZE/ADAPT/LIFT/ADD.
+
+## 3. Entités
+- **Unit** : `code, group?, resourceType, status(available|assigned|maintenance|retired), lastAssignedAt, externalRef?, meta?` + rel `currentHolder?(User)`.
+- **Allocation** : `unitId, holderId(User), since, dueAt?, price?, status(active|returned|overdue)`.
+- **AllocationEvent** : `unitId, holderId?, action(assigned|released|renewed|overdue|maintenance_*), at, performedBy(User), notes`.
+
+## 4. API (extraite/généralisée)
+`createAllocations({repositories, users?, booking?, payment?, notifications?, now?})` →
+`units.{create,list,findAvailable(group?),setMaintenance,retire}` · `alloc.{assign(unitId,holderId,{dueAt?,price?}), release(unitId), renew(unitId,dueAt), markOverdue}` · `alloc.{findByHolder, history(unitId), countByStatus}`.
+**Profils** : `allocationsProfile('bike'|'gare-locker'|'gym-locker'|'book-loan'|'rental')` → presets de champs/règles.
+
+## 5. Composition (§10)
+`repository`/`orm` (persistance, requis) · **`users`** (détenteur) · `booking-stack` (période location/vélo) · `payment`/`subscriptions-plan` (prix/abonnement) · `notifications` (échéance/retour) · `qrpanel`/`scan` (déverrouillage badge) · `audit`.
+
+## 6. Versions (jalons)
+| Version | Contenu | Extraction |
+|---|---|---|
+| 0.1.0 | `Unit`+`AllocationEvent`+repo (`assign/release/findAvailable/count`) + repos mémoire + profil `locker` | A1,A2,A4 |
+| 0.2.0 | `Allocation` (dueAt/status) + `renew`/`markOverdue` + `notifications` (rappels) | A3 |
+| 0.3.0 | profils **`bike` / `gare-locker` / `gym-locker`** + compose `booking`/`payment`/`subscriptions-plan` | A5 |
+| 0.4.0 | profil `book-loan`/`rental` + adaptateurs `@mostajs/repository` prod | A5 |
+| 1.0.0 | 14 livrables §9 + portes §11 + **3 exemples §12** + article #17 + **migration SecuAccessPro `secu`→`allocations`** | — |
+
+## 7. Frontière `booking-stack` (rappel)
+`booking` = *quand* (créneau/agenda) ; `allocations` = *quelle unité, à qui, état, historique*. Vélo/location **composent** les deux (période → booking) ; casier court terme = allocations seul.
+
+## 8. Exemples §12 — **3 cas ciblés** (vérification exécutable, `examples/`)
+
+> Même module, même API — seul le **profil** (resourceType + règles) change. Démontre la généricité.
+
+### 8.1 `examples/velos/` — **allocation de vélos** (vélo-partage)
+- `Unit.resourceType='bike'`, `group=station`, `externalRef=cadenas/GPS`. `assign(bike, holder, {price})` au retrait, `release` au retour (autre station → `group` mis à jour). **Compose** `payment` (tarif durée) + `booking` (réservation). **Assert** : capacité station, vélo indisponible si `assigned`, facturation durée, historique trajets.
+
+### 8.2 `examples/casiers-gare/` — **casiers de la Gare** (MostaGare)
+- `Unit.resourceType='gare-locker'`, `group=quai/zone`. Casier consigne court terme : `assign(casier, voyageur, {dueAt})`, `release` au départ, `markOverdue` au-delà. **Compose** `qrpanel`/`scan` (ouverture par QR) + `payment` (paiement à l'usage) + `notifications` (rappel échéance). **Assert** : libération auto en retard, paiement requis, code d'ouverture.
+
+### 8.3 `examples/casiers-salle-sport/` — **casiers de salle de sport** (gym)
+- `Unit.resourceType='gym-locker'`, `group=vestiaire H/F`. Détenteur = **membre** (User dérivé) avec **abonnement** : `assign(casier, membre)` à l'entrée (RFID/badge), `release` à la sortie ; accès conditionné à `subscriptions-plan` actif. **Compose** `subscriptions-plan` (abonnement valide) + `scan`/`face` (badge/visage) + `audit`. **Assert** : refus si abonnement expiré, un casier par membre actif, historique d'occupation.
+
+> Chaque exemple : scénario headless `*.mjs` (`assert`) + README (modèle + commande). **DoD §12** : les 3 s'exécutent, assertions vertes — **prérequis de l'article #17**.
+
+## 9. Risques & portes
+| Risque | Mitigation |
+|---|---|
+| Débordement vers `booking` | frontière §7 ; allocations ne gère pas l'agenda |
+| Profils trop spécifiques | presets minces (resourceType+règles) ; cœur générique |
+| Concurrence d'assignation (unité prise) | `assign` atomique côté repo (test d'intégration) |
+
+**Portes §11** : §11.1 qualité (bloquante : build/tests, couverture ≥ 80 %) ; §11.8 SemVer ; **§11.2/§11.3 informatives** (détenteur via `users` → données perso, non bloquant).
+
+## 10. Jalons §9
+`#1` état de l'art (lockers/lending/bike-sharing — à rédiger + script §8) · `#2` audit (= doc audit) · **`#3` ce plan** · `#4` plan de test (T-cases assign/release/overdue/capacité + 3 profils) · `#6` `llms.txt` dès 0.1 · `#7` CHANGELOG · **§12 (3 exemples) AVANT #17**.
+
+---
+
+**Fin du plan de dev (extraction) `@mostajs/allocations`.**

package/examples/casiers-gare/run.mjs

@@ -0,0 +1,39 @@
+// Exemple §12 — CASIERS DE LA GARE (consigne court terme). node examples/casiers-gare/run.mjs
+// Met en évidence : @mostajs/users (voyageur) + @mostajs/allocations (profil 'gare-locker') + QR + échéance.
+import assert from 'node:assert/strict';
+import { createAllocations, createMemoryRepositories, allocationsProfile } from '../../src/index.js';
+import { createUsers, createMemoryRepositories as userRepos } from '../../../mosta-users-stack/mosta-users/src/index.js';
+
+const profile = allocationsProfile('gare-locker');
+const users = createUsers({ repositories: userRepos(), qr: { generate: (id) => `GARE-QR:${id}` } });
+
+// mock @mostajs/qrpanel + notifications (composition)
+const reminders = [];
+let clock = new Date('2026-06-18T08:00:00Z');
+const a = createAllocations({
+  repositories: createMemoryRepositories(),
+  now: () => clock,
+  onEvent: (e) => { if (e.action === 'overdue') reminders.push(e.unitId); }, // compose notifications
+});
+
+const c1 = await a.units.create({ code: 'CONS-12', group: 'Quai 2', resourceType: profile.resourceType });
+const voyageur = await users.create({ firstName: 'Nadia', lastName: 'Cherif' });
+
+// Dépôt avec échéance (paiement à l'usage simulé) + code d'ouverture QR
+const alloc = await a.alloc.assign(c1.id, voyageur.id, { dueAt: new Date('2026-06-18T10:00:00Z'), price: 100 });
+const card = await users.cardData(voyageur.id);
+assert.ok(card.qr.startsWith('GARE-QR:'), 'code QR voyageur (compose qrpanel)');
+assert.equal((await a.units.get(c1.id)).status, 'assigned');
+
+// Le temps passe → dépassement → markOverdue (rappel notifications)
+clock = new Date('2026-06-18T11:00:00Z');
+const n = await a.alloc.markOverdue();
+assert.equal(n, 1);
+assert.equal(reminders.length, 1, 'rappel d\'échéance émis');
+assert.equal((await a.alloc.countByStatus()).overdue, 1);
+
+// Récupération au départ
+await a.alloc.release(c1.id);
+assert.equal((await a.units.get(c1.id)).status, 'available');
+
+console.log('✅ casiers Gare — consigne OK (users + allocations + QR + échéance)');

package/examples/casiers-salle-sport/run.mjs

@@ -0,0 +1,43 @@
+// Exemple §12 — CASIERS DE SALLE DE SPORT (gym). node examples/casiers-salle-sport/run.mjs
+// Met en évidence : @mostajs/users (membre) + @mostajs/allocations (profil 'gym-locker') + abonnement (guard).
+import assert from 'node:assert/strict';
+import { createAllocations, createMemoryRepositories, allocationsProfile } from '../../src/index.js';
+import { createUsers, createMemoryRepositories as userRepos } from '../../../mosta-users-stack/mosta-users/src/index.js';
+
+const profile = allocationsProfile('gym-locker');
+const users = createUsers({ repositories: userRepos() });
+
+// mock @mostajs/subscriptions-plan : abonnement actif ?
+const subs = new Map();
+const subscriptions = { isActive: (memberId) => subs.get(memberId) === true };
+
+// guard : accès casier conditionné à un abonnement actif
+const a = createAllocations({
+  repositories: createMemoryRepositories(),
+  guard: (unit, holderId) => {
+    if (!subscriptions.isActive(holderId)) throw new Error('abonnement inactif — accès refusé');
+  },
+});
+
+const locker = await a.units.create({ code: 'V-07', group: 'Vestiaire H', resourceType: profile.resourceType });
+const membre = await users.create({ firstName: 'Sofiane', lastName: 'Brahimi' });
+
+// Abonnement expiré → refus
+await assert.rejects(() => a.alloc.assign(locker.id, membre.id), /abonnement inactif/);
+
+// Abonnement actif → entrée OK (badge/visage géré en amont par users/face)
+subs.set(membre.id, true);
+await a.alloc.assign(locker.id, membre.id);
+assert.equal((await a.units.get(locker.id)).status, 'assigned');
+assert.equal((await a.units.get(locker.id)).currentHolder, membre.id);
+
+// Un casier par membre actif (le casier n'est plus disponible)
+assert.equal((await a.units.findAvailable({ group: 'Vestiaire H' })).length, 0);
+
+// Sortie → libération + historique
+await a.alloc.release(locker.id);
+assert.equal((await a.units.get(locker.id)).status, 'available');
+const hist = await a.alloc.history(locker.id);
+assert.deepEqual(hist.map((e) => e.action), ['assigned', 'released']);
+
+console.log('✅ casiers salle de sport — vestiaire OK (users + allocations + abonnement)');

package/examples/showcase-3-modules/run.mjs

@@ -0,0 +1,37 @@
+// SHOWCASE — met en évidence LES TROIS MODULES ensemble :
+//   @mostajs/users (personne), @mostajs/users-ui (admin headless), @mostajs/allocations (casier gym).
+// node examples/showcase-3-modules/run.mjs
+import assert from 'node:assert/strict';
+import { createUsers, createMemoryRepositories as userRepos } from '../../../mosta-users-stack/mosta-users/src/index.js';
+import { createUsersUiController } from '../../../mosta-users-stack/mosta-users-ui/src/index.js';
+import { createAllocations, createMemoryRepositories, allocationsProfile } from '../../src/index.js';
+
+// 1) @mostajs/users — service personne (socle)
+const users = createUsers({ repositories: userRepos(), qr: { generate: (id) => `QR:${id}` } });
+
+// 2) @mostajs/users-ui — un admin crée un MEMBRE via le contrôleur (validation incluse)
+const ui = createUsersUiController({ service: users });
+const res = await ui.submit({ firstName: 'Inès', lastName: 'Mansouri', email: 'ines@gym.dz', password: 'p', confirmPassword: 'p' });
+assert.ok(res.ok, 'membre créé via users-ui');
+const member = res.user;
+console.log('  [users-ui] membre créé :', member.firstName, member.lastName, '— carte', (await users.cardData(member.id)).qr);
+
+// 3) @mostajs/allocations — abonnement actif → casier de vestiaire affecté au membre
+const subs = new Map([[member.id, true]]);
+const gym = createAllocations({
+  repositories: createMemoryRepositories(),
+  guard: (unit, holderId) => { if (!subs.get(holderId)) throw new Error('abonnement inactif'); },
+});
+const locker = await gym.units.create({ code: 'V-07', group: 'Vestiaire F', resourceType: allocationsProfile('gym-locker').resourceType });
+await gym.alloc.assign(locker.id, member.id);
+assert.equal((await gym.units.get(locker.id)).currentHolder, member.id);
+
+// vue admin (users-ui) : le membre apparaît, actif
+const vm = await ui.refresh();
+assert.equal(vm.stats.active, 1);
+
+// sortie : libération
+await gym.alloc.release(locker.id);
+assert.equal((await gym.units.get(locker.id)).status, 'available');
+
+console.log('✅ SHOWCASE — users + users-ui + allocations fonctionnent ensemble');

package/examples/velos/run.mjs

@@ -0,0 +1,42 @@
+// Exemple §12 — ALLOCATION DE VÉLOS (vélo-partage). node examples/velos/run.mjs
+// Met en évidence : @mostajs/users (détenteur) + @mostajs/allocations (profil 'bike').
+import assert from 'node:assert/strict';
+import { createAllocations, createMemoryRepositories, allocationsProfile } from '../../src/index.js';
+import { createUsers, createMemoryRepositories as userRepos } from '../../../mosta-users-stack/mosta-users/src/index.js';
+
+const profile = allocationsProfile('bike');          // resourceType='bike', group=station
+const users = createUsers({ repositories: userRepos() });
+
+// mock @mostajs/payment (tarif durée) — composition
+const billed = [];
+const payment = { charge: (holderId, amount) => billed.push({ holderId, amount }) };
+
+const a = createAllocations({
+  repositories: createMemoryRepositories(),
+  onEvent: (e) => { if (e.action === 'released') payment.charge(e.holderId, 50); }, // tarif forfaitaire démo
+});
+
+// Parc : 2 vélos station Centre, 1 station Plage
+const v1 = await a.units.create({ code: 'BIKE-001', group: 'Centre', resourceType: profile.resourceType, externalRef: 'lock-001' });
+await a.units.create({ code: 'BIKE-002', group: 'Centre', resourceType: profile.resourceType });
+await a.units.create({ code: 'BIKE-003', group: 'Plage', resourceType: profile.resourceType });
+
+// Usager (détenteur via @mostajs/users)
+const rider = await users.create({ firstName: 'Yacine', lastName: 'Saadi' });
+
+// Retrait à Centre
+await a.alloc.assign(v1.id, rider.id, { price: 50 });
+assert.equal((await a.units.get(v1.id)).status, 'assigned');
+assert.equal((await a.units.findAvailable({ group: 'Centre' })).length, 1, 'capacité station Centre');
+
+// Vélo indisponible → assign refusé
+await assert.rejects(() => a.alloc.assign(v1.id, rider.id), /non disponible/);
+
+// Retour à la station Plage (group mis à jour) → facturation durée
+await a.alloc.release(v1.id);
+await a.repositories.units.update(v1.id, { group: 'Plage' });
+assert.equal((await a.units.get(v1.id)).status, 'available');
+assert.equal(billed.length, 1, 'facturé au retour (compose payment)');
+assert.equal((await a.alloc.history(v1.id)).length, 2, 'historique assigned+released');
+
+console.log('✅ vélos — allocation OK (users + allocations + payment)');

package/examples/web-demo/README.md

@@ -0,0 +1,22 @@
+# Démo web — interface `@mostajs/allocations` (autonome)
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com>
+
+Interface **dédiée** des unités assignables — casiers / vélos / consigne (application autonome, **non fusionnée**
+avec users-ui). Zéro-build (DEVRULES §12) : importmap → modules ESM réels, état **in-memory** navigateur.
+
+## Démarrer
+```bash
+./serve.sh            # (ou ./serve.sh 8080)
+```
+Le script sert depuis la **racine commune** (`mostajs/`, car l'importmap référence `@mostajs/allocations`
+et le module voisin `@mostajs/users` pour les détenteurs) et affiche l'URL exacte, p. ex. :
+`http://localhost:8000/mosta-allocations/examples/web-demo/index.html`
+
+> Lancement manuel équivalent : depuis `mostajs/`, `python3 -m http.server` puis ouvrir l'URL ci-dessus.
+
+## Ce que ça montre
+- Ajout d'unités par **profil** (`gym-locker`, `bike`, `gare-locker`…), parc avec statut (libre/occupé), **affectation**
+  à un détenteur et **libération**, journal d'événements — via `createAllocations()`.
+- Les **détenteurs** sont des utilisateurs `@mostajs/users` (composition) — pas une UI de gestion d'utilisateurs ici
+  (celle-ci est l'application séparée `@mostajs/users-ui`).

package/examples/web-demo/app.mjs

@@ -0,0 +1,75 @@
+// Interface @mostajs/allocations (application autonome). Author: Dr Hamid MADANI <drmdh@msn.com>
+import { createAllocations, createMemoryRepositories, PROFILES } from '@mostajs/allocations';
+import { createUsers, createMemoryRepositories as userRepos } from '@mostajs/users';
+
+const $ = (id) => document.getElementById(id);
+const logs = [];
+
+// Détenteurs : quelques utilisateurs de démo (composition @mostajs/users — pas une UI de gestion ici)
+const users = createUsers({ repositories: userRepos() });
+const seedHolders = async () => {
+  for (const n of [['Inès', 'Mansouri'], ['Yacine', 'Saadi'], ['Nadia', 'Cherif']])
+    await users.create({ firstName: n[0], lastName: n[1] });
+};
+
+const alloc = createAllocations({
+  repositories: createMemoryRepositories(),
+  onEvent: (e) => { logs.unshift(`${new Date().toLocaleTimeString()} · ${e.action} · ${e.unitId.slice(0, 6)}${e.holderId ? ' → ' + e.holderId.slice(0, 6) : ''}`); render(); },
+});
+
+// remplir la liste des profils
+for (const k of Object.keys(PROFILES)) {
+  const o = document.createElement('option'); o.value = k; o.textContent = `${k} (${PROFILES[k].unitLabel})`; $('a-profile').appendChild(o);
+}
+$('a-profile').value = 'gym-locker';
+
+$('a-add').onclick = async () => {
+  const code = $('a-code').value.trim(); if (!code) return;
+  const p = PROFILES[$('a-profile').value];
+  await alloc.units.create({ code, group: $('a-group').value.trim(), resourceType: p.resourceType });
+  $('a-code').value = ''; render();
+};
+
+async function holdersOptions(selectedExclude) {
+  const list = await users.list({ pageSize: 100 });
+  return list.items.map((u) => `<option value="${u.id}">${users.fullName(u)}</option>`).join('');
+}
+
+async function render() {
+  const units = await alloc.units.list();
+  const c = await alloc.alloc.countByStatus();
+  $('a-stats').textContent = `${units.length} unités · actives ${c.active} · retournées ${c.returned} · en retard ${c.overdue}`;
+  const opts = await holdersOptions();
+  $('a-units').innerHTML = units.map((u) => `
+    <div class="unit">
+      <b>${u.code}</b> <span class="pill s-${u.status}">${u.status}</span>
+      <div class="g">${u.resourceType}${u.group ? ' · ' + u.group : ''}</div>
+      ${u.status === 'available'
+        ? `<select data-assign="${u.id}"><option value="">— détenteur —</option>${opts}</select>
+           <button class="sm" data-do="assign" data-id="${u.id}">Affecter</button>`
+        : u.status === 'assigned'
+          ? `<div class="g">détenteur: ${u.currentHolder?.slice(0, 8)}</div><button class="sm ghost" data-do="release" data-id="${u.id}">Libérer</button>`
+          : ''}
+    </div>`).join('');
+
+  $('a-units').querySelectorAll('[data-do]').forEach((btn) => {
+    btn.onclick = async () => {
+      const id = btn.dataset.id;
+      try {
+        if (btn.dataset.do === 'assign') {
+          const sel = $('a-units').querySelector(`[data-assign="${id}"]`);
+          if (!sel.value) return;
+          await alloc.alloc.assign(id, sel.value);
+        } else { await alloc.alloc.release(id); }
+        render();
+      } catch (e) { alert(e.message); }
+    };
+  });
+  $('a-log').innerHTML = logs.slice(0, 30).map((l) => `<div>${l}</div>`).join('');
+}
+
+await seedHolders();
+// quelques unités de démo
+await alloc.units.create({ code: 'V-01', group: 'Vestiaire H', resourceType: 'gym-locker' });
+await alloc.units.create({ code: 'BIKE-01', group: 'Station Centre', resourceType: 'bike' });
+render();

package/examples/web-demo/index.html

@@ -0,0 +1,71 @@
+<!doctype html>
+<html lang="fr">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Interface — @mostajs/allocations</title>
+<!--
+  Auteur : Dr Hamid MADANI <drmdh@msn.com>
+  Démo navigateur ZÉRO-BUILD (DEVRULES §12) — interface DÉDIÉE @mostajs/allocations (application autonome).
+  Lancer : python3 -m http.server  (depuis ce dossier) → http://localhost:8000
+-->
+<script type="importmap">
+{
+  "imports": {
+    "@mostajs/users":       "../../../mosta-users-stack/mosta-users/src/index.js",
+    "@mostajs/allocations": "../../src/index.js"
+  }
+}
+</script>
+<style>
+  :root { --card:#1e293b; --mut:#94a3b8; --ok:#22c55e; --warn:#f59e0b; --bad:#ef4444; --acc:#38bdf8; }
+  *{box-sizing:border-box} body{margin:0;font:14px/1.5 system-ui,sans-serif;background:#0b1220;color:#e2e8f0}
+  header{padding:16px 24px;background:#0f172a;border-bottom:1px solid #334155}
+  header h1{margin:0;font-size:18px;color:var(--acc)} header small{color:var(--mut)}
+  .wrap{max-width:880px;margin:0 auto;padding:16px 24px}
+  .card{background:var(--card);border:1px solid #334155;border-radius:12px;padding:16px;margin-bottom:16px}
+  .card h2{margin:0 0 12px;font-size:15px}
+  label{display:block;font-size:12px;color:var(--mut);margin:8px 0 2px}
+  input,select{width:100%;padding:8px;border-radius:8px;border:1px solid #475569;background:#0f172a;color:#e2e8f0}
+  button{padding:7px 12px;border-radius:8px;border:0;background:var(--acc);color:#001018;font-weight:600;cursor:pointer}
+  button.ghost{background:#334155;color:#e2e8f0} button.sm{padding:4px 8px;font-size:12px}
+  .row{display:flex;gap:8px;align-items:end}.row>*{flex:1}
+  .stats{color:var(--mut);font-size:12px;margin:8px 0}
+  .units{display:grid;grid-template-columns:repeat(auto-fill,minmax(140px,1fr));gap:8px;margin-top:10px}
+  .unit{border:1px solid #475569;border-radius:10px;padding:10px}.unit b{font-size:13px}.unit .g{color:var(--mut);font-size:11px}
+  .pill{padding:2px 8px;border-radius:999px;font-size:11px;font-weight:700}
+  .s-available{background:rgba(34,197,94,.15);color:var(--ok)} .s-assigned{background:rgba(245,158,11,.15);color:var(--warn)}
+  .s-maintenance,.s-retired{background:rgba(239,68,68,.15);color:var(--bad)}
+  .log{font-family:ui-monospace,monospace;font-size:11px;color:var(--mut);max-height:140px;overflow:auto;margin-top:8px}
+</style>
+</head>
+<body>
+<header>
+  <h1>🔐 @mostajs/allocations</h1>
+  <small>Application autonome — unités assignables (casiers / vélos / consigne). État in-memory.</small>
+</header>
+<div class="wrap">
+  <section class="card">
+    <h2>Ajouter une unité</h2>
+    <div class="row">
+      <div><label>Code</label><input id="a-code" placeholder="V-07" /></div>
+      <div><label>Groupe</label><input id="a-group" placeholder="Vestiaire H" /></div>
+      <div><label>Profil</label><select id="a-profile"></select></div>
+      <div style="flex:0 0 auto"><button id="a-add" class="ghost">+ Ajouter</button></div>
+    </div>
+    <div class="stats" id="a-stats"></div>
+  </section>
+
+  <section class="card">
+    <h2>Parc d'unités</h2>
+    <div class="units" id="a-units"></div>
+  </section>
+
+  <section class="card">
+    <h2>Journal</h2>
+    <div class="log" id="a-log"></div>
+  </section>
+</div>
+<script type="module" src="./app.mjs"></script>
+</body>
+</html>

package/examples/web-demo/serve.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# Démarre la démo web @mostajs/allocations (zéro-build). Author: Dr Hamid MADANI <drmdh@msn.com>
+# L'importmap référence des modules voisins (../../../) → on sert depuis la RACINE commune (mostajs/).
+# Usage : ./serve.sh [port]
+set -euo pipefail
+DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$DIR/../../.." && pwd)"          # mostajs/ (contient mosta-allocations + mosta-users-stack)
+REL="${DIR#"$ROOT"/}/index.html"
+PORT="${1:-8000}"
+echo "📂 racine servie : $ROOT"
+echo "🌐 ouvrir       : http://localhost:$PORT/$REL"
+cd "$ROOT"
+exec python3 -m http.server "$PORT"

package/llms.txt

@@ -0,0 +1,30 @@
+# @mostajs/allocations — fiche LLM
+
+RÔLE
+  Unités assignables génériques à un détenteur (état + historique) : casiers, prêts de livres, locations.
+  GENERALIZE du module casier de SecuAccessPro. Détenteur = @mostajs/users (holderId).
+  Compose (injectés) : booking (période), payment (prix), subscriptions-plan (abonnement), notifications (échéance), audit.
+
+EXPORTS
+  createAllocations({ repositories, guard?, onEvent?, now? }) -> api
+  createMemoryRepositories() -> { units, allocations, events }
+  allocationsProfile(name) / PROFILES        # locker|bike|gare-locker|gym-locker|book-loan|rental
+  UnitSchema, AllocationSchema, AllocationEventSchema
+
+API
+  units.create(d) get(id) list(filter) findAvailable({group,resourceType}) setMaintenance(id) endMaintenance(id) retire(id)
+  alloc.assign(unitId,holderId,{dueAt?,price?,performedBy?})  # throw si non disponible / guard refuse
+  alloc.release(unitId) renew(unitId,dueAt) markOverdue() findByHolder(id) history(unitId) countByStatus()
+
+TYPES
+  Unit{code,group,resourceType,status(available|assigned|maintenance|retired),lastAssignedAt,externalRef,meta,currentHolder}
+  Allocation{unitId,holderId,since,dueAt,returnedAt,price,status(active|returned|overdue)}
+  AllocationEvent{unitId,holderId,action(assigned|released|renewed|overdue|maintenance_*),at,performedBy,notes}
+
+PROFILS / EXEMPLES (examples/)
+  velos (bike-sharing) · casiers-gare (consigne) · casiers-salle-sport (gym, guard abonnement) · showcase-3-modules
+
+PIÈGES
+  - guard = règle d'éligibilité (ex. abonnement actif) — peut throw. assign refuse si unité non 'available'.
+  - Frontière booking-stack : booking = créneau/agenda ; allocations = unité↔détenteur+état+historique.
+  - Détenteur via @mostajs/users (ne pas redéfinir d'utilisateur).

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@mostajs/allocations",
+  "version": "0.1.0",
+  "description": "Unités assignables génériques à un détenteur (état + historique) : casiers, prêts de livres, locations. Détenteur = @mostajs/users. Profils : locker/bike/gare-locker/gym-locker/book-loan/rental.",
+  "license": "AGPL-3.0-or-later",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./profiles": "./src/profiles.js",
+    "./schemas": "./src/schemas.js"
+  },
+  "keywords": [
+    "mostajs",
+    "allocations",
+    "lockers",
+    "lending",
+    "rental",
+    "bike-sharing"
+  ],
+  "scripts": {
+    "test": "node test-scripts/unit/allocations.test.mjs",
+    "example:velos": "node examples/velos/run.mjs",
+    "example:gare": "node examples/casiers-gare/run.mjs",
+    "example:gym": "node examples/casiers-salle-sport/run.mjs"
+  }
+}

package/src/allocations.js

@@ -0,0 +1,93 @@
+// @mostajs/allocations — service générique (createAllocations)
+// Author: Dr Hamid MADANI <drmdh@msn.com>
+// GENERALIZE de SecuAccessPro locker.repository (assign/release/findAvailable/count).
+// Détenteur = @mostajs/users (holderId). Compose booking/payment/notifications/subscriptions-plan (injectés).
+
+/**
+ * @param {object} opts
+ * @param {object} opts.repositories { units, allocations, events }
+ * @param {(unit, holderId)=>(void|Promise<void>)} [opts.guard]  règle d'éligibilité (ex. abonnement actif) — peut throw
+ * @param {(event)=>void} [opts.onEvent]  hook (ex. notifications)
+ * @param {()=>Date} [opts.now]
+ */
+export function createAllocations({ repositories, guard, onEvent, now = () => new Date() } = {}) {
+  if (!repositories?.units) throw new Error('createAllocations: repositories.units requis');
+  const { units, allocations, events } = repositories;
+
+  const log = async (e) => { const ev = await events.create({ at: now(), ...e }); onEvent?.(ev); return ev; };
+
+  const api = {
+    units: {
+      create: (d) => units.create({ status: 'available', meta: {}, currentHolder: null, ...d }),
+      get: (id) => units.findById(id),
+      list: (filter = {}) => units.find((u) => Object.entries(filter).every(([k, v]) => u[k] === v)),
+      async findAvailable({ group, resourceType } = {}) {
+        return units.find((u) => u.status === 'available'
+          && (group === undefined || u.group === group)
+          && (resourceType === undefined || u.resourceType === resourceType));
+      },
+      async setMaintenance(id, { performedBy } = {}) {
+        const u = await units.update(id, { status: 'maintenance' });
+        await log({ unitId: id, action: 'maintenance_start', performedBy });
+        return u;
+      },
+      async endMaintenance(id, { performedBy } = {}) {
+        const u = await units.update(id, { status: 'available' });
+        await log({ unitId: id, action: 'maintenance_end', performedBy });
+        return u;
+      },
+      retire: (id) => units.update(id, { status: 'retired' }),
+    },
+
+    alloc: {
+      /** Affecte une unité à un détenteur. Throw si non disponible ou guard refuse. */
+      async assign(unitId, holderId, { dueAt = null, price = null, performedBy } = {}) {
+        const u = await units.findById(unitId);
+        if (!u) throw new Error(`unité introuvable: ${unitId}`);
+        if (u.status !== 'available') throw new Error(`unité non disponible (${u.status}): ${u.code}`);
+        if (guard) await guard(u, holderId);   // ex. abonnement actif (gym)
+        await units.update(unitId, { status: 'assigned', currentHolder: holderId, lastAssignedAt: now() });
+        const a = await allocations.create({ unitId, holderId, since: now(), dueAt, price, status: 'active' });
+        await log({ unitId, holderId, action: 'assigned', performedBy });
+        return a;
+      },
+      async release(unitId, { performedBy } = {}) {
+        const a = (await allocations.find((x) => x.unitId === unitId && x.status !== 'returned'))[0];
+        if (!a) throw new Error(`aucune allocation active pour ${unitId}`);
+        await allocations.update(a.id, { status: 'returned', returnedAt: now() });
+        await units.update(unitId, { status: 'available', currentHolder: null });
+        await log({ unitId, holderId: a.holderId, action: 'released', performedBy });
+        return units.findById(unitId);
+      },
+      async renew(unitId, dueAt, { performedBy } = {}) {
+        const a = (await allocations.find((x) => x.unitId === unitId && x.status === 'active'))[0];
+        if (!a) throw new Error(`aucune allocation active pour ${unitId}`);
+        const upd = await allocations.update(a.id, { dueAt });
+        await log({ unitId, holderId: a.holderId, action: 'renewed', performedBy });
+        return upd;
+      },
+      /** Passe en `overdue` les allocations actives dont dueAt est dépassé. */
+      async markOverdue() {
+        const t = now().getTime();
+        const due = await allocations.find((x) => x.status === 'active' && x.dueAt && new Date(x.dueAt).getTime() < t);
+        for (const a of due) {
+          await allocations.update(a.id, { status: 'overdue' });
+          await log({ unitId: a.unitId, holderId: a.holderId, action: 'overdue' });
+        }
+        return due.length;
+      },
+      findByHolder: (holderId) => allocations.find((x) => x.holderId === holderId),
+      history: (unitId) => events.find((e) => e.unitId === unitId),
+      async countByStatus() {
+        return {
+          active: await allocations.count((x) => x.status === 'active'),
+          returned: await allocations.count((x) => x.status === 'returned'),
+          overdue: await allocations.count((x) => x.status === 'overdue'),
+        };
+      },
+    },
+
+    repositories,
+  };
+  return api;
+}

package/src/index.js

@@ -0,0 +1,6 @@
+// @mostajs/allocations — point d'entrée
+// Author: Dr Hamid MADANI <drmdh@msn.com>
+export { createAllocations } from './allocations.js';
+export { createMemoryRepositories } from './memory-repo.js';
+export { UnitSchema, AllocationSchema, AllocationEventSchema } from './schemas.js';
+export { allocationsProfile, PROFILES } from './profiles.js';

package/src/memory-repo.js

@@ -0,0 +1,21 @@
+// @mostajs/allocations — repositories mémoire (tests/démo ; prod via @mostajs/repository)
+// Author: Dr Hamid MADANI <drmdh@msn.com>
+function makeCollection() {
+  const items = new Map();
+  return {
+    async create(data) {
+      const id = data.id || (globalThis.crypto?.randomUUID?.() ?? String(Date.now() + Math.random()));
+      const now = new Date();
+      const row = { id, createdAt: now, updatedAt: now, ...data };
+      items.set(id, row); return { ...row };
+    },
+    async findById(id) { const r = items.get(id); return r ? { ...r } : null; },
+    async update(id, patch) { const r = items.get(id); if (!r) return null; const row = { ...r, ...patch, updatedAt: new Date() }; items.set(id, row); return { ...row }; },
+    async remove(id) { return items.delete(id); },
+    async find(p = () => true) { return [...items.values()].filter(p).map((r) => ({ ...r })); },
+    async count(p = () => true) { return [...items.values()].filter(p).length; },
+  };
+}
+export function createMemoryRepositories() {
+  return { units: makeCollection(), allocations: makeCollection(), events: makeCollection() };
+}

package/src/profiles.js

@@ -0,0 +1,15 @@
+// @mostajs/allocations — profils (presets resourceType + libellés). Même cœur, usage différent.
+// Author: Dr Hamid MADANI <drmdh@msn.com>
+export const PROFILES = {
+  'locker':      { resourceType: 'locker',      groupLabel: 'zone',      unitLabel: 'casier' },
+  'bike':        { resourceType: 'bike',        groupLabel: 'station',   unitLabel: 'vélo' },
+  'gare-locker': { resourceType: 'gare-locker', groupLabel: 'quai/zone', unitLabel: 'casier de consigne' },
+  'gym-locker':  { resourceType: 'gym-locker',  groupLabel: 'vestiaire', unitLabel: 'casier de vestiaire' },
+  'book-loan':   { resourceType: 'book',        groupLabel: 'rayon',     unitLabel: 'exemplaire' },
+  'rental':      { resourceType: 'rental',      groupLabel: 'catégorie', unitLabel: 'article' },
+};
+export function allocationsProfile(name) {
+  const p = PROFILES[name];
+  if (!p) throw new Error(`profil inconnu: ${name} (cf. PROFILES)`);
+  return p;
+}

package/src/schemas.js

@@ -0,0 +1,51 @@
+// @mostajs/allocations — schémas (EntitySchema @mostajs/orm)
+// Author: Dr Hamid MADANI <drmdh@msn.com>
+// GENERALIZE de SecuAccessPro locker.schema.ts + locker-event.schema.ts (extraction, pas réécriture).
+
+export const UnitSchema = {
+  name: 'Unit',
+  collection: 'units',
+  timestamps: true,
+  fields: {
+    code:           { type: 'string', required: true },                         // ex-`number`
+    group:          { type: 'string' },                                         // ex-`zone` (station/quai/vestiaire)
+    resourceType:   { type: 'string', required: true },                         // locker|bike|gare-locker|gym-locker|book|rental
+    status:         { type: 'string', enum: ['available', 'assigned', 'maintenance', 'retired'], default: 'available' },
+    lastAssignedAt: { type: 'date', default: null },
+    externalRef:    { type: 'string' },                                         // ex-`rfidLockId`/cadenas
+    meta:           { type: 'object', default: () => ({}) },
+    currentHolder:  { type: 'string', default: null },                          // userId (@mostajs/users)
+  },
+  indexes: [{ fields: { resourceType: 'asc' } }, { fields: { group: 'asc' } }, { fields: { status: 'asc' } }],
+};
+
+export const AllocationSchema = {
+  name: 'Allocation',
+  collection: 'allocations',
+  timestamps: true,
+  fields: {
+    unitId:   { type: 'string', required: true },
+    holderId: { type: 'string', required: true },     // userId
+    since:    { type: 'date', default: 'now' },
+    dueAt:    { type: 'date', default: null },
+    returnedAt: { type: 'date', default: null },
+    price:    { type: 'number', default: null },
+    status:   { type: 'string', enum: ['active', 'returned', 'overdue'], default: 'active' },
+  },
+  indexes: [{ fields: { unitId: 'asc' } }, { fields: { holderId: 'asc' } }, { fields: { status: 'asc' } }],
+};
+
+export const AllocationEventSchema = {
+  name: 'AllocationEvent',
+  collection: 'allocation_events',
+  timestamps: false,
+  fields: {
+    unitId:      { type: 'string', required: true },
+    holderId:    { type: 'string', default: null },
+    action:      { type: 'string', enum: ['assigned', 'released', 'renewed', 'overdue', 'maintenance_start', 'maintenance_end'], required: true },
+    at:          { type: 'date', default: 'now' },
+    performedBy: { type: 'string', default: null },
+    notes:       { type: 'string' },
+  },
+  indexes: [{ fields: { unitId: 'asc' } }, { fields: { at: 'desc' } }],
+};

package/test-scripts/unit/allocations.test.mjs

@@ -0,0 +1,69 @@
+// @mostajs/allocations — tests unitaires (DEVRULES §5 : test-scripts/, rejouables, committés).
+// node test-scripts/unit/allocations.test.mjs
+import assert from 'node:assert/strict';
+import { createAllocations, createMemoryRepositories, allocationsProfile, PROFILES } from '../../src/index.js';
+
+let pass = 0; const test = async (n, fn) => { await fn(); pass++; console.log('  ✓', n); };
+const mk = (opts = {}) => createAllocations({ repositories: createMemoryRepositories(), ...opts });
+
+await test('units.create: status available par défaut', async () => {
+  const a = mk(); const u = await a.units.create({ code: 'C1', resourceType: 'locker' });
+  assert.equal(u.status, 'available'); assert.equal(u.currentHolder, null);
+});
+await test('assign: occupe l\'unité + crée allocation + event', async () => {
+  const a = mk(); const u = await a.units.create({ code: 'C1', resourceType: 'locker' });
+  await a.alloc.assign(u.id, 'holder-1');
+  assert.equal((await a.units.get(u.id)).status, 'assigned');
+  assert.equal((await a.units.get(u.id)).currentHolder, 'holder-1');
+  assert.deepEqual((await a.alloc.history(u.id)).map((e) => e.action), ['assigned']);
+});
+await test('assign sur unité non disponible → erreur', async () => {
+  const a = mk(); const u = await a.units.create({ code: 'C1', resourceType: 'locker' });
+  await a.alloc.assign(u.id, 'h1');
+  await assert.rejects(() => a.alloc.assign(u.id, 'h2'), /non disponible/);
+});
+await test('guard refuse (ex. abonnement)', async () => {
+  const a = mk({ guard: () => { throw new Error('abonnement inactif'); } });
+  const u = await a.units.create({ code: 'V1', resourceType: 'gym-locker' });
+  await assert.rejects(() => a.alloc.assign(u.id, 'h1'), /abonnement inactif/);
+});
+await test('release: libère + historise', async () => {
+  const a = mk(); const u = await a.units.create({ code: 'C1', resourceType: 'locker' });
+  await a.alloc.assign(u.id, 'h1'); await a.alloc.release(u.id);
+  assert.equal((await a.units.get(u.id)).status, 'available');
+  assert.deepEqual((await a.alloc.history(u.id)).map((e) => e.action), ['assigned', 'released']);
+});
+await test('findAvailable par group/resourceType', async () => {
+  const a = mk();
+  await a.units.create({ code: 'B1', group: 'Centre', resourceType: 'bike' });
+  const b2 = await a.units.create({ code: 'B2', group: 'Centre', resourceType: 'bike' });
+  await a.alloc.assign(b2.id, 'h1');
+  assert.equal((await a.units.findAvailable({ group: 'Centre', resourceType: 'bike' })).length, 1);
+});
+await test('markOverdue: échéance dépassée', async () => {
+  let clock = new Date('2026-01-01T00:00:00Z');
+  const a = mk({ now: () => clock }); const u = await a.units.create({ code: 'C1', resourceType: 'gare-locker' });
+  await a.alloc.assign(u.id, 'h1', { dueAt: new Date('2026-01-01T01:00:00Z') });
+  clock = new Date('2026-01-01T02:00:00Z');
+  assert.equal(await a.alloc.markOverdue(), 1);
+  assert.equal((await a.alloc.countByStatus()).overdue, 1);
+});
+await test('renew: repousse l\'échéance', async () => {
+  const a = mk(); const u = await a.units.create({ code: 'C1', resourceType: 'book' });
+  await a.alloc.assign(u.id, 'h1', { dueAt: new Date('2026-01-10') });
+  const r = await a.alloc.renew(u.id, new Date('2026-02-10'));
+  assert.equal(new Date(r.dueAt).getMonth(), 1);
+});
+await test('maintenance start/end', async () => {
+  const a = mk(); const u = await a.units.create({ code: 'C1', resourceType: 'locker' });
+  await a.units.setMaintenance(u.id); assert.equal((await a.units.get(u.id)).status, 'maintenance');
+  await a.units.endMaintenance(u.id); assert.equal((await a.units.get(u.id)).status, 'available');
+});
+await test('profils disponibles (velos/gare/gym)', async () => {
+  assert.equal(allocationsProfile('bike').resourceType, 'bike');
+  assert.equal(allocationsProfile('gare-locker').resourceType, 'gare-locker');
+  assert.equal(allocationsProfile('gym-locker').resourceType, 'gym-locker');
+  assert.ok(PROFILES['book-loan'] && PROFILES['rental']);
+});
+
+console.log(`\n✅ @mostajs/allocations — ${pass} tests OK`);