@mostajs/archive-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,79 @@
+# @mostajs/archive-box
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Licence** : AGPL-3.0-or-later
+**Niveau** : N0 · **Dépendances** : `jszip` + `@mostajs/crypto-box`
+
+Une archive : **un zip, un manifeste, des empreintes** — et, si vous voulez, **une signature**.
+Rien de métier.
+
+## Pourquoi ce module existe
+
+`@mostajs/ixarchive` avait les **bonnes mécaniques** (manifeste versionné, SHA-256, zip, fichiers
+hors base, import validé) — mais **prisonnières d'un domaine** : arbres de projets
+(`collectProjectTree`, `rootProjectSlug`), pierres tombales, pseudonymisation, compteurs de
+répondants et de réponses **gravés dans le format lui-même**. Impossible d'archiver autre chose
+qu'un projet d'enquête.
+
+Extrait ici, le noyau redevient réutilisable — `ixarchive` retrouve son domaine, `@mostajs/backup`
+obtient son artefact.
+
+## Une archive n'est pas « des fichiers zippés »
+
+C'est un artefact **daté, autodescriptif et vérifiable** :
+
+| | Ce que ça prouve |
+|---|---|
+| **SHA-256 par fichier** | l'archive n'a pas été **corrompue par accident** |
+| **Signature Ed25519** (facultative) | l'archive a été **produite par nous** |
+
+**La différence n'est pas rhétorique.** Un attaquant qui modifie un fichier **et recalcule son
+empreinte dans le manifeste** passe le contrôle d'intégrité : tout est « cohérent ». Seule la
+signature du manifeste le trahit.
+
+Et il y a plus subtil : une archive **parfaitement valide, signée par quelqu'un d'autre**.
+Empreintes bonnes, signature authentique — et pourtant ce n'est pas la vôtre. D'où
+`expectedPublicKey` : sans elle, on restaure une base fabriquée par un tiers.
+
+## Usage
+
+```js
+import { buildArchive, openArchive } from '@mostajs/archive-box';
+import { generateSigningKeyPair } from '@mostajs/crypto-box';
+
+const cle = generateSigningKeyPair();
+
+const { buffer } = await buildArchive({
+  name: 'sauvegarde-yalidine',
+  kind: 'backup',                      // étiquette libre — le module ne l'interprète pas
+  files: [
+    { path: 'entities/Ticket.json', content: json },
+    { path: 'config.json', content: config },
+    { path: 'files/logo.png', content: octets },
+  ],
+  extra: { siteId: 'yalidine-01', entites: 12480 },   // le DOMAINE range ce qu'il veut ici
+  signingKey: cle.privateKey,
+  signingPublicKey: cle.publicKey,
+});
+
+// Restauration — strict par défaut : LÈVE si l'intégrité ou la signature est en défaut.
+const { manifest, files, integrity, signature } = await openArchive(buffer, {
+  expectedPublicKey: cle.publicKey,
+});
+```
+
+`strict: false` permet d'**inspecter** une archive suspecte sans la refuser d'emblée.
+
+## Ce que le module ignore
+
+**Ce qu'il y a dans les fichiers.** Des entités ORM, une configuration, une licence, des images :
+il ne le sait pas et n'a pas à le savoir. C'est ce qui le rend réutilisable — et c'est exactement
+ce qui manquait à `ixarchive`.
+
+## Tests
+
+```bash
+npm test   # 14 tests mjs-unit
+```
+
+Une archive se juge sur ce qu'elle **refuse** : corruption d'un fichier, fichier manquant,
+manifeste falsifié (intégrité bernée, signature non), et **signataire inattendu**.

package/dist/index.d.ts

