brainclaw 1.21.0 → 1.23.0

package/dist/core/claim-request-schema.js

@@ -0,0 +1,72 @@
+/**
+ * Schémas zod des entrées de la famille CLAIM — `bclaw_claim` et `bclaw_release_claim`
+ * (pln#599 batch 2, deuxième famille composite).
+ *
+ * ── CONTRAINTE, INCHANGÉE DEPUIS LA FAMILLE CAPTURE ───────────────────────────
+ * Le JSON Schema produit doit être byte-identique à celui écrit à la main : le fingerprint
+ * de gouvernance (tests/unit/mcp-governance.test.ts) ne doit pas bouger. Une migration qui
+ * déplace le fingerprint n'est plus une migration, c'est un changement de surface publique.
+ *
+ * ── LES DEUX PIÈGES PAYÉS COMPTANT SUR #220/#221, REPRODUITS ICI EN GARDE ──────
+ * 1. zod émet `additionalProperties: false` d'office. Le laisser DURCIT le contrat : un
+ *    client passant une clé inconnue était ACCEPTÉ (clé ignorée) et se ferait désormais
+ *    rejeter. Le générateur le retire — À LA RACINE UNIQUEMENT, cf. OPEN_SCHEMAS.
+ * 2. Un champ REQUIS dans la version manuelle doit le rester. `rank` était passé optionnel
+ *    par inadvertance sur la famille séquence : assouplissement du contrat, attrapé par le
+ *    seul fingerprint. Ici les requis sont `scope`+`description` (claim) et `id` (release).
+ *
+ * Ni l'un ni l'autre n'avait été vu par mes propres vérifications, ni par le snapshot du
+ * registre CLI — qui mesure quelque chose de plus faible et donne une fausse assurance.
+ *
+ * ── CE QUI N'EST PAS RESSERRÉ, DÉLIBÉRÉMENT ───────────────────────────────────
+ * `store` et `planStatus` restent des chaînes libres et non des enums, bien que leurs
+ * valeurs utiles soient énumérées dans leur description. Les resserrer mérite sa propre
+ * décision : ce serait un rejet nouveau sur des appels aujourd'hui acceptés.
+ * `handoffMode` garde en revanche son enum, parce qu'il en avait DÉJÀ un.
+ */
+import { z } from 'zod';
+/** Identité de l'appelant — commune à la famille, comme pour capture et séquence. */
+const CallerIdentity = {
+    agent: z.string().describe('Agent or person name.').optional(),
+    agentId: z.string().describe('Registered agent id.').optional(),
+};
+export const ClaimRequestSchema = z.object({
+    scope: z.string().describe('Scope being claimed.'),
+    description: z.string().describe('Description of the work.'),
+    ...CallerIdentity,
+    planId: z.string().describe('Optional linked plan item ID.').optional(),
+    project: z
+        .string()
+        .describe('Project name or path. Use this when working on a project different from the MCP server workspace (e.g. CLI agents in a different directory).')
+        .optional(),
+    // Chaîne libre, PAS un enum : les trois niveaux sont documentés mais la valeur reste
+    // ouverte côté schéma publié.
+    store: z.string().describe('Target store level: local (default), repo, workspace.').optional(),
+    worktreeBranch: z
+        .string()
+        .describe('Branch name for the worktree. Defaults to feat/<scope-slug>.')
+        .optional(),
+    worktree: z
+        .boolean()
+        .describe('Whether to create an isolated git worktree (default true). Pass false for an advisory-only lock with no worktree (trp#431) — for in-place work in the main tree.')
+        .optional(),
+    advisory: z
+        .boolean()
+        .describe('Alias for worktree:false — advisory-only lock with no worktree (trp#431).')
+        .optional(),
+    // Enum CONSERVÉ : il existait déjà dans le schéma manuel. Le retirer serait
+    // l'assouplissement symétrique du durcissement qu'on évite ailleurs.
+    handoffMode: z
+        .enum(['self-commit', 'integrator'])
+        .describe('Handoff mode: "self-commit" (worker commits+merges) or "integrator" (another agent reviews+merges). Default: self-commit.')
+        .optional(),
+});
+export const ReleaseClaimRequestSchema = z.object({
+    id: z.string().describe('Claim ID to release.'),
+    planStatus: z.string().describe('Optional: update linked plan status.').optional(),
+    coordinator_override: z
+        .boolean()
+        .describe('Opt-in override for a trusted+ caller releasing a claim they do NOT own (cross-agent teardown, ghost-claim cleanup). Rejected for contributor-level callers; audited when used. trp#928.')
+        .optional(),
+});
+//# sourceMappingURL=claim-request-schema.js.map

