@sebastienrousseau/crypto-benchmarks 0.0.8

package/LICENSE

@@ -0,0 +1,8 @@
+This project is dual-licensed under either of:
+
+  * Apache License, Version 2.0 — see LICENSE-APACHE
+  * MIT license — see LICENSE-MIT
+
+at your option.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT

package/README.md

@@ -0,0 +1,90 @@
+<!-- SPDX-License-Identifier: Apache-2.0 OR MIT -->
+
+# `@sebastienrousseau/crypto-benchmarks`
+
+> Performance benchmarking and latency profiling harness comparing classical vs post-quantum cryptographic primitives across JavaScript, WebAssembly, and native runtimes.
+
+[![Version](https://img.shields.io/npm/v/@sebastienrousseau/crypto-benchmarks.svg)](https://www.npmjs.com/package/@sebastienrousseau/crypto-benchmarks)
+[![License](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## Overview
+
+`@sebastienrousseau/crypto-benchmarks` provides high-precision latency, throughput (MB/s), and operations-per-second (ops/sec) profiling across classical algorithms (RSA, ECDSA, AES, SHA-2) and post-quantum standards (NIST FIPS 203 ML-KEM, FIPS 204 ML-DSA, FIPS 205 SLH-DSA).
+
+## Features
+
+- **High-Precision Timing Harness**: Sub-microsecond timing using `process.hrtime.bigint()` with statistical distribution metrics (mean, median, p95, p99, standard deviation, ops/sec).
+- **Comparative Profiling**:
+  - Symmetric Encryption: `AES-256-GCM` vs `ChaCha20-Poly1305` vs `AES-128-CBC`.
+  - Asymmetric Signatures: `ML-DSA-65` vs `Ed25519` vs `ECDSA-P256` vs `RSA-2048`.
+  - Key Encapsulation: `ML-KEM-768` vs `ECDH` vs `RSA-3072`.
+  - Cryptographic Hashing: `SHA-256` vs `SHA-512` vs `SHA3-256` vs `BLAKE2b`.
+- **Multiple Output Formats**: Human-readable tables, JSON reports, and Markdown summaries suitable for CI performance tracking.
+
+## CLI Usage
+
+```bash
+# Run all benchmark suites
+crypto-benchmarks --suite all
+
+# Run specific suite with custom iterations
+crypto-benchmarks --suite pqc --iterations 100 --format markdown
+
+# Output JSON report for automated monitoring
+crypto-benchmarks --suite symmetric --format json > report.json
+```
+
+## Programmatic API
+
+```typescript
+import {
+  runSuite,
+  benchmarkSymmetric,
+  benchmarkPqc,
+} from "@sebastienrousseau/crypto-benchmarks";
+
+// Run comprehensive benchmark
+const report = await runSuite({ suite: "all", iterations: 50 });
+console.log(report.summaryMarkdown);
+```
+
+---
+
+## Development
+
+```bash
+pnpm --filter @sebastienrousseau/crypto-benchmarks run build
+pnpm --filter @sebastienrousseau/crypto-benchmarks run test
+pnpm --filter @sebastienrousseau/crypto-benchmarks run lint
+pnpm --filter @sebastienrousseau/crypto-benchmarks run format
+```
+
+All 18 packages in the Crypto Service workspace maintain a **100% coverage floor** across statements, branches, functions, and lines.
+
+---
+
+## Documentation
+
+- [Full Suite Documentation](https://docs.crypto-service.co/)
+- [API Reference (TypeDoc)](https://docs.crypto-service.co/packages/crypto-benchmarks/)
+- [Developer Guide](../../DEVELOPMENT.md)
+- [Security Policy](../../SECURITY.md)
+- [Architecture & Design](../../ARCHITECTURE.md)
+
+---
+
+## Stability guarantees
+
+Versions advance strictly one step at a time on the `0.0.x` line (`v0.0.1` → `v0.0.2` → `v0.0.3` ... → `v0.0.999` → `v0.1.0`). Work for every release iteration begins on a dedicated `feat/v<version>` branch.
+
+All 18 packages in the workspace move in lockstep. Public API signatures, cipher output formats, and serialization schemas are strictly versioned. Breaking changes to serialized formats or algorithm defaults are considered major breaking changes. Minimum toolchain upgrades (e.g. Node.js LTS floor) are governed by [POLICIES.md](../../docs/POLICIES.md).
+
+---
+
+## License
+
+Dual-licensed under [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) or [MIT](https://opensource.org/licenses/MIT), at your option.
+
+Copyright (c) 2022-2026 Sebastien Rousseau and The Crypto Service Suite contributors.

package/dist/benchmarks/asymmetric.d.ts

@@ -0,0 +1,3 @@
+import { BenchmarkItemResult } from "../types";
+export declare function runAsymmetricBenchmarks(iterations?: number): Promise<BenchmarkItemResult[]>;
+//# sourceMappingURL=asymmetric.d.ts.map

package/dist/benchmarks/asymmetric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asymmetric.d.ts","sourceRoot":"","sources":["../../src/benchmarks/asymmetric.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAM/C,wBAAsB,uBAAuB,CAC3C,UAAU,SAAK,GACd,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAsFhC"}

package/dist/benchmarks/asymmetric.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAsymmetricBenchmarks = runAsymmetricBenchmarks;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const timer_1 = require("../timer");
+async function runAsymmetricBenchmarks(iterations = 20) {
+    const results = [];
+    const message = Buffer.from("Financial Transaction ISO 20022 Compliance Payload");
+    const edKeys = node_crypto_1.default.generateKeyPairSync("ed25519");
+    let edSig = Buffer.alloc(0);
+    const edSignStats = await (0, timer_1.benchmarkOperation)(() => {
+        edSig = node_crypto_1.default.sign(null, message, edKeys.privateKey);
+    }, { iterations, warmup: 3 });
+    results.push({
+        name: "Ed25519 Digital Signing",
+        category: "asymmetric",
+        algorithm: "Ed25519",
+        operation: "sign",
+        quantumSafe: false,
+        stats: edSignStats,
+    });
+    const edVerifyStats = await (0, timer_1.benchmarkOperation)(() => {
+        node_crypto_1.default.verify(null, message, edKeys.publicKey, edSig);
+    }, { iterations, warmup: 3 });
+    results.push({
+        name: "Ed25519 Signature Verification",
+        category: "asymmetric",
+        algorithm: "Ed25519",
+        operation: "verify",
+        quantumSafe: false,
+        stats: edVerifyStats,
+    });
+    const ecKeys = node_crypto_1.default.generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+    const ecSignStats = await (0, timer_1.benchmarkOperation)(() => {
+        const sign = node_crypto_1.default.createSign("SHA256");
+        sign.update(message);
+        sign.end();
+        sign.sign(ecKeys.privateKey);
+    }, { iterations, warmup: 3 });
+    results.push({
+        name: "ECDSA (P-256) Digital Signing",
+        category: "asymmetric",
+        algorithm: "ECDSA-P256",
+        operation: "sign",
+        quantumSafe: false,
+        stats: ecSignStats,
+    });
+    const rsaKeys = node_crypto_1.default.generateKeyPairSync("rsa", { modulusLength: 2048 });
+    const rsaSignStats = await (0, timer_1.benchmarkOperation)(() => {
+        const sign = node_crypto_1.default.createSign("SHA256");
+        sign.update(message);
+        sign.end();
+        sign.sign(rsaKeys.privateKey);
+    }, { iterations: Math.min(iterations, 10), warmup: 2 });
+    results.push({
+        name: "RSA-2048 Digital Signing",
+        category: "asymmetric",
+        algorithm: "RSA-2048",
+        operation: "sign",
+        quantumSafe: false,
+        stats: rsaSignStats,
+    });
+    return results;
+}
+//# sourceMappingURL=asymmetric.js.map

package/dist/benchmarks/hash.d.ts

@@ -0,0 +1,3 @@
+import { BenchmarkItemResult } from "../types";
+export declare function runHashBenchmarks(iterations?: number): Promise<BenchmarkItemResult[]>;
+//# sourceMappingURL=hash.d.ts.map

package/dist/benchmarks/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/benchmarks/hash.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAM/C,wBAAsB,iBAAiB,CACrC,UAAU,SAAK,GACd,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAwDhC"}

package/dist/benchmarks/hash.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHashBenchmarks = runHashBenchmarks;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const timer_1 = require("../timer");
+async function runHashBenchmarks(iterations = 50) {
+    const results = [];
+    const payload = node_crypto_1.default.randomBytes(4096);
+    const sha256Stats = await (0, timer_1.benchmarkOperation)(() => {
+        node_crypto_1.default.createHash("sha256").update(payload).digest();
+    }, { iterations, warmup: 5 });
+    results.push({
+        name: "SHA-256 Throughput (4KB)",
+        category: "hash",
+        algorithm: "SHA-256",
+        operation: "hash",
+        quantumSafe: true,
+        stats: sha256Stats,
+    });
+    const sha512Stats = await (0, timer_1.benchmarkOperation)(() => {
+        node_crypto_1.default.createHash("sha512").update(payload).digest();
+    }, { iterations, warmup: 5 });
+    results.push({
+        name: "SHA-512 Throughput (4KB)",
+        category: "hash",
+        algorithm: "SHA-512",
+        operation: "hash",
+        quantumSafe: true,
+        stats: sha512Stats,
+    });
+    const sha3Stats = await (0, timer_1.benchmarkOperation)(() => {
+        node_crypto_1.default.createHash("sha3-256").update(payload).digest();
+    }, { iterations, warmup: 5 });
+    results.push({
+        name: "SHA3-256 (Keccak) Throughput (4KB)",
+        category: "hash",
+        algorithm: "SHA3-256",
+        operation: "hash",
+        quantumSafe: true,
+        stats: sha3Stats,
+    });
+    return results;
+}
+//# sourceMappingURL=hash.js.map

package/dist/benchmarks/pqc.d.ts

@@ -0,0 +1,10 @@
+import type { MlKemEncapResult, MlDsaVerifyResult } from "@sebastienrousseau/crypto-lib";
+import { BenchmarkItemResult } from "../types";
+export interface PqcOperations {
+    mlKem768Encapsulate: () => MlKemEncapResult;
+    mlKem768SecretKey: string;
+    mlDsa65Verify: () => MlDsaVerifyResult;
+}
+export declare function createPqcOperations(): PqcOperations;
+export declare function runPqcBenchmarks(iterations?: number): Promise<BenchmarkItemResult[]>;
+//# sourceMappingURL=pqc.d.ts.map

package/dist/benchmarks/pqc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pqc.d.ts","sourceRoot":"","sources":["../../src/benchmarks/pqc.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAI/C,MAAM,WAAW,aAAa;IAE5B,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;IAE5C,iBAAiB,EAAE,MAAM,CAAC;IAE1B,aAAa,EAAE,MAAM,iBAAiB,CAAC;CACxC;AAOD,wBAAgB,mBAAmB,IAAI,aAAa,CAWnD;AAOD,wBAAsB,gBAAgB,CACpC,UAAU,SAAK,GACd,OAAO,CAAC,mBAAmB,EAAE,CAAC,CA+DhC"}

package/dist/benchmarks/pqc.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPqcOperations = createPqcOperations;
+exports.runPqcBenchmarks = runPqcBenchmarks;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const crypto_lib_1 = require("@sebastienrousseau/crypto-lib");
+const timer_1 = require("../timer");
+function createPqcOperations() {
+    const kem = (0, crypto_lib_1.mlKemKeygen)(768);
+    const dsa = (0, crypto_lib_1.mlDsaKeygen)(65);
+    const message = node_crypto_1.default.randomBytes(32);
+    const { signature } = (0, crypto_lib_1.mlDsaSign)(65, dsa.secretKey, message);
+    return {
+        mlKem768Encapsulate: () => (0, crypto_lib_1.mlKemEncap)(768, kem.publicKey),
+        mlKem768SecretKey: kem.secretKey,
+        mlDsa65Verify: () => (0, crypto_lib_1.mlDsaVerify)(65, dsa.publicKey, message, signature),
+    };
+}
+async function runPqcBenchmarks(iterations = 30) {
+    const results = [];
+    const ecdh1 = node_crypto_1.default.createECDH("prime256v1");
+    const ecdh2 = node_crypto_1.default.createECDH("prime256v1");
+    ecdh1.generateKeys();
+    ecdh2.generateKeys();
+    const pub2 = ecdh2.getPublicKey();
+    const ecdhStats = await (0, timer_1.benchmarkOperation)(() => {
+        ecdh1.computeSecret(pub2);
+    }, { iterations, warmup: 5 });
+    results.push({
+        name: "Classical ECDH Key Agreement (P-256)",
+        category: "pqc",
+        algorithm: "ECDH-P256",
+        operation: "key-exchange",
+        quantumSafe: false,
+        stats: ecdhStats,
+    });
+    const ops = createPqcOperations();
+    const kemStats = await (0, timer_1.benchmarkOperation)(() => {
+        ops.mlKem768Encapsulate();
+    }, { iterations, warmup: 5 });
+    results.push({
+        name: "Post-Quantum ML-KEM-768 Key Encapsulation",
+        category: "pqc",
+        algorithm: "ML-KEM-768",
+        operation: "encapsulate",
+        quantumSafe: true,
+        stats: kemStats,
+    });
+    const dsaStats = await (0, timer_1.benchmarkOperation)(() => {
+        ops.mlDsa65Verify();
+    }, { iterations, warmup: 5 });
+    results.push({
+        name: "Post-Quantum ML-DSA-65 Verification",
+        category: "pqc",
+        algorithm: "ML-DSA-65",
+        operation: "verify",
+        quantumSafe: true,
+        stats: dsaStats,
+    });
+    return results;
+}
+//# sourceMappingURL=pqc.js.map

package/dist/benchmarks/symmetric.d.ts

@@ -0,0 +1,3 @@
+import { BenchmarkItemResult } from "../types";
+export declare function runSymmetricBenchmarks(iterations?: number): Promise<BenchmarkItemResult[]>;
+//# sourceMappingURL=symmetric.d.ts.map

package/dist/benchmarks/symmetric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symmetric.d.ts","sourceRoot":"","sources":["../../src/benchmarks/symmetric.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAM/C,wBAAsB,sBAAsB,CAC1C,UAAU,SAAK,GACd,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAsEhC"}

package/dist/benchmarks/symmetric.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSymmetricBenchmarks = runSymmetricBenchmarks;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const timer_1 = require("../timer");
+async function runSymmetricBenchmarks(iterations = 50) {
+    const results = [];
+    const payload = node_crypto_1.default.randomBytes(1024);
+    const key32 = node_crypto_1.default.randomBytes(32);
+    const key16 = node_crypto_1.default.randomBytes(16);
+    const iv12 = node_crypto_1.default.randomBytes(12);
+    const iv16 = node_crypto_1.default.randomBytes(16);
+    const aesGcmEncStats = await (0, timer_1.benchmarkOperation)(() => {
+        const cipher = node_crypto_1.default.createCipheriv("aes-256-gcm", key32, iv12);
+        cipher.update(payload);
+        cipher.final();
+        cipher.getAuthTag();
+    }, { iterations, warmup: 5 });
+    results.push({
+        name: "AES-256-GCM Encryption (1KB)",
+        category: "symmetric",
+        algorithm: "AES-256-GCM",
+        operation: "encrypt",
+        quantumSafe: true,
+        stats: aesGcmEncStats,
+    });
+    const chachaEncStats = await (0, timer_1.benchmarkOperation)(() => {
+        const cipher = node_crypto_1.default.createCipheriv("chacha20-poly1305", key32, iv12, {
+            authTagLength: 16,
+        });
+        cipher.update(payload);
+        cipher.final();
+        cipher.getAuthTag();
+    }, { iterations, warmup: 5 });
+    results.push({
+        name: "ChaCha20-Poly1305 Encryption (1KB)",
+        category: "symmetric",
+        algorithm: "ChaCha20-Poly1305",
+        operation: "encrypt",
+        quantumSafe: true,
+        stats: chachaEncStats,
+    });
+    const aesCbcEncStats = await (0, timer_1.benchmarkOperation)(() => {
+        const cipher = node_crypto_1.default.createCipheriv("aes-128-cbc", key16, iv16);
+        cipher.update(payload);
+        cipher.final();
+    }, { iterations, warmup: 5 });
+    results.push({
+        name: "AES-128-CBC Encryption (1KB)",
+        category: "symmetric",
+        algorithm: "AES-128-CBC",
+        operation: "encrypt",
+        quantumSafe: false,
+        stats: aesCbcEncStats,
+    });
+    return results;
+}
+//# sourceMappingURL=symmetric.js.map

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(args?: string[]): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAOA,wBAAsB,GAAG,CACvB,IAAI,GAAE,MAAM,EAA0B,GACrC,OAAO,CAAC,MAAM,CAAC,CAsDjB"}

package/dist/cli.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const node_process_1 = __importDefault(require("node:process"));
+const runner_1 = require("./runner");
+async function run(args = node_process_1.default.argv.slice(2)) {
+    if (args.includes("--help") || args.includes("-h")) {
+        node_process_1.default.stdout.write("Usage: crypto-benchmarks [options]\n");
+        node_process_1.default.stdout.write("Options:\n");
+        node_process_1.default.stdout.write("  --suite <all|symmetric|asymmetric|pqc|hash>  Benchmark suite to run (default: all)\n");
+        node_process_1.default.stdout.write("  --iterations <N>                             Number of iterations (default: 30)\n");
+        node_process_1.default.stdout.write("  --format <table|json|markdown>               Output format (default: table)\n");
+        return 0;
+    }
+    let suite = "all";
+    const suiteIdx = args.indexOf("--suite");
+    if (suiteIdx !== -1 && args[suiteIdx + 1]) {
+        const s = args[suiteIdx + 1].toLowerCase();
+        if (["all", "symmetric", "asymmetric", "pqc", "hash"].includes(s)) {
+            suite = s;
+        }
+    }
+    let iterations = 30;
+    const iterIdx = args.indexOf("--iterations");
+    if (iterIdx !== -1 && args[iterIdx + 1]) {
+        const parsed = parseInt(args[iterIdx + 1], 10);
+        if (!isNaN(parsed) && parsed > 0) {
+            iterations = parsed;
+        }
+    }
+    let format = "table";
+    const formatIdx = args.indexOf("--format");
+    if (formatIdx !== -1 && args[formatIdx + 1]) {
+        const f = args[formatIdx + 1].toLowerCase();
+        if (["table", "json", "markdown"].includes(f)) {
+            format = f;
+        }
+    }
+    const report = await (0, runner_1.runSuite)({ suite, iterations, format });
+    if (format === "json") {
+        node_process_1.default.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    }
+    else if (format === "markdown") {
+        node_process_1.default.stdout.write(report.summaryMarkdown + "\n");
+    }
+    else {
+        node_process_1.default.stdout.write(report.summaryTable + "\n");
+    }
+    return 0;
+}
+if (require.main === module) {
+    run().then((code) => node_process_1.default.exit(code));
+}
+//# sourceMappingURL=cli.js.map

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./types";
+export * from "./timer";
+export * from "./benchmarks/symmetric";
+export * from "./benchmarks/asymmetric";
+export * from "./benchmarks/pqc";
+export * from "./benchmarks/hash";
+export * from "./runner";
+export * from "./cli";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC"}

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./timer"), exports);
+__exportStar(require("./benchmarks/symmetric"), exports);
+__exportStar(require("./benchmarks/asymmetric"), exports);
+__exportStar(require("./benchmarks/pqc"), exports);
+__exportStar(require("./benchmarks/hash"), exports);
+__exportStar(require("./runner"), exports);
+__exportStar(require("./cli"), exports);
+//# sourceMappingURL=index.js.map

package/dist/runner.d.ts

@@ -0,0 +1,3 @@
+import { BenchmarkConfig, BenchmarkReport } from "./types";
+export declare function runSuite(config?: BenchmarkConfig): Promise<BenchmarkReport>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAuB,eAAe,EAAE,MAAM,SAAS,CAAC;AAShF,wBAAsB,QAAQ,CAC5B,MAAM,GAAE,eAAoB,GAC3B,OAAO,CAAC,eAAe,CAAC,CAsE1B"}

package/dist/runner.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSuite = runSuite;
+const node_process_1 = __importDefault(require("node:process"));
+const node_os_1 = __importDefault(require("node:os"));
+const symmetric_1 = require("./benchmarks/symmetric");
+const asymmetric_1 = require("./benchmarks/asymmetric");
+const pqc_1 = require("./benchmarks/pqc");
+const hash_1 = require("./benchmarks/hash");
+async function runSuite(config = {}) {
+    const suite = config.suite || "all";
+    const iterations = config.iterations || 30;
+    const results = [];
+    if (suite === "all" || suite === "symmetric") {
+        results.push(...(await (0, symmetric_1.runSymmetricBenchmarks)(iterations)));
+    }
+    if (suite === "all" || suite === "asymmetric") {
+        results.push(...(await (0, asymmetric_1.runAsymmetricBenchmarks)(iterations)));
+    }
+    if (suite === "all" || suite === "pqc") {
+        results.push(...(await (0, pqc_1.runPqcBenchmarks)(iterations)));
+    }
+    if (suite === "all" || suite === "hash") {
+        results.push(...(await (0, hash_1.runHashBenchmarks)(iterations)));
+    }
+    const timestamp = new Date().toISOString();
+    const platform = `${node_os_1.default.platform()} ${node_os_1.default.arch()}`;
+    const nodeVersion = node_process_1.default.version;
+    const mdRows = results.map((r) => {
+        const qs = r.quantumSafe ? "✅ Yes" : "❌ No";
+        return `| ${r.name} | ${r.algorithm} | ${r.stats.meanMs.toFixed(3)} | ${r.stats.p95Ms.toFixed(3)} | ${r.stats.opsPerSec.toLocaleString()} | ${qs} |`;
+    });
+    const summaryMarkdown = [
+        `# Cryptographic Performance Benchmark Report`,
+        ``,
+        `- **Date:** ${timestamp}`,
+        `- **Platform:** ${platform}`,
+        `- **Node.js:** ${nodeVersion}`,
+        `- **Total Benchmarks:** ${results.length}`,
+        ``,
+        `| Benchmark | Algorithm | Mean (ms) | p95 (ms) | Ops/sec | Quantum Safe |`,
+        `| :--- | :--- | :--- | :--- | :--- | :--- |`,
+        ...mdRows,
+        ``,
+    ].join("\n");
+    const tableHeader = `Name                            Algorithm      Mean(ms)  Ops/sec    QuantumSafe`;
+    const tableDivider = `--------------------------------------------------------------------------------`;
+    const tableRows = results.map((r) => {
+        const name = r.name.padEnd(32).slice(0, 32);
+        const alg = r.algorithm.padEnd(14).slice(0, 14);
+        const mean = r.stats.meanMs.toFixed(3).padStart(8);
+        const ops = r.stats.opsPerSec.toLocaleString().padStart(10);
+        const qs = (r.quantumSafe ? "Yes" : "No").padStart(10);
+        return `${name} ${alg} ${mean} ${ops} ${qs}`;
+    });
+    const summaryTable = [
+        tableHeader,
+        tableDivider,
+        ...tableRows,
+        tableDivider,
+    ].join("\n");
+    return {
+        timestamp,
+        platform,
+        nodeVersion,
+        totalBenchmarks: results.length,
+        results,
+        summaryMarkdown,
+        summaryTable,
+    };
+}
+//# sourceMappingURL=runner.js.map

package/dist/timer.d.ts

@@ -0,0 +1,7 @@
+import { BenchmarkStats } from "./types";
+export interface TimerOptions {
+    iterations?: number | undefined;
+    warmup?: number | undefined;
+}
+export declare function benchmarkOperation(fn: () => void | Promise<void>, options?: TimerOptions): Promise<BenchmarkStats>;
+//# sourceMappingURL=timer.d.ts.map

package/dist/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../src/timer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B;AAKD,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC9B,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,cAAc,CAAC,CAmEzB"}

package/dist/timer.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.benchmarkOperation = benchmarkOperation;
+const node_process_1 = __importDefault(require("node:process"));
+async function benchmarkOperation(fn, options = {}) {
+    const iterations = options.iterations && options.iterations > 0 ? options.iterations : 10;
+    const warmup = options.warmup !== undefined && options.warmup >= 0 ? options.warmup : 2;
+    for (let i = 0; i < warmup; i++) {
+        const res = fn();
+        if (res instanceof Promise) {
+            await res;
+        }
+    }
+    const timesMs = [];
+    const startTotal = node_process_1.default.hrtime.bigint();
+    for (let i = 0; i < iterations; i++) {
+        const start = node_process_1.default.hrtime.bigint();
+        const res = fn();
+        if (res instanceof Promise) {
+            await res;
+        }
+        const end = node_process_1.default.hrtime.bigint();
+        const diffMs = Number(end - start) / 1_000_000;
+        timesMs.push(diffMs);
+    }
+    const endTotal = node_process_1.default.hrtime.bigint();
+    const totalDurationMs = Number(endTotal - startTotal) / 1_000_000;
+    timesMs.sort((a, b) => a - b);
+    const minMs = timesMs[0];
+    const maxMs = timesMs[timesMs.length - 1];
+    const sumMs = timesMs.reduce((acc, val) => acc + val, 0);
+    const meanMs = sumMs / iterations;
+    const mid = Math.floor(timesMs.length / 2);
+    const medianMs = timesMs.length % 2 !== 0
+        ? timesMs[mid]
+        : (timesMs[mid - 1] + timesMs[mid]) / 2;
+    const p95Idx = Math.min(timesMs.length - 1, Math.floor(timesMs.length * 0.95));
+    const p99Idx = Math.min(timesMs.length - 1, Math.floor(timesMs.length * 0.99));
+    const p95Ms = timesMs[p95Idx];
+    const p99Ms = timesMs[p99Idx];
+    const opsPerSec = (iterations / totalDurationMs) * 1000;
+    return {
+        meanMs: Number(meanMs.toFixed(4)),
+        medianMs: Number(medianMs.toFixed(4)),
+        minMs: Number(minMs.toFixed(4)),
+        maxMs: Number(maxMs.toFixed(4)),
+        p95Ms: Number(p95Ms.toFixed(4)),
+        p99Ms: Number(p99Ms.toFixed(4)),
+        opsPerSec: Math.round(opsPerSec),
+        totalDurationMs: Number(totalDurationMs.toFixed(4)),
+        iterations,
+    };
+}
+//# sourceMappingURL=timer.js.map

package/dist/types.d.ts

@@ -0,0 +1,37 @@
+export type SuiteName = "all" | "symmetric" | "asymmetric" | "pqc" | "hash";
+export type OutputFormat = "table" | "json" | "markdown";
+export interface BenchmarkConfig {
+    suite?: SuiteName | undefined;
+    iterations?: number | undefined;
+    warmup?: number | undefined;
+    format?: OutputFormat | undefined;
+}
+export interface BenchmarkStats {
+    meanMs: number;
+    medianMs: number;
+    minMs: number;
+    maxMs: number;
+    p95Ms: number;
+    p99Ms: number;
+    opsPerSec: number;
+    totalDurationMs: number;
+    iterations: number;
+}
+export interface BenchmarkItemResult {
+    name: string;
+    category: "symmetric" | "asymmetric" | "pqc" | "hash";
+    algorithm: string;
+    operation: string;
+    quantumSafe: boolean;
+    stats: BenchmarkStats;
+}
+export interface BenchmarkReport {
+    timestamp: string;
+    platform: string;
+    nodeVersion: string;
+    totalBenchmarks: number;
+    results: BenchmarkItemResult[];
+    summaryMarkdown: string;
+    summaryTable: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,GAAG,KAAK,GAAG,MAAM,CAAC;AAC5E,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,CAAC;AAEzD,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,MAAM,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;CACnC;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,WAAW,GAAG,YAAY,GAAG,KAAK,GAAG,MAAM,CAAC;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,EAAE,cAAc,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,mBAAmB,EAAE,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;CACtB"}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@sebastienrousseau/crypto-benchmarks",
+  "version": "0.0.8",
+  "description": "Performance benchmarking and latency profiling harness comparing classical vs post-quantum cryptographic primitives across JavaScript, WebAssembly, and native runtimes.",
+  "author": "Sebastien Rousseau <sebastienrousseau@users.noreply.github.com>",
+  "license": "MIT OR Apache-2.0",
+  "homepage": "https://crypto-service.co",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sebastienrousseau/crypto-service.git",
+    "directory": "packages/crypto-benchmarks"
+  },
+  "bugs": {
+    "url": "https://github.com/sebastienrousseau/crypto-service/issues"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "bin": {
+    "crypto-benchmarks": "./dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map"
+  ],
+  "dependencies": {
+    "@sebastienrousseau/crypto-lib": "0.0.8"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.7",
+    "@types/chai-as-promised": "^8.0.2",
+    "@types/mocha": "^10.0.2",
+    "@types/node": "^26.6.3",
+    "c8": "^12.0.0",
+    "chai": "^4.5.0",
+    "chai-as-promised": "^7.1.2",
+    "mocha": "^10.8.2",
+    "rimraf": "^6.1.3",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.28.20",
+    "typescript": "~5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc --build tsconfig.json",
+    "clean": "rimraf ./coverage ./dist ./docs",
+    "lint": "eslint --ext .ts src __tests__",
+    "lint:fix": "eslint --cache --fix --ext .ts src __tests__",
+    "format": "prettier --write src/**/*.ts",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "test": "c8 --check-coverage --lines 100 --branches 100 --functions 100 --reporter=lcov --reporter=text mocha --config=.mocharc.cjs",
+    "docs": "typedoc"
+  }
+}