@mostajs/crypto-box 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,84 @@
+# @mostajs/crypto-box
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Licence** : AGPL-3.0-or-later
+**Niveau** : N0 (primitif) · **Zéro dépendance** (`node:crypto` uniquement)
+
+Les primitives cryptographiques de l'écosystème. **Une seule maison.**
+
+## Pourquoi ce module existe
+
+En consolidant les URLs signées (13/07/2026), on a trouvé la **même comparaison de signature
+implémentée deux fois** : « best effort » (boucle JS) dans `@mostajs/url` — le **kernel**,
+utilisé partout — et correcte (`timingSafeEqual`) dans `@mostajs/storage`, une simple feuille.
+**Le durcissement n'avait jamais circulé.**
+
+C'est ça, le vrai coût d'un doublon cryptographique : ce n'est pas la place qu'il prend, c'est
+que **les corrections ne remontent pas**. Une seule maison = un seul endroit à durcir, un seul
+endroit à auditer.
+
+## Ce que ce module n'est PAS
+
+Ce n'est **pas** une « bibliothèque de crypto générique ». C'est une **enveloppe mince et
+opinionée** sur `node:crypto` :
+
+- pas de choix d'algorithme,
+- pas de mode dangereux,
+- **pas d'IV fourni par l'appelant**.
+
+Un module de crypto qui offre des options est la manière classique d'écrire du chiffrement
+cassé. Le périmètre est dicté par la **demande réelle** — on l'enrichira au prochain besoin
+constaté, pas avant.
+
+## API
+
+| Fonction | Réclamée par |
+|---|---|
+| `sha256` · `sha256Bytes` | `blob-store` (SigV4, checksums) |
+| `hmacSha256` · `hmacSha256Bytes` | `@mostajs/url` (URLs signées), SigV4 |
+| `equalsConstantTime` | **toute** comparaison de secret, signature ou jeton |
+| `aeadEncrypt` · `aeadDecrypt` | `@mostajs/backup` (archives chiffrées) |
+| `deriveKey` · `randomKey` | `@mostajs/backup` (clé depuis une phrase) |
+
+```js
+import { deriveKey, aeadEncrypt, aeadDecrypt } from '@mostajs/crypto-box';
+
+// Le client ne retient qu'une phrase. Le sel se conserve à côté du chiffré (il n'est pas secret).
+const { key, salt } = await deriveKey('la phrase du client');
+const chiffre = aeadEncrypt(key, archive);
+
+// Plus tard, ailleurs :
+const { key: k2 } = await deriveKey('la phrase du client', { salt });
+const restaure = aeadDecrypt(k2, chiffre);   // lève si la clé est fausse OU si UN BIT a changé
+```
+
+**AES-256-GCM** — chiffrement *authentifié* : confidentialité **et** intégrité. Le format est
+autoportant (`MJSC1 | iv | tag | chiffré`) : rien d'autre à conserver que la clé.
+**Dérivation par scrypt** (lente et gourmande à dessein) : un simple SHA-256 d'une phrase se
+casse par force brute à des millions d'essais par seconde.
+
+## Ce dont ce module ne répond pas
+
+La **garde de la clé** est une décision produit, pas une affaire de module. Pour les
+sauvegardes TicketFlow : la clé reste **chez le client**, la console ne stocke que du chiffré
+qu'elle **ne peut pas lire**. Corollaire assumé, à contractualiser : **clé perdue = archive
+irrécupérable.**
+
+## Tests
+
+```bash
+npm test   # 18 tests mjs-unit
+```
+
+En cryptographie, un test qui prouve que « ça marche » ne prouve presque rien : **du
+chiffrement cassé chiffre et déchiffre parfaitement**. Ces tests prouvent ce qui **tue** :
+
+- **un seul bit altéré** fait échouer le déchiffrement (tag GCM) — un déchiffrement qui
+  « réussirait » sur des octets corrompus rendrait une sauvegarde silencieusement fausse ;
+- **l'IV n'est jamais réutilisé** (deux chiffrés du même clair diffèrent) ;
+- une **clé fausse** échoue, jamais de sortie silencieuse ;
+- `equalsConstantTime` **ne plante pas** sur des longueurs différentes — `timingSafeEqual` de
+  Node lève, et un appel naïf tomberait sur une signature tronquée, c'est-à-dire sur une
+  entrée d'attaquant.
+
+Vecteurs **vérifiés indépendamment** : SHA-256 (coreutils), HMAC (**RFC 4231**, cas 1). Jamais
+recopiés depuis le module — un test qui compare la sortie à elle-même ne teste rien.

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+/**
+ * @mostajs/crypto-box — Les primitives cryptographiques de l'écosystème. Une seule maison.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ * Niveau : N0 (primitif) · ZÉRO dépendance (`node:crypto` uniquement)
+ *
+ * ─── POURQUOI CE MODULE EXISTE ───────────────────────────────────────────────
+ * Le 13/07/2026, en consolidant les URLs signées, on a trouvé la MÊME comparaison de
+ * signature implémentée deux fois : « best effort » (boucle JS) dans `@mostajs/url` — le
+ * KERNEL, utilisé partout — et correcte (`timingSafeEqual`) dans `@mostajs/storage`, une
+ * simple feuille. Le durcissement n'avait jamais circulé.
+ *
+ * Voilà le vrai coût d'un doublon cryptographique : ce n'est pas la place qu'il prend,
+ * c'est que **les corrections ne remontent pas**. Une seule maison = un seul endroit à
+ * durcir, un seul endroit à auditer.
+ *
+ * ─── CE QUE CE MODULE N'EST PAS ──────────────────────────────────────────────
+ * Ce n'est PAS une « bibliothèque de crypto générique ». C'est une **enveloppe mince et
+ * opinionée** sur `node:crypto` : pas de choix d'algorithme, pas de mode dangereux, pas
+ * d'IV fourni par l'appelant. Un module de crypto qui offre des options est la manière
+ * classique d'écrire du chiffrement cassé.
+ *
+ * Le périmètre est dicté par la DEMANDE RÉELLE, pas par la spéculation :
+ *   - `hmacSha256` + `equalsConstantTime` → réclamés par @mostajs/url (URLs signées)
+ *   - `sha256`                           → réclamé par blob-store (SigV4, checksums)
+ *   - `aeadEncrypt` / `aeadDecrypt`      → réclamés par @mostajs/backup (archives chiffrées)
+ *   - `deriveKey`                        → réclamé par @mostajs/backup (clé depuis un secret)
+ * On l'enrichira au prochain besoin RÉEL. Pas avant.
+ *
+ * ─── CE DONT CE MODULE NE RÉPOND PAS ─────────────────────────────────────────
+ * La GARDE de la clé n'est pas son affaire — c'est une décision produit. Pour les
+ * sauvegardes TicketFlow : la clé reste chez le client, la console ne stocke que du chiffré
+ * qu'elle ne peut pas lire. Corollaire assumé : **clé perdue = archive irrécupérable.**
+ */
+export declare const moduleInfo: {
+    readonly name: "@mostajs/crypto-box";
+    readonly version: "0.1.0";
+    readonly level: "N0";
+};
+export type Bytes = Uint8Array | Buffer;
+type Encoding = 'hex' | 'base64url';
+/** SHA-256. Défaut : hex (convention des checksums et de SigV4). */
+export declare function sha256(data: Bytes | string, encoding?: Encoding): string;
+/** SHA-256 brut — pour les chaînages (dérivation de clé SigV4, par ex.). */
+export declare function sha256Bytes(data: Bytes | string): Buffer;
+/** HMAC-SHA256. Défaut : hex. */
+export declare function hmacSha256(key: Bytes | string, data: Bytes | string, encoding?: Encoding): string;
+/** HMAC-SHA256 brut — pour les chaînages (SigV4 dérive sa clé par HMAC successifs). */
+export declare function hmacSha256Bytes(key: Bytes | string, data: Bytes | string): Buffer;
+/**
+ * Compare deux valeurs en TEMPS CONSTANT. **Toute** comparaison de secret, de signature ou
+ * de jeton doit passer par ici — jamais par `===`, jamais par une boucle maison.
+ *
+ * C'est LA fonction dont l'absence d'un foyer unique a causé la divergence du 13/07 : le
+ * kernel comparait « best effort » quand une feuille faisait correctement.
+ *
+ * La différence de longueur est renvoyée sans comparaison — elle ne fuit rien : la longueur
+ * d'un HMAC-SHA256 est publique et constante.
+ */
+export declare function equalsConstantTime(a: Bytes | string, b: Bytes | string): boolean;
+export interface DeriveKeyOptions {
+    /** Sel — 16 octets aléatoires recommandés. Généré si absent (et RETOURNÉ : conservez-le). */
+    salt?: Bytes;
+    /** Coût CPU/mémoire (puissance de 2). Défaut 2^17 — ~100 ms, coûteux à brute-forcer. */
+    cost?: number;
+}
+/**
+ * Dérive une clé AES-256 (32 octets) depuis une phrase secrète, par **scrypt**.
+ *
+ * Pourquoi scrypt et pas un simple SHA-256 de la phrase : un hachage est INSTANTANÉ, donc
+ * une phrase faible se casse par force brute à des millions d'essais par seconde. scrypt est
+ * délibérément **lent et gourmand en mémoire** — c'est le but.
+ *
+ * Le `salt` est RETOURNÉ : sans lui, la clé est irrécupérable. Il n'est pas secret et doit
+ * être stocké à côté du chiffré (c'est ce que fait `aeadEncrypt`).
+ */
+export declare function deriveKey(passphrase: string, opts?: DeriveKeyOptions): Promise<{
+    key: Buffer;
+    salt: Buffer;
+}>;
+/** Secret aléatoire (défaut 32 octets) — clés, sels, jetons. */
+export declare function randomKey(bytes?: number): Buffer;
+/**
+ * Chiffre en **AES-256-GCM** (chiffrement AUTHENTIFIÉ : confidentialité ET intégrité).
+ *
+ * Le format de sortie est **autoportant** — `MJSC1 | iv(12) | tag(16) | chiffré` : il n'y a
+ * rien d'autre à conserver que la clé. Sans cela, l'appelant devrait gérer lui-même l'IV et
+ * le tag, et un seul oubli rend le déchiffrement impossible… ou pire, l'IV est réutilisé.
+ *
+ * L'IV est TIRÉ AU HASARD À CHAQUE APPEL et n'est jamais fourni par l'appelant. Réutiliser un
+ * IV en GCM est catastrophique — cela révèle le XOR des clairs et permet de forger des
+ * messages. C'est la raison pour laquelle cette API n'offre pas l'option.
+ */
+export declare function aeadEncrypt(key: Bytes, plaintext: Bytes | string): Buffer;
+/**
+ * Déchiffre un blob produit par `aeadEncrypt`.
+ *
+ * Lève si la clé est fausse OU si le chiffré a été **altéré d'un seul bit** : c'est le tag
+ * GCM qui l'impose. Un déchiffrement qui « réussit » sur des octets corrompus est exactement
+ * ce qu'on ne veut pas d'une sauvegarde.
+ */
+export declare function aeadDecrypt(key: Bytes, blob: Bytes): Buffer;
+export {};