package/dist/core/claims.js

@@ -16,7 +16,6 @@ import { loadState, persistState } from './state.js';
 import { createRuntimeEvent } from './events.js';
 import { latestActivityMs, readHeartbeat } from './runtime-signals.js';
 import { emitRegistryPostImage, registryFaultPoint } from './events/registry-post-image.js';
-import { maybeEnqueueClaimTransition, isFederationEnqueueActive } from './federation-outbox.js';
 /** Parse duration string like '4h', '30m' to ms. */
 function parseTtl(value) {
     const match = /^(\d+)([mhd])$/i.exec(value.trim());
@@ -79,26 +78,9 @@ function saveClaimUnlocked(claim, cwd, options) {
     // pln#568 (I2): journal the post-image BEFORE the projection write, so a
     // crash can only leave the journal ahead of the projection, never behind.
     const created = !store.exists(parsed.id);
-    // Federation (pln#101): capture the PREVIOUS status BEFORE the write so we can
-    // diff it after (create or active↔terminal transition ⇒ enqueue for cloud
-    // sync). Only pay the prev-load when federation is actually active; this whole
-    // block runs under the store mutation mutex, which serializes rev reservation.
-    const fedActive = isFederationEnqueueActive(cwd, options?.federation?.suppressEnqueue);
-    let fedPrevStatus;
-    if (fedActive) {
-        try {
-            fedPrevStatus = loadClaimFromAnyDir(parsed.id, cwd).status;
-        }
-        catch {
-            fedPrevStatus = undefined;
-        }
-    }
     emitRegistryPostImage('claim', parsed, { created, agent: parsed.agent, agent_id: parsed.agent_id, session_id: parsed.session_id, cwd });
     registryFaultPoint('after_registry_journal');
     store.save(parsed);
-    if (fedActive) {
-        maybeEnqueueClaimTransition(parsed, fedPrevStatus, fedPrevStatus === undefined, cwd, options?.federation?.suppressEnqueue);
-    }
     const writeDir = claimsDir(cwd, 'write');
     for (const dirPath of claimDirs(cwd)) {
         if (dirPath === writeDir)

package/dist/core/code-map/aggregate.js

@@ -468,6 +468,41 @@ export function aggregateBrief(target, limit, resolved, currentHead, memoryReade
         ...(capped[i].cross_package ? { cross_package: true } : {}),
         ...(capped[i].local ? { local: true } : {}),
     }));
-    return { target, suggested_files_to_read: suggested, related_memory: related, freshness_badge: mergeBadges(perStore.map((p) => ({ ref: p.ref, badge: p.badge, hasIndex: p.r.hasIndex }))) };
+    return {
+        target,
+        suggested_files_to_read: suggested,
+        related_memory: summarizeRelatedMemory(related),
+        freshness_badge: mergeBadges(perStore.map((p) => ({ ref: p.ref, badge: p.badge, hasIndex: p.r.hasIndex }))),
+    };
+}
+/**
+ * Resume la memoire liee servie par `code_brief` (pln#598 etape 3).
+ *
+ * POURQUOI. Un trap ou une decision de ce depot depasse regulierement 2 000 caracteres —
+ * plusieurs des textes ecrits pendant la refonte federation v2 en font le double. Un
+ * `code_brief` qui attache trois d'entre eux sert des milliers de caracteres avant meme
+ * que l'agent n'ait ouvert un fichier, pour un contenu qu'il ne lira peut-etre pas.
+ *
+ * LE TEXTE N'EST PAS PERDU, IL EST DIFFERE. Chaque entree raccourcie porte l'appel EXACT
+ * qui rend l'integralite. Un allegement qui supprime l'information au lieu de la deplacer
+ * force l'agent a deviner — et deviner sur un trap est precisement ce que les traps
+ * existent pour eviter.
+ *
+ * `id`, `kind`, `tags` et `related_paths` restent ENTIERS : ce sont eux qui permettent de
+ * decider s'il vaut la peine d'aller lire. Les tronquer ferait economiser des octets sur
+ * la seule partie qui sert a trier.
+ */
+const RELATED_MEMORY_TEXT_LIMIT = 300;
+export function summarizeRelatedMemory(items) {
+    return items.map((item) => {
+        if (typeof item.text !== 'string' || item.text.length <= RELATED_MEMORY_TEXT_LIMIT)
+            return item;
+        return {
+            ...item,
+            text: `${item.text.slice(0, RELATED_MEMORY_TEXT_LIMIT)}…`,
+            text_truncated: true,
+            full_text_via: { tool: 'bclaw_get', args: { entity: item.kind, id: item.id } },
+        };
+    });
 }
 //# sourceMappingURL=aggregate.js.map

