@mostajs/enrollment 0.1.0

package/LICENSE

@@ -0,0 +1,29 @@
+GNU AFFERO GENERAL PUBLIC LICENSE
+Version 3, 19 November 2007
+
+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/>.
+
+COMMERCIAL LICENSE
+
+For organizations that cannot comply with the AGPL open-source requirements,
+a commercial license is available. Contact: drmdh@msn.com
+
+The commercial license allows you to:
+- Use the software in proprietary/closed-source projects
+- Modify without publishing your source code
+- Get priority support and SLA
+
+Contact: Dr Hamid MADANI <drmdh@msn.com>

package/README.md

@@ -0,0 +1,80 @@
+# @mostajs/enrollment
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Licence** : AGPL-3.0-or-later
+**Niveau** : N1 · **Dépendance** : `@mostajs/crypto-box`
+
+Enrôler une machine chez un client distant — **sans configuration**.
+
+## Ce que ce module n'est PAS
+
+**Ce n'est pas de la licence.** Deux questions distinctes, qu'il ne faut **jamais** fusionner :
+
+| Question | Module |
+|---|---|
+| « Ce client a-t-il le **droit** d'utiliser le logiciel ? » | `@mostajs/licensing` |
+| « Cette machine **est-elle** bien la sienne ? » | **ce module** |
+
+Les mélanger interdirait de révoquer un enrôlement (machine volée) **sans couper la licence**.
+
+## Les trois verrous
+
+**1. Pas de jeton générique dans le binaire.** Un jeton d'amorçage embarqué dans chaque `.exe`
+est une faille : **quiconque possède le binaire** pourrait s'enrôler et devenir un « site »
+légitime de votre console.
+→ Un **code par client**, dictable au téléphone, **usage unique**, **7 jours**.
+
+**2. `machineId` n'authentifie pas** — il **identifie**. C'est une valeur publique et
+**falsifiable**.
+→ Une paire **Ed25519** générée sur la machine ; la clé **privée ne sort jamais**. Un jeton volé
+(fichier de config, sauvegarde, capture réseau) est **rejouable** ; une clé qui ne bouge pas, non.
+
+**3. La console peut être usurpée** (DNS détourné, certificat frauduleux). TLS prouve qu'on parle
+à `console.example` — pas qu'on parle à **LA** console.
+→ Chaque approbation est **signée Ed25519**, vérifiée avec la clé publique **embarquée dans le
+binaire**. Même si TLS tombait, un faux jeton **ne pourrait pas être forgé**.
+
+## Rien à configurer chez le client
+
+L'enrôlement est **sortant** : la machine **appelle** la console, jamais l'inverse. **Aucun
+certificat, aucun port ouvert, aucun reverse proxy.** Fonctionne derrière une box, un NAT, un
+pare-feu d'entreprise.
+
+## Le code, dictable au téléphone
+
+```
+MJSE-7K4P-2XQ9-M3TA
+```
+
+**Crockford Base32** — ni `I`, ni `L`, ni `O`, ni `U`. Fini le « c'est un zéro ou un O ? », la
+question qui fait échouer une installation à distance. Insensible à la casse, tirets décoratifs.
+
+**10 caractères aléatoires + 2 de contrôle** : une faute de frappe est rejetée **hors ligne**, le
+client voit « code invalide » **tout de suite** — pas après trente secondes d'attente pour un refus
+qui ne lui dit pas si c'est lui ou le serveur.
+
+**Jamais stocké en clair** côté console : seule son empreinte HMAC est conservée. Une fuite de la
+base ne donne **aucun** code utilisable.
+
+## Le clic est indolore
+
+L'approbation est **humaine** — mais l'agent **re-sonde en boucle**. Le client installe et part
+travailler ; vous approuvez **quand vous voulez** ; la machine **se rattache toute seule**.
+**Personne ne refait rien.**
+
+Sans cette re-tentative, le client qui installe un dimanche à 8 h devrait tout recommencer lundi.
+
+## Le piège du ré-enrôlement
+
+Une machine **déjà enrôlée** qui revient avec une **clé publique différente** : disque remplacé
+chez le client, ou **usurpation** ? **On ne peut pas deviner** — donc on **ne décide pas**. La
+console lève une **alerte explicite** et **refuse d'approuver** sans confirmation consciente.
+
+## Tests
+
+```bash
+npm test   # 16 tests mjs-unit
+```
+
+Un protocole d'enrôlement se juge sur ce qu'il **refuse** : force brute verrouillée, faute de
+frappe qui **ne verrouille pas** le client maladroit, code expiré, code réutilisé, ré-enrôlement
+non confirmé, **approbation forgée par un imposteur**.

