@jmoak/vibrissa 0.1.0 → 2.0.0

package/dist/runner-J_V7pgax.d.ts

@@ -0,0 +1,1194 @@
+import { Client } from '@modelcontextprotocol/client';
+
+/**
+ * Vibrissa v2 shared types: case files, config, and the session's summary shapes.
+ * See docs/V2_ARCHITECTURE.md ("Shared interfaces") for the contract these implement.
+ */
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+/** A single MCP operation. Exactly one of tool | resource | resourceTemplate | prompt. */
+interface Operation {
+    /** `tools/call` by tool name. */
+    tool?: string;
+    /** `resources/read` by URI. */
+    resource?: string;
+    /** RFC 6570 URI template; expanded with `args`, then `resources/read`. */
+    resourceTemplate?: string;
+    /** `prompts/get` by prompt name. */
+    prompt?: string;
+    /** Tool arguments, template variables, or prompt arguments. */
+    args?: Record<string, JsonValue>;
+}
+interface ExpectError {
+    /** Error code name (`InvalidParams`, `RequestTimeout`, ...) or numeric JSON-RPC code. */
+    code?: string | number;
+    message?: string | {
+        $regex: string;
+        flags?: string;
+    };
+}
+/** Tasks extension polling (SEP-2663): poll `tasks/get` until the task is terminal. */
+interface AwaitOptions {
+    /** Poll interval override in ms. Default: the task's `pollIntervalMs`, else 500. */
+    pollMs?: number;
+    /** Give up after this many ms. Default 30000. */
+    timeoutMs?: number;
+}
+interface Step extends Operation {
+    name?: string;
+    expect?: JsonValue;
+    expectError?: ExpectError;
+    /** Scripted answers for MRTR input_required rounds, keyed by request method. */
+    respond?: Record<string, JsonValue>;
+    /** Matcher over the InputRequests map(s) the server sent (see Outcome.inputRequests). */
+    expectInputRequired?: JsonValue;
+    /** Matcher over the CreateTaskResult the server returned (tasks extension). */
+    expectTask?: JsonValue;
+    /** Tasks extension: poll until terminal (`true` = defaults). */
+    await?: AwaitOptions | boolean;
+    /** name → dotted path into the normalized result. */
+    capture?: Record<string, string>;
+    budgetMs?: number;
+    timeoutMs?: number;
+    /** Teardown steps: never fail the case. */
+    ignoreErrors?: boolean;
+    /** Validate structuredContent against the tool's outputSchema. Default true when declared. */
+    validateOutput?: boolean;
+    normalize?: NormalizeConfig | false;
+}
+interface TestCase extends Step {
+    $schema?: string;
+    tags?: string[];
+    /** Key into config.servers. */
+    server?: string;
+    /** Flow; when present, top-level op fields are ignored. */
+    steps?: Step[];
+    setup?: Step[];
+    teardown?: Step[];
+    flaky?: boolean;
+    skip?: boolean | string;
+}
+/**
+ * Protocol era negotiation.
+ * - `auto` (default): probe `server/discover`, fall back to the 2025 `initialize` handshake.
+ * - `legacy`: 2025 `initialize` handshake only.
+ * - `modern`: require the 2026-07-28 era (sugar for `{ pin: "2026-07-28" }`).
+ * - `{ pin }`: modern era at exactly this revision; no fallback.
+ */
+type ProtocolMode = 'auto' | 'legacy' | 'modern' | {
+    pin: string;
+};
+interface ServerCommon {
+    protocol?: ProtocolMode;
+    /** Max time for spawn + handshake (stdio) or connect (http). Default: clamp(timeoutMs, 2000, 10000). */
+    spawnTimeoutMs?: number;
+}
+interface StdioServerConfig {
+    cmd: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}
+interface HttpServerConfig {
+    url: string;
+    headers?: Record<string, string>;
+}
+type ServerConfig = (StdioServerConfig | HttpServerConfig) & ServerCommon;
+type ResolvedStdioServer = StdioServerConfig & ServerCommon;
+type ResolvedHttpServer = HttpServerConfig & ServerCommon;
+declare function isHttpServerConfig(server: ServerConfig): server is ResolvedHttpServer;
+declare function isStdioServerConfig(server: ServerConfig): server is ResolvedStdioServer;
+interface NormalizeConfig {
+    /** Glob-ish keys under `_meta` to strip. Default `["io.modelcontextprotocol/*"]`. */
+    stripMeta?: string[];
+    /** Top-level result keys to drop. Default `["resultType"]`. */
+    dropKeys?: string[];
+    /** List results' `ttlMs`/`cacheScope`. Default `ignore`. */
+    ttlMs?: 'keep' | 'ignore';
+}
+interface ShardSpec {
+    /** 1-based shard index. */
+    index: number;
+    total: number;
+}
+interface SuiteHooks {
+    setup?: Step[];
+    teardown?: Step[];
+}
+interface RunOptions {
+    servers: Record<string, ServerConfig>;
+    defaultServer: string;
+    globs: string[];
+    /** Path; default tests/integration/__manifest__.json. */
+    manifest?: string;
+    normalize: NormalizeConfig;
+    timeoutMs: number;
+    budgetMs?: number;
+    failFast: boolean;
+    allowEmpty: boolean;
+    /** Reporter names; default ["console"]. */
+    reporters: string[];
+    tags?: string[];
+    excludeTags?: string[];
+    grep?: string;
+    repeat?: number;
+    shard?: ShardSpec;
+    concurrency?: number;
+    update?: boolean;
+    trace?: boolean;
+    check?: boolean;
+    baseline?: string;
+    /** Suite-level setup/teardown steps. */
+    hooks?: SuiteHooks;
+    /** `vib check` / `--check` tuning: skipped check ids and per-check severity overrides. */
+    checks?: {
+        allow?: string[];
+        severity?: Record<string, 'failed' | 'warned'>;
+    };
+    /**
+     * Dotted manifest paths ignored by the lock diff. Filled by loadConfig:
+     * ["server.version", "protocolVersion", "listMeta"].
+     */
+    manifestIgnore?: string[];
+    /** Fail the run when a server's manifest lock file is missing (CI). Default false (warn). */
+    requireManifest?: boolean;
+    /** Reporter artifact directory (relative to rootDir). Unset unless configured; the runner defaults to "reports". */
+    outDir?: string;
+    /** Directory the config was loaded from; relative paths resolve against it. */
+    rootDir: string;
+}
+interface ToolSummary$1 {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: JsonValue;
+    outputSchema?: JsonValue;
+    annotations?: JsonValue;
+    icons?: JsonValue;
+    execution?: JsonValue;
+    _meta?: JsonValue;
+}
+interface ResourceSummary$1 {
+    uri: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+    annotations?: JsonValue;
+    icons?: JsonValue;
+    _meta?: JsonValue;
+}
+interface ResourceTemplateSummary$1 {
+    uriTemplate: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    annotations?: JsonValue;
+    icons?: JsonValue;
+    _meta?: JsonValue;
+}
+interface PromptArgumentSummary$1 {
+    name: string;
+    title?: string;
+    description?: string;
+    required?: boolean;
+}
+interface PromptSummary$1 {
+    name: string;
+    title?: string;
+    description?: string;
+    arguments?: PromptArgumentSummary$1[];
+    icons?: JsonValue;
+    _meta?: JsonValue;
+}
+/** A list verb's aggregated result plus the list-level cache hints (2026-07-28). */
+interface ListResult<T> {
+    items: T[];
+    /** `ttlMs` from the (first page of the) list result, when the server sent one. */
+    ttlMs?: number;
+    /** `cacheScope` from the list result, when the server sent one. */
+    cacheScope?: string;
+    /** List-level `_meta` (e.g. the stamped serverInfo), when present. */
+    _meta?: JsonValue;
+}
+interface ServerIdentity {
+    name?: string;
+    version?: string;
+    title?: string;
+    [key: string]: JsonValue | undefined;
+}
+interface DiscoverInfo {
+    era: 'legacy' | 'modern';
+    /** Negotiated revision, e.g. "2026-07-28" or "2025-11-25". */
+    protocolVersion: string;
+    /** Revisions the server advertises (modern) or `[protocolVersion]` (legacy). */
+    supportedVersions: string[];
+    /** Modern: `_meta["io.modelcontextprotocol/serverInfo"]`; legacy: `initialize.serverInfo`. */
+    serverInfo?: ServerIdentity;
+    capabilities: JsonValue;
+    /** Keys of `capabilities.extensions` (e.g. "io.modelcontextprotocol/tasks"). */
+    extensions: string[];
+    instructions?: string;
+    /** True when built from the legacy `initialize` result instead of `server/discover`. */
+    synthesized: boolean;
+    /** The raw wire result (`server/discover` or `initialize`). */
+    raw: JsonValue;
+}
+/** One JSON-RPC message (or stderr chunk) observed by the session. */
+interface TranscriptEntry {
+    /** `out` = client → server, `in` = server → client, `stderr` = server stderr text. */
+    dir: 'in' | 'out' | 'stderr';
+    /** Epoch milliseconds. */
+    ts: number;
+    message?: JsonValue;
+    text?: string;
+}
+
+/**
+ * Shared run-event model. Reporters consume these; the runner emits them.
+ * This file is the contract between runner and reporters — change with care.
+ */
+
+interface CaseRef {
+    /** Stable id: relative case file path, plus `#<index>` for repeated runs. */
+    id: string;
+    name: string;
+    file: string;
+    tags: string[];
+    server: string;
+    /** Case declared `flaky: true` (pass-rate floor applies under --repeat). */
+    flaky?: boolean;
+    /** 1-based line of the case in its file when known (for annotations). */
+    line?: number;
+}
+interface StepRef {
+    index: number;
+    name: string;
+    /** 'tool' | 'resource' | 'resourceTemplate' | 'prompt' */
+    kind: string;
+    target: string;
+}
+interface Mismatch {
+    path: string;
+    message: string;
+    expected?: unknown;
+    actual?: unknown;
+    /** Which case field the mismatch belongs to (machine-patchable failures). */
+    field?: 'expect' | 'expectError' | 'expectInputRequired' | 'expectTask' | 'structuredContent';
+    /** RFC 6901 JSON Pointer into the case file (e.g. "/steps/1/expect/content/0/text"). */
+    pointer?: string;
+    /** 0-based step index for flows. */
+    stepIndex?: number;
+}
+type CaseStatus = 'passed' | 'failed' | 'skipped' | 'updated';
+interface CaseOutcome {
+    status: CaseStatus;
+    durationMs: number;
+    /** Human-readable one-line reason for failure / skip. */
+    reason?: string;
+    /** Distinguishes an assertion failure from an error/timeout (JUnit <failure> vs <error>). */
+    errorKind?: 'assertion' | 'error' | 'timeout' | 'budget' | 'load';
+    /** Path to captured server stderr for this case, if any. */
+    stderrPath?: string;
+    mismatches?: Mismatch[];
+    expected?: JsonValue;
+    actual?: JsonValue;
+    /** Path to a transcript written for this case, if any. */
+    tracePath?: string;
+    /** Per-step timings (flows). */
+    steps?: Array<{
+        step: StepRef;
+        durationMs: number;
+        status: CaseStatus;
+        reason?: string;
+    }>;
+    /** Budget breach, if `budgetMs` was set and exceeded. */
+    budget?: {
+        budgetMs: number;
+        actualMs: number;
+    };
+    /** Under --update: why this failing case was not rewritten (matchers, expectError, ...). */
+    updateSkipped?: {
+        reason: string;
+    };
+}
+interface CheckOutcome {
+    id: string;
+    server?: string;
+    title: string;
+    status: 'passed' | 'failed' | 'warned';
+    detail?: string;
+}
+interface RunSummary {
+    /** Case executions (cases × repeat). Distinct cases = distinct case ids (without `#<n>`). */
+    total: number;
+    /** Status counts are per execution and sum to `total`; per-case verdicts: passRates / ok. */
+    passed: number;
+    failed: number;
+    skipped: number;
+    updated: number;
+    durationMs: number;
+    /** Present when --repeat > 1: executions (= total; cases × repeat, fewer on failFast). */
+    runs?: number;
+    /** Present when --repeat > 1: pass rate per case id. */
+    passRates?: Record<string, number>;
+}
+type RunEvent = {
+    type: 'run:start';
+    /** Case runs announced (cases × repeat). */
+    totalCases: number;
+    servers: string[];
+    startedAt: number;
+    repeat?: number;
+    /** Present when the run is one shard of a suite (`--shard i/n`). */
+    shard?: {
+        index: number;
+        total: number;
+    };
+} | {
+    type: 'session:start';
+    server: string;
+    era: 'legacy' | 'modern';
+    protocolVersion: string;
+    serverInfo?: {
+        name?: string;
+        version?: string;
+    };
+} | {
+    type: 'session:end';
+    server: string;
+} | {
+    type: 'manifest:ok';
+    path: string;
+    server?: string;
+} | {
+    type: 'manifest:diff';
+    path: string;
+    summary: string;
+    diff: JsonValue;
+    server?: string;
+} | {
+    type: 'check';
+    outcome: CheckOutcome;
+} | {
+    type: 'case:start';
+    case: CaseRef;
+} | {
+    type: 'step:start';
+    case: CaseRef;
+    step: StepRef;
+} | {
+    type: 'step:end';
+    case: CaseRef;
+    step: StepRef;
+    durationMs: number;
+    status: CaseStatus;
+    reason?: string;
+} | {
+    type: 'case:end';
+    case: CaseRef;
+    outcome: CaseOutcome;
+} | {
+    type: 'warning';
+    message: string;
+}
+/** `ok` mirrors the runner's exit decision so every reporter agrees with it. */
+ | {
+    type: 'run:end';
+    summary: RunSummary;
+    ok?: boolean;
+};
+interface Reporter {
+    readonly name: string;
+    onEvent(event: RunEvent): void | Promise<void>;
+    /** Called once after run:end; flush files here. */
+    close?(): void | Promise<void>;
+}
+interface ReporterContext {
+    rootDir: string;
+    /** Directory for reporter artifacts (junit.xml, results.json, traces/...). Default: reports/ */
+    outDir: string;
+    pretty: boolean;
+    /** Write to stdout; injectable for tests. */
+    stdout: (line: string) => void;
+    stderr: (line: string) => void;
+}
+
+type OpKind = 'tool' | 'resource' | 'resourceTemplate' | 'prompt';
+declare const OP_KINDS: readonly OpKind[];
+declare const STEP_KEYS: readonly ["name", "tool", "resource", "resourceTemplate", "prompt", "args", "expect", "expectError", "respond", "expectInputRequired", "expectTask", "await", "capture", "budgetMs", "timeoutMs", "ignoreErrors", "validateOutput", "normalize"];
+declare const CASE_KEYS: readonly ["$schema", "name", "tool", "resource", "resourceTemplate", "prompt", "args", "expect", "expectError", "respond", "expectInputRequired", "expectTask", "await", "capture", "budgetMs", "timeoutMs", "ignoreErrors", "validateOutput", "normalize", "tags", "server", "steps", "setup", "teardown", "flaky", "skip"];
+interface LoadedCase {
+    /** Stable reference (id = root-relative posix path; `line` 1). */
+    ref: CaseRef;
+    /** Absolute path of the case file. */
+    path: string;
+    /** The case with `$ref`s expanded. Undefined when the file failed to load. */
+    data?: TestCase;
+    /** The case exactly as parsed (no `$ref` expansion): the basis for `--update` rewrites. */
+    source?: TestCase;
+    /** Raw file text. */
+    text?: string;
+    /** Load / validation problem: the case is reported failed with errorKind `load`. */
+    error?: string;
+    /** Set when the case declares `skip: true | "reason"`. */
+    skip?: string;
+    /**
+     * The file is not a case, and loadCases drops it: a manifest lock, or a `$ref` fragment (no
+     * operation / `steps`, and referenced by another matched file or kept in `shared/` /
+     * `fragments/`).
+     */
+    notACase?: 'manifest' | 'fragment';
+}
+interface CaseFilters {
+    /** Keep cases carrying at least one of these tags. */
+    tags?: string[];
+    /** Drop cases carrying any of these tags. */
+    excludeTags?: string[];
+    /** Keep cases whose name or id matches (case-insensitive regex, else substring). */
+    grep?: string;
+    /** Keep every `total`-th case (1-based `index`) of the id-sorted selection. */
+    shard?: ShardSpec;
+}
+interface LoadCasesOptions extends CaseFilters {
+    rootDir: string;
+    globs: string[];
+    /** Server for cases without `server`. Default `"default"`. */
+    defaultServer?: string;
+    /** Known server names; a case naming another server fails to load. */
+    servers?: string[];
+    /** Suite hooks: their captures are valid `{{names}}` in every case. */
+    hooks?: SuiteHooks;
+    /** Environment for `{{env.X}}` checks. Default process.env. */
+    env?: Record<string, string | undefined>;
+    /**
+     * Config `manifest` path (default tests/integration/__manifest__.json). The lock files (this
+     * path for the default server and the `<name>.<server>.json` siblings for `servers`) are
+     * never loaded as cases, even when the globs match them. Files shaped like a manifest
+     * (`"vibrissa": 2` + a `tools` array) are skipped too.
+     */
+    manifest?: string;
+    /** Extra files (absolute, or relative to rootDir) that are never cases. */
+    exclude?: string[];
+}
+interface LoadCasesResult {
+    /** Selected cases, sorted by id. */
+    cases: LoadedCase[];
+    /** Number of case files the globs matched (before filters). */
+    matched: number;
+    /** Non-fatal loader notes (ignored top-level op fields, ...). */
+    warnings: string[];
+    /** Ids of `$ref` fragment files the globs matched and that were skipped (not cases). */
+    fragments?: string[];
+}
+/** Resolve case globs (relative to rootDir; `!` negates) to absolute, sorted file paths. */
+declare function resolveCaseFiles(globs: string[], rootDir: string): Promise<string[]>;
+/** Root-relative posix path when the file is inside rootDir, else the absolute posix path. */
+declare function caseIdFor(file: string, rootDir: string): string;
+/** Parse JSONC (comments and trailing commas allowed). Throws "<where>: invalid JSON ...". */
+declare function parseCaseText(text: string, where: string): unknown;
+/** Shape problems for a parsed case ("<where>: <problem>. <hint>" without the file). */
+declare function validateCaseShape(raw: unknown): {
+    problems: string[];
+    warnings: string[];
+};
+type StepPhase = 'setup' | 'main' | 'teardown';
+interface PlannedStep {
+    phase: StepPhase;
+    step: Step;
+    /** Where the step lives in the case file (e.g. `["steps", 1]`, `[]` = the case itself). */
+    source: Array<string | number>;
+    /** Matcher-path label of the step: `steps[1]`, `setup[0]`, or `` for a single-op case. */
+    at: string;
+}
+/** setup → steps (or the case's own op) → teardown, in run order. */
+declare function planSteps(data: TestCase): PlannedStep[];
+interface InterpolationScope {
+    vars: Record<string, JsonValue>;
+    env?: Record<string, string | undefined>;
+}
+declare class InterpolationError extends Error {
+    /** The placeholder name (`sid`, `env.TOKEN`). */
+    readonly placeholder: string;
+    readonly at: string;
+    constructor(message: string, 
+    /** The placeholder name (`sid`, `env.TOKEN`). */
+    placeholder: string, at: string);
+}
+/**
+ * Replace `{{name}}` / `{{env.X}}` in every string of `value` (keys untouched). A string that
+ * is exactly one placeholder becomes the raw captured JSON value; otherwise values are
+ * inlined (strings as-is, everything else as JSON). Unknown names throw InterpolationError.
+ */
+declare function interpolate(value: JsonValue, scope: InterpolationScope, at?: string): JsonValue;
+/** Every `{{name}}` used in `value`, with where it was found. */
+declare function placeholdersIn(value: unknown, at?: string): Array<{
+    name: string;
+    at: string;
+}>;
+/** Interpolate a step's interpolated fields. */
+declare function interpolateStep(step: Step, scope: InterpolationScope, at: string): Step;
+interface LoadCaseFileOptions {
+    rootDir: string;
+    defaultServer?: string;
+    servers?: string[];
+    hooks?: SuiteHooks;
+    env?: Record<string, string | undefined>;
+}
+/** A manifest lock (`vib manifest record` output), not a case. */
+declare function looksLikeManifest(raw: unknown): boolean;
+/**
+ * Load one case file. Never throws: problems land in `error` (and `warnings`). A file shaped
+ * like a manifest lock comes back with `notACase: 'manifest'` (and no data).
+ */
+declare function loadCaseFile(file: string, opts: LoadCaseFileOptions, warnings?: string[]): LoadedCase;
+/** Apply tag / exclude-tag / grep filters, then the shard, to id-sorted cases. */
+declare function filterCases(cases: LoadedCase[], filters: CaseFilters): LoadedCase[];
+/** Keep every `total`-th case of the (already sorted) list, starting at `index` (1-based). */
+declare function shardCases<T>(cases: T[], shard: ShardSpec | undefined): T[];
+/** Resolve globs, load every case, apply filters. Never throws for bad case files. */
+declare function loadCases(options: LoadCasesOptions): Promise<LoadCasesResult>;
+/** Synchronous loadCases (for test-runner bridges that register tests at import time). */
+declare function loadCasesSync(options: LoadCasesOptions): LoadCasesResult;
+/** Split `a.b[0].c` / `a.b.0.c` into segments. */
+declare function parsePath(dotted: string): string[];
+/** Read a dotted path (`structuredContent.items[0].id`) from a JSON value. */
+declare function getPath(value: JsonValue | undefined, dotted: string): JsonValue | undefined;
+
+/**
+ * Minimal input shapes for the lint module. They mirror the field names in
+ * docs/V2_ARCHITECTURE.md (ToolSummary, Manifest, ...) and are deliberately
+ * permissive (mostly optional) so that the foundation's richer types — and raw
+ * JSON read from a manifest file — are assignable to them. Every check treats
+ * these values as untrusted server output and re-validates them at runtime.
+ */
+
+interface ToolAnnotationsLike {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+interface ToolSummary {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema?: JsonValue;
+    outputSchema?: JsonValue;
+    annotations?: ToolAnnotationsLike | JsonValue;
+}
+interface ResourceSummary {
+    uri: string;
+    name?: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+}
+interface ResourceTemplateSummary {
+    uriTemplate: string;
+    name?: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+}
+interface PromptArgumentSummary {
+    name: string;
+    title?: string;
+    description?: string;
+    required?: boolean;
+}
+interface PromptSummary {
+    name: string;
+    title?: string;
+    description?: string;
+    arguments?: PromptArgumentSummary[];
+}
+/** Cache metadata carried by a 2026-07-28 list result. Raw wire values; validated by spec checks. */
+interface ListMetaEntry {
+    ttlMs?: JsonValue;
+    cacheScope?: JsonValue;
+}
+interface ListMeta {
+    tools?: ListMetaEntry;
+    resources?: ListMetaEntry;
+    resourceTemplates?: ListMetaEntry;
+    prompts?: ListMetaEntry;
+}
+/**
+ * Anything shaped like a recorded Manifest (src/manifest.ts). `listMeta` holds the
+ * `ttlMs` / `cacheScope` of each list result; leave a list's entry undefined when
+ * that list was not fetched. `instructions` is the optional server instructions
+ * string from discover/initialize (model-visible, so it is linted too).
+ */
+interface ManifestLike {
+    protocolVersion?: string;
+    server?: {
+        name?: string;
+        version?: string;
+    };
+    capabilities?: JsonValue;
+    instructions?: string;
+    tools: ToolSummary[];
+    resources?: ResourceSummary[];
+    resourceTemplates?: ResourceTemplateSummary[];
+    prompts?: PromptSummary[];
+    listMeta?: ListMeta;
+    /** How the session reached the server. Decides whether stdout hygiene applies. */
+    transport?: 'stdio' | 'http';
+    /** Non-JSON-RPC lines a stdio server wrote to stdout (from `session.stdoutNoise`). */
+    stdoutNoise?: StdoutNoise$1;
+}
+interface StdoutNoise$1 {
+    lines: number;
+    sample: string[];
+}
+
+type ToolErrorKind = 'protocol' | 'tool' | 'transport' | 'timeout';
+interface ToolError {
+    /**
+     * - `protocol`: JSON-RPC error response (or an SDK-level protocol violation, see `local`)
+     * - `tool`: the tool ran and returned `isError: true`
+     * - `transport`: the connection failed / closed
+     * - `timeout`: no response within the time budget
+     */
+    kind: ToolErrorKind;
+    /** Numeric JSON-RPC code, when the error has one. */
+    code?: number;
+    /** Stable human name: `InvalidParams`, `MethodNotFound`, `RequestTimeout`, `ConnectionClosed`, ... */
+    codeName?: string;
+    message: string;
+    /** JSON-RPC `error.data`, when present. */
+    data?: JsonValue;
+    /** True when raised by the client SDK rather than received from the server. */
+    local?: boolean;
+}
+declare function errorCodeName(code: number): string | undefined;
+/** Canonical code name for a user-supplied name (handles aliases); undefined when unknown. */
+declare function canonicalCodeName(name: string): string;
+/** Every code name known to Vibrissa (numeric + SDK), for docs / schema / migrate. */
+declare function knownCodeNames(): string[];
+/**
+ * Does an observed error satisfy `expectError.code`? Accepts names (with aliases) and
+ * numbers. `ResourceNotFound` also matches the 2026-07-28 `-32602 + { uri }` shape.
+ */
+declare function errorMatchesCode(error: ToolError, expected: string | number): boolean;
+
+declare const MODERN_PROTOCOL_VERSION = "2026-07-28";
+declare const TASKS_EXTENSION = "io.modelcontextprotocol/tasks";
+/** Non-JSON-RPC lines a stdio server wrote to stdout (the SDK drops them silently). */
+interface StdoutNoise {
+    lines: number;
+    /** The first few offending lines (truncated). */
+    sample: string[];
+}
+/**
+ * Answers one embedded input request (MRTR round or legacy server→client request).
+ * Return the bare result (e.g. `{ action: "accept", content: {...} }`), or `undefined`
+ * to leave it unanswered (the call then resolves to `kind: 'input_required'`).
+ */
+type InputResponder = (method: string, params: JsonValue) => JsonValue | undefined | Promise<JsonValue | undefined>;
+interface SessionOptions {
+    /** Default per-request timeout (ms). Also bounds a whole MRTR flow. */
+    timeoutMs: number;
+    /** Called for every JSON-RPC message in/out (and stderr chunks when piped). */
+    transcript?: (entry: TranscriptEntry) => void;
+    /** Session-level responder; `CallOptions.respond` is consulted first. */
+    inputResponder?: InputResponder;
+    /**
+     * Server stderr (stdio only): `inherit` (default) forwards to this process's stderr,
+     * `capture` keeps it out of the console (transcript / onStderr only), `ignore` drops it.
+     */
+    stderr?: 'inherit' | 'capture' | 'ignore';
+    onStderr?: (text: string) => void;
+    /**
+     * Called for every non-JSON-RPC line a stdio server writes to stdout (e.g. a stray
+     * `console.log`). Such lines corrupt the protocol stream; see also `session.stdoutNoise`.
+     */
+    onStdoutNoise?: (line: string) => void;
+    /** Declare the tasks extension (servers may then answer with tasks). Default true. */
+    tasks?: boolean;
+    clientInfo?: {
+        name: string;
+        version: string;
+    };
+}
+interface CallOptions {
+    timeoutMs?: number;
+    /** Per-call responder: a function, or a map keyed by request method (`elicitation/create`). */
+    respond?: InputResponder | Record<string, JsonValue>;
+    /** Tasks extension: poll `tasks/get` until terminal. `true` = defaults. */
+    await?: AwaitOptions | boolean;
+}
+interface OutcomeBase {
+    durationMs: number;
+    /** Every InputRequests map the server sent during this call, one per round, in order. */
+    inputRequests?: JsonValue[];
+    /** The CreateTaskResult, when the server answered with a task. */
+    task?: JsonValue;
+}
+type Outcome = (OutcomeBase & {
+    kind: 'result';
+    result: JsonValue;
+}) | (OutcomeBase & {
+    kind: 'error';
+    error: ToolError;
+    result?: JsonValue;
+}) | (OutcomeBase & {
+    kind: 'input_required';
+    requests: JsonValue;
+    requestState?: string;
+});
+type SessionStartErrorCode = 'spawn' | 'exited' | 'timeout' | 'negotiation' | 'http' | 'config';
+/** Thrown by McpSession.start when the server cannot be reached / spawned / negotiated. */
+declare class SessionStartError extends Error {
+    readonly code: SessionStartErrorCode;
+    readonly stderr?: string | undefined;
+    constructor(message: string, code: SessionStartErrorCode, stderr?: string | undefined, options?: {
+        cause?: unknown;
+    });
+}
+/** Thrown by list/discover verbs (which return plain data, not an Outcome). */
+declare class SessionRequestError extends Error {
+    readonly error: ToolError;
+    constructor(message: string, error: ToolError);
+}
+/** Expand an RFC 6570 URI template with case args (non-strings are stringified). */
+declare function expandUriTemplate(template: string, args?: Record<string, JsonValue>): string;
+declare class McpSession {
+    private readonly client;
+    private readonly transport;
+    readonly server: ServerConfig;
+    private readonly opts;
+    private readonly stdio?;
+    private readonly httpClient?;
+    private queue;
+    private active;
+    private readonly toolDefs;
+    private toolsListed;
+    private initializeRaw;
+    private stderrBuffer;
+    private isClosed;
+    private _era;
+    private _protocolVersion;
+    private readonly noise;
+    private stdoutPending;
+    private readonly stdoutDecoder;
+    /** A request was left unanswered (timeout): the server may be hung, so close() kills at once. */
+    private hungRequest;
+    private closing;
+    private constructor();
+    /** Non-JSON-RPC lines the stdio server wrote to stdout so far (protocol pollution). */
+    get stdoutNoise(): StdoutNoise;
+    /** Negotiated era: `modern` = 2026-07-28+ via server/discover, `legacy` = 2025 initialize. */
+    get era(): 'legacy' | 'modern';
+    /** Negotiated protocol revision, e.g. "2026-07-28". */
+    get protocolVersion(): string;
+    /** True once the connection closed (server exit, transport failure, or close()). */
+    get closed(): boolean;
+    /** The last few KB of server stderr (stdio, unless stderr: 'ignore'). */
+    get stderrTail(): string;
+    /** Escape hatch: the underlying SDK client. Calls made here bypass serialization/capture. */
+    get sdk(): Client;
+    static start(server: ServerConfig, opts: SessionOptions): Promise<McpSession>;
+    /**
+     * See every raw stdout chunk (in order, before the SDK parses it) by wrapping the stdio
+     * transport's line buffer. The SDK silently drops lines that are not JSON-RPC.
+     */
+    private watchStdout;
+    private scanStdout;
+    /** Install transport taps, stderr capture, and the input-request handlers. */
+    private wire;
+    private tap;
+    private answerInputRequest;
+    private connect;
+    private startError;
+    /** Run `fn` exclusively, with a fresh wire tracker. */
+    private exclusive;
+    /** `server/discover` on modern; synthesized from the `initialize` result on legacy. */
+    discover(): Promise<DiscoverInfo>;
+    private synthesizeDiscover;
+    listTools(): Promise<ToolSummary$1[]>;
+    listResources(): Promise<ResourceSummary$1[]>;
+    listResourceTemplates(): Promise<ResourceTemplateSummary$1[]>;
+    listPrompts(): Promise<PromptSummary$1[]>;
+    listToolsResult(): Promise<ListResult<ToolSummary$1>>;
+    listResourcesResult(): Promise<ListResult<ResourceSummary$1>>;
+    listResourceTemplatesResult(): Promise<ListResult<ResourceTemplateSummary$1>>;
+    listPromptsResult(): Promise<ListResult<PromptSummary$1>>;
+    /** Walk all pages through the SDK, then rebuild the aggregate from the raw wire pages. */
+    private listPages;
+    callTool(name: string, args?: Record<string, JsonValue>, opts?: CallOptions): Promise<Outcome>;
+    readResource(uri: string, opts?: CallOptions): Promise<Outcome>;
+    /** Expand `template` with `args`, then `resources/read`. */
+    readResourceTemplate(template: string, args?: Record<string, JsonValue>, opts?: CallOptions): Promise<Outcome>;
+    getPrompt(name: string, args?: Record<string, JsonValue>, opts?: CallOptions): Promise<Outcome>;
+    /**
+     * Liveness round trip; false when the server is gone or does not answer in time.
+     * `ping` does not exist on 2026-07-28, so modern sessions use `server/discover`.
+     */
+    ping(timeoutMs?: number): Promise<boolean>;
+    /**
+     * Close the connection and release every OS resource, so the process can exit naturally.
+     * - stdio: stdin EOF, then SIGTERM after 500ms (at once if a call was left hanging), then
+     *   SIGKILL after another 500ms (Windows: kill the process tree).
+     * - HTTP: terminate a legacy server session (DELETE) when one exists, close the transport,
+     *   then destroy the session's sockets.
+     * Idempotent; concurrent callers share one teardown.
+     */
+    close(): Promise<void>;
+    private teardown;
+    /**
+     * The tool definition handed to the SDK: our cached one with `outputSchema` removed, so the
+     * SDK never validates structuredContent itself (the runner does, with better errors and a
+     * per-case opt-out). On modern HTTP, list once so SEP-2243 `Mcp-Param-*` mirroring has data.
+     */
+    private toolDefinitionFor;
+    /** Turn what happened on the wire (and what the SDK threw) into an Outcome. */
+    private finish;
+    private resultOutcome;
+    /** Tasks extension: poll `tasks/get` until completed / failed / cancelled. */
+    private awaitTask;
+    private taskRequest;
+}
+
+declare const MANIFEST_VERSION = 2;
+/**
+ * Dotted paths ignored by diffManifest unless overridden (`manifestIgnore`): the server's
+ * release version, and what differs only by protocol era (`protocolVersion`, `listMeta`), so
+ * one lock serves both eras. `vib manifest diff --strict` compares everything.
+ */
+declare const DEFAULT_MANIFEST_IGNORE: readonly string[];
+interface Manifest {
+    vibrissa: 2;
+    protocolVersion: string;
+    server: {
+        name?: string;
+        version?: string;
+    };
+    capabilities: JsonValue;
+    instructions?: string;
+    /** Sorted by name. */
+    tools: ToolSummary$1[];
+    /** Sorted by uri. */
+    resources: ResourceSummary$1[];
+    /** Sorted by uriTemplate. */
+    resourceTemplates: ResourceTemplateSummary$1[];
+    /** Sorted by name. */
+    prompts: PromptSummary$1[];
+    /** `ttlMs` / `cacheScope` of each list result that was fetched. */
+    listMeta: ListMeta;
+}
+interface CaptureManifestOptions {
+    /** How many tools/list results to collect for the stability check. Default 1. */
+    toolsListSamples?: number;
+}
+interface CapturedManifest {
+    manifest: Manifest;
+    /** Raw tools/list results in server order (the first one built the manifest). */
+    toolsListSamples: ToolSummary$1[][];
+    discover: DiscoverInfo;
+}
+/** Assemble a Manifest from already-fetched data (pure). */
+declare function manifestFrom(input: {
+    protocolVersion: string;
+    discover: Pick<DiscoverInfo, 'serverInfo' | 'capabilities' | 'instructions'>;
+    tools?: ListResult<ToolSummary$1>;
+    resources?: ListResult<ResourceSummary$1>;
+    resourceTemplates?: ListResult<ResourceTemplateSummary$1>;
+    prompts?: ListResult<PromptSummary$1>;
+}): Manifest;
+/**
+ * Snapshot the live server: discover + tools/list (+ resources, templates, prompts when the
+ * server declares them). Lists the server does not implement (MethodNotFound) are empty.
+ * Throws SessionRequestError when a list call fails for another reason.
+ */
+declare function captureManifest(session: McpSession, opts?: CaptureManifestOptions): Promise<CapturedManifest>;
+/** Snapshot the live server's manifest. */
+declare function buildManifest(session: McpSession): Promise<Manifest>;
+/**
+ * Lock file for `server`: the configured `manifest` path for the default server, and a
+ * sibling `<name>.<server>.json` for any other server (e.g. `__manifest__.staging.json`).
+ */
+declare function manifestPathFor(options: Pick<RunOptions, 'manifest' | 'rootDir' | 'defaultServer'>, server?: string): string;
+declare class ManifestFileError extends Error {
+    constructor(message: string);
+}
+/** Read and sanity-check a manifest lock file. */
+declare function readManifest(file: string): Manifest;
+/** Write a manifest as 2-space JSON (creating directories). */
+declare function writeManifest(file: string, manifest: Manifest): void;
+interface FieldChange {
+    /**
+     * Dotted sub-path of what changed, as deep as it goes: `description`,
+     * `inputSchema.required`, `inputSchema.properties.city.type`, `capabilities.tools`.
+     */
+    path: string;
+    /** Absent when the field was added. */
+    before?: JsonValue;
+    /** Absent when the field was removed. */
+    after?: JsonValue;
+    /**
+     * Would existing clients / cases break? True for: a removed or renamed input property, a
+     * newly required property or prompt argument, a type change, removed enum values, a tightened
+     * `additionalProperties`, any outputSchema change, a changed resource mimeType, a removed
+     * capability, a protocolVersion change. Descriptions, titles and annotations are not breaking.
+     */
+    breaking: boolean;
+}
+interface ItemChange {
+    /** Tool / prompt name, resource uri, or uriTemplate. */
+    key: string;
+    /** Any of `fields` is breaking. */
+    breaking: boolean;
+    fields: FieldChange[];
+}
+/** Only non-empty lists are present. Every removed item is a breaking change. */
+interface SectionDiff {
+    added?: string[];
+    removed?: string[];
+    changed?: ItemChange[];
+}
+declare const MANIFEST_SECTIONS: readonly ["tools", "resources", "resourceTemplates", "prompts"];
+type ManifestSection = (typeof MANIFEST_SECTIONS)[number];
+/** Machine shape: empty lists and unchanged sections are omitted. */
+interface ManifestDiff {
+    identical: boolean;
+    /** At least one breaking change (see FieldChange.breaking) or removed item. */
+    breaking: boolean;
+    /** Server-level changes: protocolVersion, instructions, server.*, capabilities.*, listMeta.* */
+    changes?: FieldChange[];
+    tools?: SectionDiff;
+    resources?: SectionDiff;
+    resourceTemplates?: SectionDiff;
+    prompts?: SectionDiff;
+}
+interface DiffManifestOptions {
+    /**
+     * Dotted paths to ignore. Sections are keyed by item name / uri (`tools.*.annotations`,
+     * `tools.notes.search.description`); prompt arguments by name
+     * (`prompts.*.arguments.*.description`); `*` matches any key. Default
+     * `["server.version", "protocolVersion", "listMeta"]` (per-release and per-era noise); pass
+     * `[]` to compare everything (`vib manifest diff --strict`).
+     */
+    ignore?: readonly string[];
+}
+/** Deep equality ignoring object key order. */
+declare function jsonEqual(a: unknown, b: unknown): boolean;
+/** Structured diff of a locked manifest against the live one. */
+declare function diffManifest(locked: Manifest, live: Manifest, opts?: DiffManifestOptions): ManifestDiff;
+/**
+ * One-line summary: `1 tool changed (echo: description); 1 prompt added (greet)`, ending in
+ * ` (breaking)` when any change is breaking.
+ */
+declare function summarizeDiff(diff: ManifestDiff): string;
+/** Word-level diff in git's `--word-diff=plain` notation: `[-removed-]{+added+}`. */
+declare function wordDiff(before: string, after: string): string | undefined;
+/**
+ * Multi-line, uncolored rendering: one line per changed sub-path (word diff for prose),
+ * `+` / `-` per added / removed item, `(breaking)` on breaking lines; empty sections omitted.
+ */
+declare function formatDiff(diff: ManifestDiff): string;
+
+/**
+ * RunOptions (incl. `outDir`, `manifestIgnore`, `checks` from config) plus runner-only knobs.
+ * `outDir` holds results.json, junit.xml and traces/ (relative to rootDir; default "reports").
+ */
+interface RunnerOptions extends RunOptions {
+    /** Allow pretty console output (still subject to TTY / NO_COLOR). Default true. */
+    pretty?: boolean;
+    /** Reporter output sinks. Default console.log / console.error. */
+    stdout?: (line: string) => void;
+    stderr?: (line: string) => void;
+    /** Reporter instances added to the ones named in `reporters`. */
+    extraReporters?: Reporter[];
+    /** Informational lines (e.g. skipped `$ref` fragments). Default: `stdout`. */
+    info?: (line: string) => void;
+    /** `--update=all`: also rewrite expectations that contain matchers. */
+    updateAll?: boolean;
+    /** `--update-manifest`: rewrite the manifest lock on drift (or create it when missing). */
+    updateManifest?: boolean;
+    /** Verify the manifest lock at all. Default true. */
+    lockManifest?: boolean;
+    /** Minimum pass rate for `flaky: true` cases under --repeat. Default 0.5. */
+    flakyFloor?: number;
+    /** --baseline: fail when a passing case's durationMs grows by more than this percent. Default 50. */
+    baselineLatencyPct?: number;
+    /** --baseline: ignore latency growth smaller than this many ms (timer noise). Default 10. */
+    baselineLatencyMinMs?: number;
+    /** Server stderr for runner sessions: kept out of the console and saved with traces by default. */
+    serverStderr?: 'inherit' | 'capture' | 'ignore';
+    /** Environment for `{{env.X}}`. Default process.env. */
+    env?: Record<string, string | undefined>;
+}
+interface ManifestResult {
+    server: string;
+    path: string;
+    /** `missing-required`: no lock while requireManifest is on (fails the run). */
+    status: 'ok' | 'diff' | 'missing' | 'missing-required' | 'updated' | 'created' | 'error';
+    diff?: ManifestDiff;
+    summary?: string;
+}
+interface RunResult {
+    /** 0 ok, 1 failures, 2 configuration error (e.g. an invalid server entry). */
+    exitCode: number;
+    ok: boolean;
+    summary: RunSummary;
+    cases: Array<{
+        ref: CaseRef;
+        outcome: CaseOutcome;
+    }>;
+    checks: CheckOutcome[];
+    manifests: ManifestResult[];
+    warnings: string[];
+}
+declare const DEFAULT_FLAKY_FLOOR = 0.5;
+declare const DEFAULT_BASELINE_LATENCY_PCT = 50;
+declare const DEFAULT_BASELINE_LATENCY_MIN_MS = 10;
+/** `content[0].text` / `_meta["a/b"]` / `(root)` → path segments. */
+declare function matcherPathSegments(path: string): string[];
+/** RFC 6901 JSON Pointer for path segments (`["steps", 1, "expect"]` → `/steps/1/expect`). */
+declare function toPointer(segments: Array<string | number>): string;
+/**
+ * The value `expectInputRequired` is matched against, built from every InputRequests round
+ * of the call:
+ *
+ * - **by key** (default): `{ "<request key>": { "method": "...", "params": {...} } }`, the
+ *   server's own InputRequests keys merged over all rounds. On 2025-era connections the keys
+ *   are JSON-RPC request ids, so prefer the method view for suites that run on both eras.
+ * - **by method** (when every plain key of the expectation contains `/`):
+ *   `{ "elicitation/create": <params> }`; a method asked several times maps to an array of
+ *   params in order.
+ */
+declare function inputRequestView(expected: JsonValue, rounds: JsonValue[]): JsonObject;
+
+interface ExecuteContext {
+    session: McpSession;
+    /** Run-level normalization (merged under case / step `normalize`). */
+    normalize: NormalizeConfig;
+    timeoutMs: number;
+    /** Default case budget (config `budgetMs`). */
+    budgetMs?: number;
+    /** Tool definitions by name: outputSchema enforcement, args pre-validation, name hints. */
+    tools?: Map<string, ToolSummary$1>;
+    /** Values visible to `{{name}}` before the case captures anything (suite setup). */
+    vars?: Record<string, JsonValue>;
+    env?: Record<string, string | undefined>;
+    /**
+     * `failing` (= --update) rewrites mismatched plain leaves of `expect`; `all` (=
+     * --update=all) also replaces mismatched matchers and `$ref`s with literal values.
+     */
+    update?: 'off' | 'failing' | 'all';
+    /** Case as written in its file (no `$ref` expansion): decides what --update may rewrite. */
+    source?: TestCase;
+    /** Set when the case file must not be rewritten (e.g. it has comments): the reason. */
+    cannotRewrite?: string;
+    /** Mention `--update` in failure reasons when it would help. Default true. */
+    updateHint?: boolean;
+    /** Case id for messages. */
+    caseId?: string;
+    onStepStart?: (step: StepRef) => void | Promise<void>;
+    onStepEnd?: (step: StepRef, result: {
+        durationMs: number;
+        status: CaseStatus;
+        reason?: string;
+    }) => void | Promise<void>;
+}
+interface ExpectationUpdate {
+    /** Path inside the case file, e.g. `["steps", 1, "expect"]`. */
+    source: Array<string | number>;
+    value: JsonValue;
+}
+interface CaseExecution {
+    /** tracePath / stderrPath are filled in by the runner. */
+    outcome: CaseOutcome;
+    /** Normalized observation of every executed step, in run order (used by `vib diff`). */
+    observations: Array<{
+        step: StepRef;
+        observed: JsonValue;
+        planned: PlannedStep;
+    }>;
+    /** Goldens accepted under --update (the caller writes them). */
+    updates: ExpectationUpdate[];
+    warnings: string[];
+    /** Final `{{name}}` scope (suite setup uses this). */
+    vars: Record<string, JsonValue>;
+}
+/**
+ * Run one case on a session: setup → steps → teardown, with interpolation, MRTR answers,
+ * tasks, outputSchema enforcement, expectations, captures and budgets. Never throws.
+ */
+declare function executeCase(data: TestCase, ctx: ExecuteContext): Promise<CaseExecution>;
+/** The indent the file uses (`"  "`, `"    "`, `"\t"`), for rewrites that keep its format. */
+declare function detectIndent(text: string | undefined): string | number;
+/** Write accepted goldens back into the case file (its own indent and EOL; key order kept). */
+declare function applyUpdates(loaded: LoadedCase, updates: ExpectationUpdate[]): void;
+/**
+ * Trace file name (relative, no extension) for a case id: `cases/echo.basic.json#2` →
+ * `cases/echo.basic.run2`. Cases outside rootDir (absolute ids) get a flat
+ * `_external/<basename>-<hash>` name instead of mirroring the absolute path.
+ */
+declare function traceName(caseId: string): string;
+declare class Runner {
+    readonly options: RunnerOptions;
+    private reporter;
+    private ctx;
+    private rootDir;
+    private readonly results;
+    private readonly checks;
+    private readonly manifests;
+    private readonly warnings;
+    private readonly flakyIds;
+    /** Case ids that regressed against --baseline (set once the baseline was applied). */
+    private readonly baselineFailures;
+    private baselineActive;
+    private stopped;
+    private fatal;
+    /** Every session started per server (restarts included), for the stdout-noise report. */
+    private readonly sessionsByServer;
+    constructor(options: RunnerOptions);
+    /** Run and return the exit code (0 ok, 1 failures, 2 configuration error). */
+    run(): Promise<number>;
+    execute(): Promise<RunResult>;
+    private emit;
+    private warn;
+    private runAll;
+    private orderServers;
+    private startWorker;
+    private runServer;
+    /** stdio servers must keep stdout for JSON-RPC: report stray lines (even without --check). */
+    private warnStdoutNoise;
+    private toolDefinitions;
+    private suiteSetup;
+    private suiteTeardown;
+    private executeContext;
+    private workerLoop;
+    /** Emit a case that needs no session: load errors, skips, or a dead server. */
+    private runImmediate;
+    private runCase;
+    private writeTrace;
+    private verifyManifest;
+    /** ` --server <name>` for non-default servers (CLI hints). */
+    private serverFlag;
+    private missingLock;
+    private runServerChecks;
+    private applyBaseline;
+    private caseVerdicts;
+    private finish;
+}
+/** v1-compatible partial options: `server` (singular) is sugar for `servers.default`. */
+type RunCasesInput = Partial<RunnerOptions> & {
+    server?: ServerConfig;
+};
+/** Fill defaults (and map v1 `server` → `servers.default`). */
+declare function resolveRunnerOptions(input?: RunCasesInput): RunnerOptions;
+/** Run cases and resolve to the exit code (0 ok, 1 failures, 2 configuration error). */
+declare function runCases(options?: RunCasesInput): Promise<number>;
+
+export { type ManifestResult as $, type AwaitOptions as A, type InterpolationScope as B, type CaseStatus as C, DEFAULT_BASELINE_LATENCY_MIN_MS as D, type ExecuteContext as E, type FieldChange as F, type ItemChange as G, type HttpServerConfig as H, type InputResponder as I, type JsonValue as J, type JsonObject as K, type ListResult as L, type Mismatch as M, type NormalizeConfig as N, type LoadCasesOptions as O, type PromptSummary as P, type LoadCasesResult as Q, type Reporter as R, type ServerConfig as S, type ToolSummary as T, type LoadedCase as U, MANIFEST_SECTIONS as V, MANIFEST_VERSION as W, MODERN_PROTOCOL_VERSION as X, type Manifest as Y, type ManifestDiff as Z, ManifestFileError as _, type ReporterContext as a, resolveRunnerOptions as a$, type ManifestSection as a0, McpSession as a1, OP_KINDS as a2, type OpKind as a3, type Operation as a4, type Outcome as a5, type PlannedStep as a6, type PromptSummary$1 as a7, type ResourceSummary$1 as a8, type ResourceTemplateSummary$1 as a9, errorCodeName as aA, errorMatchesCode as aB, executeCase as aC, expandUriTemplate as aD, filterCases as aE, formatDiff as aF, getPath as aG, inputRequestView as aH, interpolate as aI, interpolateStep as aJ, isHttpServerConfig as aK, isStdioServerConfig as aL, jsonEqual as aM, knownCodeNames as aN, loadCaseFile as aO, loadCases as aP, loadCasesSync as aQ, looksLikeManifest as aR, manifestFrom as aS, manifestPathFor as aT, matcherPathSegments as aU, parseCaseText as aV, parsePath as aW, placeholdersIn as aX, planSteps as aY, readManifest as aZ, resolveCaseFiles as a_, type RunCasesInput as aa, type RunResult as ab, type RunSummary as ac, Runner as ad, type RunnerOptions as ae, STEP_KEYS as af, type SectionDiff as ag, type SessionOptions as ah, SessionRequestError as ai, SessionStartError as aj, type SessionStartErrorCode as ak, type StdioServerConfig as al, type Step as am, type StepRef as an, TASKS_EXTENSION as ao, type TestCase as ap, type ToolError as aq, type ToolSummary$1 as ar, type TranscriptEntry as as, applyUpdates as at, buildManifest as au, canonicalCodeName as av, captureManifest as aw, caseIdFor as ax, detectIndent as ay, diffManifest as az, type RunEvent as b, runCases as b0, shardCases as b1, summarizeDiff as b2, toPointer as b3, traceName as b4, validateCaseShape as b5, wordDiff as b6, writeManifest as b7, type CheckOutcome as c, type ResourceSummary as d, type ResourceTemplateSummary as e, type ManifestLike as f, type ShardSpec as g, type SuiteHooks as h, type RunOptions as i, type ProtocolMode as j, CASE_KEYS as k, type CallOptions as l, type CaptureManifestOptions as m, type CapturedManifest as n, type CaseExecution as o, type CaseFilters as p, type CaseOutcome as q, type CaseRef as r, DEFAULT_BASELINE_LATENCY_PCT as s, DEFAULT_FLAKY_FLOOR as t, DEFAULT_MANIFEST_IGNORE as u, type DiffManifestOptions as v, type DiscoverInfo as w, type ExpectError as x, type ExpectationUpdate as y, InterpolationError as z };