package/dist/core/coordination.js

@@ -300,9 +300,7 @@ function buildIncomingSignalsSummary(cwd) {
     try {
         const fedSignals = pullSignalsFromLinkedProjects(cwd);
         for (const sig of fedSignals) {
-            const payloadPreview = typeof sig.payload === 'string'
-                ? sig.payload.slice(0, 120)
-                : JSON.stringify(sig.payload).slice(0, 120);
+            const payloadPreview = JSON.stringify(sig.payload).slice(0, 120);
             incomingSignals.push({
                 id: sig.id,
                 entity_type: sig.type,

package/dist/core/federation-attestation.js

@@ -0,0 +1,96 @@
+/**
+ * Contrat d'attestation de clé, côté CLIENT (pln#651 étape 4, RFC §5.2).
+ *
+ * ── CE FICHIER A UN JUMEAU, ET C'EST DÉLIBÉRÉ ─────────────────────────────────
+ * Le même contrat existe côté Cloud dans `brainclaw-cloud/src/lib/attestation.ts`.
+ * Les deux DOIVENT produire octet pour octet la même chaîne : le CLI signe, le Worker
+ * vérifie. Ils ne peuvent pas partager un module — deux dépôts, deux runtimes (Node ici,
+ * Workers là-bas) — donc la duplication est assumée et le gel de la forme est verrouillé
+ * DES DEUX CÔTÉS par un test sur le littéral exact.
+ *
+ * Ce n'est pas une précaution théorique. La première livraison côté Cloud reconstruisait
+ * `created_at` avec l'horloge du serveur au moment de l'approbation : la signature portait
+ * sur d'autres octets que ceux vérifiés, et AUCUN appairage ne pouvait aboutir. Le défaut
+ * a survécu à un typecheck vert parce que rien n'exerçait les deux côtés ensemble.
+ *
+ * RÈGLE QUI EN DÉCOULE, valable au-delà de ce fichier : tout champ couvert par une
+ * signature doit venir du signataire, ou d'une valeur qu'il connaît déjà. Un champ que le
+ * vérificateur fabrique lui-même ne peut pas être signé.
+ */
+import crypto from 'node:crypto';
+/**
+ * Payload canonique de l'attestation.
+ *
+ * LA FORME EST GELÉE. Changer l'ordre des clés ou ajouter un champ invalide toutes les
+ * attestations déjà émises — ce qui est voulu, mais doit être un acte délibéré, jamais
+ * l'effet de bord d'une refactorisation. Le test de gel existe pour cela.
+ */
+export function attestationPayload(input) {
+    return JSON.stringify({
+        v: 1,
+        kind: 'brainclaw.federation.v2.key_attestation',
+        enrollment_id: input.enrollment_id,
+        project_id: input.project_id,
+        agent_id: input.agent_id,
+        key_type: input.key_type,
+        key_purpose: input.key_purpose,
+        key_fingerprint: input.key_fingerprint,
+        key_epoch: input.key_epoch,
+        created_at: input.created_at,
+    });
+}
+/**
+ * Empreinte canonique d'un PEM — MÊME RÈGLE que `fingerprintPublicKeyPem` d'agent-registry
+ * et que `fingerprintPem` côté Cloud.
+ *
+ * Le retrait des CR et le trim ne sont pas cosmétiques : le même PEM traversant un champ
+ * JSON ou un éditeur Windows ressort avec un CRLF ou un saut de ligne final. Sans
+ * canonicalisation, deux représentations de LA MÊME clé donnent deux empreintes
+ * différentes — et la comparaison locale↔distante, qui EST la preuve d'identité de la
+ * clé, échouerait sur une différence invisible à l'œil.
+ */
+export function fingerprintPem(pem) {
+    return crypto.createHash('sha256').update(pem.replace(/\r/g, '').trim()).digest('hex');
+}
+/**
+ * Signe des octets avec une clé privée Ed25519 au format PEM, en base64.
+ *
+ * Ed25519 ne prend pas d'algorithme de hachage séparé — d'où le `null` en premier
+ * argument, qui n'est pas un oubli : passer un digest ici lèverait.
+ */
+export function signEd25519(privateKeyPem, message) {
+    const key = crypto.createPrivateKey(privateKeyPem);
+    return crypto.sign(null, Buffer.from(message), key).toString('base64');
+}
+/**
+ * Construit et signe l'attestation liant la clé de chiffrement X25519 de l'appareil à son
+ * identité Ed25519.
+ *
+ * C'EST LA PIÈCE QUI EMPÊCHE LE MEMBRE FANTÔME. Sans elle, le Cloud — qui orchestre
+ * l'appairage — pourrait insérer sa propre clé dans la liste d'enveloppement : un
+ * chiffrement de bout en bout dont l'échange de clés serait arbitré par la partie même
+ * qu'il prétend neutraliser.
+ *
+ * Retourne aussi l'horodatage, que l'appelant DOIT transmettre au serveur : sans lui, le
+ * vérificateur ne peut pas reconstruire les octets signés.
+ */
+export function buildKeyAttestation(params) {
+    const keyFingerprint = fingerprintPem(params.encryptionPublicKeyPem);
+    const payload = attestationPayload({
+        enrollment_id: params.enrollmentId,
+        project_id: params.projectId,
+        agent_id: params.agentId,
+        key_type: 'encryption',
+        key_purpose: 'envelope',
+        key_fingerprint: keyFingerprint,
+        key_epoch: params.keyEpoch ?? 1,
+        created_at: params.createdAt,
+    });
+    return {
+        payload,
+        signature: signEd25519(params.identityPrivateKeyPem, new TextEncoder().encode(payload)),
+        created_at: params.createdAt,
+        key_fingerprint: keyFingerprint,
+    };
+}
+//# sourceMappingURL=federation-attestation.js.map

package/dist/core/federation-canonical.js

@@ -0,0 +1,95 @@
+/**
+ * Sérialisation canonique — fédération v2 (pln#651 étape 5, RFC §3.1).
+ *
+ * ── POURQUOI « CANONIQUE » ET PAS SIMPLEMENT `JSON.stringify` ─────────────────
+ * Ces octets sont hachés, chiffrés et signés par UN programme, puis vérifiés par UN
+ * AUTRE. Une différence d'un seul octet — un espace, un ordre de clés, un `1e3` au lieu
+ * de `1000` — fait échouer la vérification sans qu'aucun message ne dise laquelle des
+ * deux implémentations a tort.
+ *
+ * `JSON.stringify` sur un OBJET n'est déterministe que si l'ordre d'insertion l'est. Il
+ * ne l'est pas quand l'objet vient d'un `JSON.parse`, d'un spread ou d'un tri différent.
+ * D'où un sérialiseur explicite qui trie par point de code, comme l'exige le RFC.
+ *
+ * Le RFC dit aussi : « Core et Cloud partagent les vecteurs de test ; ils ne
+ * réimplémentent pas chacun une quasi-canonicalisation. » Les vecteurs vivent dans les
+ * tests des deux dépôts, sur les mêmes chaînes littérales.
+ */
+import crypto from 'node:crypto';
+/**
+ * Trie par POINT DE CODE et non par `localeCompare`.
+ *
+ * `Array.prototype.sort()` sans comparateur trie déjà par unité de code UTF-16, ce qui
+ * diffère du point de code pour les caractères hors du plan multilingue de base. Un
+ * emoji dans un nom de clé suffirait à faire diverger deux implémentations qui croient
+ * toutes deux « trier les clés ». On compare donc explicitement les points de code.
+ */
+function compareCodePoints(a, b) {
+    const ai = Array.from(a);
+    const bi = Array.from(b);
+    const n = Math.min(ai.length, bi.length);
+    for (let i = 0; i < n; i++) {
+        const ca = ai[i].codePointAt(0);
+        const cb = bi[i].codePointAt(0);
+        if (ca !== cb)
+            return ca - cb;
+    }
+    return ai.length - bi.length;
+}
+/**
+ * JSON canonique : clés triées, aucune espace, chaînes NFC, entiers finis sans notation
+ * exponentielle.
+ *
+ * REFUSE plutôt que d'inventer une représentation pour ce que JSON ne porte pas
+ * fidèlement : `undefined`, `NaN`, `Infinity`, fonctions, symboles, `BigInt`. Les
+ * sérialiser en `null` — ce que fait `JSON.stringify` pour certains — produirait deux
+ * objets différents avec les mêmes octets, donc une signature valide pour un contenu
+ * qu'on n'a pas signé.
+ */
+export function canonicalJson(value) {
+    if (value === null)
+        return 'null';
+    switch (typeof value) {
+        case 'boolean':
+            return value ? 'true' : 'false';
+        case 'number':
+            if (!Number.isFinite(value)) {
+                throw new Error(`Canonicalisation impossible : nombre non fini (${String(value)}).`);
+            }
+            // `String(1e21)` rend "1e+21". Le RFC interdit la notation exponentielle, et un
+            // vérificateur qui lirait "1e+21" produirait d'autres octets que celui qui écrit
+            // "1000000000000000000000". Refuser est plus sûr qu'une conversion approximative.
+            if (Number.isInteger(value) && Math.abs(value) >= 1e21) {
+                throw new Error(`Canonicalisation impossible : entier hors de la plage sérialisable sans exposant (${value}).`);
+            }
+            return JSON.stringify(value);
+        case 'string':
+            // NFC : « é » composé et « e + accent » combinés sont visuellement identiques et
+            // produisent des octets différents. Sans normalisation, un titre saisi sur macOS
+            // (NFD par défaut) et le même titre saisi sur Windows ne se vérifieraient pas.
+            return JSON.stringify(value.normalize('NFC'));
+        case 'object': {
+            if (Array.isArray(value)) {
+                return `[${value.map((v) => canonicalJson(v)).join(',')}]`;
+            }
+            const obj = value;
+            const keys = Object.keys(obj).filter((k) => obj[k] !== undefined).sort(compareCodePoints);
+            return `{${keys.map((k) => `${JSON.stringify(k.normalize('NFC'))}:${canonicalJson(obj[k])}`).join(',')}}`;
+        }
+        default:
+            throw new Error(`Canonicalisation impossible : type '${typeof value}' non sérialisable en JSON.`);
+    }
+}
+/** base64url sans padding — la seule forme admise par le RFC pour les champs binaires. */
+export function b64url(bytes) {
+    return Buffer.from(bytes).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+export function b64urlDecode(s) {
+    const padded = s.replace(/-/g, '+').replace(/_/g, '/');
+    return new Uint8Array(Buffer.from(padded + '='.repeat((4 - (padded.length % 4)) % 4), 'base64'));
+}
+/** SHA-256 des octets canoniques d'une valeur, rendu en base64url (RFC §3.2). */
+export function canonicalSha256(value) {
+    return b64url(new Uint8Array(crypto.createHash('sha256').update(canonicalJson(value), 'utf-8').digest()));
+}
+//# sourceMappingURL=federation-canonical.js.map

package/dist/core/federation-hpke.js

@@ -0,0 +1,213 @@
+/**
+ * HPKE mode base — DHKEM(X25519, HKDF-SHA256) / HKDF-SHA256 / ChaCha20-Poly1305.
+ * Suite v1 du RFC fédération §3.1, conforme à la RFC 9180.
+ *
+ * ── POURQUOI CE CODE EXISTE PLUTÔT QU'UNE DÉPENDANCE ──────────────────────────
+ * Node n'expose pas HPKE. Le projet tient à zéro dépendance d'exécution hors
+ * commander/yaml/zod, et ajouter une bibliothèque de crypto pour un usage aussi restreint
+ * — mode base, une suite, chiffrement à un coup — élargirait la surface d'audit bien
+ * au-delà du besoin.
+ *
+ * CE QUI EST IMPLÉMENTÉ, ET CE QUI NE L'EST PAS. Uniquement le MODE BASE (`mode = 0x00`)
+ * en un seul coup. Ni PSK, ni authentification de l'expéditeur, ni API à secret exporté,
+ * ni chiffrements multiples sur un même contexte. L'authenticité de l'émetteur ne repose
+ * PAS sur HPKE ici : elle vient de la signature Ed25519 d'origine, portée dans
+ * l'enveloppe et vérifiée par tout lecteur (RFC §3.1). Confondre les deux serait une
+ * erreur d'architecture — HPKE en mode base ne dit rien de QUI a chiffré.
+ *
+ * TOUTES LES CONSTANTES SONT CELLES DE LA RFC 9180 et sont vérifiées contre le vecteur de
+ * test A.2 dans tests/unit/federation-hpke.test.ts. Un « ça a l'air juste » sur du code
+ * cryptographique ne vaut rien : soit le vecteur officiel passe, soit l'implémentation
+ * est fausse.
+ */
+import crypto from 'node:crypto';
+// Identifiants d'algorithmes (RFC 9180 §7). Encodés en 16 bits gros-boutiste dans suite_id.
+const KEM_ID = 0x0020; // DHKEM(X25519, HKDF-SHA256)
+const KDF_ID = 0x0001; // HKDF-SHA256
+const AEAD_ID = 0x0003; // ChaCha20-Poly1305
+const NH = 32; // taille de sortie de SHA-256
+const NK = 32; // taille de clé ChaCha20-Poly1305
+const NN = 12; // taille de nonce ChaCha20-Poly1305
+const MODE_BASE = 0x00;
+export const HPKE_SUITE = 'HPKE-v1/X25519-HKDF-SHA256-CHACHA20POLY1305';
+function concat(...parts) {
+    const total = parts.reduce((n, p) => n + p.length, 0);
+    const out = new Uint8Array(total);
+    let off = 0;
+    for (const p of parts) {
+        out.set(p, off);
+        off += p.length;
+    }
+    return out;
+}
+function u16(n) {
+    return new Uint8Array([(n >> 8) & 0xff, n & 0xff]);
+}
+function ascii(s) {
+    return new TextEncoder().encode(s);
+}
+/** RFC 9180 §4 : suite_id du KEM, distinct de celui du contexte HPKE. */
+function kemSuiteId() {
+    return concat(ascii('KEM'), u16(KEM_ID));
+}
+/**
+ * RFC 9180 §5.1 : suite_id du contexte, couvrant KEM, KDF et AEAD.
+ *
+ * `aeadId` est paramétrable UNIQUEMENT pour la validation par vecteurs. La RFC ne publie
+ * en clair dans son corps que l'appendice A.1 (AES-128-GCM) ; pouvoir instancier le
+ * schedule sous cet identifiant permet de vérifier toute la machinerie
+ * labeled_extract/labeled_expand contre des valeurs officielles, plutôt que de se
+ * contenter d'un aller-retour interne qui passerait tout aussi bien avec deux erreurs
+ * symétriques. La suite de production reste figée à ChaCha20-Poly1305.
+ */
+function hpkeSuiteId(aeadId = AEAD_ID) {
+    return concat(ascii('HPKE'), u16(KEM_ID), u16(KDF_ID), u16(aeadId));
+}
+function labeledExtract(suiteId, salt, label, ikm) {
+    // labeled_ikm = "HPKE-v1" || suite_id || label || ikm  (RFC 9180 §4)
+    const labeledIkm = concat(ascii('HPKE-v1'), suiteId, ascii(label), ikm);
+    return new Uint8Array(crypto.createHmac('sha256', Buffer.from(salt)).update(Buffer.from(labeledIkm)).digest());
+}
+function labeledExpand(suiteId, prk, label, info, length) {
+    const labeledInfo = concat(u16(length), ascii('HPKE-v1'), suiteId, ascii(label), info);
+    // HKDF-Expand (RFC 5869) : T(i) = HMAC(prk, T(i-1) || info || i)
+    const out = new Uint8Array(length);
+    let t = new Uint8Array(0);
+    let off = 0;
+    for (let i = 1; off < length; i++) {
+        t = new Uint8Array(crypto.createHmac('sha256', Buffer.from(prk))
+            .update(Buffer.from(concat(t, labeledInfo, new Uint8Array([i]))))
+            .digest());
+        const take = Math.min(t.length, length - off);
+        out.set(t.subarray(0, take), off);
+        off += take;
+    }
+    return out;
+}
+function extractAndExpand(dh, kemContext) {
+    const suiteId = kemSuiteId();
+    const eaePrk = labeledExtract(suiteId, new Uint8Array(0), 'eae_prk', dh);
+    return labeledExpand(suiteId, eaePrk, 'shared_secret', kemContext, NH);
+}
+// ── Conversions de clés X25519 ────────────────────────────────────────────────
+/**
+ * Octets bruts (32) d'une clé publique X25519 depuis son PEM SPKI.
+ *
+ * L'en-tête SPKI d'une X25519 fait exactement 12 octets et est constant pour cet
+ * algorithme ; les 32 derniers octets sont la clé. On prend la FIN du DER plutôt qu'un
+ * décalage fixe depuis le début : le préfixe pourrait varier d'un encodeur à l'autre,
+ * la longueur de la clé, non.
+ */
+export function rawPublicKey(pem) {
+    const der = crypto.createPublicKey(pem).export({ type: 'spki', format: 'der' });
+    return new Uint8Array(der.subarray(der.length - 32));
+}
+function publicKeyFromRaw(raw) {
+    // Préfixe SPKI de X25519 : SEQUENCE { SEQUENCE { OID 1.3.101.110 }, BIT STRING }
+    const prefix = Buffer.from('302a300506032b656e032100', 'hex');
+    return crypto.createPublicKey({
+        key: Buffer.concat([prefix, Buffer.from(raw)]),
+        format: 'der',
+        type: 'spki',
+    });
+}
+// ── KEM : encapsulation / décapsulation ───────────────────────────────────────
+function encapsulate(recipientPublicPem) {
+    const ephemeral = crypto.generateKeyPairSync('x25519');
+    const recipientKey = crypto.createPublicKey(recipientPublicPem);
+    const dh = new Uint8Array(crypto.diffieHellman({ privateKey: ephemeral.privateKey, publicKey: recipientKey }));
+    const enc = new Uint8Array(ephemeral.publicKey.export({ type: 'spki', format: 'der' }).subarray(-32));
+    const pkRm = rawPublicKey(recipientPublicPem);
+    // kem_context = enc || pkRm — l'ordre est normatif ; l'inverser produit un secret
+    // différent des deux côtés et un échec de déchiffrement sans explication.
+    return { sharedSecret: extractAndExpand(dh, concat(enc, pkRm)), enc };
+}
+function decapsulate(enc, recipientPrivateKey) {
+    const ephemeralPublic = publicKeyFromRaw(enc);
+    const dh = new Uint8Array(crypto.diffieHellman({ privateKey: recipientPrivateKey, publicKey: ephemeralPublic }));
+    const pkRm = new Uint8Array(crypto.createPublicKey(recipientPrivateKey).export({ type: 'spki', format: 'der' }).subarray(-32));
+    return extractAndExpand(dh, concat(enc, pkRm));
+}
+// ── Contexte HPKE ─────────────────────────────────────────────────────────────
+function keySchedule(sharedSecret, info, suite = { aeadId: AEAD_ID, nk: NK, nn: NN }) {
+    const suiteId = hpkeSuiteId(suite.aeadId);
+    // En mode base, psk et psk_id sont vides — mais leurs hachages entrent QUAND MÊME dans
+    // le contexte. Les omettre donnerait un contexte différent de toute autre
+    // implémentation conforme.
+    const pskIdHash = labeledExtract(suiteId, new Uint8Array(0), 'psk_id_hash', new Uint8Array(0));
+    const infoHash = labeledExtract(suiteId, new Uint8Array(0), 'info_hash', info);
+    const keyScheduleContext = concat(new Uint8Array([MODE_BASE]), pskIdHash, infoHash);
+    const secret = labeledExtract(suiteId, sharedSecret, 'secret', new Uint8Array(0));
+    return {
+        key: labeledExpand(suiteId, secret, 'key', keyScheduleContext, suite.nk),
+        baseNonce: labeledExpand(suiteId, secret, 'base_nonce', keyScheduleContext, suite.nn),
+        keyScheduleContext,
+        secret,
+    };
+}
+/**
+ * Scelle un texte clair pour un destinataire, lié à un AAD.
+ *
+ * L'AAD est passé en OCTETS DÉJÀ CANONIQUES, jamais en objet : la canonicalisation
+ * appartient à l'appelant, qui doit produire exactement les mêmes octets à la
+ * vérification. L'accepter en objet ici inviterait deux canonicalisations différentes.
+ *
+ * `seq` vaut 0 : un contexte n'est utilisé que pour UN chiffrement. Le RFC interdit toute
+ * répétition du couple de contexte de nonce, et la garantie la plus simple est qu'un
+ * contexte ne serve jamais deux fois — chaque appel génère une clé éphémère neuve.
+ */
+export function seal(params) {
+    const { sharedSecret, enc } = encapsulate(params.recipientPublicKeyPem);
+    const { key, baseNonce } = keySchedule(sharedSecret, params.info ?? new Uint8Array(0));
+    const cipher = crypto.createCipheriv('chacha20-poly1305', Buffer.from(key), Buffer.from(baseNonce), {
+        authTagLength: 16,
+    });
+    cipher.setAAD(Buffer.from(params.aadCanonicalBytes), { plaintextLength: params.plaintext.length });
+    const body = Buffer.concat([cipher.update(Buffer.from(params.plaintext)), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return {
+        alg: HPKE_SUITE,
+        enc: Buffer.from(enc).toString('base64url'),
+        nonce: Buffer.from(baseNonce).toString('base64url'),
+        ciphertext: Buffer.concat([body, tag]).toString('base64url'),
+    };
+}
+/**
+ * Ouvre un blob scellé. Échoue FERMÉ au moindre octet d'AAD différent.
+ *
+ * Toute erreur est convertie en `undefined` plutôt qu'en exception détaillée : distinguer
+ * « mauvaise clé » de « AAD divergent » de « tag invalide » donnerait à un attaquant un
+ * oracle sur la cause de l'échec. L'appelant apprend seulement que ça n'ouvre pas.
+ */
+export function open(params) {
+    try {
+        if (params.sealed.alg !== HPKE_SUITE)
+            return undefined;
+        const enc = new Uint8Array(Buffer.from(params.sealed.enc, 'base64url'));
+        const sharedSecret = decapsulate(enc, params.recipientPrivateKey);
+        const { key, baseNonce } = keySchedule(sharedSecret, params.info ?? new Uint8Array(0));
+        // Le nonce annoncé DOIT être celui dérivé du schedule. Accepter un nonce arbitraire
+        // laisserait un émetteur en réutiliser un — la faute la plus grave possible sur un
+        // AEAD à nonce, qui trahit le clair de deux messages d'un simple XOR.
+        const announced = Buffer.from(params.sealed.nonce, 'base64url');
+        if (!announced.equals(Buffer.from(baseNonce)))
+            return undefined;
+        const raw = Buffer.from(params.sealed.ciphertext, 'base64url');
+        if (raw.length < 16)
+            return undefined;
+        const body = raw.subarray(0, raw.length - 16);
+        const tag = raw.subarray(raw.length - 16);
+        const decipher = crypto.createDecipheriv('chacha20-poly1305', Buffer.from(key), Buffer.from(baseNonce), {
+            authTagLength: 16,
+        });
+        decipher.setAAD(Buffer.from(params.aadCanonicalBytes), { plaintextLength: body.length });
+        decipher.setAuthTag(tag);
+        return new Uint8Array(Buffer.concat([decipher.update(body), decipher.final()]));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Exposé pour les vecteurs de test RFC 9180 ; hors de ce cadre, utiliser `seal`/`open`. */
+export const __testing = { labeledExtract, labeledExpand, keySchedule, kemSuiteId, hpkeSuiteId, extractAndExpand };
+//# sourceMappingURL=federation-hpke.js.map