package/dist/index.js

@@ -0,0 +1,146 @@
+/**
+ * @mostajs/crypto-box — Les primitives cryptographiques de l'écosystème. Une seule maison.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ * Niveau : N0 (primitif) · ZÉRO dépendance (`node:crypto` uniquement)
+ *
+ * ─── POURQUOI CE MODULE EXISTE ───────────────────────────────────────────────
+ * Le 13/07/2026, en consolidant les URLs signées, on a trouvé la MÊME comparaison de
+ * signature implémentée deux fois : « best effort » (boucle JS) dans `@mostajs/url` — le
+ * KERNEL, utilisé partout — et correcte (`timingSafeEqual`) dans `@mostajs/storage`, une
+ * simple feuille. Le durcissement n'avait jamais circulé.
+ *
+ * Voilà le vrai coût d'un doublon cryptographique : ce n'est pas la place qu'il prend,
+ * c'est que **les corrections ne remontent pas**. Une seule maison = un seul endroit à
+ * durcir, un seul endroit à auditer.
+ *
+ * ─── CE QUE CE MODULE N'EST PAS ──────────────────────────────────────────────
+ * Ce n'est PAS une « bibliothèque de crypto générique ». C'est une **enveloppe mince et
+ * opinionée** sur `node:crypto` : pas de choix d'algorithme, pas de mode dangereux, pas
+ * d'IV fourni par l'appelant. Un module de crypto qui offre des options est la manière
+ * classique d'écrire du chiffrement cassé.
+ *
+ * Le périmètre est dicté par la DEMANDE RÉELLE, pas par la spéculation :
+ *   - `hmacSha256` + `equalsConstantTime` → réclamés par @mostajs/url (URLs signées)
+ *   - `sha256`                           → réclamé par blob-store (SigV4, checksums)
+ *   - `aeadEncrypt` / `aeadDecrypt`      → réclamés par @mostajs/backup (archives chiffrées)
+ *   - `deriveKey`                        → réclamé par @mostajs/backup (clé depuis un secret)
+ * On l'enrichira au prochain besoin RÉEL. Pas avant.
+ *
+ * ─── CE DONT CE MODULE NE RÉPOND PAS ─────────────────────────────────────────
+ * La GARDE de la clé n'est pas son affaire — c'est une décision produit. Pour les
+ * sauvegardes TicketFlow : la clé reste chez le client, la console ne stocke que du chiffré
+ * qu'elle ne peut pas lire. Corollaire assumé : **clé perdue = archive irrécupérable.**
+ */
+import { createHash, createHmac, timingSafeEqual as nodeTimingSafeEqual, randomBytes, createCipheriv, createDecipheriv, scrypt as nodeScrypt, } from 'node:crypto';
+export const moduleInfo = { name: '@mostajs/crypto-box', version: '0.1.0', level: 'N0' };
+const enc = (buf, encoding) => encoding === 'hex' ? buf.toString('hex') : buf.toString('base64url');
+// ─── Empreintes ──────────────────────────────────────────────────────────────
+/** SHA-256. Défaut : hex (convention des checksums et de SigV4). */
+export function sha256(data, encoding = 'hex') {
+    return enc(createHash('sha256').update(data).digest(), encoding);
+}
+/** SHA-256 brut — pour les chaînages (dérivation de clé SigV4, par ex.). */
+export function sha256Bytes(data) {
+    return createHash('sha256').update(data).digest();
+}
+/** HMAC-SHA256. Défaut : hex. */
+export function hmacSha256(key, data, encoding = 'hex') {
+    return enc(createHmac('sha256', key).update(data).digest(), encoding);
+}
+/** HMAC-SHA256 brut — pour les chaînages (SigV4 dérive sa clé par HMAC successifs). */
+export function hmacSha256Bytes(key, data) {
+    return createHmac('sha256', key).update(data).digest();
+}
+// ─── Comparaison ─────────────────────────────────────────────────────────────
+/**
+ * Compare deux valeurs en TEMPS CONSTANT. **Toute** comparaison de secret, de signature ou
+ * de jeton doit passer par ici — jamais par `===`, jamais par une boucle maison.
+ *
+ * C'est LA fonction dont l'absence d'un foyer unique a causé la divergence du 13/07 : le
+ * kernel comparait « best effort » quand une feuille faisait correctement.
+ *
+ * La différence de longueur est renvoyée sans comparaison — elle ne fuit rien : la longueur
+ * d'un HMAC-SHA256 est publique et constante.
+ */
+export function equalsConstantTime(a, b) {
+    const bufA = Buffer.isBuffer(a) ? a : Buffer.from(a);
+    const bufB = Buffer.isBuffer(b) ? b : Buffer.from(b);
+    if (bufA.length !== bufB.length)
+        return false;
+    if (bufA.length === 0)
+        return true;
+    return nodeTimingSafeEqual(bufA, bufB);
+}
+/**
+ * Dérive une clé AES-256 (32 octets) depuis une phrase secrète, par **scrypt**.
+ *
+ * Pourquoi scrypt et pas un simple SHA-256 de la phrase : un hachage est INSTANTANÉ, donc
+ * une phrase faible se casse par force brute à des millions d'essais par seconde. scrypt est
+ * délibérément **lent et gourmand en mémoire** — c'est le but.
+ *
+ * Le `salt` est RETOURNÉ : sans lui, la clé est irrécupérable. Il n'est pas secret et doit
+ * être stocké à côté du chiffré (c'est ce que fait `aeadEncrypt`).
+ */
+export function deriveKey(passphrase, opts = {}) {
+    const salt = opts.salt ? Buffer.from(opts.salt) : randomBytes(16);
+    const cost = opts.cost ?? 2 ** 17;
+    return new Promise((resolve, reject) => {
+        // `maxmem` doit suivre le coût, sinon Node refuse (« memory limit exceeded »).
+        nodeScrypt(passphrase, salt, 32, { N: cost, r: 8, p: 1, maxmem: 256 * cost * 8 }, (err, key) => {
+            if (err)
+                reject(err);
+            else
+                resolve({ key: key, salt });
+        });
+    });
+}
+/** Secret aléatoire (défaut 32 octets) — clés, sels, jetons. */
+export function randomKey(bytes = 32) {
+    return randomBytes(bytes);
+}
+// ─── Chiffrement authentifié (AEAD) ──────────────────────────────────────────
+const MAGIC = Buffer.from('MJSC1'); // 5 octets — repère de format, versionné
+const IV_LEN = 12; // GCM : 96 bits, la taille recommandée
+const TAG_LEN = 16;
+/**
+ * Chiffre en **AES-256-GCM** (chiffrement AUTHENTIFIÉ : confidentialité ET intégrité).
+ *
+ * Le format de sortie est **autoportant** — `MJSC1 | iv(12) | tag(16) | chiffré` : il n'y a
+ * rien d'autre à conserver que la clé. Sans cela, l'appelant devrait gérer lui-même l'IV et
+ * le tag, et un seul oubli rend le déchiffrement impossible… ou pire, l'IV est réutilisé.
+ *
+ * L'IV est TIRÉ AU HASARD À CHAQUE APPEL et n'est jamais fourni par l'appelant. Réutiliser un
+ * IV en GCM est catastrophique — cela révèle le XOR des clairs et permet de forger des
+ * messages. C'est la raison pour laquelle cette API n'offre pas l'option.
+ */
+export function aeadEncrypt(key, plaintext) {
+    if (key.length !== 32)
+        throw new Error('crypto-box : la clé AES-256 doit faire 32 octets (voir deriveKey)');
+    const iv = randomBytes(IV_LEN);
+    const cipher = createCipheriv('aes-256-gcm', Buffer.from(key), iv);
+    const body = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    return Buffer.concat([MAGIC, iv, cipher.getAuthTag(), body]);
+}
+/**
+ * Déchiffre un blob produit par `aeadEncrypt`.
+ *
+ * Lève si la clé est fausse OU si le chiffré a été **altéré d'un seul bit** : c'est le tag
+ * GCM qui l'impose. Un déchiffrement qui « réussit » sur des octets corrompus est exactement
+ * ce qu'on ne veut pas d'une sauvegarde.
+ */
+export function aeadDecrypt(key, blob) {
+    if (key.length !== 32)
+        throw new Error('crypto-box : la clé AES-256 doit faire 32 octets');
+    const buf = Buffer.from(blob);
+    if (buf.length < MAGIC.length + IV_LEN + TAG_LEN)
+        throw new Error('crypto-box : blob tronqué');
+    if (!buf.subarray(0, MAGIC.length).equals(MAGIC))
+        throw new Error('crypto-box : format inconnu (pas un blob MJSC1)');
+    const iv = buf.subarray(MAGIC.length, MAGIC.length + IV_LEN);
+    const tag = buf.subarray(MAGIC.length + IV_LEN, MAGIC.length + IV_LEN + TAG_LEN);
+    const body = buf.subarray(MAGIC.length + IV_LEN + TAG_LEN);
+    const decipher = createDecipheriv('aes-256-gcm', Buffer.from(key), iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(body), decipher.final()]); // `final()` vérifie le tag
+}

