aifastdb 3.10.2 → 3.10.5

package/dist/concurrent-document-store-benchmark.js

@@ -0,0 +1,726 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * ConcurrentDocumentStore TypeScript API benchmark.
+ *
+ * Measures Node/TypeScript API-layer throughput for the high-concurrency
+ * document engine. Inspired by Karpathy's autoresearch experiment loop and
+ * the SocialGraphV2 benchmark used to discover the addPersonFast optimisation
+ * (research/program.md). It establishes a fixed protocol so before/after runs
+ * are directly comparable, and emits grep-friendly summary lines suitable for
+ * `research/results.tsv` ingestion.
+ *
+ * Scenarios covered:
+ *   - write              (per-call enqueue; current default JS path)
+ *   - writeSync          (per-call wait-for-persistence)
+ *   - writeBatch-N       (TS-side batching with batchSize=N)
+ *   - writeFast (opt-in) (auto-batched fire-and-forget, see writeFast() helper)
+ *   - randomGet          (point reads, random IDs)
+ *   - findByTag          (single-tag scan)
+ *   - findByMetadata     (operator-style filter)
+ *
+ * Usage:
+ *   node dist/concurrent-document-store-benchmark.js
+ *   node dist/concurrent-document-store-benchmark.js --total=20000 --batch-size=2000 --shards=16 --wal=false
+ *
+ *   # Only run a subset (comma-separated):
+ *   node dist/concurrent-document-store-benchmark.js --scenarios=write,writeBatch,writeFast
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const concurrent_document_store_1 = require("./concurrent-document-store");
+const DEFAULT_SCENARIOS = [
+    'write',
+    'writeSync',
+    'writeSyncConcurrent',
+    'writeBatch',
+    'writeFast',
+    'writeFastAndWait',
+    'randomGet',
+    'findByTag',
+    'findByMetadata',
+];
+function parseArgs() {
+    const cpuCount = os.cpus().length;
+    const defaults = {
+        total: 20000,
+        batchSize: 2000,
+        shardCount: Math.max(4, Math.min(cpuCount, 32)),
+        wal: false,
+        readOps: 50000,
+        scanOps: 2000,
+        fastBatch: 2000,
+        fastFlushMs: 5,
+    };
+    const args = new Map();
+    for (const rawArg of process.argv.slice(2)) {
+        if (!rawArg.startsWith('--'))
+            continue;
+        const [key, value] = rawArg.slice(2).split('=');
+        if (key && value !== undefined)
+            args.set(key, value);
+    }
+    const readPositiveInt = (key, raw) => {
+        if (raw === undefined)
+            return defaults[key];
+        const parsed = Number.parseInt(raw, 10);
+        if (!Number.isFinite(parsed) || parsed < 0) {
+            throw new Error(`Invalid --${key} value: ${raw}`);
+        }
+        return parsed;
+    };
+    const rawWal = args.get('wal');
+    const rawScenarios = args.get('scenarios');
+    return {
+        total: readPositiveInt('total', args.get('total')),
+        batchSize: readPositiveInt('batchSize', args.get('batchSize') ?? args.get('batch-size')),
+        shardCount: readPositiveInt('shardCount', args.get('shardCount') ?? args.get('shards')),
+        wal: rawWal === undefined ? defaults.wal : rawWal !== 'false',
+        readOps: readPositiveInt('readOps', args.get('readOps') ?? args.get('read-ops')),
+        scanOps: readPositiveInt('scanOps', args.get('scanOps') ?? args.get('scan-ops')),
+        fastBatch: readPositiveInt('fastBatch', args.get('fastBatch') ?? args.get('fast-batch')),
+        fastFlushMs: readPositiveInt('fastFlushMs', args.get('fastFlushMs') ?? args.get('fast-flush-ms')),
+        scenarios: rawScenarios
+            ? new Set(rawScenarios.split(',').map((s) => s.trim()).filter(Boolean))
+            : null,
+    };
+}
+function shouldRun(options, name) {
+    return options.scenarios === null || options.scenarios.has(name);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeTempDir(prefix) {
+    return fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
+}
+function cleanupDir(dir) {
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch {
+        // Best-effort cleanup; Windows may briefly hold the WAL handle.
+    }
+}
+function createStore(dbPath, options) {
+    return new concurrent_document_store_1.ConcurrentDocumentStore(dbPath, {
+        shardCount: options.shardCount,
+        enableWal: options.wal,
+        mode: 'high_throughput',
+        enableFileLock: false,
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForWrites(store, expected, timeoutMs = 30000) {
+    // Tight 1ms poll — settle time is on the critical path of every benchmark.
+    // Note: `currentQueueSize` is not reliable as a "fully drained" signal —
+    // the underlying core can keep an outstanding queue counter even after all
+    // user writes succeed, so we only gate on `successfulWrites`.
+    const deadline = performance.now() + timeoutMs;
+    while (performance.now() < deadline) {
+        if (store.metrics().successfulWrites >= expected)
+            return;
+        await sleep(1);
+    }
+}
+const TAG_POOL = ['bench', 'alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta', 'eta'];
+function makeDoc(index) {
+    return {
+        id: `doc-${index}`,
+        content: `ConcurrentDocumentStore benchmark payload #${index}`,
+        tags: [TAG_POOL[index % TAG_POOL.length], TAG_POOL[(index * 3 + 1) % TAG_POOL.length]],
+        docType: index % 2 === 0 ? 'note' : 'report',
+        importance: (index % 100) / 100,
+        metadata: {
+            source: `bench-${index % 16}`,
+            bucket: index % 64,
+            priority: 1 + (index % 5),
+            active: index % 2 === 0,
+        },
+    };
+}
+function fmt(n) {
+    return n.toLocaleString('en-US', { maximumFractionDigits: 1 });
+}
+function getMemoryMB() {
+    const u = process.memoryUsage();
+    return (u.rss + (u.external || 0)) / (1024 * 1024);
+}
+function printHeader(options) {
+    console.log('============================================================');
+    console.log('  ConcurrentDocumentStore TypeScript API Benchmark');
+    console.log('============================================================');
+    console.log(`  Total documents: ${options.total.toLocaleString()}`);
+    console.log(`  Batch size: ${options.batchSize.toLocaleString()}`);
+    console.log(`  writeFast batch: ${options.fastBatch.toLocaleString()} (flush=${options.fastFlushMs}ms)`);
+    console.log(`  Shards: ${options.shardCount.toLocaleString()}`);
+    console.log(`  WAL: ${options.wal}`);
+    console.log(`  Read ops: ${options.readOps.toLocaleString()}, Scan ops: ${options.scanOps.toLocaleString()}`);
+    console.log(`  CPU cores: ${os.cpus().length}, Platform: ${process.platform}-${process.arch}`);
+    console.log(`  Node: ${process.version}`);
+    console.log('');
+}
+function printResult(result) {
+    console.log(`\n=== ${result.scenario} ===`);
+    console.log(`  Items:       ${result.total.toLocaleString()} ${result.unit}`);
+    console.log(`  Elapsed:     ${result.elapsedMs.toFixed(2)} ms`);
+    console.log(`  Throughput:  ${Math.round(result.throughput).toLocaleString()} ${result.unit}/sec`);
+    console.log(`  Avg cost:    ${result.avgMsPerItem.toFixed(4)} ms/${result.unit === 'docs' ? 'doc' : 'op'}`);
+    if (result.metrics) {
+        const m = result.metrics;
+        console.log(`  Metrics:     writes=${m.successfulWrites}, failed=${m.failedWrites}, rejected=${m.rejectedRequests}, avgWrite=${(m.avgWriteTimeUs / 1000).toFixed(2)}ms, avgQueue=${(m.avgQueueTimeUs / 1000).toFixed(2)}ms, avgBatch=${m.avgBatchSize.toFixed(1)}, queue=${m.currentQueueSize}/${m.peakQueueSize}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Scenarios — writes
+// ---------------------------------------------------------------------------
+async function benchmarkWrite(options) {
+    const root = makeTempDir('cds-bench-write');
+    const store = createStore(path.join(root, 'store'), options);
+    try {
+        const start = performance.now();
+        for (let i = 0; i < options.total; i += 1) {
+            const doc = makeDoc(i);
+            store.write(doc.id, doc.content, {
+                tags: doc.tags,
+                docType: doc.docType,
+                importance: doc.importance,
+                metadata: doc.metadata,
+            });
+        }
+        store.flush();
+        await waitForWrites(store, options.total);
+        const elapsedMs = performance.now() - start;
+        return {
+            scenario: 'write (single-call enqueue)',
+            total: options.total,
+            elapsedMs,
+            throughput: options.total / (elapsedMs / 1000),
+            avgMsPerItem: elapsedMs / options.total,
+            unit: 'docs',
+            len: store.len(),
+            metrics: store.metrics(),
+        };
+    }
+    finally {
+        await store.closeAsync().catch(() => undefined);
+        cleanupDir(root);
+    }
+}
+async function benchmarkWriteSync(options) {
+    const root = makeTempDir('cds-bench-write-sync');
+    const store = createStore(path.join(root, 'store'), options);
+    try {
+        const start = performance.now();
+        for (let i = 0; i < options.total; i += 1) {
+            const doc = makeDoc(i);
+            store.writeSync(doc.id, doc.content, {
+                tags: doc.tags,
+                docType: doc.docType,
+                importance: doc.importance,
+                metadata: doc.metadata,
+            });
+        }
+        store.flush();
+        await waitForWrites(store, options.total);
+        const elapsedMs = performance.now() - start;
+        return {
+            scenario: 'writeSync (wait per call)',
+            total: options.total,
+            elapsedMs,
+            throughput: options.total / (elapsedMs / 1000),
+            avgMsPerItem: elapsedMs / options.total,
+            unit: 'docs',
+            len: store.len(),
+            metrics: store.metrics(),
+        };
+    }
+    finally {
+        await store.closeAsync().catch(() => undefined);
+        cleanupDir(root);
+    }
+}
+/**
+ * phase-375/T375.1: concurrent writeSync via the new `writeSyncAsync`
+ * NAPI method. The single-threaded `for { writeSync }` loop in
+ * `benchmarkWriteSync` is capped by NAPI sync round-trip (~48 K ops/s
+ * end of phase-373). This scenario fans out N JS Promises so the
+ * underlying multi-thread runtime + completion-triggered flush
+ * actually batch writes from multiple callers. Target: 80 K+.
+ */
+async function benchmarkWriteSyncConcurrent(options) {
+    const root = makeTempDir('cds-bench-write-sync-concurrent');
+    const store = createStore(path.join(root, 'store'), options);
+    const concurrency = Math.max(8, Math.min(options.shardCount * 4, 256));
+    try {
+        const start = performance.now();
+        let nextIndex = 0;
+        await Promise.all(Array.from({ length: concurrency }, async () => {
+            while (true) {
+                const i = nextIndex;
+                nextIndex += 1;
+                if (i >= options.total)
+                    break;
+                const doc = makeDoc(i);
+                await store.writeSyncAsync(doc.id, doc.content, {
+                    tags: doc.tags,
+                    docType: doc.docType,
+                    importance: doc.importance,
+                    metadata: doc.metadata,
+                });
+            }
+        }));
+        store.flush();
+        await waitForWrites(store, options.total);
+        const elapsedMs = performance.now() - start;
+        return {
+            scenario: `writeSyncConcurrent (concurrency=${concurrency})`,
+            total: options.total,
+            elapsedMs,
+            throughput: options.total / (elapsedMs / 1000),
+            avgMsPerItem: elapsedMs / options.total,
+            unit: 'docs',
+            len: store.len(),
+            metrics: store.metrics(),
+        };
+    }
+    finally {
+        await store.closeAsync().catch(() => undefined);
+        cleanupDir(root);
+    }
+}
+async function benchmarkWriteBatch(options) {
+    const root = makeTempDir('cds-bench-write-batch');
+    const store = createStore(path.join(root, 'store'), options);
+    try {
+        const start = performance.now();
+        for (let batchStart = 0; batchStart < options.total; batchStart += options.batchSize) {
+            const batchEnd = Math.min(batchStart + options.batchSize, options.total);
+            const batch = [];
+            for (let i = batchStart; i < batchEnd; i += 1)
+                batch.push(makeDoc(i));
+            store.writeBatch(batch);
+        }
+        store.flush();
+        await waitForWrites(store, options.total);
+        const elapsedMs = performance.now() - start;
+        return {
+            scenario: `writeBatch (batchSize=${options.batchSize})`,
+            total: options.total,
+            elapsedMs,
+            throughput: options.total / (elapsedMs / 1000),
+            avgMsPerItem: elapsedMs / options.total,
+            unit: 'docs',
+            len: store.len(),
+            metrics: store.metrics(),
+        };
+    }
+    finally {
+        await store.closeAsync().catch(() => undefined);
+        cleanupDir(root);
+    }
+}
+async function benchmarkWriteFast(options) {
+    const mod = await Promise.resolve().then(() => __importStar(require('./concurrent-document-store')));
+    const factory = mod.createBatchedWriter;
+    if (typeof factory !== 'function') {
+        console.log('\n=== writeFast — SKIPPED ===');
+        console.log('  createBatchedWriter() not available yet. Run T365.3 to enable.');
+        return null;
+    }
+    const root = makeTempDir('cds-bench-write-fast');
+    const store = createStore(path.join(root, 'store'), options);
+    try {
+        const writer = factory(store, {
+            batchSize: options.fastBatch,
+            flushIntervalMs: options.fastFlushMs,
+        });
+        const start = performance.now();
+        for (let i = 0; i < options.total; i += 1)
+            writer.writeFast(makeDoc(i));
+        await writer.flush();
+        store.flush();
+        await waitForWrites(store, options.total);
+        const elapsedMs = performance.now() - start;
+        await writer.close();
+        return {
+            scenario: `writeFast (autoBatch=${options.fastBatch})`,
+            total: options.total,
+            elapsedMs,
+            throughput: options.total / (elapsedMs / 1000),
+            avgMsPerItem: elapsedMs / options.total,
+            unit: 'docs',
+            len: store.len(),
+            metrics: store.metrics(),
+        };
+    }
+    finally {
+        await store.closeAsync().catch(() => undefined);
+        cleanupDir(root);
+    }
+}
+async function benchmarkWriteFastAndWait(options) {
+    const mod = await Promise.resolve().then(() => __importStar(require('./concurrent-document-store')));
+    const factory = mod.createBatchedWriter;
+    if (typeof factory !== 'function') {
+        console.log('\n=== writeFastAndWait — SKIPPED ===');
+        console.log('  createBatchedWriter() not available yet.');
+        return null;
+    }
+    const root = makeTempDir('cds-bench-write-fast-wait');
+    const store = createStore(path.join(root, 'store'), options);
+    try {
+        const writer = factory(store, {
+            batchSize: options.fastBatch,
+            flushIntervalMs: options.fastFlushMs,
+        });
+        const start = performance.now();
+        const promises = new Array(options.total);
+        for (let i = 0; i < options.total; i += 1) {
+            promises[i] = writer.writeFastAndWait(makeDoc(i));
+        }
+        await Promise.all(promises);
+        store.flush();
+        await waitForWrites(store, options.total);
+        const elapsedMs = performance.now() - start;
+        await writer.close();
+        return {
+            scenario: `writeFastAndWait (autoBatch=${options.fastBatch})`,
+            total: options.total,
+            elapsedMs,
+            throughput: options.total / (elapsedMs / 1000),
+            avgMsPerItem: elapsedMs / options.total,
+            unit: 'docs',
+            len: store.len(),
+            metrics: store.metrics(),
+        };
+    }
+    finally {
+        await store.closeAsync().catch(() => undefined);
+        cleanupDir(root);
+    }
+}
+// ---------------------------------------------------------------------------
+// Scenarios — reads / queries
+// ---------------------------------------------------------------------------
+async function seedReadStore(options) {
+    const root = makeTempDir('cds-bench-read');
+    const store = createStore(path.join(root, 'store'), options);
+    try {
+        const seedBatch = Math.max(500, Math.min(options.batchSize, 2000));
+        for (let i = 0; i < options.total; i += seedBatch) {
+            const end = Math.min(i + seedBatch, options.total);
+            const batch = [];
+            for (let j = i; j < end; j += 1)
+                batch.push(makeDoc(j));
+            store.writeBatch(batch);
+        }
+        store.flush();
+        await waitForWrites(store, options.total);
+        return {
+            store,
+            ids: store.ids(),
+            cleanup: () => {
+                try {
+                    store.close();
+                }
+                catch {
+                    // ignore double-close
+                }
+                cleanupDir(root);
+            },
+        };
+    }
+    catch (e) {
+        cleanupDir(root);
+        throw e;
+    }
+}
+function benchmarkRandomGet(store, ids, readOps) {
+    const len = ids.length;
+    store.readProfileReset();
+    const start = performance.now();
+    let hits = 0;
+    for (let i = 0; i < readOps; i += 1) {
+        const node = store.get(ids[(i * 2654435761) % len]);
+        if (node)
+            hits += 1;
+    }
+    const elapsedMs = performance.now() - start;
+    if (hits === 0)
+        throw new Error('randomGet: zero hits — seed data missing');
+    console.log('\n--- read profile (randomGet) ---');
+    console.log(store.readProfileSnapshot());
+    return {
+        scenario: 'randomGet (point read)',
+        total: readOps,
+        elapsedMs,
+        throughput: readOps / (elapsedMs / 1000),
+        avgMsPerItem: elapsedMs / readOps,
+        unit: 'ops',
+        len: store.len(),
+    };
+}
+function benchmarkFindByTag(store, scanOps) {
+    const tag = TAG_POOL[0];
+    store.readProfileReset();
+    const start = performance.now();
+    let total = 0;
+    for (let i = 0; i < scanOps; i += 1) {
+        total += store.findByTag(tag, { limit: 100 }).length;
+    }
+    const elapsedMs = performance.now() - start;
+    if (total === 0)
+        throw new Error('findByTag: zero results — seed data missing');
+    console.log('\n--- read profile (findByTag) ---');
+    console.log(store.readProfileSnapshot());
+    return {
+        scenario: 'findByTag (tag=bench, limit=100)',
+        total: scanOps,
+        elapsedMs,
+        throughput: scanOps / (elapsedMs / 1000),
+        avgMsPerItem: elapsedMs / scanOps,
+        unit: 'ops',
+        len: store.len(),
+    };
+}
+function benchmarkFindByMetadata(store, scanOps) {
+    store.readProfileReset();
+    const start = performance.now();
+    let total = 0;
+    for (let i = 0; i < scanOps; i += 1) {
+        total += store.findByMetadata({ priority: { $gte: 3 }, active: true }, { limit: 50 }).length;
+    }
+    const elapsedMs = performance.now() - start;
+    if (total === 0)
+        throw new Error('findByMetadata: zero results — seed data missing');
+    console.log('\n--- read profile (findByMetadata) ---');
+    console.log(store.readProfileSnapshot());
+    return {
+        scenario: 'findByMetadata (operator + limit=50)',
+        total: scanOps,
+        elapsedMs,
+        throughput: scanOps / (elapsedMs / 1000),
+        avgMsPerItem: elapsedMs / scanOps,
+        unit: 'ops',
+        len: store.len(),
+    };
+}
+// ---------------------------------------------------------------------------
+// Summary
+// ---------------------------------------------------------------------------
+function geometricMean(values) {
+    const valid = values.filter((v) => Number.isFinite(v) && v > 0);
+    if (valid.length === 0)
+        return 0;
+    const log = valid.reduce((acc, v) => acc + Math.log(v), 0) / valid.length;
+    return Math.exp(log);
+}
+function printSummary(results, options, peakMemMb, totalSeconds) {
+    console.log('\n============================================================');
+    console.log('  Summary (human-readable)');
+    console.log('============================================================');
+    for (const r of results) {
+        console.log(`  ${r.scenario.padEnd(40)} ${fmt(Math.round(r.throughput))} ${r.unit}/s  (${r.avgMsPerItem.toFixed(4)} ms/${r.unit === 'docs' ? 'doc' : 'op'})`);
+    }
+    const get = (name) => {
+        const r = results.find((x) => x.scenario.startsWith(name));
+        return r ? r.throughput : 0;
+    };
+    const single = get('write (single-call');
+    const sync = get('writeSync');
+    const batch = get('writeBatch');
+    const fast = get('writeFast (');
+    const fastWait = get('writeFastAndWait');
+    const reads = get('randomGet');
+    const tagScan = get('findByTag');
+    const metaScan = get('findByMetadata');
+    console.log('');
+    if (sync && single) {
+        console.log(`  write vs writeSync:             ${(single / Math.max(sync, 1)).toFixed(2)}x faster`);
+    }
+    if (batch && single) {
+        console.log(`  writeBatch vs write:            ${(batch / Math.max(single, 1)).toFixed(2)}x faster`);
+    }
+    if (fast && single) {
+        console.log(`  writeFast vs write:             ${(fast / Math.max(single, 1)).toFixed(2)}x faster`);
+    }
+    if (fast && batch) {
+        console.log(`  writeFast vs writeBatch:        ${(fast / Math.max(batch, 1)).toFixed(2)}x`);
+    }
+    if (fastWait && sync) {
+        console.log(`  writeFastAndWait vs writeSync:  ${(fastWait / Math.max(sync, 1)).toFixed(0)}x faster (autoresearch fire-and-forget pattern)`);
+    }
+    if (fastWait && fast) {
+        console.log(`  writeFastAndWait vs writeFast:  ${(fastWait / Math.max(fast, 1)).toFixed(2)}x`);
+    }
+    // ---------------------------------------------------------------------
+    // Machine-parseable block (autoresearch-style)
+    // ---------------------------------------------------------------------
+    const composite = geometricMean([single, batch, reads, Math.max(tagScan, 0.01)]);
+    console.log('');
+    console.log('---');
+    console.log(`single_write_ops:    ${single.toFixed(1)}`);
+    console.log(`sync_write_ops:      ${sync.toFixed(1)}`);
+    console.log(`batch_write_ops:     ${batch.toFixed(1)}`);
+    console.log(`fast_write_ops:      ${fast.toFixed(1)}`);
+    console.log(`fast_wait_write_ops: ${fastWait.toFixed(1)}`);
+    console.log(`random_read_ops:     ${reads.toFixed(1)}`);
+    console.log(`tag_scan_ops:        ${tagScan.toFixed(1)}`);
+    console.log(`metadata_scan_ops:   ${metaScan.toFixed(1)}`);
+    console.log(`composite_score:     ${composite.toFixed(1)}`);
+    console.log(`peak_memory_mb:      ${peakMemMb.toFixed(1)}`);
+    console.log(`total_seconds:       ${totalSeconds.toFixed(1)}`);
+    console.log(`total_docs:          ${options.total}`);
+    console.log(`batch_size:          ${options.batchSize}`);
+    console.log(`fast_batch:          ${options.fastBatch}`);
+    console.log(`shards:              ${options.shardCount}`);
+    console.log(`wal:                 ${options.wal}`);
+    console.log(`platform:            ${process.platform}-${process.arch}`);
+    console.log(`cpus:                ${os.cpus().length}`);
+    console.log(`node_version:        ${process.version}`);
+    console.log('---');
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function cooldown() {
+    // Brief pause between scenarios so the prior store's tempdir cleanup,
+    // shard worker shutdown, and Node GC don't pollute the next scenario's
+    // settle-phase timings. Tuned empirically: under 100ms left enough cross-
+    // scenario noise to skew writeFastAndWait by 5x; 250ms is solid.
+    await sleep(250);
+    if (typeof global.gc === 'function')
+        global.gc();
+}
+async function main() {
+    const options = parseArgs();
+    printHeader(options);
+    const t0 = performance.now();
+    let peakMem = getMemoryMB();
+    const results = [];
+    if (shouldRun(options, 'write')) {
+        const r = await benchmarkWrite(options);
+        peakMem = Math.max(peakMem, getMemoryMB());
+        printResult(r);
+        results.push(r);
+        await cooldown();
+    }
+    if (shouldRun(options, 'writeSync')) {
+        const r = await benchmarkWriteSync(options);
+        peakMem = Math.max(peakMem, getMemoryMB());
+        printResult(r);
+        results.push(r);
+        await cooldown();
+    }
+    if (shouldRun(options, 'writeSyncConcurrent')) {
+        const r = await benchmarkWriteSyncConcurrent(options);
+        peakMem = Math.max(peakMem, getMemoryMB());
+        printResult(r);
+        results.push(r);
+        await cooldown();
+    }
+    if (shouldRun(options, 'writeBatch')) {
+        const r = await benchmarkWriteBatch(options);
+        peakMem = Math.max(peakMem, getMemoryMB());
+        printResult(r);
+        results.push(r);
+        await cooldown();
+    }
+    if (shouldRun(options, 'writeFast')) {
+        const r = await benchmarkWriteFast(options);
+        peakMem = Math.max(peakMem, getMemoryMB());
+        if (r) {
+            printResult(r);
+            results.push(r);
+        }
+        await cooldown();
+    }
+    if (shouldRun(options, 'writeFastAndWait')) {
+        const r = await benchmarkWriteFastAndWait(options);
+        peakMem = Math.max(peakMem, getMemoryMB());
+        if (r) {
+            printResult(r);
+            results.push(r);
+        }
+        await cooldown();
+    }
+    // Read scenarios share a single seeded store
+    const needsRead = shouldRun(options, 'randomGet') || shouldRun(options, 'findByTag') || shouldRun(options, 'findByMetadata');
+    if (needsRead) {
+        console.log(`\n[bench] Seeding read store with ${options.total.toLocaleString()} docs ...`);
+        const seedT0 = performance.now();
+        const seeded = await seedReadStore(options);
+        console.log(`[bench] Seeded in ${((performance.now() - seedT0) / 1000).toFixed(1)}s (${seeded.ids.length} ids)`);
+        try {
+            if (shouldRun(options, 'randomGet')) {
+                const r = benchmarkRandomGet(seeded.store, seeded.ids, options.readOps);
+                peakMem = Math.max(peakMem, getMemoryMB());
+                printResult(r);
+                results.push(r);
+            }
+            if (shouldRun(options, 'findByTag')) {
+                const r = benchmarkFindByTag(seeded.store, options.scanOps);
+                peakMem = Math.max(peakMem, getMemoryMB());
+                printResult(r);
+                results.push(r);
+            }
+            if (shouldRun(options, 'findByMetadata')) {
+                const r = benchmarkFindByMetadata(seeded.store, options.scanOps);
+                peakMem = Math.max(peakMem, getMemoryMB());
+                printResult(r);
+                results.push(r);
+            }
+        }
+        finally {
+            seeded.cleanup();
+        }
+    }
+    const totalSeconds = (performance.now() - t0) / 1000;
+    printSummary(results, options, peakMem, totalSeconds);
+}
+main().catch((err) => {
+    console.error('Benchmark failed:', err);
+    console.error(err.stack);
+    process.exit(1);
+});
+// Allow `--scenarios` to be referenced inside printResult etc. without warnings.
+void DEFAULT_SCENARIOS;
+//# sourceMappingURL=concurrent-document-store-benchmark.js.map