package/dist/agent.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @mostajs/enrollment — L'agent MACHINE : se présente, insiste, se rattache tout seul.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+export interface EnrollmentAgent {
+    start(): void;
+    stop(): void;
+    /** Un tour de boucle (tests, ou déclenchement manuel). */
+    tick(): Promise<void>;
+    state(): AgentState;
+}
+export type AgentState = {
+    state: 'non_enrole';
+} | {
+    state: 'en_attente';
+    requestId: string;
+    depuis: string;
+} | {
+    state: 'refuse';
+} | {
+    state: 'enrole';
+    siteId: string;
+    name: string;
+    token: string;
+} | {
+    state: 'erreur';
+    message: string;
+};
+export interface AgentIdentity {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+}
+export interface EnrollmentAgentOptions {
+    /** URL de la console (HTTPS). EMBARQUÉE dans le binaire, jamais saisie par le client. */
+    consoleUrl: string;
+    /** Code d'enrôlement saisi par le client (une seule fois). */
+    code: string;
+    machineId: string;
+    hostname: string;
+    app: string;
+    version: string;
+    /** Identité de la machine. Générée au 1er démarrage, PERSISTÉE — la privée ne sort jamais. */
+    identity: AgentIdentity;
+    /**
+     * Clé publique Ed25519 de la console, EMBARQUÉE dans le binaire.
+     *
+     * C'est le verrou contre la console usurpée : TLS prouve qu'on parle à `console.example`, mais
+     * pas qu'on parle à LA console — DNS détourné, certificat frauduleux. La signature, si.
+     */
+    consolePublicKey: Uint8Array;
+    /** Persistance de l'état (fichier, base…). Fournie par l'hôte. */
+    persist: (state: AgentState) => Promise<void> | void;
+    onState?: (state: AgentState) => void;
+    /** Cadence de re-tentative (ms). Défaut 60 000. */
+    intervalMs?: number;
+    fetchImpl?: typeof fetch;
+}
+/** Génère l'identité de la machine (au premier démarrage). La PRIVÉE ne quitte jamais le poste. */
+export declare function generateIdentity(): AgentIdentity;
+/**
+ * Crée l'agent d'enrôlement.
+ *
+ * ─── LA RE-TENTATIVE EST LE CŒUR ─────────────────────────────────────────────
+ * Sans elle, l'approbation manuelle est un piège : le client installe un dimanche à 8 h, voit
+ * « en attente »… et devrait tout recommencer lundi ? Absurde.
+ *
+ * L'agent RE-SONDE en boucle (`@mostajs/scheduler`). Le client installe et part travailler ;
+ * vous approuvez quand vous voulez ; la machine se rattache TOUTE SEULE et la bannière
+ * disparaît. **Personne ne refait rien.**
+ *
+ * L'appel est SORTANT : aucun certificat, aucun port ouvert, aucun reverse proxy chez le client.
+ * Fonctionne derrière une box, un NAT, un pare-feu d'entreprise.
+ */
+export declare function createEnrollmentAgent(opts: EnrollmentAgentOptions): EnrollmentAgent;

package/dist/agent.js

@@ -0,0 +1,119 @@
+/**
+ * @mostajs/enrollment — L'agent MACHINE : se présente, insiste, se rattache tout seul.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+import { generateSigningKeyPair, verifySignature, equalsConstantTime } from '@mostajs/crypto-box';
+/** Génère l'identité de la machine (au premier démarrage). La PRIVÉE ne quitte jamais le poste. */
+export function generateIdentity() {
+    return generateSigningKeyPair();
+}
+/**
+ * Crée l'agent d'enrôlement.
+ *
+ * ─── LA RE-TENTATIVE EST LE CŒUR ─────────────────────────────────────────────
+ * Sans elle, l'approbation manuelle est un piège : le client installe un dimanche à 8 h, voit
+ * « en attente »… et devrait tout recommencer lundi ? Absurde.
+ *
+ * L'agent RE-SONDE en boucle (`@mostajs/scheduler`). Le client installe et part travailler ;
+ * vous approuvez quand vous voulez ; la machine se rattache TOUTE SEULE et la bannière
+ * disparaît. **Personne ne refait rien.**
+ *
+ * L'appel est SORTANT : aucun certificat, aucun port ouvert, aucun reverse proxy chez le client.
+ * Fonctionne derrière une box, un NAT, un pare-feu d'entreprise.
+ */
+export function createEnrollmentAgent(opts) {
+    const http = opts.fetchImpl ?? fetch;
+    let etat = { state: 'non_enrole' };
+    const poser = async (s) => {
+        etat = s;
+        await opts.persist(s);
+        opts.onState?.(s);
+    };
+    async function cycle() {
+        if (etat.state === 'enrole' || etat.state === 'refuse')
+            return; // terminal
+        try {
+            // 1. Se présenter (une fois), puis 2. sonder jusqu'à décision.
+            if (etat.state !== 'en_attente') {
+                const r = await http(`${opts.consoleUrl}/enroll/request`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({
+                        code: opts.code,
+                        machineId: opts.machineId,
+                        hostname: opts.hostname,
+                        app: opts.app,
+                        version: opts.version,
+                        publicKey: Buffer.from(opts.identity.publicKey).toString('hex'),
+                    }),
+                }).then((x) => x.json());
+                if (!r.ok) {
+                    await poser({ state: 'erreur', message: r.error ?? 'refus' });
+                    return;
+                }
+                await poser({ state: 'en_attente', requestId: r.requestId, depuis: new Date().toISOString() });
+                return;
+            }
+            const s = await http(`${opts.consoleUrl}/enroll/status/${etat.requestId}`).then((x) => x.json());
+            if (s.state === 'rejected') {
+                await poser({ state: 'refuse' });
+                return;
+            }
+            if (s.state !== 'approved')
+                return; // toujours en attente — on repassera
+            // ── VÉRIFIER LA SIGNATURE avant de croire quoi que ce soit.
+            const approval = s.approval;
+            const valide = verifySignature(opts.consolePublicKey, JSON.stringify(approval), Buffer.from(s.signature, 'hex'));
+            if (!valide) {
+                // Une réponse non signée par NOTRE console est une réponse d'imposteur. On ne l'applique
+                // pas, et on ne se tait pas.
+                await poser({ state: 'erreur', message: 'approbation NON SIGNÉE par la console attendue — réponse ignorée' });
+                return;
+            }
+            // La console doit aussi présenter LA clé publique qu'on connaît.
+            if (!equalsConstantTime(approval.consolePublicKey, Buffer.from(opts.consolePublicKey).toString('hex'))) {
+                await poser({ state: 'erreur', message: 'la console renvoie une clé publique INATTENDUE' });
+                return;
+            }
+            await poser({ state: 'enrole', siteId: approval.siteId, name: approval.name, token: approval.token });
+        }
+        catch (e) {
+            // Console injoignable : ce n'est PAS une erreur fatale. La machine continue de servir en
+            // local, et réessaiera au prochain tour. Les tickets doivent continuer à sortir.
+            opts.onState?.({ state: 'erreur', message: e.message });
+        }
+    }
+    // ─── POURQUOI PAS `@mostajs/scheduler` ? ──────────────────────────────────
+    // La tentation était forte : il y a une boucle, une cadence. Mais son CONTRAT est celui d'un
+    // déclencheur à FRONTIÈRES : il adopte la période courante au démarrage SANS rien lancer, et
+    // ne déclenche qu'une fois par frontière franchie. C'est exactement ce qu'il faut pour une
+    // sauvegarde nocturne — et exactement ce qu'il NE faut PAS ici : l'agent doit sonder à CHAQUE
+    // tour, dès le premier, jusqu'à obtenir une réponse.
+    //
+    // Le détourner (mode `count` avec un compteur artificiel) « marcherait »… puis casserait au
+    // premier changement de sémantique du planificateur. Une boucle de re-tentative n'est pas un
+    // planificateur : on ne force pas l'un dans l'autre. Douze lignes ici valent mieux qu'une
+    // dépendance mal utilisée.
+    let timer = null;
+    return {
+        start() {
+            if (timer)
+                return;
+            void cycle(); // on sonde IMMÉDIATEMENT — le client ne doit pas attendre une minute pour rien
+            timer = setInterval(() => { void cycle(); }, opts.intervalMs ?? 60_000);
+            // Le processus ne doit pas être maintenu en vie par cette boucle.
+            if (typeof timer?.unref === 'function') {
+                timer.unref();
+            }
+        },
+        stop() {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+        },
+        tick: cycle,
+        state: () => etat,
+    };
+}

