pow-equix-wasm 0.1.0

package/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

package/README.md

@@ -0,0 +1,151 @@
+# pow-equix-wasm
+
+Preuve de travail **Equi-X** (celle que Tor utilise contre les dénis de service)
+compilée en WebAssembly : **un seul module de 45 Kio** résout la preuve dans le
+navigateur, sur plusieurs cœurs, et la vérifie côté serveur en quelques centaines
+de microsecondes.
+
+- **Démo et calibrage** : <https://contribulibre.github.io/pow-equix-wasm/>
+- **Paquet npm** : [`pow-equix-wasm`](https://www.npmjs.com/package/pow-equix-wasm)
+
+> *English summary: Equi-X proof of work (from Tor's Arti project) as a single
+> WebAssembly module. It solves in the browser across Web Workers (cancellable,
+> with progress) and verifies server-side in ~0.2 ms per part. The build is
+> reproducible byte for byte. LGPL-3.0.*
+
+## Pourquoi Equi-X plutôt que SHA-256
+
+Une preuve SHA-256 (façon hashcash) se calcule des milliers de fois plus vite sur
+une carte graphique ou une puce de minage que dans un navigateur. Equi-X tire au
+sort un nouveau programme HashX à chaque essai et demande environ 1,8 Mio de
+mémoire par essai : l’avantage d’un attaquant équipé tombe à un facteur de
+l’ordre de 20 face à un navigateur. La vérification, elle, reste très bon marché.
+
+## Protocole
+
+Le défi d’un essai est `graine ‖ compteur` (compteur u32 petit-boutiste). La
+graine appartient à l’appelant : en général un domaine propre à son protocole,
+un octet nul, puis l’empreinte SHA-256 de la requête à protéger
+(`construireGraine`). Une preuve calculée pour une requête ne vaut donc rien pour
+une autre.
+
+- Equi-X trouve en moyenne deux solutions par défi. Une solution est retenue si
+  `blake2b-256(défi ‖ solution)`, lu en u32 gros-boutiste, multiplié par
+  l’**effort**, ne dépasse pas 2³² − 1 : c’est la règle d’effort de Tor (`hs_pow`).
+- Une preuve réunit **`nombre` parts** de 20 octets (`compteur ‖ solution`), aux
+  compteurs strictement croissants. Plusieurs petites preuves plutôt qu’une
+  grande rendent l’attente régulière (écart type relatif en `1/√nombre`).
+- Probabilité qu’un essai aboutisse : environ `1 − e^(−2/effort)`, soit 86 %
+  pour l’effort 1, 62 % pour 2, 12 % pour 16 (`probabiliteEssai`).
+
+## Utilisation
+
+```ts
+import { ModuleEquix, construireGraine, hexadecimal, resoudre } from 'pow-equix-wasm'
+
+// Navigateur : le module est un fichier du paquet, que le bundler publie (ici Vite).
+import urlEquix from 'pow-equix-wasm/equix.wasm?url'
+const octets = new Uint8Array(await (await fetch(urlEquix)).arrayBuffer())
+
+const graine = await construireGraine('mon-service/1', JSON.stringify(requete))
+const annulation = new AbortController()
+const { parts, essais } = await resoudre({
+  octets, graine, effort: 1, nombre: 4,
+  signal: annulation.signal,
+  onProgression: ({ essais, parts, memoireOctets }) => { /* … */ },
+})
+envoyer({ ...requete, preuve: hexadecimal(parts) })
+```
+
+Côté serveur (Bun, Node, Deno), la même bibliothèque vérifie :
+
+```ts
+import { readFile } from 'node:fs/promises'
+import { ModuleEquix, construireGraine, depuisHexadecimal } from 'pow-equix-wasm'
+
+const module = await ModuleEquix.instancier(await readFile(new URL(import.meta.resolve('pow-equix-wasm/equix.wasm'))))
+const graine = await construireGraine('mon-service/1', JSON.stringify(requeteSansPreuve))
+const valide = module.verifier(graine, depuisHexadecimal(preuve) ?? new Uint8Array(), 1, 4)
+```
+
+Une page qui ne peut rien télécharger (ouverte en `file://`, script unique) peut
+intégrer le module en base64 :
+
+```ts
+import { octetsEquix } from 'pow-equix-wasm/octets'
+const octets = octetsEquix()
+```
+
+Ce qui reste à la charge de l’appelant, et que le paquet ne fait pas :
+refuser les preuves rejouées, vérifier la fraîcheur de la requête (horodatage
+dans le contenu haché) et limiter le débit des vérifications.
+
+### Web Workers
+
+`resoudre` répartit les compteurs entre des Web Workers créés depuis un Blob
+(aucun fichier supplémentaire à publier) : par défaut un par cœur annoncé, huit
+au plus, et jamais plus que d’essais attendus. Si les Web Workers sont refusés
+(politique de sécurité, `file://` dans certains navigateurs), le calcul continue
+sur le fil courant, essai par essai. `fils: 0` force ce mode.
+
+## Mesures
+
+Linux x86_64, un fil, module WebAssembly :
+
+| | Chromium | Bun 1.4 |
+|---|---|---|
+| un essai | ≈ 410 ms | ≈ 400 ms |
+| vérification d’une part | ≈ 230 µs | ≈ 250 µs |
+| mémoire par fil | ≈ 1,8 Mio de zone de travail (2,9 Mio pour l’instance) | |
+
+Les temps varient fortement d’un appareil à l’autre : c’est tout l’objet de la
+page de démo, qui mesure sur l’appareil utilisé le temps d’une preuve (médiane,
+90ᵉ centile), la mémoire par fil et le coût de la vérification, et exporte le
+tout en JSON pour comparer plusieurs appareils.
+
+## Construction reproductible
+
+Le module est construit, jamais versionné : `dist/` et `site/` sont produits
+par la CI.
+
+- Rust figé par `rust-toolchain.toml`, dépendances verrouillées par `Cargo.lock`
+  (`cargo build --locked`), chemins locaux effacés du binaire
+  (`--remap-path-prefix`), pas de compilation incrémentale.
+- `bun run verify:reproductible` reconstruit depuis une copie des sources placée
+  ailleurs et exige un module identique à l’octet près.
+- Chaque release GitHub donne le SHA-256 du module publié ; pour le vérifier :
+  `bun run build && bun run verify:reproductible --attendu <sha256>`.
+
+```sh
+bun install
+bun run check   # tests Rust et TS, construction, démo, reproductibilité
+bun run demo    # construit puis sert la démo sur http://127.0.0.1:4600/
+```
+
+Il faut Rust (via rustup, qui installe seul la version figée et la cible
+`wasm32-unknown-unknown`) et Bun.
+
+## Publication
+
+- **Démo** : chaque push sur `main` la publie sur GitHub Pages (réglage du dépôt :
+  *Settings → Pages → Source : GitHub Actions*).
+- **npm** : pousser un tag `vX.Y.Z` égal à la version de `package.json`. Le
+  workflow vérifie tout, publie sans aucun secret (publication de confiance
+  npm par OIDC, avec provenance signée), puis crée la release GitHub avec
+  `equix.wasm` et son empreinte.
+
+## Organisation
+
+- `crates/pow-equix` : défi, résolution et vérification en Rust ; réutilisable en
+  natif (option `compilateur` pour générer du code machine HashX, par exemple
+  dans une application Tauri).
+- `crates/pow-equix-wasm` : interface C minimale vers WebAssembly, sans
+  wasm-bindgen.
+- `src/index.ts` : chargeur, Web Workers, annulation, progression, vérification.
+- `demo/` : page de démo et de calibrage.
+
+## Licence
+
+LGPL-3.0 (voir `LICENSE` et `COPYING`). Le module intègre les crates `equix` et
+`hashx` du projet [Arti](https://gitlab.torproject.org/tpo/core/arti) de Tor,
+elles-mêmes sous LGPL-3.0, d’après les algorithmes de tevador.

package/dist/empreinte.json

@@ -0,0 +1,6 @@
+{
+  "version": "0.1.0",
+  "rustc": "rustc 1.93.1 (01f6ddf75 2026-02-11)",
+  "octets": 44968,
+  "sha256": "f6c72e8e6b48386c23b6d1259c1739fef0711b11ffa692bcaed3e40a5a41c840"
+}

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * pow-equix-wasm : preuve de travail Equi-X pour le web.
+ *
+ * Un seul module WebAssembly résout (navigateur, Web Workers) et vérifie
+ * (serveur Bun, Node ou Deno). Ce fichier ne dépend ni du DOM ni d’un
+ * bundler : chaque environnement fournit les octets du module comme il peut
+ * (`fetch` de `pow-equix-wasm/equix.wasm`, lecture de fichier, ou
+ * `pow-equix-wasm/octets` qui les intègre en base64).
+ *
+ * Protocole : le défi d’un essai est `graine ‖ compteur` (u32 petit-boutiste).
+ * Une preuve réunit `nombre` parts de 20 octets, `compteur ‖ solution Equi-X`,
+ * aux compteurs strictement croissants ; chaque solution doit passer la règle
+ * d’effort de Tor (`hs_pow`). Voir README.md.
+ */
+export declare const VERSION_FORMAT = 1;
+export declare const GRAINE_MAX = 256;
+export declare const TAILLE_SOLUTION = 16;
+export declare const TAILLE_PART: number;
+export declare const PARTS_MAX = 64;
+/** Au-delà, l’effort n’a plus de sens : une chance sur 2³² par solution. */
+export declare const EFFORT_MAX: number;
+export declare function effortValide(effort: number): boolean;
+export declare function nombreValide(nombre: number): boolean;
+/** Un module Equi-X instancié. Une instance n’est pas réentrante : un appel à la fois. */
+export declare class ModuleEquix {
+    private readonly exports;
+    private constructor();
+    static instancier(source: BufferSource | WebAssembly.Module): Promise<ModuleEquix>;
+    /** Mémoire linéaire actuellement réservée par le module, en octets. */
+    get memoireOctets(): number;
+    private tampon;
+    /** Vérifie une preuve complète ; quelques centaines de microsecondes par part. */
+    verifier(graine: Uint8Array, parts: Uint8Array, effort: number, nombre: number): boolean;
+    /** Un essai de résolution : la solution retenue pour ce compteur, ou null. */
+    essayer(graine: Uint8Array, compteur: number, effort: number): Uint8Array | null;
+}
+/**
+ * Graine conseillée : le domaine (UTF-8), un octet nul, puis l’empreinte SHA-256
+ * du contenu à protéger. Le domaine sépare les protocoles : une preuve calculée
+ * pour l’un ne vaut rien pour l’autre.
+ */
+export declare function construireGraine(domaine: string, contenu: string | Uint8Array): Promise<Uint8Array>;
+/**
+ * Probabilité qu’un essai aboutisse. Equi-X donne en moyenne deux solutions par
+ * défi, chacune retenue avec une chance sur `effort` : 1 − e^(−2/effort),
+ * légèrement réduit par les défis sans programme HashX valide. Mesuré : 0,858
+ * pour l’effort 1, 0,623 pour 2, 0,119 pour 16.
+ */
+export declare function probabiliteEssai(effort: number): number;
+/** Nombre moyen d’essais pour une preuve de `nombre` parts. */
+export declare function essaisAttendus(effort: number, nombre: number): number;
+export declare function hexadecimal(octets: Uint8Array): string;
+export declare function depuisHexadecimal(texte: string): Uint8Array | null;
+export interface Progression {
+    /** Essais cumulés, tous fils confondus. */
+    essais: number;
+    /** Parts trouvées, au plus `nombre`. */
+    parts: number;
+    /** Mémoire WebAssembly cumulée des fils en cours, en octets. */
+    memoireOctets: number;
+}
+export interface OptionsResolution {
+    /** Octets du module, transmis tels quels aux Web Workers. */
+    octets: Uint8Array;
+    graine: Uint8Array;
+    effort: number;
+    nombre: number;
+    onProgression?: (progression: Progression) => void;
+    signal?: AbortSignal;
+    /**
+     * Nombre de Web Workers ; par défaut un par cœur annoncé, huit au plus, et
+     * jamais plus que d’essais attendus : un fil sans essai à mener ne ferait que
+     * disputer le processeur aux autres. 0 force le calcul sur le fil courant.
+     */
+    fils?: number;
+    /** Fabrique de Web Worker, remplaçable (tests, politique de sécurité particulière). */
+    creerTravailleur?: () => Worker;
+}
+export interface Resolution {
+    parts: Uint8Array;
+    essais: number;
+    /** Nombre de fils effectivement utilisés ; 0 pour le fil courant. */
+    fils: number;
+    /** Mémoire WebAssembly maximale cumulée de tous les fils, en octets. */
+    memoireOctets: number;
+}
+/** Nombre de fils par défaut : un par cœur annoncé, huit au plus. */
+export declare function filsParDefaut(): number;
+/**
+ * Résout une preuve dans des Web Workers, un compteur sur `fils` chacun. Sans
+ * Web Worker disponible ou autorisé, le calcul se fait sur le fil courant,
+ * essai par essai, en rendant la main entre deux essais.
+ */
+export declare function resoudre(options: OptionsResolution): Promise<Resolution>;

package/dist/index.js

@@ -0,0 +1,248 @@
+// src/index.ts
+var VERSION_FORMAT = 1;
+var GRAINE_MAX = 256;
+var TAILLE_SOLUTION = 16;
+var TAILLE_PART = 4 + TAILLE_SOLUTION;
+var PARTS_MAX = 64;
+var EFFORT_MAX = 2 ** 32 - 1;
+function exportsValides(exports) {
+  return exports.memory instanceof WebAssembly.Memory && ["tampon_adresse", "tampon_taille", "graine_max", "version_format", "verifier", "essayer"].every((nom) => typeof exports[nom] === "function");
+}
+function effortValide(effort) {
+  return Number.isInteger(effort) && effort >= 1 && effort <= EFFORT_MAX;
+}
+function nombreValide(nombre) {
+  return Number.isInteger(nombre) && nombre >= 1 && nombre <= PARTS_MAX;
+}
+function graineValide(graine) {
+  return graine.length >= 1 && graine.length <= GRAINE_MAX;
+}
+
+class ModuleEquix {
+  exports;
+  constructor(exports) {
+    this.exports = exports;
+  }
+  static async instancier(source) {
+    const module = source instanceof WebAssembly.Module ? source : await WebAssembly.compile(source);
+    const instance = await WebAssembly.instantiate(module, {});
+    if (!exportsValides(instance.exports))
+      throw new Error("Module Equi-X invalide.");
+    if (instance.exports.version_format() !== VERSION_FORMAT)
+      throw new Error("Module Equi-X d’une autre version du format.");
+    if (instance.exports.graine_max() !== GRAINE_MAX)
+      throw new Error("Module Equi-X incompatible avec ce chargeur.");
+    return new ModuleEquix(instance.exports);
+  }
+  get memoireOctets() {
+    return this.exports.memory.buffer.byteLength;
+  }
+  tampon() {
+    return new Uint8Array(this.exports.memory.buffer, this.exports.tampon_adresse(), this.exports.tampon_taille());
+  }
+  verifier(graine, parts, effort, nombre) {
+    if (!graineValide(graine) || !nombreValide(nombre) || !effortValide(effort) || parts.length !== nombre * TAILLE_PART)
+      return false;
+    const tampon = this.tampon();
+    tampon.set(graine, 0);
+    tampon.set(parts, GRAINE_MAX);
+    return this.exports.verifier(graine.length, effort >>> 0, nombre) === 1;
+  }
+  essayer(graine, compteur, effort) {
+    if (!graineValide(graine) || !effortValide(effort))
+      throw new Error("Graine ou effort invalide.");
+    this.tampon().set(graine, 0);
+    if (this.exports.essayer(graine.length, effort >>> 0, compteur >>> 0) !== 1)
+      return null;
+    return this.tampon().slice(GRAINE_MAX, GRAINE_MAX + TAILLE_SOLUTION);
+  }
+}
+async function construireGraine(domaine, contenu) {
+  const encodeur = new TextEncoder;
+  const prefixe = encodeur.encode(domaine);
+  const octets = typeof contenu === "string" ? encodeur.encode(contenu) : new Uint8Array(contenu);
+  const empreinte = new Uint8Array(await crypto.subtle.digest("SHA-256", octets));
+  const graine = new Uint8Array(prefixe.length + 1 + empreinte.length);
+  graine.set(prefixe, 0);
+  graine.set(empreinte, prefixe.length + 1);
+  if (!graineValide(graine))
+    throw new Error(`Domaine trop long : la graine ne doit pas dépasser ${GRAINE_MAX} octets.`);
+  return graine;
+}
+function probabiliteEssai(effort) {
+  return 0.99 * (1 - Math.exp(-2 / Math.max(1, effort)));
+}
+function essaisAttendus(effort, nombre) {
+  return nombre / probabiliteEssai(effort);
+}
+function hexadecimal(octets) {
+  return Array.from(octets, (octet) => octet.toString(16).padStart(2, "0")).join("");
+}
+function depuisHexadecimal(texte) {
+  if (texte.length % 2 !== 0 || !/^[0-9a-f]*$/i.test(texte))
+    return null;
+  const octets = new Uint8Array(texte.length / 2);
+  for (let index = 0;index < octets.length; index++)
+    octets[index] = Number.parseInt(texte.slice(index * 2, index * 2 + 2), 16);
+  return octets;
+}
+function corpsTravailleur() {
+  const portee = self;
+  portee.onmessage = async (evenement) => {
+    const { octets, graine, effort, debut, pas, graineMax } = evenement.data;
+    try {
+      const { instance } = await WebAssembly.instantiate(octets, {});
+      const exports = instance.exports;
+      for (let compteur = debut;compteur <= 4294967295; compteur += pas) {
+        new Uint8Array(exports.memory.buffer, exports.tampon_adresse(), graine.length).set(graine);
+        const trouve = exports.essayer(graine.length, effort, compteur) === 1;
+        const solution = trouve ? new Uint8Array(exports.memory.buffer, exports.tampon_adresse() + graineMax, 16).slice() : null;
+        portee.postMessage({ type: "essai", compteur, solution, memoire: exports.memory.buffer.byteLength });
+      }
+      portee.postMessage({ type: "erreur", message: "Compteurs épuisés." });
+    } catch (erreur) {
+      portee.postMessage({ type: "erreur", message: erreur instanceof Error ? erreur.message : String(erreur) });
+    }
+  };
+}
+var urlTravailleur;
+function travailleurParDefaut() {
+  urlTravailleur ??= URL.createObjectURL(new Blob([`(${corpsTravailleur.toString()})()`], { type: "text/javascript" }));
+  return new Worker(urlTravailleur);
+}
+function erreurAnnulation(signal) {
+  return signal.reason ?? new DOMException("Calcul annulé.", "AbortError");
+}
+function filsParDefaut() {
+  const coeurs = typeof navigator !== "undefined" && Number.isInteger(navigator.hardwareConcurrency) ? navigator.hardwareConcurrency : 1;
+  return Math.max(1, Math.min(8, coeurs));
+}
+function assembler(trouvees, nombre) {
+  const parts = new Uint8Array(nombre * TAILLE_PART);
+  const vue = new DataView(parts.buffer);
+  const compteurs = [...trouvees.keys()].sort((gauche, droite) => gauche - droite).slice(0, nombre);
+  compteurs.forEach((compteur, index) => {
+    vue.setUint32(index * TAILLE_PART, compteur, true);
+    parts.set(trouvees.get(compteur), index * TAILLE_PART + 4);
+  });
+  return parts;
+}
+
+class ErreurTravailleur extends Error {
+}
+async function resoudre(options) {
+  const { graine, effort, nombre, signal } = options;
+  if (!graineValide(graine) || !effortValide(effort) || !nombreValide(nombre))
+    throw new Error("Paramètres de preuve invalides.");
+  signal?.throwIfAborted();
+  const fils = options.fils === undefined ? Math.min(filsParDefaut(), Math.ceil(essaisAttendus(effort, nombre))) : Math.max(0, Math.floor(options.fils));
+  const disponible = typeof Worker === "function" && typeof Blob === "function" && typeof URL.createObjectURL === "function";
+  const creer = options.creerTravailleur ?? (disponible ? travailleurParDefaut : undefined);
+  if (fils > 0 && creer) {
+    try {
+      return await resoudreEnParallele(options, creer, fils);
+    } catch (erreur) {
+      if (signal?.aborted || !(erreur instanceof ErreurTravailleur))
+        throw erreur;
+    }
+  }
+  return resoudreSurCeFil(options);
+}
+async function resoudreSurCeFil(options) {
+  const { graine, effort, nombre, signal, onProgression } = options;
+  const module = await ModuleEquix.instancier(options.octets);
+  const trouvees = new Map;
+  let essais = 0;
+  for (let compteur = 0;trouvees.size < nombre; compteur++) {
+    signal?.throwIfAborted();
+    const solution = module.essayer(graine, compteur, effort);
+    essais++;
+    if (solution)
+      trouvees.set(compteur, solution);
+    onProgression?.({ essais, parts: trouvees.size, memoireOctets: module.memoireOctets });
+    if (trouvees.size < nombre)
+      await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  signal?.throwIfAborted();
+  return { parts: assembler(trouvees, nombre), essais, fils: 0, memoireOctets: module.memoireOctets };
+}
+function resoudreEnParallele(options, creer, fils) {
+  const { graine, effort, nombre, signal, onProgression } = options;
+  return new Promise((resolve, reject) => {
+    const travailleurs = [];
+    const memoires = new Map;
+    const trouvees = new Map;
+    let essais = 0;
+    let memoireMax = 0;
+    let fini = false;
+    const terminer = () => {
+      fini = true;
+      for (const travailleur of travailleurs)
+        travailleur.terminate();
+      signal?.removeEventListener("abort", annuler);
+    };
+    const annuler = () => {
+      if (fini)
+        return;
+      terminer();
+      reject(erreurAnnulation(signal));
+    };
+    const echouer = (message) => {
+      if (fini)
+        return;
+      terminer();
+      reject(new ErreurTravailleur(message));
+    };
+    signal?.addEventListener("abort", annuler, { once: true });
+    try {
+      for (let index = 0;index < fils; index++) {
+        const travailleur = creer();
+        travailleurs.push(travailleur);
+        travailleur.onerror = (evenement) => {
+          evenement.preventDefault?.();
+          echouer(evenement.message || "Web Worker Equi-X indisponible.");
+        };
+        travailleur.onmessage = (evenement) => {
+          if (fini)
+            return;
+          const message = evenement.data;
+          if (message.type === "erreur")
+            return echouer(message.message ?? "Erreur du Web Worker Equi-X.");
+          essais++;
+          if (message.memoire)
+            memoires.set(index, message.memoire);
+          const memoire = [...memoires.values()].reduce((somme, valeur) => somme + valeur, 0);
+          memoireMax = Math.max(memoireMax, memoire);
+          if (message.solution && message.compteur !== undefined)
+            trouvees.set(message.compteur, message.solution);
+          onProgression?.({ essais, parts: Math.min(trouvees.size, nombre), memoireOctets: memoire });
+          if (trouvees.size >= nombre) {
+            terminer();
+            resolve({ parts: assembler(trouvees, nombre), essais, fils, memoireOctets: memoireMax });
+          }
+        };
+        travailleur.postMessage({ octets: options.octets.slice().buffer, graine, effort, debut: index, pas: fils, graineMax: GRAINE_MAX });
+      }
+    } catch (erreur) {
+      echouer(erreur instanceof Error ? erreur.message : String(erreur));
+    }
+  });
+}
+export {
+  EFFORT_MAX,
+  GRAINE_MAX,
+  ModuleEquix,
+  PARTS_MAX,
+  TAILLE_PART,
+  TAILLE_SOLUTION,
+  VERSION_FORMAT,
+  construireGraine,
+  depuisHexadecimal,
+  effortValide,
+  essaisAttendus,
+  filsParDefaut,
+  hexadecimal,
+  nombreValide,
+  probabiliteEssai,
+  resoudre
+};

package/dist/octets.d.ts

@@ -0,0 +1,4 @@
+/** Octets du module Equi-X, décodés à chaque appel (une copie neuve). */
+export declare function octetsEquix(): Uint8Array
+/** Empreinte SHA-256 du module intégré. */
+export declare const SHA256_EQUIX: string