@bitclaw/sqlite 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniel Chavez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,251 @@
+# @bitclaw/sqlite
+
+High-performance SQLite optimization package for multi-app SaaS deployments.
+
+## Features
+
+- **Worker Thread Pool**: Multiple SQLite connections for concurrent read/write operations
+- **Statement Caching**: Automatic prepared statement caching per worker
+- **Write Concurrency**: Per-resource write mutex and retry with exponential backoff
+- **Prisma Integration**: BEGIN IMMEDIATE transaction wrapper for Prisma + libsql
+- **JSON File Cache**: levelsio-style file-based caching with TTL support
+- **Zero External Dependencies**: Uses bun:sqlite (built into the Bun runtime)
+- **TypeScript**: Full type safety and IDE autocomplete
+
+## Modules
+
+| Import | Purpose |
+|--------|---------|
+| `@bitclaw/sqlite/pool` | Worker thread pool for concurrent SQLite operations |
+| `@bitclaw/sqlite/connection` | Single connection with optimized PRAGMAs |
+| `@bitclaw/sqlite/json-cache` | File-based JSON cache with TTL |
+| `@bitclaw/sqlite/write-mutex` | Promise-based per-resource write mutex |
+| `@bitclaw/sqlite/retry` | Exponential backoff retry for SQLITE_BUSY errors |
+| `@bitclaw/sqlite/prisma-immediate-tx` | BEGIN IMMEDIATE wrapper for Prisma transactions |
+| `@bitclaw/sqlite/query-logger` | Dev-mode SQL logging for bun:sqlite (mirrors Prisma's `prisma:query`) |
+| `@bitclaw/sqlite/ttl-cache` | In-memory TTL cache for server-side deduplication across HTTP requests |
+
+## Performance
+
+### Pool-Level Benchmarks (raw `pool.exec()`)
+
+Based on benchmarks from SecureLogin project:
+
+- **6,102 - 13,781 req/s** on Hetzner CPX21 (3 vCPU, 4GB RAM)
+- **P95 latency**: 12-22ms
+- **100% success rate** under load
+- **Prepared statement cache hit rate**: 100%
+
+These numbers reflect **direct SQLite pool operations** — no HTTP server, no ORM, no middleware. Application-level throughput (through TanStack Start + Prisma + SSR) will be lower. Use `bun run test:load` in each app for end-to-end numbers.
+
+## Benchmarking Methodology
+
+### Pool-Level (`scripts/benchmark.ts`)
+
+Tests raw `pool.exec()` calls against an in-process SQLite database:
+
+- Creates a temporary database with a `users` table
+- Runs concurrent workers executing `SELECT COUNT(*)` (reads) and `INSERT` (writes)
+- Measures latency per operation, calculates P50/P95/P99
+- No HTTP, no ORM, no serialization overhead
+
+This represents the **theoretical ceiling** for SQLite throughput on given hardware.
+
+### Application-Level (`bun run test:load`)
+
+Tests end-to-end HTTP throughput through the full stack:
+
+- Uses native `fetch()` against a running application server
+- Measures real response times including: HTTP parsing, middleware, Prisma ORM, SSR rendering, serialization
+- Tests at multiple concurrency levels (10/50/100)
+- Reports req/s, P50/P95/P99 latency, success rate
+
+This represents **actual user-facing performance**.
+
+## Installation
+
+```bash
+bun add @bitclaw/sqlite
+```
+
+## Usage
+
+### Worker Pool
+
+```typescript
+import { createPool } from '@bitclaw/sqlite/pool';
+
+const pool = createPool({
+  databasePath: './data/app.db',
+  poolSize: 4,
+  timeout: 30000
+});
+
+// Execute query
+const users = await pool.exec('SELECT * FROM users WHERE id = ?', [userId]);
+
+// Graceful shutdown
+await pool.shutdown();
+```
+
+### Write Mutex
+
+Serialize writes per resource to prevent SQLITE_BUSY contention before it reaches SQLite:
+
+```typescript
+import { WriteMutex, WriteMutexMap } from '@bitclaw/sqlite/write-mutex';
+
+// Single mutex
+const mutex = new WriteMutex();
+const result = await mutex.acquire(() => db.run('INSERT INTO ...'));
+
+// Named mutexes (e.g. per-tenant)
+const mutexes = new WriteMutexMap();
+await mutexes.withLock('workspace-123', () => db.run('INSERT INTO ...'));
+```
+
+### Retry with Backoff
+
+Retry operations that fail with SQLITE_BUSY using exponential backoff + jitter:
+
+```typescript
+import { withRetry } from '@bitclaw/sqlite/retry';
+
+const result = await withRetry(
+  () => db.run('INSERT INTO ...'),
+  { maxAttempts: 3, baseDelayMs: 100 }
+);
+```
+
+### Prisma BEGIN IMMEDIATE
+
+Prevent SQLITE_BUSY from Prisma's default deferred transactions:
+
+```typescript
+import { immediateTransaction } from '@bitclaw/sqlite/prisma-immediate-tx';
+import { withRetry } from '@bitclaw/sqlite/retry';
+
+await withRetry(() =>
+  immediateTransaction(prisma, async () => {
+    await prisma.user.create({ data: { ... } });
+    await prisma.session.update({ where: { ... }, data: { ... } });
+  })
+);
+```
+
+### JSON Cache
+
+```typescript
+import { createJsonCache } from '@bitclaw/sqlite/json-cache';
+
+const cache = createJsonCache({
+  cacheDir: './cache',
+  defaultTtl: 300000 // 5 minutes
+});
+
+// Set value
+await cache.set('user:123', userData, { ttl: 600000 });
+
+// Get value
+const user = await cache.get('user:123');
+
+// Delete value
+await cache.delete('user:123');
+```
+
+### Query Logger
+
+Dev-mode SQL logging for bun:sqlite — mirrors Prisma's `prisma:query` output. Zero overhead in production.
+
+```typescript
+import { Database } from 'bun:sqlite';
+import { wrapWithQueryLogging } from '@bitclaw/sqlite/query-logger';
+
+const raw = new Database('./data/workspace.db');
+const db = wrapWithQueryLogging(raw, { label: 'ws:abc123' });
+
+// In development, every query/prepare/run/exec logs to stdout:
+//   sqlite:query [ws:abc123] SELECT * FROM servers WHERE id = ?
+//
+// In production (NODE_ENV !== 'development'), returns the database unchanged.
+db.query('SELECT * FROM servers WHERE id = ?').get(serverId);
+```
+
+### TTL Cache
+
+In-memory TTL cache for server-side deduplication across HTTP requests. Designed for caching expensive lookups (auth sessions, membership checks, bootstrap data) that repeat when frameworks like TanStack Router re-run loaders on client hydration.
+
+```typescript
+import { TTLCache } from '@bitclaw/sqlite/ttl-cache';
+
+type BootstrapData = { user: User; workspaces: Workspace[] };
+
+const bootstrapCache = new TTLCache<BootstrapData>({
+  ttl: 30_000,   // 30s (default)
+  maxSize: 100   // auto-prune expired entries when exceeded (default)
+});
+
+// In your server function:
+const cached = bootstrapCache.get(sessionId);
+if (cached) return cached;
+
+const data = await expensiveQuery();
+bootstrapCache.set(sessionId, data);
+return data;
+```
+
+Unlike `WeakMap` per-request caching (which deduplicates within a single SSR request), `TTLCache` deduplicates **across** HTTP requests — e.g. when TanStack Router replays `beforeLoad` on client hydration, the server returns the cached result instantly (0 DB queries).
+
+## Configuration
+
+### Environment Variables
+
+```bash
+SQLITE_POOL_SIZE=4              # Number of worker threads
+SQLITE_WORKER_TIMEOUT=30000     # Query timeout in milliseconds
+DATABASE_PATH=./data/app.db     # Database file path
+JSON_CACHE_DIR=./cache          # Cache directory
+JSON_CACHE_TTL=300000           # Default TTL in milliseconds
+```
+
+## Benchmarking
+
+```bash
+# Quick benchmark (5 seconds, default)
+bun run benchmark
+
+# Quick benchmark (explicit)
+bun run benchmark:quick
+
+# CPX21 tier benchmark (matches production)
+bun run benchmark -- --tier cpx21
+
+# All Hetzner tiers
+bun run benchmark -- --tiers
+
+# Help
+bun run benchmark -- --help
+```
+
+## Architecture
+
+### Worker Pool
+- Uses Node.js worker threads for true concurrency
+- Round-robin query distribution
+- Automatic connection health monitoring
+- Graceful shutdown with connection cleanup
+
+### Write Concurrency
+- **Write Mutex**: Promise-based per-resource lock serializes writes before they hit SQLite, eliminating contention at near-zero overhead
+- **Retry**: Exponential backoff with jitter catches any remaining SQLITE_BUSY errors as a safety net (default: 3 attempts, 100ms base delay)
+- **BEGIN IMMEDIATE**: Prisma wrapper acquires write lock upfront instead of deferring, preventing the deadlock-prone lock upgrade path
+
+### JSON Cache
+- Atomic writes using temp files
+- TTL-based expiration
+- Stale-while-revalidate support
+- No external dependencies
+
+## License
+
+MIT

package/dist/scripts/benchmark.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=benchmark.d.ts.map

package/dist/scripts/benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../../scripts/benchmark.ts"],"names":[],"mappings":""}

package/dist/scripts/benchmark.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env bun
+// packages/sqlite/scripts/benchmark.ts
+// SQLite performance benchmark for Hetzner VPS tiers
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { createPool, shutdownPool } from '../src/pool';
+/* ------------------------------------------------------------------
+ * Hetzner VPS Tiers (vs AWS Lambda)
+ * ------------------------------------------------------------------ */
+const HETZNER_TIERS = [
+    { name: 'CPX11', vcpu: 2, ram: 2048, pool: 2, monthly: 4.15 }, // Entry
+    { name: 'CPX21', vcpu: 3, ram: 4096, pool: 4, monthly: 7.49 }, // DEFAULT
+    { name: 'CPX31', vcpu: 4, ram: 8192, pool: 4, monthly: 15.49 }, // Mid
+    { name: 'CPX41', vcpu: 8, ram: 16384, pool: 6, monthly: 30.99 } // High
+];
+/* ------------------------------------------------------------------
+ * Performance Targets
+ * ------------------------------------------------------------------ */
+const TARGETS = {
+    p95LatencyMs: 40,
+    errorRatePct: 0.5,
+    throughputQps: 1000
+};
+/* ------------------------------------------------------------------
+ * Helper utilities
+ * ------------------------------------------------------------------ */
+function percentile(sorted, p) {
+    if (!sorted.length)
+        return 0;
+    const idx = (p / 100) * (sorted.length - 1);
+    const lo = Math.floor(idx);
+    const hi = Math.ceil(idx);
+    if (lo === hi)
+        return sorted[lo];
+    return sorted[lo] + (sorted[hi] - sorted[lo]) * (idx - lo);
+}
+/* ------------------------------------------------------------------
+ * Benchmark runner class
+ * ------------------------------------------------------------------ */
+class PoolBench {
+    results = [];
+    failCount = 0;
+    async run(cfg) {
+        this.failCount = 0;
+        await PoolBench.initDatabase();
+        const pool = createPool({
+            databasePath: process.env.DATABASE_PATH,
+            poolSize: cfg.poolSize,
+            timeout: 30000
+        });
+        const lat = [];
+        const t0 = performance.now();
+        const end = t0 + cfg.durationSec * 1_000;
+        // Create concurrent workers
+        const workers = Array.from({ length: cfg.concurrency }, () => PoolBench.workerLoop(cfg.op, pool.exec.bind(pool), end, lat, this));
+        await Promise.allSettled(workers);
+        const durSec = (performance.now() - t0) / 1_000;
+        lat.sort((a, b) => a - b);
+        const total = lat.length;
+        const fail = this.failCount;
+        const ok = total - fail;
+        const r = {
+            op: cfg.op,
+            pool: cfg.poolSize,
+            tierName: cfg.tierName,
+            tierCost: cfg.tierCost,
+            total,
+            ok,
+            fail,
+            errPct: total ? (fail / total) * 100 : 0,
+            tput: total / durSec,
+            p50: percentile(lat, 50),
+            p95: percentile(lat, 95),
+            p99: percentile(lat, 99),
+            max: lat.at(-1) ?? 0,
+            min: lat[0] ?? 0
+        };
+        this.results.push(r);
+        await PoolBench.cleanupPool();
+    }
+    static async initDatabase() {
+        // Ensure data/ directory exists
+        const dataDir = path.resolve(import.meta.dir, '..', 'data');
+        if (!fs.existsSync(dataDir)) {
+            fs.mkdirSync(dataDir, { recursive: true });
+        }
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substring(2, 8);
+        const pid = process.pid;
+        const dbFile = path.join(dataDir, `bench-${timestamp}-${pid}-${random}.db`);
+        process.env.DATABASE_PATH = dbFile;
+        // Clean up old test files
+        for (const ext of ['', '-shm', '-wal']) {
+            const file = dbFile + ext;
+            if (fs.existsSync(file)) {
+                fs.unlinkSync(file);
+            }
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Create test table using bun:sqlite
+        const { Database } = await import('bun:sqlite');
+        const testDb = new Database(dbFile);
+        try {
+            // Pre-set WAL mode so pool workers don't race to set it
+            testDb.run('PRAGMA journal_mode = WAL');
+            testDb.run('PRAGMA busy_timeout = 5000');
+            testDb.run(`
+        CREATE TABLE IF NOT EXISTS users (
+          id TEXT PRIMARY KEY,
+          primary_email TEXT NOT NULL UNIQUE,
+          name TEXT,
+          max_sessions INTEGER DEFAULT 5,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE INDEX IF NOT EXISTS idx_users_email ON users(primary_email);
+      `);
+        }
+        catch (error) {
+            console.error('[db] CRITICAL: Tables not found:', error);
+            throw new Error('Migration verification failed');
+        }
+        finally {
+            testDb.close();
+        }
+        // Give the OS time to release the file lock after close
+        await new Promise(resolve => setTimeout(resolve, 200));
+    }
+    static async cleanupPool() {
+        try {
+            // shutdownPool can hang if workers are stuck; add a timeout
+            await Promise.race([
+                shutdownPool(),
+                new Promise(resolve => setTimeout(resolve, 5000))
+            ]);
+        }
+        finally {
+            const dbPath = process.env.DATABASE_PATH;
+            if (dbPath && dbPath !== ':memory:' && fs.existsSync(dbPath)) {
+                try {
+                    await new Promise(resolve => setTimeout(resolve, 200));
+                    for (const ext of ['', '-shm', '-wal']) {
+                        const file = dbPath + ext;
+                        if (fs.existsSync(file)) {
+                            fs.unlinkSync(file);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.warn(`Warning: Could not clean up ${dbPath}:`, error);
+                }
+            }
+            delete process.env.DATABASE_PATH;
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+    }
+    static async workerLoop(op, exec, endTs, lat, benchInstance) {
+        let localFailCount = 0;
+        while (performance.now() < endTs) {
+            const start = performance.now();
+            try {
+                await PoolBench.doOne(op, exec);
+            }
+            catch (error) {
+                localFailCount += 1;
+                benchInstance.failCount += 1;
+                if (localFailCount <= 3) {
+                    console.error(`Worker failure ${localFailCount}:`, error instanceof Error ? error.message : String(error));
+                }
+            }
+            finally {
+                lat.push(performance.now() - start);
+            }
+            await new Promise(res => setTimeout(res, 1));
+        }
+    }
+    static async doOne(op, exec) {
+        const id = `u-${Math.random().toString(36).slice(2)}`;
+        const email = `${id}@bench.test`;
+        switch (op) {
+            case 'read':
+                return exec('SELECT COUNT(*) as c FROM users;');
+            case 'write':
+                return exec(`INSERT INTO users (id, primary_email, max_sessions, created_at, updated_at)
+           VALUES (?, ?, 5, ?, ?)`, [id, email, new Date().toISOString(), new Date().toISOString()]);
+            default: // mixed
+                return Math.random() < 0.7
+                    ? exec('SELECT COUNT(*) as c FROM users;')
+                    : exec(`INSERT INTO users (id, primary_email, max_sessions, created_at, updated_at)
+             VALUES (?, ?, 5, ?, ?)`, [id, email, new Date().toISOString(), new Date().toISOString()]);
+        }
+    }
+    print() {
+        console.info('\n═══════════════════════════════════════════════════════');
+        console.info('  SQLite Pool Benchmark Results');
+        console.info('═══════════════════════════════════════════════════════\n');
+        for (const r of this.results) {
+            const tierText = r.tierName ? `  tier=${r.tierName}` : '';
+            const costText = r.tierCost ? ` (€${r.tierCost}/mo)` : '';
+            console.info(`  op=${r.op}  pool=${r.pool}${tierText}${costText}`);
+            console.info(`  total=${r.total}  ok=${r.ok}  fail=${r.fail}  err=${r.errPct.toFixed(2)}%`);
+            console.info(`  throughput=${r.tput.toFixed(0)} qps`);
+            console.info(`  latency: p50=${r.p50.toFixed(1)}ms  p95=${r.p95.toFixed(1)}ms  p99=${r.p99.toFixed(1)}ms  max=${r.max.toFixed(1)}ms`);
+            console.info('');
+        }
+    }
+    allPassed() {
+        return this.results.every(r => r.p95 <= TARGETS.p95LatencyMs &&
+            r.errPct <= TARGETS.errorRatePct &&
+            r.tput >= TARGETS.throughputQps);
+    }
+}
+/* ------------------------------------------------------------------
+ * CLI runner
+ * ------------------------------------------------------------------ */
+async function main() {
+    const bench = new PoolBench();
+    const args = process.argv.slice(2);
+    const wantQuick = args.includes('--quick');
+    const wantTiers = args.includes('--tiers');
+    const wantCpx21 = args.includes('--tier') && args.includes('cpx21');
+    if (args.includes('--help')) {
+        console.info(`Usage: bun benchmark [options]
+
+Options:
+  --quick        Quick benchmark (pool=4, concurrency=20, 5s)
+  --tier cpx21   Simulate CPX21 tier (pool=4, concurrency=60, 10s)
+  --tiers        Run all Hetzner tiers (CPX11/21/31/41)
+  --help         Show this help
+
+Targets: p95 < ${TARGETS.p95LatencyMs}ms, error < ${TARGETS.errorRatePct}%, throughput > ${TARGETS.throughputQps} qps
+`);
+        process.exit(0);
+    }
+    try {
+        if (wantTiers) {
+            for (const t of HETZNER_TIERS) {
+                await bench.run({
+                    poolSize: t.pool,
+                    concurrency: t.pool * 15,
+                    durationSec: 10,
+                    op: 'mixed',
+                    tierName: t.name,
+                    tierCost: t.monthly
+                });
+            }
+        }
+        else if (wantCpx21) {
+            const cpx21 = HETZNER_TIERS.find(t => t.name === 'CPX21');
+            await bench.run({
+                poolSize: cpx21.pool,
+                concurrency: cpx21.pool * 15,
+                durationSec: 10,
+                op: 'mixed',
+                tierName: cpx21.name,
+                tierCost: cpx21.monthly
+            });
+        }
+        else if (wantQuick) {
+            await bench.run({
+                poolSize: 4,
+                concurrency: 20,
+                durationSec: 5,
+                op: 'mixed'
+            });
+        }
+        else {
+            // Default: Quick test
+            await bench.run({
+                poolSize: 4,
+                concurrency: 20,
+                durationSec: 5,
+                op: 'mixed'
+            });
+        }
+        bench.print();
+        const ok = bench.allPassed();
+        process.exit(ok ? 0 : 1);
+    }
+    catch (error) {
+        console.error('❌ Benchmark failed:', error);
+        process.exit(1);
+    }
+}
+main().catch(console.error);

package/dist/scripts/load-test-utils.d.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env bun
+/**
+ * Shared load test utilities for application-level HTTP throughput testing.
+ *
+ * Unlike benchmark.ts (which tests raw SQLite pool.exec() calls), these utilities
+ * measure end-to-end HTTP performance through the full stack: HTTP server, middleware,
+ * ORM (Prisma), SSR rendering, etc.
+ *
+ * Usage:
+ *   Import into app-specific load tests:
+ *     import { runLoadTest, formatResults } from '@bitclaw/sqlite/load-test-utils'
+ *
+ *   Or run directly for a quick test:
+ *     bun run packages/sqlite/scripts/load-test-utils.ts --url http://localhost:3001
+ */
+export type LoadTestConfig = {
+    /** Base URL of the application (e.g., http://localhost:3001) */
+    baseUrl: string;
+    /** Endpoints to test, relative to baseUrl */
+    endpoints: EndpointConfig[];
+    /** Concurrency levels to test */
+    concurrencyLevels: number[];
+    /** Duration per scenario in seconds */
+    durationSec: number;
+    /** Optional: warm-up requests before timing */
+    warmupRequests?: number;
+};
+export type EndpointConfig = {
+    /** Path relative to baseUrl (e.g., '/healthcheck') */
+    path: string;
+    /** HTTP method (default: GET) */
+    method?: string;
+    /** Request body for POST/PUT */
+    body?: string;
+    /** Additional headers */
+    headers?: Record<string, string>;
+    /** Human-readable label */
+    label?: string;
+};
+export type RequestResult = {
+    statusCode: number;
+    latencyMs: number;
+    success: boolean;
+    bodySize: number;
+};
+export type ScenarioResult = {
+    endpoint: string;
+    label: string;
+    method: string;
+    concurrency: number;
+    durationSec: number;
+    totalRequests: number;
+    successCount: number;
+    failCount: number;
+    successRate: number;
+    throughput: number;
+    p50: number;
+    p95: number;
+    p99: number;
+    min: number;
+    max: number;
+    avg: number;
+    statusCodes: Record<number, number>;
+    avgBodySize: number;
+    via?: 'cdn' | 'direct';
+};
+export type LoadTestResults = {
+    baseUrl: string;
+    startedAt: string;
+    completedAt: string;
+    scenarios: ScenarioResult[];
+};
+export declare function percentile(sorted: number[], p: number): number;
+export declare function measureResponseTime(url: string, method?: string, body?: string, headers?: Record<string, string>): Promise<RequestResult>;
+export declare function runLoadTest(config: LoadTestConfig): Promise<LoadTestResults>;
+export declare function formatResults(results: LoadTestResults): string;
+//# sourceMappingURL=load-test-utils.d.ts.map

package/dist/scripts/load-test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-test-utils.d.ts","sourceRoot":"","sources":["../../scripts/load-test-utils.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;GAaG;AAKH,MAAM,MAAM,cAAc,GAAG;IAC3B,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,iCAAiC;IACjC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yBAAyB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IAEpB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IAEpB,UAAU,EAAE,MAAM,CAAC;IAEnB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IAEZ,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;IAEpB,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,cAAc,EAAE,CAAC;CAC7B,CAAC;AAKF,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAS9D;AAKD,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,EACX,MAAM,SAAQ,EACd,IAAI,CAAC,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,OAAO,CAAC,aAAa,CAAC,CA6BxB;AA8FD,wBAAsB,WAAW,CAC/B,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,eAAe,CAAC,CA0B1B;AAKD,wBAAgB,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,CAoE9D"}