package/dist/code.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @mostajs/enrollment — Le code d'enrôlement : dictable au téléphone.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+export interface EnrollmentCode {
+    /** Forme affichée / dictée : `MJSE-7K4P-2XQ9-M3TA`. */
+    display: string;
+    /** Forme canonique (sans tirets ni préfixe) — c'est ELLE qu'on hache. */
+    canonical: string;
+    /** Empreinte à stocker côté console. Le code EN CLAIR n'est jamais persisté. */
+    hash: string;
+}
+/** Somme de contrôle : 2 caractères dérivés du corps du code. */
+declare function checksum(body: string): string;
+/** Met en forme : `MJSE-XXXX-XXXX-XXXX`. */
+declare function format(body12: string): string;
+/**
+ * Génère un code d'enrôlement.
+ *
+ * 10 caractères aléatoires (50 bits) + 2 de contrôle. 50 bits ne résistent PAS à une attaque
+ * en ligne illimitée — c'est pourquoi le service verrouille après quelques échecs (voir
+ * `service.ts`). Un code n'est pas un mot de passe : il est à usage unique et expire en 7 jours.
+ */
+export declare function generateCode(secret: string): EnrollmentCode;
+/**
+ * Normalise une saisie humaine : majuscules, tirets et espaces retirés, préfixe optionnel,
+ * confusions Crockford corrigées (`O`→`0`, `I`/`L`→`1`, `U`→`V`).
+ *
+ * On accepte donc `mjse 7k4p-2xq9 m3ta`, `7K4P2XQ9M3TA`, ou une saisie où le client a tapé `O`
+ * au lieu de zéro. Refuser un code correct pour une virgule de forme serait absurde : c'est
+ * l'ENTROPIE qui protège, pas la ponctuation.
+ */
+export declare function normalizeCode(input: string): string;
+export type CodeError = 'longueur' | 'caractere_invalide' | 'somme_de_controle';
+/**
+ * Valide la FORME d'un code, **hors ligne**.
+ *
+ * C'est tout l'intérêt de la somme de contrôle : une faute de frappe est rejetée **avant le
+ * moindre appel réseau**. Le client voit « code invalide » immédiatement, au lieu d'attendre
+ * trente secondes pour un « refusé » qui ne lui dit pas si c'est lui ou le serveur.
+ *
+ * Elle ne prouve RIEN sur la validité du code — seulement qu'il a été correctement recopié.
+ */
+export declare function parseCode(input: string): {
+    ok: true;
+    canonical: string;
+} | {
+    ok: false;
+    error: CodeError;
+};
+/**
+ * Empreinte du code, pour la console.
+ *
+ * Le code n'est **jamais** stocké en clair : une fuite de la base ne doit donner **aucun** code
+ * utilisable. C'est un secret d'authentification — on le traite comme un mot de passe.
+ * HMAC (et non simple SHA) : sans le `secret` de la console, on ne peut pas pré-calculer un
+ * dictionnaire de 2⁵⁰ empreintes.
+ */
+export declare function hashCode(canonical: string, secret: string): string;
+/** Compare un code saisi à une empreinte — en TEMPS CONSTANT. */
+export declare function verifyCode(input: string, hash: string, secret: string): boolean;
+export declare const _internal: {
+    ALPHABET: string;
+    checksum: typeof checksum;
+    format: typeof format;
+    PREFIX: string;
+    RANDOM_LEN: number;
+    CHECK_LEN: number;
+};
+export {};

package/dist/code.js