@@ -0,0 +1,141 @@
+/**
+ * @mostajs/archive-box — Une archive : un zip, un manifeste, des empreintes. Rien de métier.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ * Niveau : N0 (primitif) · Dépendances : `jszip` + `@mostajs/crypto-box`
+ *
+ * ─── POURQUOI CE MODULE EXISTE ───────────────────────────────────────────────
+ * `@mostajs/ixarchive` avait les BONNES mécaniques — manifeste versionné, SHA-256 par fichier,
+ * zip, fichiers hors base, import avec validation — mais elles étaient **prisonnières d'un
+ * domaine** : arbres de projets (`collectProjectTree`, `rootProjectSlug`), pierres tombales,
+ * pseudonymisation, comptes de répondants et de réponses. Impossible d'archiver autre chose
+ * qu'un projet d'enquête.
+ *
+ * Extrait ici, le noyau devient réutilisable :
+ *   - `@mostajs/ixarchive` → archive-box + son domaine « projets »  (sa généralisation, enfin)
+ *   - `@mostajs/backup`    → archive-box + orm-copy-data + crypto-box
+ *
+ * ─── CE QU'UNE ARCHIVE EST, ET N'EST PAS ─────────────────────────────────────
+ * Une archive n'est pas « des fichiers zippés ». C'est un artefact **daté, autodescriptif et
+ * VÉRIFIABLE** :
+ *   - chaque fichier porte son **SHA-256** dans le manifeste → la corruption est détectée ;
+ *   - le manifeste peut être **SIGNÉ** (Ed25519) → l'archive prouve **qui l'a produite**.
+ *
+ * La différence n'est pas rhétorique. L'empreinte dit « pas corrompue par accident ». La
+ * signature dit « produite par nous ». Pour une archive qu'on restaure chez un client — et
+ * pour une garantie de déploiement — c'est une différence de nature.
+ *
+ * ─── CE QUE CE MODULE IGNORE ─────────────────────────────────────────────────
+ * Ce qu'il y a DANS les fichiers. Des entités ORM, une configuration, une licence, des
+ * images : il ne le sait pas et n'a pas à le savoir. C'est ce qui le rend réutilisable —
+ * et c'est exactement ce qui manquait à `ixarchive`.
+ */
+export declare const moduleInfo: {
+    readonly name: "@mostajs/archive-box";
+    readonly version: "0.1.0";
+    readonly level: "N0";
+};
+/** Version du FORMAT d'archive (pas du module) : ce qui garantit la lisibilité future. */
+export declare const ARCHIVE_VERSION = "1.0.0";
+/** Un fichier de l'archive, avec son empreinte. */
+export interface ManifestFile {
+    path: string;
+    size: number;
+    sha256: string;
+}
+/** Signature détachée du manifeste (Ed25519). */
+export interface ArchiveSignature {
+    algo: 'ed25519';
+    /** Clé publique du signataire, en hex — pour identifier QUI a signé. */
+    publicKey: string;
+    /** Signature de la charge canonique (manifeste sans son bloc `signature`), en hex. */
+    value: string;
+}
+export interface ArchiveMeta {
+    /** Version du FORMAT. */
+    version: string;
+    /** Étiquette libre du producteur : 'backup', 'project', 'seed'… Le module ne l'interprète pas. */
+    kind: string;
+    createdAt: string;
+    createdBy?: string;
+    sourceApp?: string;
+    sourceUrl?: string;
+    files: ManifestFile[];
+    signature?: ArchiveSignature;
+    /**
+     * Le domaine met ici CE QU'IL VEUT (compteurs, identifiants, versions de schémas…).
+     * C'est cette poche qui a manqué à `ixarchive` : faute d'elle, ses compteurs de répondants
+     * et son `rootProjectSlug` étaient gravés dans le format lui-même.
+     */
+    extra?: Record<string, unknown>;
+}
+export interface ArchiveManifest {
+    $schema: string;
+    '@context': string;
+    '@type': string;
+    archiveBox: ArchiveMeta;
+    name: string;
+    description: string;
+}
+export interface ArchiveFile {
+    path: string;
+    content: Buffer | Uint8Array | string;
+}
+export interface BuildArchiveOptions {
+    files: ArchiveFile[];
+    name: string;
+    description?: string;
+    kind?: string;
+    createdBy?: string;
+    sourceApp?: string;
+    sourceUrl?: string;
+    extra?: Record<string, unknown>;
+    /** Clé privée Ed25519 (32 o). Fournie → le manifeste est SIGNÉ. */
+    signingKey?: Uint8Array | Buffer;
+    /** Clé publique correspondante (32 o) — inscrite au manifeste pour identifier le signataire. */
+    signingPublicKey?: Uint8Array | Buffer;
+}
+export interface BuiltArchive {
+    buffer: Buffer;
+    manifest: ArchiveManifest;
+    /** Empreinte de l'archive ENTIÈRE (le zip) — à conserver hors de l'archive. */
+    sha256: string;
+}
+/** Construit une archive : zip + manifeste + empreinte par fichier (+ signature facultative). */
+export declare function buildArchive(opts: BuildArchiveOptions): Promise<BuiltArchive>;
+export type IntegrityVerdict = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'manifest_absent' | 'manifest_illisible' | 'fichier_absent' | 'empreinte_invalide';
+    detail?: string;
+};
+export type SignatureVerdict = 'absente' | 'valide' | 'invalide' | 'signataire_inattendu';
+export interface OpenedArchive {
+    manifest: ArchiveManifest;
+    /** Contenu des fichiers, par chemin. */
+    files: Map<string, Buffer>;
+    integrity: IntegrityVerdict;
+    signature: SignatureVerdict;
+}
+/** Lit le manifeste sans extraire l'archive (peu coûteux, utile pour lister). */
+export declare function readManifest(zipBuffer: Buffer | Uint8Array): Promise<ArchiveManifest | null>;
+/**
+ * Ouvre une archive en VÉRIFIANT chaque empreinte, et la signature si une clé est fournie.
+ *
+ * `strict` (défaut **true**) : lève si l'intégrité échoue. C'est le bon défaut — restaurer
+ * une archive corrompue est pire que ne pas restaurer du tout. Passer `strict: false` pour
+ * inspecter une archive suspecte sans la refuser d'emblée.
+ */
+export declare function openArchive(zipBuffer: Buffer | Uint8Array, opts?: {
+    expectedPublicKey?: Uint8Array | Buffer;
+    strict?: boolean;
+}): Promise<OpenedArchive>;
+/** Vérifie une archive sans en extraire le contenu (verdict seul). */
+export declare function verifyArchive(zipBuffer: Buffer | Uint8Array, opts?: {
+    expectedPublicKey?: Uint8Array | Buffer;
+}): Promise<{
+    integrity: IntegrityVerdict;
+    signature: SignatureVerdict;
+    manifest: ArchiveManifest | null;
+}>;

