mcp-vitals 0.1.0

package/dist/glob.js

@@ -0,0 +1,40 @@
+// Minimal name-glob matcher for --filter/--only/--skip. Supports `*` and `?`.
+// No external dependency, no path semantics — just simple name matching.
+//
+// Implemented as a linear two-pointer matcher rather than a `.*`-based regex,
+// so there is no catastrophic backtracking (ReDoS) on pathological globs like
+// `"*".repeat(20) + "x"` against a long name.
+export function matchesGlob(name, glob) {
+    let n = 0;
+    let g = 0;
+    let star = -1;
+    let mark = 0;
+    while (n < name.length) {
+        if (g < glob.length && (glob[g] === '?' || glob[g] === name[n])) {
+            n++;
+            g++;
+        }
+        else if (g < glob.length && glob[g] === '*') {
+            star = g;
+            mark = n;
+            g++;
+        }
+        else if (star !== -1) {
+            g = star + 1;
+            mark++;
+            n = mark;
+        }
+        else {
+            return false;
+        }
+    }
+    while (g < glob.length && glob[g] === '*')
+        g++;
+    return g === glob.length;
+}
+/** True if `name` matches any of the provided globs (empty list => true). */
+export function matchesAny(name, globs) {
+    if (!globs || globs.length === 0)
+        return true;
+    return globs.some((g) => matchesGlob(name, g));
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { Connection } from './mcpClient.js';
+export type { CallResult } from './mcpClient.js';
+export { runBench } from './bench/engine.js';
+export type { BenchHooks } from './bench/engine.js';
+export { computeStats, percentile } from './stats.js';
+export { parseExpr, parseDuration, evaluate, evaluateExpr } from './thresholds.js';
+export { validateJsonSchema } from './schema.js';
+export { loadConfig, discoverConfig } from './assertions/loader.js';
+export { runChecks } from './assertions/run.js';
+export { main, buildProgram } from './cli.js';
+export { EXIT_CODES } from './errors.js';
+export type * from './types.js';

package/dist/index.js

@@ -0,0 +1,11 @@
+// Public library surface. The CLI is the primary interface, but the protocol
+// client, bench engine, stats, and assertion runner are exported for reuse.
+export { Connection } from './mcpClient.js';
+export { runBench } from './bench/engine.js';
+export { computeStats, percentile } from './stats.js';
+export { parseExpr, parseDuration, evaluate, evaluateExpr } from './thresholds.js';
+export { validateJsonSchema } from './schema.js';
+export { loadConfig, discoverConfig } from './assertions/loader.js';
+export { runChecks } from './assertions/run.js';
+export { main, buildProgram } from './cli.js';
+export { EXIT_CODES } from './errors.js';

package/dist/mcpClient.d.ts

@@ -0,0 +1,38 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { CapabilitySummary, ProbeOp, PromptInfo, ResourceInfo, ServerIdentity, ToolInfo, TransportKind, TransportSpec } from './types.js';
+export interface CallResult {
+    content: unknown[];
+    isError: boolean;
+    structuredContent?: unknown;
+}
+/** A live, connected MCP client plus the metadata mcp-vitals needs. */
+export declare class Connection {
+    readonly client: Client;
+    readonly kind: TransportKind;
+    readonly target: string;
+    readonly coldStartMs: number;
+    private readonly requestTimeoutMs;
+    private constructor();
+    /**
+     * Wrap an already-connected SDK Client (e.g. over InMemoryTransport in tests,
+     * or a client you manage yourself). The client must already be `connect()`ed.
+     */
+    static fromClient(client: Client, opts?: {
+        kind?: TransportKind;
+        target?: string;
+        coldStartMs?: number;
+        requestTimeoutMs?: number;
+    }): Connection;
+    /** Connect (timed), with an automatic Streamable-HTTP → SSE fallback. */
+    static connect(spec: TransportSpec): Promise<Connection>;
+    identity(): ServerIdentity;
+    capabilities(): CapabilitySummary;
+    listTools(): Promise<ToolInfo[]>;
+    listResources(): Promise<ResourceInfo[]>;
+    listPrompts(): Promise<PromptInfo[]>;
+    callTool(name: string, args: unknown, timeoutMs?: number): Promise<CallResult>;
+    ping(timeoutMs?: number): Promise<void>;
+    /** A single no-arg protocol round-trip (always hits the server, no early return). */
+    probeOnce(op: ProbeOp, timeoutMs?: number): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/mcpClient.js

@@ -0,0 +1,192 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { createTransport, describeTarget, inferKind } from './transport.js';
+import { ConnectionError } from './errors.js';
+const CLIENT_INFO = { name: 'mcp-vitals', version: '0.1.0' };
+function nowMs() {
+    return process.hrtime.bigint();
+}
+function elapsedMs(start) {
+    return Number(nowMs() - start) / 1e6;
+}
+/** A live, connected MCP client plus the metadata mcp-vitals needs. */
+export class Connection {
+    client;
+    kind;
+    target;
+    coldStartMs;
+    requestTimeoutMs;
+    constructor(client, kind, target, coldStartMs, requestTimeoutMs) {
+        this.client = client;
+        this.kind = kind;
+        this.target = target;
+        this.coldStartMs = coldStartMs;
+        this.requestTimeoutMs = requestTimeoutMs;
+    }
+    /**
+     * Wrap an already-connected SDK Client (e.g. over InMemoryTransport in tests,
+     * or a client you manage yourself). The client must already be `connect()`ed.
+     */
+    static fromClient(client, opts = {}) {
+        return new Connection(client, opts.kind ?? 'stdio', opts.target ?? 'in-memory', opts.coldStartMs ?? 0, opts.requestTimeoutMs ?? 10_000);
+    }
+    /** Connect (timed), with an automatic Streamable-HTTP → SSE fallback. */
+    static async connect(spec) {
+        const kind = inferKind(spec);
+        const target = describeTarget(spec, kind);
+        // First attempt with the resolved/forced transport.
+        let firstErr;
+        try {
+            const r = await connectOnce(spec, kind);
+            return new Connection(r.client, kind, target, r.coldStartMs, spec.requestTimeoutMs);
+        }
+        catch (err) {
+            // Fall back to SSE only when http was inferred (not explicitly forced).
+            const canFallback = kind === 'http' && spec.forced === undefined && Boolean(spec.url);
+            if (!canFallback) {
+                throw new ConnectionError(connectMessage(target, spec, err));
+            }
+            firstErr = err;
+        }
+        try {
+            const r = await connectOnce(spec, 'sse');
+            return new Connection(r.client, 'sse', target, r.coldStartMs, spec.requestTimeoutMs);
+        }
+        catch (err) {
+            const base = connectMessage(target, spec, err);
+            // Preserve the original Streamable-HTTP error (e.g. the server's auth body)
+            // instead of misattributing the failure to the SSE attempt.
+            const httpNote = firstErr
+                ? `\n  (Streamable HTTP attempt failed first: ${firstErr.message})`
+                : '';
+            throw new ConnectionError(base + httpNote);
+        }
+    }
+    identity() {
+        const v = this.client.getServerVersion();
+        // The negotiated protocol version has no stable client getter in SDK 1.29.
+        // Streamable HTTP exposes a public `protocolVersion`; SSE keeps it in a
+        // private field. stdio tracks it nowhere, so it stays undefined there.
+        const t = this.client
+            .transport;
+        const proto = (typeof t?.protocolVersion === 'string' ? t.protocolVersion : undefined) ??
+            (typeof t?._protocolVersion === 'string' ? t._protocolVersion : undefined);
+        return {
+            name: v?.name ?? '(unknown)',
+            version: v?.version ?? '0.0.0',
+            protocolVersion: proto,
+            instructions: this.client.getInstructions(),
+        };
+    }
+    capabilities() {
+        const caps = (this.client.getServerCapabilities() ?? {});
+        return {
+            tools: caps.tools !== undefined,
+            resources: caps.resources !== undefined,
+            prompts: caps.prompts !== undefined,
+            logging: caps.logging !== undefined,
+            completions: caps.completions !== undefined,
+            raw: caps,
+        };
+    }
+    async listTools() {
+        if (!this.capabilities().tools)
+            return [];
+        const out = [];
+        let cursor;
+        do {
+            const res = await this.client.listTools(cursor ? { cursor } : undefined, { timeout: this.requestTimeoutMs });
+            for (const t of res.tools) {
+                const input = t.inputSchema;
+                const props = input?.properties ?? {};
+                out.push({
+                    name: t.name,
+                    title: t.title ?? t.annotations?.title,
+                    description: t.description,
+                    inputSchema: t.inputSchema,
+                    outputSchema: t.outputSchema,
+                    requiredArgs: input?.required?.length ?? 0,
+                    totalArgs: Object.keys(props).length,
+                    schemaValid: true,
+                    schemaErrors: [],
+                });
+            }
+            cursor = res.nextCursor;
+        } while (cursor);
+        return out;
+    }
+    async listResources() {
+        if (!this.capabilities().resources)
+            return [];
+        const out = [];
+        let cursor;
+        do {
+            const res = await this.client.listResources(cursor ? { cursor } : undefined, { timeout: this.requestTimeoutMs });
+            for (const r of res.resources) {
+                out.push({ uri: r.uri, name: r.name, mimeType: r.mimeType });
+            }
+            cursor = res.nextCursor;
+        } while (cursor);
+        return out;
+    }
+    async listPrompts() {
+        if (!this.capabilities().prompts)
+            return [];
+        const out = [];
+        let cursor;
+        do {
+            const res = await this.client.listPrompts(cursor ? { cursor } : undefined, { timeout: this.requestTimeoutMs });
+            for (const p of res.prompts) {
+                out.push({
+                    name: p.name,
+                    description: p.description,
+                    arguments: (p.arguments ?? []).map((a) => ({ name: a.name, required: a.required })),
+                });
+            }
+            cursor = res.nextCursor;
+        } while (cursor);
+        return out;
+    }
+    async callTool(name, args, timeoutMs) {
+        const res = await this.client.callTool({ name, arguments: (args ?? {}) }, undefined, { timeout: timeoutMs ?? this.requestTimeoutMs });
+        return {
+            content: (res.content ?? []),
+            isError: res.isError === true,
+            structuredContent: res.structuredContent,
+        };
+    }
+    async ping(timeoutMs) {
+        await this.client.ping({ timeout: timeoutMs ?? this.requestTimeoutMs });
+    }
+    /** A single no-arg protocol round-trip (always hits the server, no early return). */
+    async probeOnce(op, timeoutMs) {
+        const options = { timeout: timeoutMs ?? this.requestTimeoutMs };
+        if (op === 'listTools')
+            await this.client.listTools(undefined, options);
+        else if (op === 'listResources')
+            await this.client.listResources(undefined, options);
+        else
+            await this.client.listPrompts(undefined, options);
+    }
+    async close() {
+        try {
+            await this.client.close();
+        }
+        catch {
+            // closing best-effort; never mask the real result.
+        }
+    }
+}
+/** Build a transport and connect a fresh Client over it (timed cold start). */
+async function connectOnce(spec, kind) {
+    const start = nowMs();
+    const client = new Client(CLIENT_INFO);
+    await client.connect(createTransport(spec, kind), { timeout: spec.connectTimeoutMs });
+    return { client, coldStartMs: elapsedMs(start) };
+}
+function connectMessage(target, spec, err) {
+    const base = `could not connect to ${target}: ${err.message}`;
+    if (spec.command) {
+        return `${base}\n  hint: the server may need env vars — try --env KEY=VALUE or --inherit-env`;
+    }
+    return base;
+}

package/dist/output.d.ts

@@ -0,0 +1,2 @@
+export declare function writeOut(line?: string): void;
+export declare function writeErr(line?: string): void;

package/dist/output.js

@@ -0,0 +1,8 @@
+// Centralized stdout/stderr writers to keep --json output pure.
+// Human/result output -> stdout. Progress/logs -> stderr.
+export function writeOut(line = '') {
+    process.stdout.write(line + '\n');
+}
+export function writeErr(line = '') {
+    process.stderr.write(line + '\n');
+}

package/dist/renderers/colors.d.ts

@@ -0,0 +1,9 @@
+import pc from 'picocolors';
+export type Colors = ReturnType<typeof pc.createColors>;
+/** Build a picocolors instance honoring our resolved color decision. */
+export declare function makeColors(enabled: boolean): Colors;
+/**
+ * Decide whether to emit ANSI color: explicit --no-color and NO_COLOR win,
+ * otherwise only when stdout is a TTY.
+ */
+export declare function resolveColor(noColor: boolean): boolean;

package/dist/renderers/colors.js

@@ -0,0 +1,16 @@
+import pc from 'picocolors';
+/** Build a picocolors instance honoring our resolved color decision. */
+export function makeColors(enabled) {
+    return pc.createColors(enabled);
+}
+/**
+ * Decide whether to emit ANSI color: explicit --no-color and NO_COLOR win,
+ * otherwise only when stdout is a TTY.
+ */
+export function resolveColor(noColor) {
+    if (noColor)
+        return false;
+    if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== '')
+        return false;
+    return process.stdout.isTTY === true;
+}

package/dist/renderers/json.d.ts

@@ -0,0 +1,2 @@
+/** Emit exactly one self-contained JSON object to stdout (never NDJSON). */
+export declare function emitJson(obj: unknown): void;

package/dist/renderers/json.js

@@ -0,0 +1,5 @@
+import { writeOut } from '../output.js';
+/** Emit exactly one self-contained JSON object to stdout (never NDJSON). */
+export function emitJson(obj) {
+    writeOut(JSON.stringify(obj, null, 2));
+}

package/dist/renderers/junit.d.ts

@@ -0,0 +1,3 @@
+import type { CheckRow, CheckSummary } from '../types.js';
+/** Render check results as JUnit XML (one <testcase> per assertion). */
+export declare function renderJUnit(rows: CheckRow[], summary: CheckSummary): string;

package/dist/renderers/junit.js

@@ -0,0 +1,32 @@
+function escapeXml(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/** Render check results as JUnit XML (one <testcase> per assertion). */
+export function renderJUnit(rows, summary) {
+    const seconds = (summary.durationMs / 1000).toFixed(3);
+    const lines = [];
+    lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+    lines.push(`<testsuites name="mcp-vitals" tests="${rows.length}" failures="${summary.failed}" skipped="${summary.skipped}" time="${seconds}">`);
+    lines.push(`  <testsuite name="mcp-vitals" tests="${rows.length}" failures="${summary.failed}" skipped="${summary.skipped}" time="${seconds}">`);
+    for (const row of rows) {
+        const name = escapeXml(row.id);
+        const cls = `mcp-vitals.${row.kind}`;
+        lines.push(`    <testcase name="${name}" classname="${escapeXml(cls)}" time="0">`);
+        if (row.status === 'fail') {
+            const msg = escapeXml(`${row.target}: expected ${row.expected}, got ${row.actual}`);
+            lines.push(`      <failure message="${msg}">${msg}</failure>`);
+        }
+        else if (row.status === 'skip') {
+            lines.push('      <skipped/>');
+        }
+        lines.push('    </testcase>');
+    }
+    lines.push('  </testsuite>');
+    lines.push('</testsuites>');
+    return lines.join('\n');
+}

package/dist/renderers/progress.d.ts

@@ -0,0 +1,16 @@
+export interface ProgressOptions {
+    quiet: boolean;
+    json: boolean;
+}
+/**
+ * Stderr-only progress reporter. No-ops under --quiet. Output always goes to
+ * stderr so --json stdout stays a single clean object.
+ */
+export declare class Progress {
+    private readonly enabled;
+    constructor(opts: ProgressOptions);
+    note(message: string): void;
+    /** Emit a one-line status that overwrites in place on a TTY. */
+    status(message: string): void;
+    clearStatus(): void;
+}

package/dist/renderers/progress.js

@@ -0,0 +1,29 @@
+import { writeErr } from '../output.js';
+const ERASE_LINE = '\r';
+/**
+ * Stderr-only progress reporter. No-ops under --quiet. Output always goes to
+ * stderr so --json stdout stays a single clean object.
+ */
+export class Progress {
+    enabled;
+    constructor(opts) {
+        this.enabled = !opts.quiet;
+    }
+    note(message) {
+        if (this.enabled)
+            writeErr(message);
+    }
+    /** Emit a one-line status that overwrites in place on a TTY. */
+    status(message) {
+        if (!this.enabled)
+            return;
+        if (process.stderr.isTTY) {
+            process.stderr.write(`\r${message}`);
+        }
+    }
+    clearStatus() {
+        if (this.enabled && process.stderr.isTTY) {
+            process.stderr.write(ERASE_LINE);
+        }
+    }
+}

package/dist/renderers/table.d.ts

@@ -0,0 +1,14 @@
+import type { Colors } from './colors.js';
+export interface Column {
+    header: string;
+    align?: 'left' | 'right';
+}
+/**
+ * Render an aligned text table. Padding is computed on plain text, then color
+ * is applied to already-padded cells so ANSI codes never break alignment.
+ */
+export declare function renderTable(columns: Column[], rows: string[][], c: Colors): string;
+/** A "Key: value" header block, keys dimmed. */
+export declare function renderKeyValues(pairs: [string, string][], c: Colors): string;
+export declare function formatMs(n: number | null | undefined): string;
+export declare function formatPct(fraction: number): string;

package/dist/renderers/table.js

@@ -0,0 +1,43 @@
+/**
+ * Render an aligned text table. Padding is computed on plain text, then color
+ * is applied to already-padded cells so ANSI codes never break alignment.
+ */
+export function renderTable(columns, rows, c) {
+    const widths = columns.map((col, i) => {
+        let w = col.header.length;
+        for (const row of rows) {
+            const cell = row[i] ?? '';
+            if (cell.length > w)
+                w = cell.length;
+        }
+        return w;
+    });
+    const pad = (text, i) => {
+        const w = widths[i] ?? text.length;
+        const align = columns[i]?.align ?? 'left';
+        return align === 'right' ? text.padStart(w) : text.padEnd(w);
+    };
+    const headerLine = columns.map((col, i) => c.bold(pad(col.header, i))).join('  ');
+    const lines = [headerLine];
+    for (const row of rows) {
+        lines.push(columns.map((_, i) => pad(row[i] ?? '', i)).join('  '));
+    }
+    return lines.join('\n');
+}
+/** A "Key: value" header block, keys dimmed. */
+export function renderKeyValues(pairs, c) {
+    const keyWidth = Math.max(0, ...pairs.map(([k]) => k.length));
+    return pairs.map(([k, v]) => `${c.dim((k + ':').padEnd(keyWidth + 1))} ${v}`).join('\n');
+}
+export function formatMs(n) {
+    if (n === null || n === undefined || Number.isNaN(n))
+        return '—';
+    if (n >= 1000)
+        return `${(n / 1000).toFixed(2)} s`;
+    if (n >= 100)
+        return `${n.toFixed(0)} ms`;
+    return `${n.toFixed(1)} ms`;
+}
+export function formatPct(fraction) {
+    return `${(fraction * 100).toFixed(1)}%`;
+}

package/dist/schema.d.ts

@@ -0,0 +1,12 @@
+import type { SchemaError } from './types.js';
+export interface SchemaCheck {
+    valid: boolean;
+    errors: SchemaError[];
+}
+/**
+ * Validate that `schema` is itself a compilable JSON Schema (draft 2020-12).
+ * A tool's inputSchema is "valid" iff Ajv can compile it.
+ */
+export declare function validateJsonSchema(schema: unknown): SchemaCheck;
+/** Validate `data` against a (trusted) JSON Schema. Used for the assertions config. */
+export declare function validateData(schema: object, data: unknown): SchemaCheck;

package/dist/schema.js

@@ -0,0 +1,47 @@
+import * as ajv2020 from 'ajv/dist/2020.js';
+import * as ajvFormats from 'ajv-formats';
+// ajv + ajv-formats are CJS with `export default`; under NodeNext the default
+// can land on `.default` or on the namespace itself. Tolerate both, and type
+// structurally against the small surface we use (avoids ajv's class/namespace merge).
+const Ajv2020 = (ajv2020.default ?? ajv2020);
+const addFormats = (ajvFormats.default ?? ajvFormats);
+function makeAjv() {
+    const ajv = new Ajv2020({ strict: false, allErrors: true, validateFormats: true });
+    addFormats(ajv);
+    return ajv;
+}
+function formatErrors(errors) {
+    if (!errors)
+        return [];
+    return errors.map((e) => ({
+        path: e.instancePath || e.schemaPath || '/',
+        message: e.message ?? 'invalid',
+    }));
+}
+/**
+ * Validate that `schema` is itself a compilable JSON Schema (draft 2020-12).
+ * A tool's inputSchema is "valid" iff Ajv can compile it.
+ */
+export function validateJsonSchema(schema) {
+    if (schema === null || typeof schema !== 'object') {
+        return { valid: false, errors: [{ path: '/', message: 'schema is not an object' }] };
+    }
+    const ajv = makeAjv();
+    try {
+        ajv.compile(schema);
+        return { valid: true, errors: [] };
+    }
+    catch (err) {
+        return {
+            valid: false,
+            errors: [{ path: '/', message: err.message.split('\n')[0] ?? 'invalid schema' }],
+        };
+    }
+}
+/** Validate `data` against a (trusted) JSON Schema. Used for the assertions config. */
+export function validateData(schema, data) {
+    const ajv = makeAjv();
+    const validate = ajv.compile(schema);
+    const ok = validate(data);
+    return { valid: ok, errors: ok ? [] : formatErrors(validate.errors) };
+}

package/dist/stats.d.ts

@@ -0,0 +1,12 @@
+import type { Stats } from './types.js';
+/**
+ * Nearest-rank percentile on an already-sorted ascending array.
+ * pct(q) = arr[min(len-1, ceil(q/100*len)-1)].
+ */
+export declare function percentile(sortedAsc: number[], q: number): number;
+export declare function mean(values: number[]): number;
+export declare function stddev(values: number[], mu?: number): number;
+/** Compute the full latency distribution from raw (unsorted) samples. */
+export declare function computeStats(samples: number[]): Stats | null;
+/** Round to 2 decimals for display without lying about precision. */
+export declare function round2(n: number): number;

package/dist/stats.js

@@ -0,0 +1,54 @@
+/**
+ * Nearest-rank percentile on an already-sorted ascending array.
+ * pct(q) = arr[min(len-1, ceil(q/100*len)-1)].
+ */
+export function percentile(sortedAsc, q) {
+    const len = sortedAsc.length;
+    if (len === 0)
+        return NaN;
+    const rank = Math.ceil((q / 100) * len) - 1;
+    const idx = Math.min(len - 1, Math.max(0, rank));
+    return sortedAsc[idx];
+}
+export function mean(values) {
+    if (values.length === 0)
+        return NaN;
+    let sum = 0;
+    for (const v of values)
+        sum += v;
+    return sum / values.length;
+}
+export function stddev(values, mu) {
+    const n = values.length;
+    if (n === 0)
+        return NaN;
+    const m = mu ?? mean(values);
+    let acc = 0;
+    for (const v of values)
+        acc += (v - m) ** 2;
+    // Population standard deviation (we have the full sample set).
+    return Math.sqrt(acc / n);
+}
+/** Compute the full latency distribution from raw (unsorted) samples. */
+export function computeStats(samples) {
+    if (samples.length === 0)
+        return null;
+    const sorted = [...samples].sort((a, b) => a - b);
+    const m = mean(sorted);
+    return {
+        count: sorted.length,
+        min: sorted[0],
+        mean: m,
+        p50: percentile(sorted, 50),
+        p90: percentile(sorted, 90),
+        p95: percentile(sorted, 95),
+        p99: percentile(sorted, 99),
+        max: sorted[sorted.length - 1],
+        stddev: stddev(sorted, m),
+        unit: 'ms',
+    };
+}
+/** Round to 2 decimals for display without lying about precision. */
+export function round2(n) {
+    return Math.round(n * 100) / 100;
+}

package/dist/thresholds.d.ts

@@ -0,0 +1,21 @@
+import type { AssertionOutcome, CompareOp, Stats, Throughput } from './types.js';
+export declare const METRICS: readonly ["p50", "p90", "p95", "p99", "max", "min", "mean", "stddev", "errorRate"];
+export type Metric = (typeof METRICS)[number];
+/**
+ * Parse a duration to milliseconds.
+ * Bare number => ms. Suffix `ms` => ms. Suffix `s` => seconds.
+ */
+export declare function parseDuration(input: string | number): number;
+/** errorRate is a fraction 0..1; everything else is a duration. */
+export declare function parseBound(metric: string, raw: string | number): number;
+export interface ParsedExpr {
+    metric: string;
+    op: CompareOp;
+    bound: number;
+}
+/** Parse an inline `--fail-on` expression like `p95<200ms` or `errorRate<=0`. */
+export declare function parseExpr(expr: string): ParsedExpr;
+/** Evaluate one parsed expression against a stats + throughput pair. */
+export declare function evaluate(parsed: ParsedExpr, stats: Stats | null, throughput: Throughput): AssertionOutcome;
+/** Convenience for inline string expressions. */
+export declare function evaluateExpr(expr: string, stats: Stats | null, throughput: Throughput): AssertionOutcome;