@@ -0,0 +1,98 @@
+/**
+ * @mostajs/enrollment — Le code d'enrôlement : dictable au téléphone.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+import { sha256, hmacSha256, equalsConstantTime, randomKey } from '@mostajs/crypto-box';
+/**
+ * Alphabet **Crockford Base32** : ni `I`, ni `L`, ni `O`, ni `U`.
+ *
+ * Ce n'est pas un détail esthétique. Un code se dicte au téléphone, et « c'est un zéro ou un
+ * O ? », « un 1 ou un I ? » sont les deux questions qui font échouer une installation à
+ * distance. `U` est retiré pour ne pas former de mot grossier par accident.
+ */
+const ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+/** Confusions courantes, corrigées SILENCIEUSEMENT à la lecture (Crockford). */
+const CORRECTIONS = { O: '0', I: '1', L: '1', U: 'V' };
+const PREFIX = 'MJSE';
+const RANDOM_LEN = 10;
+const CHECK_LEN = 2;
+/** Somme de contrôle : 2 caractères dérivés du corps du code. */
+function checksum(body) {
+    const digest = sha256(`mostajs-enrollment-code/v1:${body}`); // hex
+    const n = parseInt(digest.slice(0, 4), 16); // 16 bits
+    return ALPHABET[(n >> 5) & 31] + ALPHABET[n & 31];
+}
+/** Met en forme : `MJSE-XXXX-XXXX-XXXX`. */
+function format(body12) {
+    return `${PREFIX}-${body12.slice(0, 4)}-${body12.slice(4, 8)}-${body12.slice(8, 12)}`;
+}
+/**
+ * Génère un code d'enrôlement.
+ *
+ * 10 caractères aléatoires (50 bits) + 2 de contrôle. 50 bits ne résistent PAS à une attaque
+ * en ligne illimitée — c'est pourquoi le service verrouille après quelques échecs (voir
+ * `service.ts`). Un code n'est pas un mot de passe : il est à usage unique et expire en 7 jours.
+ */
+export function generateCode(secret) {
+    const bytes = randomKey(16);
+    let body = '';
+    for (let i = 0; i < RANDOM_LEN; i++)
+        body += ALPHABET[bytes[i] & 31];
+    body += checksum(body);
+    return { display: format(body), canonical: body, hash: hashCode(body, secret) };
+}
+/**
+ * Normalise une saisie humaine : majuscules, tirets et espaces retirés, préfixe optionnel,
+ * confusions Crockford corrigées (`O`→`0`, `I`/`L`→`1`, `U`→`V`).
+ *
+ * On accepte donc `mjse 7k4p-2xq9 m3ta`, `7K4P2XQ9M3TA`, ou une saisie où le client a tapé `O`
+ * au lieu de zéro. Refuser un code correct pour une virgule de forme serait absurde : c'est
+ * l'ENTROPIE qui protège, pas la ponctuation.
+ */
+export function normalizeCode(input) {
+    let s = String(input ?? '').toUpperCase().replace(/[\s-]/g, '');
+    if (s.startsWith(PREFIX))
+        s = s.slice(PREFIX.length);
+    return [...s].map((c) => CORRECTIONS[c] ?? c).join('');
+}
+/**
+ * Valide la FORME d'un code, **hors ligne**.
+ *
+ * C'est tout l'intérêt de la somme de contrôle : une faute de frappe est rejetée **avant le
+ * moindre appel réseau**. Le client voit « code invalide » immédiatement, au lieu d'attendre
+ * trente secondes pour un « refusé » qui ne lui dit pas si c'est lui ou le serveur.
+ *
+ * Elle ne prouve RIEN sur la validité du code — seulement qu'il a été correctement recopié.
+ */
+export function parseCode(input) {
+    const c = normalizeCode(input);
+    if (c.length !== RANDOM_LEN + CHECK_LEN)
+        return { ok: false, error: 'longueur' };
+    if ([...c].some((ch) => !ALPHABET.includes(ch)))
+        return { ok: false, error: 'caractere_invalide' };
+    const body = c.slice(0, RANDOM_LEN);
+    const check = c.slice(RANDOM_LEN);
+    if (check !== checksum(body))
+        return { ok: false, error: 'somme_de_controle' };
+    return { ok: true, canonical: c };
+}
+/**
+ * Empreinte du code, pour la console.
+ *
+ * Le code n'est **jamais** stocké en clair : une fuite de la base ne doit donner **aucun** code
+ * utilisable. C'est un secret d'authentification — on le traite comme un mot de passe.
+ * HMAC (et non simple SHA) : sans le `secret` de la console, on ne peut pas pré-calculer un
+ * dictionnaire de 2⁵⁰ empreintes.
+ */
+export function hashCode(canonical, secret) {
+    return hmacSha256(secret, `mostajs-enrollment-code/v1:${normalizeCode(canonical)}`);
+}
+/** Compare un code saisi à une empreinte — en TEMPS CONSTANT. */
+export function verifyCode(input, hash, secret) {
+    const p = parseCode(input);
+    if (!p.ok)
+        return false;
+    return equalsConstantTime(hashCode(p.canonical, secret), hash);
+}
+export const _internal = { ALPHABET, checksum, format, PREFIX, RANDOM_LEN, CHECK_LEN };

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @mostajs/enrollment — Enrôler une machine chez un client distant, sans configuration.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ * Niveau : N1 · Compose : crypto-box (Ed25519, HMAC) · scheduler (re-tentative)
+ *
+ * ─── LE PROBLÈME ─────────────────────────────────────────────────────────────
+ * Un `.exe` identique pour tous, installé chez N clients, doit s'IDENTIFIER auprès d'une console
+ * centrale — sans que le client configure quoi que ce soit.
+ *
+ * ─── CE QUE CE MODULE N'EST PAS ──────────────────────────────────────────────
+ * Ce n'est PAS de la licence. Deux questions distinctes, qu'il ne faut jamais fusionner :
+ *   « Ce client a-t-il le DROIT d'utiliser le logiciel ? »  → @mostajs/licensing
+ *   « Cette machine EST-ELLE bien la sienne ? »             → ce module
+ * Les mélanger interdirait de révoquer un enrôlement (machine volée) sans couper la licence.
+ *
+ * ─── LES TROIS VERROUS ───────────────────────────────────────────────────────
+ * 1. **Pas de jeton générique dans le binaire.** Quiconque possède le `.exe` pourrait s'enrôler.
+ *    → Un code PAR CLIENT, dictable au téléphone, à usage unique, 7 jours.
+ * 2. **`machineId` n'authentifie pas** — il identifie. Il est public et falsifiable.
+ *    → Une paire Ed25519 générée sur la machine ; la clé PRIVÉE ne sort jamais. Un jeton volé est
+ *      rejouable ; une clé qui ne bouge pas, non.
+ * 3. **La console peut être usurpée** (DNS détourné, certificat frauduleux).
+ *    → Chaque approbation est SIGNÉE, et vérifiée avec la clé publique EMBARQUÉE dans le binaire.
+ *
+ * ─── ET LE CLIENT NE REFAIT JAMAIS RIEN ──────────────────────────────────────
+ * L'approbation est un CLIC humain — mais l'agent RE-SONDE en boucle. Le client installe et part
+ * travailler ; vous approuvez quand vous voulez ; la machine se rattache toute seule.
+ */
+export declare const moduleInfo: {
+    readonly name: "@mostajs/enrollment";
+    readonly version: "0.1.0";
+    readonly level: "N1";
+};
+export { generateCode, parseCode, normalizeCode, hashCode, verifyCode } from './code.js';
+export type { EnrollmentCode, CodeError } from './code.js';
+export { createEnrollmentService } from './service.js';
+export type { EnrollmentServiceOptions, RequestOutcome } from './service.js';
+export { createEnrollmentAgent, generateIdentity } from './agent.js';
+export type { EnrollmentAgentOptions, AgentState, AgentIdentity } from './agent.js';
+export type { EnrollmentState, EnrollmentRequest, EnrolledSite, Invitation, EnrollmentStore, ApprovalPayload, ReenrollmentAlert, } from './types.js';