package/dist/index.js

@@ -0,0 +1,189 @@
+/**
+ * @mostajs/archive-box — Une archive : un zip, un manifeste, des empreintes. Rien de métier.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ * Niveau : N0 (primitif) · Dépendances : `jszip` + `@mostajs/crypto-box`
+ *
+ * ─── POURQUOI CE MODULE EXISTE ───────────────────────────────────────────────
+ * `@mostajs/ixarchive` avait les BONNES mécaniques — manifeste versionné, SHA-256 par fichier,
+ * zip, fichiers hors base, import avec validation — mais elles étaient **prisonnières d'un
+ * domaine** : arbres de projets (`collectProjectTree`, `rootProjectSlug`), pierres tombales,
+ * pseudonymisation, comptes de répondants et de réponses. Impossible d'archiver autre chose
+ * qu'un projet d'enquête.
+ *
+ * Extrait ici, le noyau devient réutilisable :
+ *   - `@mostajs/ixarchive` → archive-box + son domaine « projets »  (sa généralisation, enfin)
+ *   - `@mostajs/backup`    → archive-box + orm-copy-data + crypto-box
+ *
+ * ─── CE QU'UNE ARCHIVE EST, ET N'EST PAS ─────────────────────────────────────
+ * Une archive n'est pas « des fichiers zippés ». C'est un artefact **daté, autodescriptif et
+ * VÉRIFIABLE** :
+ *   - chaque fichier porte son **SHA-256** dans le manifeste → la corruption est détectée ;
+ *   - le manifeste peut être **SIGNÉ** (Ed25519) → l'archive prouve **qui l'a produite**.
+ *
+ * La différence n'est pas rhétorique. L'empreinte dit « pas corrompue par accident ». La
+ * signature dit « produite par nous ». Pour une archive qu'on restaure chez un client — et
+ * pour une garantie de déploiement — c'est une différence de nature.
+ *
+ * ─── CE QUE CE MODULE IGNORE ─────────────────────────────────────────────────
+ * Ce qu'il y a DANS les fichiers. Des entités ORM, une configuration, une licence, des
+ * images : il ne le sait pas et n'a pas à le savoir. C'est ce qui le rend réutilisable —
+ * et c'est exactement ce qui manquait à `ixarchive`.
+ */
+import JSZip from 'jszip';
+import { sha256, sign, verifySignature, equalsConstantTime } from '@mostajs/crypto-box';
+export const moduleInfo = { name: '@mostajs/archive-box', version: '0.1.0', level: 'N0' };
+/** Version du FORMAT d'archive (pas du module) : ce qui garantit la lisibilité future. */
+export const ARCHIVE_VERSION = '1.0.0';
+const MANIFEST_PATH = 'manifest.json';
+const VERSION_PATH = 'archive-version.txt';
+/**
+ * Charge canonique signée : le manifeste **sans son bloc `signature`**, sérialisé de façon
+ * stable. Sans cette exclusion, on signerait un objet contenant sa propre signature —
+ * impossible à vérifier.
+ */
+function signingPayload(manifest) {
+    const { signature, ...meta } = manifest.archiveBox;
+    void signature;
+    return JSON.stringify({ ...manifest, archiveBox: meta });
+}
+const toBuffer = (c) => Buffer.isBuffer(c) ? c : typeof c === 'string' ? Buffer.from(c, 'utf8') : Buffer.from(c);
+/** Construit une archive : zip + manifeste + empreinte par fichier (+ signature facultative). */
+export async function buildArchive(opts) {
+    const entries = opts.files.map((f) => ({ path: f.path, content: toBuffer(f.content) }));
+    const manifestFiles = entries.map((f) => ({
+        path: f.path,
+        size: f.content.length,
+        sha256: sha256(f.content),
+    }));
+    const manifest = {
+        $schema: 'https://mostajs.dev/schemas/archive-box/1.0.0.json',
+        '@context': 'https://mostajs.dev/context/archive-box',
+        '@type': 'Archive',
+        name: opts.name,
+        description: opts.description ?? `Archive « ${opts.name} »`,
+        archiveBox: {
+            version: ARCHIVE_VERSION,
+            kind: opts.kind ?? 'generic',
+            createdAt: new Date().toISOString(),
+            createdBy: opts.createdBy,
+            sourceApp: opts.sourceApp,
+            sourceUrl: opts.sourceUrl,
+            files: manifestFiles,
+            extra: opts.extra,
+        },
+    };
+    if (opts.signingKey) {
+        if (!opts.signingPublicKey) {
+            throw new Error('[archive-box] signingPublicKey requise : sans elle, la signature est invérifiable');
+        }
+        manifest.archiveBox.signature = {
+            algo: 'ed25519',
+            publicKey: Buffer.from(opts.signingPublicKey).toString('hex'),
+            value: sign(opts.signingKey, signingPayload(manifest)).toString('hex'),
+        };
+    }
+    const zip = new JSZip();
+    zip.file(MANIFEST_PATH, JSON.stringify(manifest, null, 2));
+    zip.file(VERSION_PATH, ARCHIVE_VERSION);
+    for (const f of entries)
+        zip.file(f.path, f.content);
+    const buffer = await zip.generateAsync({
+        type: 'nodebuffer',
+        compression: 'DEFLATE',
+        compressionOptions: { level: 9 },
+    });
+    return { buffer, manifest, sha256: sha256(buffer) };
+}
+/** Lit le manifeste sans extraire l'archive (peu coûteux, utile pour lister). */
+export async function readManifest(zipBuffer) {
+    try {
+        const zip = await JSZip.loadAsync(Buffer.from(zipBuffer));
+        const f = zip.file(MANIFEST_PATH);
+        if (!f)
+            return null;
+        return JSON.parse(await f.async('string'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Ouvre une archive en VÉRIFIANT chaque empreinte, et la signature si une clé est fournie.
+ *
+ * `strict` (défaut **true**) : lève si l'intégrité échoue. C'est le bon défaut — restaurer
+ * une archive corrompue est pire que ne pas restaurer du tout. Passer `strict: false` pour
+ * inspecter une archive suspecte sans la refuser d'emblée.
+ */
+export async function openArchive(zipBuffer, opts = {}) {
+    const strict = opts.strict !== false;
+    const buf = Buffer.from(zipBuffer);
+    const zip = await JSZip.loadAsync(buf);
+    const mf = zip.file(MANIFEST_PATH);
+    if (!mf) {
+        const verdict = { ok: false, reason: 'manifest_absent' };
+        if (strict)
+            throw new Error('[archive-box] manifeste absent — ce n’est pas une archive');
+        return { manifest: null, files: new Map(), integrity: verdict, signature: 'absente' };
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(await mf.async('string'));
+    }
+    catch (e) {
+        if (strict)
+            throw new Error(`[archive-box] manifeste illisible : ${e.message}`);
+        return { manifest: null, files: new Map(), integrity: { ok: false, reason: 'manifest_illisible' }, signature: 'absente' };
+    }
+    // ── Intégrité : chaque fichier annoncé doit être présent ET conforme à son empreinte.
+    const files = new Map();
+    let integrity = { ok: true };
+    for (const decl of manifest.archiveBox?.files ?? []) {
+        const entry = zip.file(decl.path);
+        if (!entry) {
+            integrity = { ok: false, reason: 'fichier_absent', detail: decl.path };
+            break;
+        }
+        const content = await entry.async('nodebuffer');
+        // Comparaison à temps constant : une empreinte est une valeur d'intégrité, on ne
+        // laisse pas fuir d'information par le temps de comparaison.
+        if (!equalsConstantTime(sha256(content), decl.sha256)) {
+            integrity = { ok: false, reason: 'empreinte_invalide', detail: decl.path };
+            break;
+        }
+        files.set(decl.path, content);
+    }
+    if (!integrity.ok && strict) {
+        throw new Error(`[archive-box] intégrité en défaut (${integrity.reason}${integrity.detail ? ' : ' + integrity.detail : ''})`);
+    }
+    // ── Signature : l'intégrité dit « pas corrompue » ; la signature dit « produite par X ».
+    let signature = 'absente';
+    const sig = manifest.archiveBox?.signature;
+    if (sig) {
+        const payload = signingPayload(manifest);
+        const signerPub = Buffer.from(sig.publicKey, 'hex');
+        const valide = verifySignature(signerPub, payload, Buffer.from(sig.value, 'hex'));
+        if (!valide)
+            signature = 'invalide';
+        else if (opts.expectedPublicKey && !equalsConstantTime(signerPub, Buffer.from(opts.expectedPublicKey))) {
+            // Signature authentique… mais de QUELQU'UN D'AUTRE. C'est le piège : une archive
+            // correctement signée par un tiers n'est PAS une archive de confiance.
+            signature = 'signataire_inattendu';
+        }
+        else {
+            signature = 'valide';
+        }
+    }
+    if (strict && signature === 'invalide') {
+        throw new Error('[archive-box] signature INVALIDE — le manifeste a été altéré');
+    }
+    if (strict && signature === 'signataire_inattendu') {
+        throw new Error('[archive-box] signature valide mais d’un signataire INATTENDU');
+    }
+    return { manifest, files, integrity, signature };
+}
+/** Vérifie une archive sans en extraire le contenu (verdict seul). */
+export async function verifyArchive(zipBuffer, opts = {}) {
+    const res = await openArchive(zipBuffer, { ...opts, strict: false });
+    return { integrity: res.integrity, signature: res.signature, manifest: res.manifest ?? null };
+}

package/llms.txt

@@ -0,0 +1,33 @@
+# @mostajs/archive-box — 0.1.0
+Auteur : Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later · N0 · deps : jszip + @mostajs/crypto-box
+
+RÔLE
+  Une archive = zip + manifeste + empreinte SHA-256 par fichier + signature Ed25519 facultative.
+  IGNORE ce qu'il y a dans les fichiers — c'est ce qui le rend réutilisable.
+  EXTRAIT du noyau d'@mostajs/ixarchive, débarrassé de son domaine « projets » (collectProjectTree,
+  rootProjectSlug, pierres tombales, compteurs de répondants — qui étaient GRAVÉS dans le format).
+
+API
+  buildArchive({ files:[{path,content}], name, description?, kind?, createdBy?, sourceApp?,
+                 extra?, signingKey?, signingPublicKey? })  -> { buffer, manifest, sha256 }
+  openArchive(zip, { expectedPublicKey?, strict=true })     -> { manifest, files:Map, integrity, signature }
+  verifyArchive(zip, { expectedPublicKey? })                -> { integrity, signature, manifest }
+  readManifest(zip)                                         -> manifest | null   (sans extraire)
+  ARCHIVE_VERSION = '1.0.0'
+
+VERDICTS
+  integrity : {ok:true} | {ok:false, reason: manifest_absent|manifest_illisible|fichier_absent|empreinte_invalide}
+  signature : 'absente' | 'valide' | 'invalide' | 'signataire_inattendu'
+
+INTÉGRITÉ ≠ AUTHENTICITÉ (le point du module)
+  - Empreinte : l'archive n'a pas été corrompue PAR ACCIDENT.
+  - Signature : l'archive a été PRODUITE PAR NOUS.
+  Un attaquant qui modifie un fichier ET recalcule son empreinte au manifeste PASSE l'intégrité.
+  Seule la signature le trahit. Et une archive VALIDE signée par un TIERS reste dangereuse :
+  d'où `expectedPublicKey` — sans elle on restaure une base fabriquée par quelqu'un d'autre.
+
+DOMAINE
+  `extra: Record<string,unknown>` — le producteur y range ses métadonnées. Le FORMAT ne les grave pas.
+
+TESTS
+  14 tests mjs-unit : corruption, fichier absent, manifeste falsifié (intégrité bernée), signataire inattendu.

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@mostajs/archive-box",
+  "version": "0.1.0",
+  "description": "Une archive : un zip, un manifeste, des empreintes SHA-256 par fichier, une signature Ed25519 facultative. Générique — le module ignore ce qu'il y a DANS les fichiers. Extrait du noyau d'@mostajs/ixarchive, débarrassé de son domaine « projets ».",
+  "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": ["archive", "zip", "manifest", "sha256", "ed25519", "backup", "integrity", "mostajs"],
+  "dependencies": {
+    "@mostajs/crypto-box": "^0.2.0",
+    "jszip": "^3.10.1"
+  },
+  "devDependencies": {
+    "@mostajs/mjs-unit": "^0.4.0",
+    "@types/node": "^20",
+    "typescript": "^5.6.0"
+  }
+}