package/llms.txt

@@ -0,0 +1,36 @@
+# @mostajs/crypto-box — 0.1.0
+Auteur : Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later · Niveau N0 · ZÉRO dépendance
+
+RÔLE
+  LES primitives cryptographiques de l'écosystème — une seule maison, un seul endroit à durcir.
+  Enveloppe MINCE et opinionée sur node:crypto. PAS une bibliothèque de crypto : aucun choix
+  d'algorithme, aucun mode dangereux, aucun IV fourni par l'appelant.
+
+MOTIF
+  La même comparaison de signature existait 2x : « best effort » dans @mostajs/url (le KERNEL)
+  et correcte dans @mostajs/storage (une feuille). Le durcissement n'avait pas circulé.
+
+API
+  sha256(data, 'hex'|'base64url')        -> string
+  sha256Bytes(data)                      -> Buffer      (chaînages)
+  hmacSha256(key, data, enc)             -> string
+  hmacSha256Bytes(key, data)             -> Buffer      (chaînage SigV4)
+  equalsConstantTime(a, b)               -> boolean     TOUTE comparaison de secret passe ici
+  deriveKey(passphrase, {salt?, cost?})  -> {key(32o), salt(16o)}   scrypt, N=2^17 par défaut
+  randomKey(bytes=32)                    -> Buffer
+  aeadEncrypt(key32, plaintext)          -> Buffer      AES-256-GCM, format MJSC1|iv|tag|chiffré
+  aeadDecrypt(key32, blob)               -> Buffer      LÈVE si clé fausse OU 1 bit altéré
+
+GARANTIES
+  - AEAD = confidentialité ET intégrité. Un bit modifié → échec (tag GCM).
+  - IV aléatoire à chaque appel, jamais fourni par l'appelant (réutilisation d'IV en GCM =
+    catastrophe : révèle le XOR des clairs, permet de forger).
+  - Format autoportant : rien à conserver hors la clé.
+  - equalsConstantTime ne plante pas sur longueurs différentes (timingSafeEqual de Node lève).
+
+HORS PÉRIMÈTRE
+  La garde de la clé = décision produit. TicketFlow : clé chez le CLIENT, la console ne stocke
+  que du chiffré illisible pour elle. Clé perdue = archive irrécupérable (à contractualiser).
+
+TESTS
+  18 tests mjs-unit. Vecteurs vérifiés indépendamment (sha256 coreutils, HMAC RFC 4231 cas 1).

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@mostajs/crypto-box",
+  "version": "0.1.0",
+  "description": "Les primitives cryptographiques de l'écosystème, une seule maison : sha256, hmac, comparaison à temps constant, AES-256-GCM authentifié, dérivation de clé scrypt. Enveloppe MINCE et opinionée sur node:crypto — pas une bibliothèque de crypto. Primitive N0, zéro dépendance.",
+  "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",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["crypto", "aes-256-gcm", "aead", "hmac", "scrypt", "timing-safe", "zero-dep", "mostajs"],
+  "devDependencies": {
+    "@mostajs/mjs-unit": "^0.3.1",
+    "@types/node": "^20",
+    "typescript": "^5.6.0"
+  }
+}