loadscope 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,720 @@
+import { z } from 'zod';
+
+interface RunOptions {
+    url: string;
+    duration?: number;
+    concurrency?: number;
+    rate?: number;
+    distribution?: "uniform" | "poisson";
+    honest?: boolean;
+    ttfb?: boolean;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeout?: number;
+    warmup?: number;
+    rampUp?: number;
+    mode?: "closed" | "open";
+    workers?: number | "auto";
+    dashboard?: boolean;
+    json?: string | boolean;
+    csv?: string | boolean;
+    html?: string | boolean;
+    pdf?: string;
+    aiReport?: string;
+    aiDryRun?: boolean;
+    baseline?: string;
+    saveBaseline?: string | boolean;
+    maxP95Increase?: number;
+    maxRpsDrop?: number;
+    maxP99Increase?: number;
+    maxErrors?: number;
+}
+interface LatencyPoint {
+    t: number;
+    p95: number;
+}
+interface LatencyDistribution {
+    p50: number;
+    p90: number;
+    p95: number;
+    p99: number;
+    min: number;
+    max: number;
+    mean: number;
+}
+interface HistogramSnapshot {
+    counts: Uint32Array;
+    total: number;
+    minVal: number;
+    maxVal: number;
+    sumUs: number;
+}
+interface WorkerInitData {
+    workerIndex: number;
+    totalWorkers: number;
+    url: string;
+    duration: number;
+    concurrency: number;
+    rate?: number;
+    distribution?: "uniform" | "poisson";
+    honest?: boolean;
+    ttfb?: boolean;
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+    timeout: number;
+    warmup: number;
+    rampUp: number;
+    mode: "closed" | "open";
+}
+interface WorkerTickMessage {
+    type: "tick";
+    workerIndex: number;
+    elapsedSec: number;
+    dispatched: number;
+    networkErrors: number;
+    httpErrors: number;
+    statusCodes: Record<number, number>;
+    errorsByType: Record<string, number>;
+    windowSnapshot: HistogramSnapshot;
+    cumulativeSnapshot: HistogramSnapshot;
+    serviceTimeSnapshot?: HistogramSnapshot;
+    ttfbSnapshot?: HistogramSnapshot;
+    loopLagMs: number;
+}
+interface WorkerDoneMessage {
+    type: "done";
+    workerIndex: number;
+    dispatched: number;
+    networkErrors: number;
+    httpErrors: number;
+    statusCodes: Record<number, number>;
+    errorsByType: Record<string, number>;
+    finalSnapshot: HistogramSnapshot;
+    serviceTimeSnapshot?: HistogramSnapshot;
+    ttfbSnapshot?: HistogramSnapshot;
+    loopLagMaxMs: number;
+    loopLagP99Ms: number;
+    avgDriftMs?: number;
+}
+interface WorkerErrorMessage {
+    type: "error";
+    workerIndex: number;
+    error: string;
+}
+type WorkerMessage = WorkerTickMessage | WorkerDoneMessage | WorkerErrorMessage;
+interface RunSummary {
+    target: string;
+    rps: number;
+    totalRequests: number;
+    durationSec: number;
+    p50: number;
+    p90: number;
+    p95: number;
+    p99: number;
+    errorRate: number;
+    networkErrors: number;
+    httpErrors: number;
+    statusCodes: Record<number, number>;
+    errorsByType: Record<string, number>;
+    series: LatencyPoint[];
+    selfCheckWarnings: string[];
+    workerCount?: number;
+    distribution?: "uniform" | "poisson";
+    serviceTime?: LatencyDistribution;
+    queueDelay?: LatencyDistribution;
+    ttfb?: LatencyDistribution;
+    scheduleDriftMs?: number;
+}
+interface BreakpointLimits {
+    maxP95?: number;
+    maxP99?: number;
+    maxErrorRate: number;
+}
+interface BreakpointStepResult {
+    stepIndex: number;
+    load: number;
+    rps: number;
+    p50: number;
+    p95: number;
+    p99: number;
+    errorRate: number;
+    totalRequests: number;
+    networkErrors: number;
+    httpErrors: number;
+    status: "PASS" | "BREACH";
+    breachReason?: string;
+    isRefinement?: boolean;
+    summary: RunSummary;
+}
+interface BreakpointSummary {
+    target: string;
+    mode: "concurrency" | "rate";
+    start: number;
+    max: number;
+    step: number;
+    stepDurationSec: number;
+    breakingPoint?: number;
+    safeCapacity?: number;
+    breached: boolean;
+    breachReason?: string;
+    steps: BreakpointStepResult[];
+    refinementSteps: BreakpointStepResult[];
+    limits: BreakpointLimits;
+}
+interface BreakpointOptions {
+    url: string;
+    mode?: "concurrency" | "rate";
+    start?: number;
+    max?: number;
+    step?: number;
+    stepDuration?: string | number;
+    maxP95?: number;
+    maxP99?: number;
+    maxErrorRate?: number;
+    refine?: boolean;
+    tolerance?: number;
+    workers?: number | "auto";
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeout?: number | string;
+    honest?: boolean;
+    distribution?: "uniform" | "poisson";
+    json?: string | boolean;
+    csv?: string | boolean;
+    onStepStart?: (stepNumber: number, load: number, isRefinement?: boolean) => void;
+    onStepComplete?: (result: BreakpointStepResult) => void;
+}
+interface GateThresholds {
+    maxP95IncreasePct: number;
+    maxRpsDropPct: number;
+    maxP99IncreasePct?: number;
+    maxErrorRate?: number;
+}
+interface BaselineData {
+    timestamp: string;
+    target: string;
+    concurrency?: number;
+    rate?: number;
+    durationSec: number;
+    rps: number;
+    totalRequests: number;
+    p50: number;
+    p90: number;
+    p95: number;
+    p99: number;
+    errorRate: number;
+    networkErrors: number;
+    httpErrors: number;
+    commitHash?: string;
+}
+interface ComparisonMetric {
+    name: string;
+    baseline: number;
+    current: number;
+    delta: number;
+    deltaPct: number;
+    unit: string;
+    isHigherBetter: boolean;
+    status: "PASS" | "IMPROVEMENT" | "REGRESSION";
+    threshold?: number;
+    thresholdViolation?: boolean;
+    message?: string;
+}
+interface ComparisonSummary {
+    passed: boolean;
+    baselineTarget: string;
+    currentTarget: string;
+    baselineTimestamp?: string;
+    metrics: ComparisonMetric[];
+    regressions: ComparisonMetric[];
+    improvements: ComparisonMetric[];
+    thresholds: GateThresholds;
+}
+interface ScenarioStep {
+    name: string;
+    method?: string;
+    path?: string;
+    url?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    extract?: Record<string, string>;
+    thinkTime?: string | number;
+}
+interface ScenarioDefinition {
+    name: string;
+    target: string;
+    duration?: string | number;
+    concurrency?: number;
+    timeout?: string | number;
+    steps: ScenarioStep[];
+}
+interface StepSummary {
+    name: string;
+    method: string;
+    path: string;
+    totalRequests: number;
+    rps: number;
+    p50: number;
+    p90: number;
+    p95: number;
+    p99: number;
+    min: number;
+    max: number;
+    mean: number;
+    errorRate: number;
+    statusCodes: Record<number, number>;
+    networkErrors: number;
+    httpErrors: number;
+}
+interface ScenarioSummary {
+    name: string;
+    target: string;
+    durationSec: number;
+    concurrency: number;
+    totalJourneys: number;
+    completedJourneys: number;
+    failedJourneys: number;
+    journeysPerSec: number;
+    journeyP50: number;
+    journeyP90: number;
+    journeyP95: number;
+    journeyP99: number;
+    steps: StepSummary[];
+    overallSummary: RunSummary;
+}
+
+/**
+ * Fixed-Memory Log-Bucketed Histogram.
+ *
+ * Storing raw latency arrays creates O(N) memory usage and triggers GC pauses.
+ * This histogram uses a fixed Uint32Array(1200) (~4.8 KB of memory forever).
+ * Relative error is bounded by (GROWTH - 1) ≈ 2%.
+ */
+declare class Histogram {
+    /** Fixed 4.8 KB bucket array of counts */
+    readonly counts: Uint32Array<ArrayBuffer>;
+    /** Total number of recorded samples */
+    total: number;
+    private minVal;
+    private maxVal;
+    private sumUs;
+    /**
+     * Calculate bucket index from latency in microseconds.
+     * O(1) mathematical mapping.
+     */
+    private idx;
+    /**
+     * Reconstruct microsecond value from bucket index.
+     */
+    private valFromIdx;
+    /**
+     * Record a latency value in microseconds (us).
+     */
+    record(us: number): void;
+    /**
+     * Merge another histogram into this one.
+     * Merging is simple O(B) vector addition across the fixed bucket array.
+     */
+    merge(other: Histogram): void;
+    /**
+     * Calculate the given percentile (0..100) in microseconds (us).
+     */
+    percentile(p: number): number;
+    /**
+     * Return percentile in milliseconds (ms).
+     */
+    percentileMs(p: number): number;
+    /**
+     * Minimum recorded latency in microseconds (us).
+     */
+    min(): number;
+    /**
+     * Minimum recorded latency in milliseconds (ms).
+     */
+    minMs(): number;
+    /**
+     * Maximum recorded latency in microseconds (us).
+     */
+    max(): number;
+    /**
+     * Maximum recorded latency in milliseconds (ms).
+     */
+    maxMs(): number;
+    /**
+     * Mean (average) latency in microseconds (us).
+     */
+    mean(): number;
+    /**
+     * Mean (average) latency in milliseconds (ms).
+     */
+    meanMs(): number;
+    /**
+     * Reset all bucket counts and statistics.
+     */
+    reset(): void;
+    /**
+     * Export raw snapshot data for inter-thread messaging (worker_threads).
+     */
+    toSnapshot(): {
+        counts: Uint32Array;
+        total: number;
+        minVal: number;
+        maxVal: number;
+        sumUs: number;
+    };
+    /**
+     * Restore or merge from a worker snapshot.
+     */
+    mergeSnapshot(snapshot: {
+        counts: Uint32Array;
+        total: number;
+        minVal: number;
+        maxVal: number;
+        sumUs: number;
+    }): void;
+}
+
+/**
+ * Generate a clean, formatted terminal summary report string.
+ * Kept pure without console.log side-effects for testability.
+ */
+declare function formatTerminalReport(s: RunSummary): string;
+/**
+ * Print a clean, formatted terminal summary report to stdout.
+ */
+declare function printTerminalReport(s: RunSummary): void;
+
+/**
+ * Serializes a RunSummary to formatted JSON string.
+ */
+declare function formatJsonReport(summary: RunSummary): string;
+/**
+ * Formats a RunSummary and its per-second time series into CSV format.
+ */
+declare function formatCsvReport(summary: RunSummary): string;
+/**
+ * Serializes a BreakpointSummary to formatted JSON string.
+ */
+declare function formatBreakpointJsonReport(summary: BreakpointSummary): string;
+/**
+ * Formats a BreakpointSummary and all its steps into CSV format.
+ */
+declare function formatBreakpointCsvReport(summary: BreakpointSummary): string;
+/**
+ * Serializes a ComparisonSummary to formatted JSON string.
+ */
+declare function formatComparisonJsonReport(summary: ComparisonSummary): string;
+/**
+ * Formats a ComparisonSummary into CSV format.
+ */
+declare function formatComparisonCsvReport(summary: ComparisonSummary): string;
+
+interface DashboardStats {
+    target: string;
+    elapsedSec: number;
+    totalDurationSec: number;
+    totalRequests: number;
+    currentRps: number;
+    p50Ms: number;
+    p90Ms: number;
+    p95Ms: number;
+    networkErrors: number;
+    httpErrors: number;
+    workerCount: number;
+    mode: "closed" | "open";
+    warnings?: string[];
+}
+/**
+ * Real-time terminal dashboard powered by log-update.
+ */
+declare class LiveDashboard {
+    private enabled;
+    constructor(enabled?: boolean);
+    /**
+     * Format a progress bar like [████████░░░░░░] 60%
+     */
+    private renderProgressBar;
+    /**
+     * Generates the dashboard text representation.
+     */
+    formatDashboard(stats: DashboardStats): string;
+    /**
+     * Update the live terminal display.
+     */
+    update(stats: DashboardStats): void;
+    /**
+     * Stop the live dashboard and clean up terminal state.
+     */
+    stop(): void;
+}
+
+/**
+ * Schema validating options passed to LoadScope run.
+ */
+declare const RunOptionsSchema: z.ZodObject<{
+    url: z.ZodString;
+    duration: z.ZodEffects<z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, number, string | number | undefined>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    rate: z.ZodOptional<z.ZodNumber>;
+    method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]>>;
+    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodEffects<z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, number, string | number | undefined>;
+    warmup: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, number, string | number | undefined>;
+    rampUp: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>, number, string | number | undefined>;
+    mode: z.ZodOptional<z.ZodEnum<["closed", "open"]>>;
+    distribution: z.ZodDefault<z.ZodEnum<["uniform", "poisson"]>>;
+    honest: z.ZodDefault<z.ZodBoolean>;
+    ttfb: z.ZodDefault<z.ZodBoolean>;
+    workers: z.ZodDefault<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"auto">]>>;
+    dashboard: z.ZodDefault<z.ZodBoolean>;
+    json: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    csv: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    pdf: z.ZodOptional<z.ZodString>;
+    aiReport: z.ZodOptional<z.ZodString>;
+    aiDryRun: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    concurrency: number;
+    duration: number;
+    timeout: number;
+    url: string;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+    headers: Record<string, string>;
+    warmup: number;
+    rampUp: number;
+    distribution: "uniform" | "poisson";
+    honest: boolean;
+    ttfb: boolean;
+    workers: number | "auto";
+    dashboard: boolean;
+    aiDryRun: boolean;
+    rate?: number | undefined;
+    body?: string | undefined;
+    mode?: "open" | "closed" | undefined;
+    json?: string | boolean | undefined;
+    csv?: string | boolean | undefined;
+    pdf?: string | undefined;
+    aiReport?: string | undefined;
+}, {
+    url: string;
+    concurrency?: number | undefined;
+    rate?: number | undefined;
+    duration?: string | number | undefined;
+    timeout?: string | number | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    headers?: Record<string, string> | undefined;
+    body?: string | undefined;
+    warmup?: string | number | undefined;
+    rampUp?: string | number | undefined;
+    mode?: "open" | "closed" | undefined;
+    distribution?: "uniform" | "poisson" | undefined;
+    honest?: boolean | undefined;
+    ttfb?: boolean | undefined;
+    workers?: number | "auto" | undefined;
+    dashboard?: boolean | undefined;
+    json?: string | boolean | undefined;
+    csv?: string | boolean | undefined;
+    pdf?: string | undefined;
+    aiReport?: string | undefined;
+    aiDryRun?: boolean | undefined;
+}>;
+type ValidatedRunOptions = z.infer<typeof RunOptionsSchema>;
+
+/**
+ * Execute a closed-model load test using undici.Pool.
+ *
+ * In the closed model, concurrency is fixed: exactly `concurrency` parallel
+ * workers loop, each dispatching the next request as soon as the previous finishes.
+ */
+declare function executeClosedModel(options: ValidatedRunOptions): Promise<RunSummary>;
+
+/**
+ * Execute an open-model load test using undici.Pool.
+ *
+ * In the open arrival model, requests are scheduled at target arrival times
+ * independent of whether previous requests have completed (Uniform or Poisson process).
+ * Latency is measured from the INTENDED dispatch timestamp to completion timestamp,
+ * directly revealing client-side queueing delay and eliminating Coordinated Omission.
+ */
+declare function executeOpenModel(options: ValidatedRunOptions): Promise<RunSummary>;
+
+/**
+ * Execute a multi-threaded load test across worker threads.
+ * Partitions concurrency and arrival rate across W workers, merges their
+ * log-bucketed histogram snapshots in O(B) time, and updates the live dashboard.
+ */
+declare function executeMultiThreaded(options: ValidatedRunOptions): Promise<RunSummary>;
+
+/**
+ * High-precision arrival scheduler for open-model load testing.
+ * Supports deterministic uniform intervals and stochastic Poisson arrival processes.
+ */
+declare class ArrivalScheduler {
+    private readonly rate;
+    private readonly distribution;
+    private readonly startNs;
+    private currentScheduledNs;
+    private totalDriftNs;
+    private sampleCount;
+    private maxDriftNs;
+    constructor(rate: number, distribution?: "uniform" | "poisson", startNs?: bigint);
+    /**
+     * Generates the next scheduled arrival timestamp (in nanoseconds).
+     */
+    nextArrivalNs(): bigint;
+    /**
+     * High-resolution pause until the target timestamp is reached.
+     * Uses setTimeout for long waits and micro-spinning for sub-millisecond precision.
+     */
+    waitUntil(targetNs: bigint): Promise<void>;
+    private recordDrift;
+    /**
+     * Average schedule drift in milliseconds.
+     */
+    get averageDriftMs(): number;
+    /**
+     * Maximum schedule drift in milliseconds.
+     */
+    get maxDriftMs(): number;
+}
+
+/**
+ * Gil Tene's Coordinated Omission Correction algorithm (from wrk2 / HdrHistogram).
+ *
+ * In load testing, when a request stalls or experiences high latency L exceeding
+ * the expected inter-arrival interval I, all requests that would have arrived
+ * behind it during that stall are omitted from the sample pool.
+ *
+ * This function injects the missing virtual samples (L - I, L - 2I, ...) into
+ * the histogram, accurately penalizing high percentiles (p95, p99) to reflect
+ * what real users experienced while the system was stalled.
+ */
+declare function recordWithCorrection(histogram: Histogram, latencyUs: number, expectedIntervalUs: number): number;
+/**
+ * Helper to extract formatted LatencyDistribution metrics from a Histogram.
+ */
+declare function extractDistribution(h: Histogram): LatencyDistribution;
+/**
+ * Calculates the queue delay distribution by subtracting service time from response time.
+ */
+declare function computeQueueDelay(response: LatencyDistribution, service: LatencyDistribution): LatencyDistribution;
+
+/**
+ * Runs the Breaking-Point Finder: stepped ramp + binary search capacity detection.
+ */
+declare function runBreakingPoint(options: BreakpointOptions): Promise<BreakpointSummary>;
+
+/**
+ * Format a single step table row for real-time progress logging.
+ */
+declare function formatStepRow(step: BreakpointStepResult, mode: "concurrency" | "rate"): string;
+/**
+ * Generates a comprehensive terminal report string for Breaking-Point results.
+ */
+declare function formatBreakpointTerminalReport(summary: BreakpointSummary): string;
+/**
+ * Print the Breaking-Point report to stdout.
+ */
+declare function printBreakpointTerminalReport(summary: BreakpointSummary): void;
+
+/**
+ * Saves a RunSummary as a standard JSON baseline file.
+ */
+declare function saveBaseline(summary: RunSummary, filePath?: string, options?: {
+    concurrency?: number;
+    rate?: number;
+}): Promise<string>;
+/**
+ * Loads a baseline JSON file from disk.
+ */
+declare function loadBaseline(filePath: string): Promise<BaselineData>;
+/**
+ * Compares current benchmark results against a reference baseline and evaluates regression thresholds.
+ */
+declare function compareRuns(current: RunSummary | BaselineData, baseline: BaselineData, thresholdsInput?: Partial<GateThresholds>): ComparisonSummary;
+
+/**
+ * Generates an aligned terminal comparison table string.
+ */
+declare function formatComparisonTerminalReport(summary: ComparisonSummary): string;
+/**
+ * Print the comparison report to stdout.
+ */
+declare function printComparisonTerminalReport(summary: ComparisonSummary): void;
+/**
+ * Generates GitHub Actions-flavored markdown step summary.
+ */
+declare function generateGithubStepSummary(summary: ComparisonSummary): string;
+/**
+ * Appends markdown summary to $GITHUB_STEP_SUMMARY if available in GitHub Actions.
+ */
+declare function writeGithubStepSummary(summary: ComparisonSummary): Promise<void>;
+
+/**
+ * Generates a complete publication-grade vector PDF report from a RunSummary.
+ */
+declare function generatePdfReport(summary: RunSummary, outputPath: string, aiAnalysis?: string): Promise<string>;
+
+/**
+ * Builds a structured, technical engineering prompt for an LLM to analyze load test results.
+ */
+declare function buildAiDiagnosticPrompt(summary: RunSummary): string;
+/**
+ * Generates an automated AI diagnostic assessment for the summary.
+ * If an API key is available (GEMINI_API_KEY or OPENAI_API_KEY or LLM_API_KEY),
+ * it queries the LLM API; otherwise it returns a structured algorithmic assessment.
+ */
+declare function fetchAiDiagnostic(summary: RunSummary, explicitApiKey?: string): Promise<string>;
+
+/**
+ * Generates an interactive, zero-external-dependency HTML document string.
+ */
+declare function renderHtmlReport(summary: RunSummary): string;
+/**
+ * Generates and writes the interactive HTML report to disk.
+ */
+declare function generateHtmlReport(summary: RunSummary, outputPath?: string): Promise<string>;
+
+/**
+ * Replaces all occurrences of {{varName}} in a template string with values from context.
+ */
+declare function interpolateVariables(template: string, context: Record<string, string>): string;
+/**
+ * Extracts variables from an HTTP response using configured extraction rules.
+ */
+declare function extractFromResponse(body: string, headers: Record<string, string | string[] | undefined>, rules: Record<string, string>): Record<string, string>;
+/**
+ * Parses and validates a ScenarioDefinition from a raw YAML/JSON string or file path.
+ */
+declare function parseScenario(input: string): ScenarioDefinition;
+
+interface ScenarioRunOverrides {
+    concurrency?: number;
+    duration?: number | string;
+    timeout?: number | string;
+}
+/**
+ * Executes a multi-step user journey scenario with concurrent virtual users.
+ */
+declare function runScenario(definition: ScenarioDefinition, overrides?: ScenarioRunOverrides): Promise<ScenarioSummary>;
+
+/**
+ * Formats a comprehensive terminal report for multi-step scenario execution.
+ */
+declare function formatScenarioTerminalReport(summary: ScenarioSummary): string;
+/**
+ * Prints the formatted scenario report directly to stdout.
+ */
+declare function printScenarioTerminalReport(summary: ScenarioSummary): void;
+
+/**
+ * Programmatic API to execute a load test run.
+ * Automatically delegates to multi-threaded execution when workers > 1,
+ * open arrival model when rate is specified, or single-threaded closed concurrency.
+ */
+declare function run(options: RunOptions): Promise<RunSummary>;
+
+export { ArrivalScheduler, type BaselineData, type BreakpointLimits, type BreakpointOptions, type BreakpointStepResult, type BreakpointSummary, type ComparisonMetric, type ComparisonSummary, type GateThresholds, Histogram, type HistogramSnapshot, type LatencyDistribution, type LatencyPoint, LiveDashboard, type RunOptions, type RunSummary, type ScenarioDefinition, type ScenarioStep, type ScenarioSummary, type StepSummary, type WorkerDoneMessage, type WorkerErrorMessage, type WorkerInitData, type WorkerMessage, type WorkerTickMessage, buildAiDiagnosticPrompt, compareRuns, computeQueueDelay, executeClosedModel, executeMultiThreaded, executeOpenModel, extractDistribution, extractFromResponse, fetchAiDiagnostic, formatBreakpointCsvReport, formatBreakpointJsonReport, formatBreakpointTerminalReport, formatComparisonCsvReport, formatComparisonJsonReport, formatComparisonTerminalReport, formatCsvReport, formatJsonReport, formatScenarioTerminalReport, formatStepRow, formatTerminalReport, generateGithubStepSummary, generateHtmlReport, generatePdfReport, interpolateVariables, loadBaseline, parseScenario, printBreakpointTerminalReport, printComparisonTerminalReport, printScenarioTerminalReport, printTerminalReport, recordWithCorrection, renderHtmlReport, run, runBreakingPoint, runScenario, saveBaseline, writeGithubStepSummary };