package/dist/index.js

@@ -0,0 +1,33 @@
+/**
+ * @mostajs/enrollment — Enrôler une machine chez un client distant, sans configuration.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ * Niveau : N1 · Compose : crypto-box (Ed25519, HMAC) · scheduler (re-tentative)
+ *
+ * ─── LE PROBLÈME ─────────────────────────────────────────────────────────────
+ * Un `.exe` identique pour tous, installé chez N clients, doit s'IDENTIFIER auprès d'une console
+ * centrale — sans que le client configure quoi que ce soit.
+ *
+ * ─── CE QUE CE MODULE N'EST PAS ──────────────────────────────────────────────
+ * Ce n'est PAS de la licence. Deux questions distinctes, qu'il ne faut jamais fusionner :
+ *   « Ce client a-t-il le DROIT d'utiliser le logiciel ? »  → @mostajs/licensing
+ *   « Cette machine EST-ELLE bien la sienne ? »             → ce module
+ * Les mélanger interdirait de révoquer un enrôlement (machine volée) sans couper la licence.
+ *
+ * ─── LES TROIS VERROUS ───────────────────────────────────────────────────────
+ * 1. **Pas de jeton générique dans le binaire.** Quiconque possède le `.exe` pourrait s'enrôler.
+ *    → Un code PAR CLIENT, dictable au téléphone, à usage unique, 7 jours.
+ * 2. **`machineId` n'authentifie pas** — il identifie. Il est public et falsifiable.
+ *    → Une paire Ed25519 générée sur la machine ; la clé PRIVÉE ne sort jamais. Un jeton volé est
+ *      rejouable ; une clé qui ne bouge pas, non.
+ * 3. **La console peut être usurpée** (DNS détourné, certificat frauduleux).
+ *    → Chaque approbation est SIGNÉE, et vérifiée avec la clé publique EMBARQUÉE dans le binaire.
+ *
+ * ─── ET LE CLIENT NE REFAIT JAMAIS RIEN ──────────────────────────────────────
+ * L'approbation est un CLIC humain — mais l'agent RE-SONDE en boucle. Le client installe et part
+ * travailler ; vous approuvez quand vous voulez ; la machine se rattache toute seule.
+ */
+export const moduleInfo = { name: '@mostajs/enrollment', version: '0.1.0', level: 'N1' };
+export { generateCode, parseCode, normalizeCode, hashCode, verifyCode } from './code.js';
+export { createEnrollmentService } from './service.js';
+export { createEnrollmentAgent, generateIdentity } from './agent.js';

