@bitclaw/loadtest 1.1.0

package/dist/config/defaults.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Default thresholds per Hetzner VPS tier.
+ *
+ * These are application-level targets (full HTTP stack), not raw
+ * SQLite pool benchmarks. Expect lower throughput than pool.exec().
+ */
+export declare const HETZNER_TIERS: {
+    readonly CPX11: {
+        readonly vcpu: 2;
+        readonly ram: 2048;
+        readonly monthly: 4.15;
+    };
+    readonly CPX21: {
+        readonly vcpu: 3;
+        readonly ram: 4096;
+        readonly monthly: 7.49;
+    };
+    readonly CPX31: {
+        readonly vcpu: 4;
+        readonly ram: 8192;
+        readonly monthly: 15.49;
+    };
+    readonly CPX41: {
+        readonly vcpu: 8;
+        readonly ram: 16384;
+        readonly monthly: 30.99;
+    };
+};
+export declare const DEFAULT_THRESHOLDS: {
+    /** Default (no tier specified) */
+    readonly default: {
+        readonly p95MaxMs: 500;
+        readonly minSuccessRate: 95;
+        readonly minThroughput: 50;
+    };
+    /** Per-tier overrides */
+    readonly tiers: {
+        readonly CPX11: {
+            readonly p95MaxMs: 800;
+            readonly minSuccessRate: 90;
+            readonly minThroughput: 30;
+        };
+        readonly CPX21: {
+            readonly p95MaxMs: 500;
+            readonly minSuccessRate: 95;
+            readonly minThroughput: 50;
+        };
+        readonly CPX31: {
+            readonly p95MaxMs: 300;
+            readonly minSuccessRate: 98;
+            readonly minThroughput: 100;
+        };
+        readonly CPX41: {
+            readonly p95MaxMs: 200;
+            readonly minSuccessRate: 99;
+            readonly minThroughput: 200;
+        };
+    };
+};
+export declare const DEFAULT_MODES: {
+    readonly quick: {
+        readonly concurrencyLevels: readonly [1, 10];
+        readonly durationSec: 5;
+        readonly warmupRequests: 3;
+    };
+    readonly full: {
+        readonly concurrencyLevels: readonly [10, 50, 100];
+        readonly durationSec: 10;
+        readonly warmupRequests: 5;
+    };
+    readonly stress: {
+        readonly concurrencyLevels: readonly [50, 100, 200, 500];
+        readonly durationSec: 15;
+        readonly warmupRequests: 10;
+    };
+};
+//# sourceMappingURL=defaults.d.ts.map

package/dist/config/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/config/defaults.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;CAKhB,CAAC;AAEX,eAAO,MAAM,kBAAkB;IAC7B,kCAAkC;;;;;;IAMlC,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;CAuBjB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;CAgBhB,CAAC"}

package/dist/config/defaults.js

@@ -0,0 +1,60 @@
+/**
+ * Default thresholds per Hetzner VPS tier.
+ *
+ * These are application-level targets (full HTTP stack), not raw
+ * SQLite pool benchmarks. Expect lower throughput than pool.exec().
+ */
+export const HETZNER_TIERS = {
+    CPX11: { vcpu: 2, ram: 2048, monthly: 4.15 },
+    CPX21: { vcpu: 3, ram: 4096, monthly: 7.49 },
+    CPX31: { vcpu: 4, ram: 8192, monthly: 15.49 },
+    CPX41: { vcpu: 8, ram: 16384, monthly: 30.99 }
+};
+export const DEFAULT_THRESHOLDS = {
+    /** Default (no tier specified) */
+    default: {
+        p95MaxMs: 500,
+        minSuccessRate: 95,
+        minThroughput: 50
+    },
+    /** Per-tier overrides */
+    tiers: {
+        CPX11: {
+            p95MaxMs: 800,
+            minSuccessRate: 90,
+            minThroughput: 30
+        },
+        CPX21: {
+            p95MaxMs: 500,
+            minSuccessRate: 95,
+            minThroughput: 50
+        },
+        CPX31: {
+            p95MaxMs: 300,
+            minSuccessRate: 98,
+            minThroughput: 100
+        },
+        CPX41: {
+            p95MaxMs: 200,
+            minSuccessRate: 99,
+            minThroughput: 200
+        }
+    }
+};
+export const DEFAULT_MODES = {
+    quick: {
+        concurrencyLevels: [1, 10],
+        durationSec: 5,
+        warmupRequests: 3
+    },
+    full: {
+        concurrencyLevels: [10, 50, 100],
+        durationSec: 10,
+        warmupRequests: 5
+    },
+    stress: {
+        concurrencyLevels: [50, 100, 200, 500],
+        durationSec: 15,
+        warmupRequests: 10
+    }
+};