package/dist/service.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @mostajs/enrollment — Le service CONSOLE : reçoit, approuve, révoque.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+import type { EnrolledSite, EnrollmentStore, ApprovalPayload } from './types.js';
+export interface EnrollmentServiceOptions {
+    store: EnrollmentStore;
+    /** Secret de la console — sert à hacher les codes. Jamais exposé. */
+    codeSecret: string;
+    /** Clé PRIVÉE Ed25519 de la console : signe les approbations. */
+    signingKey: Uint8Array;
+    /** Clé PUBLIQUE correspondante — celle EMBARQUÉE dans le `.exe`. */
+    signingPublicKey: Uint8Array;
+    /** Échecs consécutifs tolérés avant verrouillage. Défaut 5. */
+    maxAttempts?: number;
+    /** Durée du verrouillage (ms). Défaut 15 min. */
+    lockoutMs?: number;
+    now?: () => Date;
+}
+export type RequestOutcome = {
+    ok: true;
+    requestId: string;
+    state: 'pending';
+} | {
+    ok: false;
+    error: 'code_malforme' | 'code_invalide' | 'code_expire' | 'code_deja_utilise' | 'verrouille';
+};
+/**
+ * Le service d'enrôlement, côté console.
+ *
+ * ─── CE QU'IL PROTÈGE ────────────────────────────────────────────────────────
+ * 1. **La force brute.** 50 bits d'entropie ne résistent PAS à une attaque en ligne illimitée.
+ *    Le service VERROUILLE après quelques échecs — par code ET par origine. Sans ce verrou, le
+ *    code dictable serait une fausse sécurité.
+ * 2. **Le ré-enrôlement usurpé.** Une machine déjà enrôlée qui revient avec une clé publique
+ *    DIFFÉRENTE : disque remplacé, ou usurpation ? On ne peut pas deviner — donc on ne décide
+ *    PAS. On lève un drapeau et on exige un clic conscient.
+ * 3. **La console usurpée.** Chaque approbation est SIGNÉE (Ed25519). La machine vérifie avec la
+ *    clé publique embarquée dans son binaire : même si TLS tombait (DNS détourné, certificat
+ *    frauduleux), un faux jeton ne pourrait pas être forgé.
+ */
+export declare function createEnrollmentService(opts: EnrollmentServiceOptions): {
+    /**
+     * Une machine se présente. Elle ne reçoit RIEN d'utile ici : seulement un `requestId` pour
+     * sonder. Le jeton n'existe qu'après approbation humaine.
+     */
+    request(input: {
+        code: string;
+        machineId: string;
+        hostname: string;
+        publicKey: string;
+        app: string;
+        version: string;
+        origin?: string;
+    }): Promise<RequestOutcome>;
+    /** La machine sonde. Tant qu'aucun humain n'a cliqué, elle n'obtient rien. */
+    status(requestId: string): Promise<{
+        state: "pending" | "rejected" | "unknown";
+    } | {
+        state: "approved";
+        approval: ApprovalPayload;
+        signature: string;
+    }>;
+    /**
+     * Le clic. `acceptReenrollment` DOIT être explicite quand un drapeau est levé : on refuse de
+     * laisser approuver une usurpation par inadvertance.
+     */
+    approve(input: {
+        requestId: string;
+        siteId: string;
+        name: string;
+        approvedBy: string;
+        acceptReenrollment?: boolean;
+    }): Promise<{
+        ok: true;
+        site: EnrolledSite;
+    } | {
+        ok: false;
+        error: "inconnue" | "deja_traitee" | "reenrolement_non_confirme";
+    }>;
+    reject(requestId: string, by: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Révoque un site — machine volée, client parti. La licence, elle, n'est PAS touchée. */
+    revoke(siteId: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Le jeton présenté est-il celui d'un site enrôlé et NON révoqué ? */
+    authenticate(siteId: string, token: string): Promise<EnrolledSite | null>;
+};

package/dist/service.js

@@ -0,0 +1,176 @@
+/**
+ * @mostajs/enrollment — Le service CONSOLE : reçoit, approuve, révoque.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+import { sign, randomKey, equalsConstantTime } from '@mostajs/crypto-box';
+import { verifyCode, parseCode } from './code.js';
+/**
+ * Le service d'enrôlement, côté console.
+ *
+ * ─── CE QU'IL PROTÈGE ────────────────────────────────────────────────────────
+ * 1. **La force brute.** 50 bits d'entropie ne résistent PAS à une attaque en ligne illimitée.
+ *    Le service VERROUILLE après quelques échecs — par code ET par origine. Sans ce verrou, le
+ *    code dictable serait une fausse sécurité.
+ * 2. **Le ré-enrôlement usurpé.** Une machine déjà enrôlée qui revient avec une clé publique
+ *    DIFFÉRENTE : disque remplacé, ou usurpation ? On ne peut pas deviner — donc on ne décide
+ *    PAS. On lève un drapeau et on exige un clic conscient.
+ * 3. **La console usurpée.** Chaque approbation est SIGNÉE (Ed25519). La machine vérifie avec la
+ *    clé publique embarquée dans son binaire : même si TLS tombait (DNS détourné, certificat
+ *    frauduleux), un faux jeton ne pourrait pas être forgé.
+ */
+export function createEnrollmentService(opts) {
+    const clock = opts.now ?? (() => new Date());
+    const maxAttempts = opts.maxAttempts ?? 5;
+    const lockoutMs = opts.lockoutMs ?? 15 * 60_000;
+    /** Compteurs d'échec, par origine (IP) ET par code présenté. */
+    const echecs = new Map();
+    function verrouille(cle) {
+        const e = echecs.get(cle);
+        if (!e)
+            return false;
+        // Aucun verrou POSÉ (jusqua = 0) : on est encore en phase de comptage. Surtout NE PAS
+        // purger l'entrée ici — une première version le faisait, et remettait donc le compteur à
+        // zéro à chaque appel : il ne dépassait jamais 1, et le verrou ne se déclenchait JAMAIS.
+        // Un anti-force-brute qui ne bloque rien est pire que pas d'anti-force-brute : on se croit
+        // protégé.
+        if (e.jusqua === 0)
+            return false;
+        if (clock().getTime() < e.jusqua)
+            return true;
+        echecs.delete(cle); // le verrou a expiré : on repart à zéro
+        return false;
+    }
+    function echec(cle) {
+        const e = echecs.get(cle) ?? { n: 0, jusqua: 0 };
+        e.n += 1;
+        if (e.n >= maxAttempts)
+            e.jusqua = clock().getTime() + lockoutMs;
+        echecs.set(cle, e);
+    }
+    return {
+        /**
+         * Une machine se présente. Elle ne reçoit RIEN d'utile ici : seulement un `requestId` pour
+         * sonder. Le jeton n'existe qu'après approbation humaine.
+         */
+        async request(input) {
+            const origine = input.origin ?? 'inconnue';
+            if (verrouille(origine))
+                return { ok: false, error: 'verrouille' };
+            // Forme d'abord : rejeter une faute de frappe ne doit RIEN coûter, ni compter comme un
+            // échec de sécurité — sinon un client maladroit se verrouille tout seul.
+            const forme = parseCode(input.code);
+            if (!forme.ok)
+                return { ok: false, error: 'code_malforme' };
+            const invitation = await opts.store.findInvitationByCode((h) => verifyCode(input.code, h, opts.codeSecret));
+            if (!invitation) {
+                echec(origine);
+                return { ok: false, error: 'code_invalide' };
+            }
+            if (invitation.usedAt)
+                return { ok: false, error: 'code_deja_utilise' };
+            if (new Date(invitation.expiresAt) < clock())
+                return { ok: false, error: 'code_expire' };
+            // ── Le drapeau du ré-enrôlement. On NE tranche PAS : on alerte.
+            const existant = await opts.store.findSiteByMachineId(input.machineId);
+            const cleChangee = !!existant && !equalsConstantTime(existant.publicKey, input.publicKey);
+            const req = {
+                id: `req-${Date.now()}-${randomKey(6).toString('hex')}`,
+                invitationId: invitation.id,
+                machineId: input.machineId,
+                hostname: input.hostname,
+                publicKey: input.publicKey,
+                app: input.app,
+                version: input.version,
+                origin: origine,
+                state: 'pending',
+                createdAt: clock().toISOString(),
+                /**
+                 * Machine connue, clé DIFFÉRENTE. C'est soit un disque remplacé chez le client, soit
+                 * quelqu'un qui usurpe son identité — et rien dans la requête ne permet de distinguer
+                 * les deux. L'accepter en silence serait le piège classique de ce protocole.
+                 */
+                reenrollmentAlert: cleChangee
+                    ? { previousSiteId: existant.siteId, previousPublicKey: existant.publicKey }
+                    : undefined,
+            };
+            await opts.store.saveRequest(req);
+            echecs.delete(origine); // code valide → on remet le compteur à zéro
+            return { ok: true, requestId: req.id, state: 'pending' };
+        },
+        /** La machine sonde. Tant qu'aucun humain n'a cliqué, elle n'obtient rien. */
+        async status(requestId) {
+            const req = await opts.store.findRequest(requestId);
+            if (!req)
+                return { state: 'unknown' };
+            if (req.state !== 'approved' || !req.approval) {
+                return { state: req.state };
+            }
+            // L'approbation est SIGNÉE : la machine la vérifie avec la clé publique embarquée dans son
+            // binaire. Un imposteur ne peut pas forger de jeton, même en cassant TLS.
+            const payload = JSON.stringify(req.approval);
+            return { state: 'approved', approval: req.approval, signature: sign(opts.signingKey, payload).toString('hex') };
+        },
+        /**
+         * Le clic. `acceptReenrollment` DOIT être explicite quand un drapeau est levé : on refuse de
+         * laisser approuver une usurpation par inadvertance.
+         */
+        async approve(input) {
+            const req = await opts.store.findRequest(input.requestId);
+            if (!req)
+                return { ok: false, error: 'inconnue' };
+            if (req.state !== 'pending')
+                return { ok: false, error: 'deja_traitee' };
+            if (req.reenrollmentAlert && !input.acceptReenrollment) {
+                // Refus DÉLIBÉRÉ : l'approbateur doit avoir vu l'alerte et l'avoir acceptée sciemment.
+                return { ok: false, error: 'reenrolement_non_confirme' };
+            }
+            const token = randomKey(32).toString('hex');
+            const site = {
+                siteId: input.siteId,
+                name: input.name,
+                machineId: req.machineId,
+                publicKey: req.publicKey,
+                app: req.app,
+                token,
+                enrolledAt: clock().toISOString(),
+                revokedAt: null,
+            };
+            req.state = 'approved';
+            req.approval = { siteId: site.siteId, name: site.name, token, consolePublicKey: Buffer.from(opts.signingPublicKey).toString('hex') };
+            req.decidedAt = clock().toISOString();
+            req.decidedBy = input.approvedBy;
+            await opts.store.saveSite(site);
+            await opts.store.saveRequest(req);
+            // Le code est CONSOMMÉ. Un secret qui traîne est une porte ouverte pour rien.
+            await opts.store.markInvitationUsed(req.invitationId, clock().toISOString());
+            return { ok: true, site };
+        },
+        async reject(requestId, by) {
+            const req = await opts.store.findRequest(requestId);
+            if (!req || req.state !== 'pending')
+                return { ok: false };
+            req.state = 'rejected';
+            req.decidedAt = clock().toISOString();
+            req.decidedBy = by;
+            await opts.store.saveRequest(req);
+            return { ok: true };
+        },
+        /** Révoque un site — machine volée, client parti. La licence, elle, n'est PAS touchée. */
+        async revoke(siteId) {
+            const site = await opts.store.findSite(siteId);
+            if (!site || site.revokedAt)
+                return { ok: false };
+            site.revokedAt = clock().toISOString();
+            await opts.store.saveSite(site);
+            return { ok: true };
+        },
+        /** Le jeton présenté est-il celui d'un site enrôlé et NON révoqué ? */
+        async authenticate(siteId, token) {
+            const site = await opts.store.findSite(siteId);
+            if (!site || site.revokedAt)
+                return null;
+            return equalsConstantTime(site.token, token) ? site : null;
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @mostajs/enrollment — types partagés.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+export type EnrollmentState = 'pending' | 'approved' | 'rejected' | 'unknown';
+/** Ce que la console renvoie à la machine, APRÈS approbation. Signé Ed25519. */
+export interface ApprovalPayload {
+    siteId: string;
+    name: string;
+    /** Jeton PROPRE à cette machine. Remplace le code d'enrôlement, qui est consommé. */
+    token: string;
+    /** Clé publique de la console — la machine la compare à celle EMBARQUÉE dans son binaire. */
+    consolePublicKey: string;
+}
+/** Drapeau levé quand une machine connue revient avec une AUTRE clé publique. */
+export interface ReenrollmentAlert {
+    previousSiteId: string;
+    previousPublicKey: string;
+}
+export interface EnrollmentRequest {
+    id: string;
+    invitationId: string;
+    machineId: string;
+    hostname: string;
+    /** Clé PUBLIQUE Ed25519 de la machine (hex). La privée ne quitte jamais le client. */
+    publicKey: string;
+    app: string;
+    version: string;
+    origin: string;
+    state: EnrollmentState;
+    createdAt: string;
+    decidedAt?: string;
+    decidedBy?: string;
+    approval?: ApprovalPayload;
+    /** Non nul ⇒ l'approbation exige une confirmation EXPLICITE. */
+    reenrollmentAlert?: ReenrollmentAlert;
+}
+/** Invitation = un code émis pour UN client. À usage unique, expirant. */
+export interface Invitation {
+    id: string;
+    /** EMPREINTE du code. Le code en clair n'est JAMAIS persisté. */
+    codeHash: string;
+    label: string;
+    expiresAt: string;
+    usedAt?: string | null;
+}
+export interface EnrolledSite {
+    siteId: string;
+    name: string;
+    machineId: string;
+    publicKey: string;
+    app: string;
+    token: string;
+    enrolledAt: string;
+    revokedAt: string | null;
+}
+/**
+ * Persistance — INJECTÉE.
+ *
+ * Le module ne choisit pas votre base : il ne dépend donc pas de l'ORM. Une console qui veut du
+ * @mostajs/orm l'implémente avec ; une démo, avec une Map en mémoire. C'est ce qui rend le
+ * module réutilisable ailleurs.
+ */
+export interface EnrollmentStore {
+    /** Retrouve l'invitation dont l'empreinte satisfait `match` (comparaison à temps constant). */
+    findInvitationByCode(match: (codeHash: string) => boolean): Promise<Invitation | null>;
+    markInvitationUsed(invitationId: string, at: string): Promise<void>;
+    saveRequest(req: EnrollmentRequest): Promise<void>;
+    findRequest(id: string): Promise<EnrollmentRequest | null>;
+    listPendingRequests(): Promise<EnrollmentRequest[]>;
+    saveSite(site: EnrolledSite): Promise<void>;
+    findSite(siteId: string): Promise<EnrolledSite | null>;
+    findSiteByMachineId(machineId: string): Promise<EnrolledSite | null>;
+    listSites(): Promise<EnrolledSite[]>;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * @mostajs/enrollment — types partagés.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+export {};

package/llms.txt

@@ -0,0 +1,80 @@
+# @mostajs/enrollment
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Licence** : AGPL-3.0-or-later
+**Niveau** : N1 · **Dépendance** : `@mostajs/crypto-box`
+
+Enrôler une machine chez un client distant — **sans configuration**.
+
+## Ce que ce module n'est PAS
+
+**Ce n'est pas de la licence.** Deux questions distinctes, qu'il ne faut **jamais** fusionner :
+
+| Question | Module |
+|---|---|
+| « Ce client a-t-il le **droit** d'utiliser le logiciel ? » | `@mostajs/licensing` |
+| « Cette machine **est-elle** bien la sienne ? » | **ce module** |
+
+Les mélanger interdirait de révoquer un enrôlement (machine volée) **sans couper la licence**.
+
+## Les trois verrous
+
+**1. Pas de jeton générique dans le binaire.** Un jeton d'amorçage embarqué dans chaque `.exe`
+est une faille : **quiconque possède le binaire** pourrait s'enrôler et devenir un « site »
+légitime de votre console.
+→ Un **code par client**, dictable au téléphone, **usage unique**, **7 jours**.
+
+**2. `machineId` n'authentifie pas** — il **identifie**. C'est une valeur publique et
+**falsifiable**.
+→ Une paire **Ed25519** générée sur la machine ; la clé **privée ne sort jamais**. Un jeton volé
+(fichier de config, sauvegarde, capture réseau) est **rejouable** ; une clé qui ne bouge pas, non.
+
+**3. La console peut être usurpée** (DNS détourné, certificat frauduleux). TLS prouve qu'on parle
+à `console.example` — pas qu'on parle à **LA** console.
+→ Chaque approbation est **signée Ed25519**, vérifiée avec la clé publique **embarquée dans le
+binaire**. Même si TLS tombait, un faux jeton **ne pourrait pas être forgé**.
+
+## Rien à configurer chez le client
+
+L'enrôlement est **sortant** : la machine **appelle** la console, jamais l'inverse. **Aucun
+certificat, aucun port ouvert, aucun reverse proxy.** Fonctionne derrière une box, un NAT, un
+pare-feu d'entreprise.
+
+## Le code, dictable au téléphone
+
+```
+MJSE-7K4P-2XQ9-M3TA
+```
+
+**Crockford Base32** — ni `I`, ni `L`, ni `O`, ni `U`. Fini le « c'est un zéro ou un O ? », la
+question qui fait échouer une installation à distance. Insensible à la casse, tirets décoratifs.
+
+**10 caractères aléatoires + 2 de contrôle** : une faute de frappe est rejetée **hors ligne**, le
+client voit « code invalide » **tout de suite** — pas après trente secondes d'attente pour un refus
+qui ne lui dit pas si c'est lui ou le serveur.
+
+**Jamais stocké en clair** côté console : seule son empreinte HMAC est conservée. Une fuite de la
+base ne donne **aucun** code utilisable.
+
+## Le clic est indolore
+
+L'approbation est **humaine** — mais l'agent **re-sonde en boucle**. Le client installe et part
+travailler ; vous approuvez **quand vous voulez** ; la machine **se rattache toute seule**.
+**Personne ne refait rien.**
+
+Sans cette re-tentative, le client qui installe un dimanche à 8 h devrait tout recommencer lundi.
+
+## Le piège du ré-enrôlement
+
+Une machine **déjà enrôlée** qui revient avec une **clé publique différente** : disque remplacé
+chez le client, ou **usurpation** ? **On ne peut pas deviner** — donc on **ne décide pas**. La
+console lève une **alerte explicite** et **refuse d'approuver** sans confirmation consciente.
+
+## Tests
+
+```bash
+npm test   # 16 tests mjs-unit
+```
+
+Un protocole d'enrôlement se juge sur ce qu'il **refuse** : force brute verrouillée, faute de
+frappe qui **ne verrouille pas** le client maladroit, code expiré, code réutilisé, ré-enrôlement
+non confirmé, **approbation forgée par un imposteur**.

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@mostajs/enrollment",
+  "version": "0.1.0",
+  "description": "Enrôler une machine chez un client distant, sans configuration : code dictable au téléphone (usage unique, 7 jours), identité Ed25519 générée sur la machine, approbation par un clic dans la console, re-tentative automatique. Compose crypto-box et scheduler.",
+  "license": "AGPL-3.0-or-later",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "llms.txt",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bash test-scripts/run-tests.sh",
+    "example": "node examples/demo.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "enrollment",
+    "provisioning",
+    "device",
+    "fleet",
+    "bootstrap",
+    "ed25519",
+    "mostajs"
+  ],
+  "dependencies": {
+    "@mostajs/crypto-box": "^0.2.0"
+  },
+  "devDependencies": {
+    "@mostajs/mjs-unit": "^0.4.1",
+    "@types/node": "^20",
+    "typescript": "^5.6.0"
+  }
+}