package/dist/config/loader.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Config loader — resolves per-app loadtest.config.ts files.
+ */
+import type { AppLoadTestConfig } from '../types';
+/**
+ * Load the loadtest config for a given app name.
+ * Expects the file at `apps/{appName}/loadtest.config.ts`.
+ */
+export declare function loadConfig(appName: string): Promise<AppLoadTestConfig>;
+/**
+ * List all available app names that have loadtest configs.
+ */
+export declare function listConfiguredApps(): Promise<string[]>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAKlD;;;GAGG;AACH,wBAAsB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAuC5E;AAED;;GAEG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAe5D"}

package/dist/config/loader.js

@@ -0,0 +1,56 @@
+/**
+ * Config loader — resolves per-app loadtest.config.ts files.
+ */
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..', '..', '..', '..');
+/**
+ * Load the loadtest config for a given app name.
+ * Expects the file at `apps/{appName}/loadtest.config.ts`.
+ */
+export async function loadConfig(appName) {
+    const configPath = join(REPO_ROOT, 'apps', appName, 'loadtest.config.ts');
+    try {
+        const mod = await import(configPath);
+        const config = mod.default ?? mod.config;
+        if (!config) {
+            throw new Error(`No default export or named "config" export found in ${configPath}`);
+        }
+        if (config.appName !== appName) {
+            console.warn(`Warning: Config appName "${config.appName}" doesn't match requested "${appName}"`);
+        }
+        return config;
+    }
+    catch (error) {
+        const message = error instanceof Error
+            ? error.message
+            : typeof error === 'object' && error !== null && 'message' in error
+                ? String(error.message)
+                : '';
+        if (message.includes('Cannot find module') ||
+            message.includes('ERR_MODULE_NOT_FOUND')) {
+            throw new Error(`No loadtest config found for app "${appName}".\n` +
+                `Expected: apps/${appName}/loadtest.config.ts\n` +
+                `Create one following the pattern in apps/runmist/loadtest.config.ts`);
+        }
+        throw error;
+    }
+}
+/**
+ * List all available app names that have loadtest configs.
+ */
+export async function listConfiguredApps() {
+    const { readdirSync, existsSync } = await import('node:fs');
+    const appsDir = join(REPO_ROOT, 'apps');
+    const apps = [];
+    for (const entry of readdirSync(appsDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            const configPath = join(appsDir, entry.name, 'loadtest.config.ts');
+            if (existsSync(configPath)) {
+                apps.push(entry.name);
+            }
+        }
+    }
+    return apps;
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @bitclaw/loadtest — Load testing infrastructure.
+ *
+ * Public API for programmatic usage from app-specific test files
+ * and the CLI.
+ */
+export { authenticateSession, createSessionPool } from './auth/session';
+export { DEFAULT_MODES, DEFAULT_THRESHOLDS, HETZNER_TIERS } from './config/defaults';
+export { listConfiguredApps, loadConfig } from './config/loader';
+export { checkThresholds, formatJson, formatReport } from './reports/formatter';
+export { runAppLoadTest } from './runner/bun-runner';
+export { runK6Test } from './runner/k6-runner';
+export type { AppLoadTestConfig, AuthConfig, EndpointConfig, Engine, K6RunOptions, LoadTestResults, ModeConfig, RunOptions, ScenarioResult, SessionState, TestMode, ThresholdConfig, ThresholdResult, ThresholdViolation } from './types';
+//# 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":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,aAAa,EACd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAEjE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEhF,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EACV,iBAAiB,EACjB,UAAU,EACV,cAAc,EACd,MAAM,EACN,YAAY,EACZ,eAAe,EACf,UAAU,EACV,UAAU,EACV,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,eAAe,EACf,eAAe,EACf,kBAAkB,EACnB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * @bitclaw/loadtest — Load testing infrastructure.
+ *
+ * Public API for programmatic usage from app-specific test files
+ * and the CLI.
+ */
+// Auth
+export { authenticateSession, createSessionPool } from './auth/session';
+export { DEFAULT_MODES, DEFAULT_THRESHOLDS, HETZNER_TIERS } from './config/defaults';
+// Config
+export { listConfiguredApps, loadConfig } from './config/loader';
+// Reports
+export { checkThresholds, formatJson, formatReport } from './reports/formatter';
+// Runners
+export { runAppLoadTest } from './runner/bun-runner';
+export { runK6Test } from './runner/k6-runner';

package/dist/reports/formatter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Report formatting and threshold checking.
+ */
+import type { AppLoadTestConfig, LoadTestResults, ThresholdConfig, ThresholdResult } from '../types';
+/**
+ * Format load test results as a human-readable report.
+ * Extends the upstream formatResults() with threshold checks.
+ */
+export declare function formatReport(results: LoadTestResults, config?: AppLoadTestConfig, tier?: string): string;
+/**
+ * Format results as JSON for machine consumption.
+ */
+export declare function formatJson(results: LoadTestResults, config?: AppLoadTestConfig, tier?: string): string;
+/**
+ * Check all scenarios against the given thresholds.
+ */
+export declare function checkThresholds(results: LoadTestResults, thresholds: Omit<ThresholdConfig, 'tiers'>): ThresholdResult;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/reports/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../src/reports/formatter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,eAAe,EAEhB,MAAM,UAAU,CAAC;AAElB;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,eAAe,EACxB,MAAM,CAAC,EAAE,iBAAiB,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,CAqCR;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,eAAe,EACxB,MAAM,CAAC,EAAE,iBAAiB,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,CAYR;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,GACzC,eAAe,CAsCjB"}

package/dist/reports/formatter.js

@@ -0,0 +1,99 @@
+/**
+ * Report formatting and threshold checking.
+ */
+import { formatResults as formatTable } from '@bitclaw/sqlite/load-test-utils';
+/**
+ * Format load test results as a human-readable report.
+ * Extends the upstream formatResults() with threshold checks.
+ */
+export function formatReport(results, config, tier) {
+    const lines = [];
+    // Use upstream table formatter
+    lines.push(formatTable(results));
+    // Add threshold results if config provided
+    if (config) {
+        const thresholds = resolveThresholds(config.thresholds, tier);
+        const check = checkThresholds(results, thresholds);
+        lines.push('');
+        lines.push('='.repeat(70));
+        lines.push(check.passed ? '  THRESHOLDS: ALL PASSED' : '  THRESHOLDS: FAILED');
+        if (tier) {
+            lines.push(`  Tier: ${tier}`);
+        }
+        lines.push(`  P95 max: ${thresholds.p95MaxMs}ms | Min success: ${thresholds.minSuccessRate}% | Min throughput: ${thresholds.minThroughput} req/s`);
+        lines.push('='.repeat(70));
+        if (!check.passed) {
+            lines.push('');
+            lines.push('  Violations:');
+            for (const v of check.violations) {
+                lines.push(`    ${v.scenario}: ${v.metric} = ${v.actual.toFixed(1)} (threshold: ${v.threshold})`);
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Format results as JSON for machine consumption.
+ */
+export function formatJson(results, config, tier) {
+    const output = {
+        ...results,
+        thresholds: undefined
+    };
+    if (config) {
+        const thresholds = resolveThresholds(config.thresholds, tier);
+        output.thresholds = checkThresholds(results, thresholds);
+    }
+    return JSON.stringify(output, null, 2);
+}
+/**
+ * Check all scenarios against the given thresholds.
+ */
+export function checkThresholds(results, thresholds) {
+    const violations = [];
+    for (const scenario of results.scenarios) {
+        const label = `${scenario.label} @${scenario.concurrency}`;
+        if (scenario.p95 > thresholds.p95MaxMs) {
+            violations.push({
+                scenario: label,
+                metric: 'p95',
+                actual: scenario.p95,
+                threshold: thresholds.p95MaxMs
+            });
+        }
+        if (scenario.successRate < thresholds.minSuccessRate) {
+            violations.push({
+                scenario: label,
+                metric: 'successRate',
+                actual: scenario.successRate,
+                threshold: thresholds.minSuccessRate
+            });
+        }
+        if (scenario.throughput < thresholds.minThroughput) {
+            violations.push({
+                scenario: label,
+                metric: 'throughput',
+                actual: scenario.throughput,
+                threshold: thresholds.minThroughput
+            });
+        }
+    }
+    return {
+        passed: violations.length === 0,
+        violations
+    };
+}
+/**
+ * Resolve the effective thresholds for a given tier.
+ */
+function resolveThresholds(config, tier) {
+    if (tier && config.tiers?.[tier]) {
+        return config.tiers[tier];
+    }
+    return {
+        p95MaxMs: config.p95MaxMs,
+        minSuccessRate: config.minSuccessRate,
+        minThroughput: config.minThroughput
+    };
+}

package/dist/runner/bun-runner.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Enhanced Bun-native load test runner.
+ *
+ * Wraps the existing runLoadTest() from load-test-utils.ts and adds
+ * authentication support, per-app config, and threshold checking.
+ */
+import { type LoadTestResults } from '@bitclaw/sqlite/load-test-utils';
+import type { AppLoadTestConfig, TestMode } from '../types';
+/**
+ * Run a full load test for an app using the Bun-native runner.
+ *
+ * 1. Tests public endpoints (no auth)
+ * 2. Authenticates session pool (if auth configured)
+ * 3. Tests authenticated endpoints with session cookies
+ * 4. Merges results
+ */
+export declare function runAppLoadTest(config: AppLoadTestConfig, mode: TestMode, options?: {
+    publicOnly?: boolean;
+    baseUrl?: string;
+}): Promise<LoadTestResults>;
+//# sourceMappingURL=bun-runner.d.ts.map

package/dist/runner/bun-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun-runner.d.ts","sourceRoot":"","sources":["../../src/runner/bun-runner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAGL,KAAK,eAAe,EAErB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAE5D;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,iBAAiB,EACzB,IAAI,EAAE,QAAQ,EACd,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACvD,OAAO,CAAC,eAAe,CAAC,CA+H1B"}

package/dist/runner/bun-runner.js

@@ -0,0 +1,140 @@
+/**
+ * Enhanced Bun-native load test runner.
+ *
+ * Wraps the existing runLoadTest() from load-test-utils.ts and adds
+ * authentication support, per-app config, and threshold checking.
+ */
+import { runLoadTest } from '@bitclaw/sqlite/load-test-utils';
+import { createSessionPool } from '../auth/session';
+/**
+ * Run a full load test for an app using the Bun-native runner.
+ *
+ * 1. Tests public endpoints (no auth)
+ * 2. Authenticates session pool (if auth configured)
+ * 3. Tests authenticated endpoints with session cookies
+ * 4. Merges results
+ */
+export async function runAppLoadTest(config, mode, options = {}) {
+    const modeConfig = config.modes[mode];
+    const baseUrl = options.baseUrl ?? config.baseUrl;
+    // Verify the app is reachable
+    await verifyApp(baseUrl, config);
+    const directUrl = config.directUrl;
+    const allScenarios = [];
+    let startedAt = new Date().toISOString();
+    // 1. Public endpoints (CDN/main URL)
+    if (config.publicEndpoints.length > 0) {
+        const publicConfig = {
+            baseUrl,
+            endpoints: config.publicEndpoints,
+            concurrencyLevels: [...modeConfig.concurrencyLevels],
+            durationSec: modeConfig.durationSec,
+            warmupRequests: modeConfig.warmupRequests
+        };
+        const publicResults = await runLoadTest(publicConfig);
+        startedAt = publicResults.startedAt;
+        if (directUrl) {
+            for (const s of publicResults.scenarios) {
+                s.via = 'cdn';
+                s.label = `${s.label} (CDN)`;
+            }
+        }
+        allScenarios.push(...publicResults.scenarios);
+    }
+    // 2. Direct origin pass — run public endpoints against directUrl and interleave
+    if (directUrl && config.publicEndpoints.length > 0) {
+        await verifyApp(directUrl, config);
+        const directConfig = {
+            baseUrl: directUrl,
+            endpoints: config.publicEndpoints,
+            concurrencyLevels: [...modeConfig.concurrencyLevels],
+            durationSec: modeConfig.durationSec,
+            warmupRequests: modeConfig.warmupRequests
+        };
+        const directResults = await runLoadTest(directConfig);
+        for (const s of directResults.scenarios) {
+            s.via = 'direct';
+            s.label = `${s.label} (Direct)`;
+        }
+        // Interleave CDN and Direct: CDN@50, Direct@50, CDN@100, Direct@100...
+        const cdnScenarios = allScenarios.splice(0);
+        const directScenarios = directResults.scenarios;
+        for (let i = 0; i < cdnScenarios.length; i++) {
+            allScenarios.push(cdnScenarios[i]);
+            if (i < directScenarios.length) {
+                allScenarios.push(directScenarios[i]);
+            }
+        }
+        if (directScenarios.length > cdnScenarios.length) {
+            allScenarios.push(...directScenarios.slice(cdnScenarios.length));
+        }
+    }
+    // 2. Authenticated endpoints
+    if (!options.publicOnly &&
+        config.auth &&
+        config.authenticatedEndpoints.length > 0) {
+        const email = config.auth.credentials?.email ?? process.env[config.auth.emailEnvVar];
+        const password = config.auth.credentials?.password ??
+            process.env[config.auth.passwordEnvVar];
+        if (!email || !password) {
+            console.warn(`Skipping ${config.authenticatedEndpoints.length} authenticated endpoint(s) — no credentials provided. ` +
+                `Set ${config.auth.emailEnvVar} and ${config.auth.passwordEnvVar} to include them.`);
+        }
+        else {
+            // Determine session pool size (1 per 20 max concurrent workers)
+            const maxConcurrency = Math.max(...modeConfig.concurrencyLevels);
+            const poolSize = Math.max(1, Math.ceil(maxConcurrency / 20));
+            const sessions = await createSessionPool(baseUrl, config.auth, poolSize);
+            // Inject Cookie header into each authenticated endpoint
+            // Round-robin across session pool
+            const authedEndpoints = config.authenticatedEndpoints.map((ep, i) => ({
+                ...ep,
+                headers: {
+                    ...ep.headers,
+                    Cookie: sessions[i % sessions.length].cookies
+                }
+            }));
+            const authedConfig = {
+                baseUrl,
+                endpoints: authedEndpoints,
+                concurrencyLevels: [...modeConfig.concurrencyLevels],
+                durationSec: modeConfig.durationSec,
+                warmupRequests: modeConfig.warmupRequests
+            };
+            const authedResults = await runLoadTest(authedConfig);
+            allScenarios.push(...authedResults.scenarios);
+        }
+    }
+    else if (!options.publicOnly &&
+        config.authenticatedEndpoints.length > 0 &&
+        !config.auth) {
+        console.warn(`Skipping ${config.authenticatedEndpoints.length} authenticated endpoint(s) — no auth config provided`);
+    }
+    return {
+        baseUrl,
+        startedAt,
+        completedAt: new Date().toISOString(),
+        scenarios: allScenarios
+    };
+}
+async function verifyApp(baseUrl, config) {
+    const checkPath = config.publicEndpoints[0]?.path ??
+        config.authenticatedEndpoints[0]?.path ??
+        '/';
+    try {
+        const response = await fetch(`${baseUrl}${checkPath}`, {
+            signal: AbortSignal.timeout(5000),
+            redirect: 'manual'
+        });
+        if (response.status >= 500) {
+            throw new Error(`App returned ${response.status} at ${baseUrl}${checkPath}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('App returned')) {
+            throw error;
+        }
+        throw new Error(`Cannot reach ${baseUrl}\n` +
+            `Make sure ${config.appName} is running (e.g., bun run dev)`);
+    }
+}

package/dist/runner/k6-runner.d.ts

@@ -0,0 +1,12 @@
+/**
+ * k6 runner — spawns k6 as a subprocess.
+ *
+ * k6 scripts live in packages/loadtest/k6/{appName}.js and are
+ * hand-written JavaScript (k6 doesn't support TypeScript natively).
+ */
+import type { K6RunOptions } from '../types';
+/**
+ * Run a k6 load test script for the given app.
+ */
+export declare function runK6Test(appName: string, options: K6RunOptions): Promise<void>;
+//# sourceMappingURL=k6-runner.d.ts.map

package/dist/runner/k6-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"k6-runner.d.ts","sourceRoot":"","sources":["../../src/runner/k6-runner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAoB7C;;GAEG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CAmDf"}

package/dist/runner/k6-runner.js

@@ -0,0 +1,80 @@
+/**
+ * k6 runner — spawns k6 as a subprocess.
+ *
+ * k6 scripts live in packages/loadtest/k6/{appName}.js and are
+ * hand-written JavaScript (k6 doesn't support TypeScript natively).
+ */
+import { existsSync, readdirSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const K6_SCRIPTS_DIR = resolve(__dirname, '..', '..', 'k6');
+/**
+ * Check if k6 is installed.
+ */
+async function checkK6() {
+    try {
+        const proc = Bun.spawn(['k6', 'version'], {
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        const code = await proc.exited;
+        return code === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Run a k6 load test script for the given app.
+ */
+export async function runK6Test(appName, options) {
+    // Verify k6 is installed
+    const hasK6 = await checkK6();
+    if (!hasK6) {
+        throw new Error('k6 is not installed.\n' +
+            'Install: https://grafana.com/docs/k6/latest/set-up/install-k6/\n' +
+            '  macOS: brew install k6\n' +
+            '  Linux: sudo apt install k6  (or snap install k6)\n' +
+            '  Docker: docker run -i grafana/k6 run -');
+    }
+    // Find the script
+    const scriptPath = join(K6_SCRIPTS_DIR, `${appName}.js`);
+    if (!existsSync(scriptPath)) {
+        throw new Error(`No k6 script found for "${appName}".\n` +
+            `Expected: packages/loadtest/k6/${appName}.js\n` +
+            `Available scripts: ${listK6Scripts().join(', ') || '(none)'}`);
+    }
+    // Build k6 args
+    const args = ['run'];
+    // Pass config via env vars
+    const env = {
+        ...process.env,
+        BASE_URL: options.baseUrl,
+        ...(options.email ? { LOADTEST_EMAIL: options.email } : {}),
+        ...(options.password ? { LOADTEST_PASSWORD: options.password } : {})
+    };
+    // JSON summary output
+    if (options.jsonOutput) {
+        args.push('--summary-export', options.jsonOutput);
+    }
+    args.push(scriptPath);
+    // Spawn k6 and stream output
+    const child = Bun.spawn(['k6', ...args], {
+        env,
+        stdio: ['inherit', 'inherit', 'inherit']
+    });
+    const exitCode = await child.exited;
+    if (exitCode !== 0) {
+        throw new Error(`k6 exited with code ${exitCode}`);
+    }
+}
+function listK6Scripts() {
+    try {
+        return readdirSync(K6_SCRIPTS_DIR)
+            .filter(f => f.endsWith('.js'))
+            .map(f => f.replace('.js', ''));
+    }
+    catch {
+        return [];
+    }
+}