@omniaura/scenario-sim 0.1.0

package/dist/engine-2w32ngB2.d.ts

@@ -0,0 +1,897 @@
+/**
+ * Seeded PRNG (sfc32). Every scenario run owns one, seeded from the run's
+ * seed, so ids, latencies, jitter and fixture data replay identically for the
+ * same seed — never use Math.random or wall-clock ids inside a scenario.
+ */
+declare class Rng {
+    readonly seed: string | number;
+    private a;
+    private b;
+    private c;
+    private d;
+    /** Draws so far; useful when asserting determinism across runs. */
+    draws: number;
+    constructor(seed: string | number);
+    /** Uniform in [0, 1). */
+    next(): number;
+    /** Integer in [min, max] inclusive. */
+    int(min: number, max: number): number;
+    float(min?: number, max?: number): number;
+    chance(probability: number): boolean;
+    pick<T>(items: readonly T[]): T;
+    shuffle<T>(items: readonly T[]): T[];
+    /** Deterministic opaque id: `<prefix>_<8 base36 chars>`. */
+    id(prefix?: string): string;
+    /** RFC-4122-shaped id (version 4 bits set) from the seeded stream. */
+    uuid(): string;
+    /** Fork a child generator with a derived seed (stable across runs). */
+    fork(label: string): Rng;
+}
+
+/**
+ * Virtual clock. Everything time-related in a scenario — response delays,
+ * scheduled stream events, disconnects, timestamps in fixtures — goes through
+ * the run's clock so it can be replayed:
+ *
+ *   realtime  timers fire on real setTimeout scaled by `speed` (default 1)
+ *   manual    nothing fires until `step(ms)` advances the clock (tests, and
+ *             "step" in the control plane / panel / CLI)
+ *
+ * `now()` is virtual milliseconds since the run started, and `wall()` maps it
+ * onto a fixed epoch so fixture timestamps are stable across runs.
+ */
+type ClockMode = "realtime" | "manual";
+interface ClockTimer {
+    id: number;
+    at: number;
+    label: string;
+    cancel(): void;
+}
+declare class VirtualClock {
+    mode: ClockMode;
+    speed: number;
+    readonly epoch: number;
+    private entries;
+    private nextId;
+    private base;
+    private startedReal;
+    private manualNow;
+    constructor(mode?: ClockMode, speed?: number, epoch?: number);
+    /** Virtual ms since the run started. */
+    now(): number;
+    /** Virtual wall-clock ms (epoch + now). */
+    wall(): number;
+    iso(offsetMs?: number): string;
+    after(ms: number, fn: () => void, label?: string): ClockTimer;
+    /** Promise that resolves after `ms` virtual milliseconds. */
+    sleep(ms: number, label?: string): Promise<void>;
+    cancel(id: number): void;
+    /** Manual mode: advance by `ms`, firing due timers in order. Returns what fired. */
+    step(ms: number): {
+        now: number;
+        fired: {
+            id: number;
+            at: number;
+            label: string;
+        }[];
+    };
+    /** Switch modes; pending timers are re-armed (realtime) or parked (manual). */
+    setMode(mode: ClockMode): void;
+    pending(): {
+        id: number;
+        at: number;
+        label: string;
+    }[];
+    clear(): void;
+    private fire;
+}
+
+/**
+ * Per-run state. Collections of records keyed by id, with every mutation
+ * appended to a bounded event log and delivered to listeners — that is how
+ * "a PATCH publishes a stream event" is wired without coupling routes to
+ * transports: routes mutate state, stream routes subscribe to state.
+ */
+type Record_ = Record<string, unknown> & {
+    id: string;
+};
+type StoreEventKind = "insert" | "update" | "remove" | "clear" | "custom";
+interface StoreEvent {
+    seq: number;
+    /** Virtual clock ms when it happened. */
+    t: number;
+    kind: StoreEventKind;
+    collection: string;
+    id?: string;
+    record?: Record_;
+    previous?: Record_;
+    /** For `custom` events. */
+    name?: string;
+    data?: unknown;
+}
+type StoreListener = (event: StoreEvent) => void;
+declare class Store {
+    private now;
+    private logLimit;
+    private collections;
+    private listeners;
+    private log;
+    private seq;
+    constructor(now: () => number, logLimit?: number);
+    collection(name: string): Map<string, Record_>;
+    collections_(): string[];
+    insert<T extends Record_>(collection: string, record: T): T;
+    upsert<T extends Record_>(collection: string, record: T): T;
+    get<T extends Record_ = Record_>(collection: string, id: string): T | undefined;
+    list<T extends Record_ = Record_>(collection: string, opts?: {
+        where?: (r: T) => boolean;
+        sort?: (a: T, b: T) => number;
+        offset?: number;
+        limit?: number;
+    }): T[];
+    count(collection: string): number;
+    update<T extends Record_ = Record_>(collection: string, id: string, patch: Partial<T> | ((current: T) => T)): T | undefined;
+    remove(collection: string, id: string): Record_ | undefined;
+    clear(collection?: string): void;
+    /** Application-level event (not tied to a record), e.g. "job.progress". */
+    custom(collection: string, name: string, data?: unknown, id?: string): void;
+    on(listener: StoreListener): () => boolean;
+    events(opts?: {
+        since?: number;
+        collection?: string;
+        limit?: number;
+    }): StoreEvent[];
+    get lastSeq(): number;
+    snapshot(): Record<string, Record_[]>;
+    counts(): Record<string, number>;
+    private emit;
+}
+
+/**
+ * Streams: topics with per-topic monotonic event ids and bounded replay, plus
+ * SSE and WebSocket routes whose connections the control plane can list,
+ * pause, disconnect or hard-drop. Transports are pluggable — a Bun/Node
+ * server, Vite's http server, or an in-page fake WebSocket — and the scenario
+ * code never sees the difference.
+ */
+
+interface TopicEvent {
+    topic: string;
+    /** Monotonic per topic, as a decimal string (matches how most protocols carry it). */
+    eventID: string;
+    t: number;
+    data: Record<string, unknown>;
+}
+declare class TopicLog {
+    private now;
+    readonly retain: number;
+    private seqs;
+    private logs;
+    constructor(now: () => number, retain?: number);
+    publish(topic: string, data: Record<string, unknown>): TopicEvent;
+    last(topic: string): string;
+    /**
+     * Events after `since`. `missed` is true when `since` predates the retained
+     * window. `null`/`undefined` means "no resume point": live only, nothing is
+     * replayed (what a fresh EventSource without Last-Event-ID gets). Pass "0"
+     * to replay everything retained.
+     */
+    replay(topic: string, since: string | number | null | undefined): {
+        events: TopicEvent[];
+        missed: boolean;
+    };
+    topics(): string[];
+    clear(): void;
+}
+interface StreamContext {
+    request: Request;
+    url: URL;
+    params: Record<string, string>;
+    query: URLSearchParams;
+    state: Store;
+    rng: Rng;
+    clock: VirtualClock;
+    streams: StreamHub;
+    run: {
+        id: string;
+        scenario: string;
+        seed: string;
+    };
+    log(message: string, data?: unknown): void;
+}
+/** What a transport must provide for one WebSocket connection. */
+interface SocketTransport {
+    send(data: string | ArrayBuffer): void;
+    /** Graceful close with a close frame. */
+    close(code?: number, reason?: string): void;
+    /** Hard drop: no close frame; the client sees an abnormal close (1006). */
+    drop(): void;
+}
+type Serializer = (event: TopicEvent) => string;
+interface Subscription {
+    topic: string;
+    serialize: Serializer;
+}
+interface ConnectionBase {
+    id: string;
+    kind: "ws" | "sse";
+    path: string;
+    url: URL;
+    openedAt: number;
+    sent: number;
+    received: number;
+    paused: boolean;
+    subscriptions: Map<string, Subscription>;
+    meta: Record<string, unknown>;
+}
+interface SimSocket extends ConnectionBase {
+    kind: "ws";
+    protocol: string | null;
+    readyState: "open" | "closed";
+    send(data: string | ArrayBuffer | Record<string, unknown>): void;
+    close(code?: number, reason?: string): void;
+    drop(): void;
+    /** Replay `since` then stay subscribed; returns what was replayed. */
+    subscribe(topic: string, opts?: {
+        since?: string | number | null;
+        serialize?: Serializer;
+    }): {
+        replayed: number;
+        missed: boolean;
+        last: string;
+    };
+    unsubscribe(topic: string): void;
+    onClose(cb: (code: number, reason: string) => void): void;
+}
+interface SimSseStream extends ConnectionBase {
+    kind: "sse";
+    lastEventId: string | null;
+    /** Send one SSE message. Objects are JSON-encoded. */
+    send(data: unknown, opts?: {
+        event?: string;
+        id?: string;
+        retry?: number;
+    }): void;
+    comment(text: string): void;
+    close(): void;
+    drop(): void;
+    subscribe(topic: string, opts?: {
+        since?: string | number | null;
+        event?: (e: TopicEvent) => string;
+    }): {
+        replayed: number;
+        missed: boolean;
+        last: string;
+    };
+    unsubscribe(topic: string): void;
+    onClose(cb: () => void): void;
+    /** The Response to return to the client. */
+    response: Response;
+}
+interface WsRoute {
+    kind: "ws";
+    path: string;
+    name?: string;
+    /** Subprotocols the server will select from (first match with the client's list wins). */
+    protocols?: string[];
+    onOpen?(ctx: StreamContext, socket: SimSocket): void | Promise<void>;
+    onMessage?(ctx: StreamContext, socket: SimSocket, data: string | ArrayBuffer): void | Promise<void>;
+    onClose?(ctx: StreamContext, socket: SimSocket, code: number, reason: string): void;
+}
+interface SseRoute {
+    kind: "sse";
+    path: string;
+    name?: string;
+    /** Some APIs open SSE with POST (request body = the prompt). Default GET. */
+    method?: "GET" | "POST";
+    /** Keepalive comment interval in virtual ms (default 15000; 0 disables). */
+    keepaliveMs?: number;
+    onOpen(ctx: StreamContext, stream: SimSseStream): void | Promise<void>;
+}
+type StreamRoute = WsRoute | SseRoute;
+interface ConnectionSummary {
+    id: string;
+    kind: "ws" | "sse";
+    path: string;
+    openedAt: number;
+    sent: number;
+    received: number;
+    paused: boolean;
+    topics: string[];
+    protocol?: string | null;
+    meta: Record<string, unknown>;
+}
+declare class StreamHub {
+    private clock;
+    private log;
+    readonly topics: TopicLog;
+    private connections;
+    private nextId;
+    /** Extra virtual latency applied to every outgoing stream message. */
+    latencyMs: number;
+    constructor(clock: VirtualClock, log: (message: string, data?: unknown) => void);
+    /** Publish to a topic: appended to the replay log and fanned out to subscribers. */
+    publish(topic: string, data: Record<string, unknown>): TopicEvent;
+    private deliver;
+    private deliverSse;
+    /** Called by a transport adapter once the WebSocket handshake completed. */
+    openSocket(route: WsRoute, ctx: StreamContext, transport: SocketTransport, protocol: string | null): SimSocket;
+    /** Transport → hub: a client frame arrived. */
+    receive(route: WsRoute, ctx: StreamContext, socket: SimSocket, data: string | ArrayBuffer): void;
+    /** Transport → hub: the client closed. */
+    clientClosed(route: WsRoute, ctx: StreamContext, socket: SimSocket, code: number, reason: string): void;
+    private finish;
+    /** Build the SSE Response for a route; the adapter just returns it. */
+    openSse(route: SseRoute, ctx: StreamContext): SimSseStream;
+    list(): ConnectionSummary[];
+    get(id: string): SimSocket | SimSseStream | null;
+    /**
+     * Disconnect connections: by id, by topic, by path, or all. `drop` cuts the
+     * connection without a close frame (what a network blip looks like).
+     */
+    disconnect(target: {
+        id?: string;
+        topic?: string;
+        path?: string;
+        all?: boolean;
+    }, opts?: {
+        code?: number;
+        reason?: string;
+        drop?: boolean;
+    }): string[];
+    /** Pause delivery on a connection (messages queue); resume flushes them in order. */
+    pause(id: string, paused: boolean): boolean;
+    closeAll(): void;
+}
+
+/**
+ * HTTP routing on Web `Request`/`Response`, so the same scenario runs on a
+ * Bun/Node server, inside Vite's dev server, or entirely in the browser.
+ */
+
+type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS" | "*";
+interface RouteContext {
+    request: Request;
+    url: URL;
+    method: string;
+    /** `:name` captures. */
+    params: Record<string, string>;
+    query: URLSearchParams;
+    /** Parsed JSON body (or `{}` when absent/invalid). */
+    body<T = Record<string, unknown>>(): Promise<T>;
+    state: Store;
+    rng: Rng;
+    clock: VirtualClock;
+    streams: StreamHub;
+    /** Run id and scenario name, for logging or per-run behaviour. */
+    run: {
+        id: string;
+        scenario: string;
+        seed: string;
+    };
+    /** Per-route call counter (1-based) — handy for "fail on the 3rd call". */
+    calls: number;
+    log(message: string, data?: unknown): void;
+}
+type Handler = (ctx: RouteContext) => Response | Promise<Response>;
+interface Route {
+    method: Method;
+    path: string;
+    handler: Handler;
+    /** Optional label for logs and the control plane. */
+    name?: string;
+}
+interface CompiledRoute extends Route {
+    match: (pathname: string) => Record<string, string> | null;
+    calls: number;
+}
+type MalformedKind = "invalid-json" | "wrong-content-type" | "truncated" | "empty-200" | "html-500" | "schema-drift";
+
+/**
+ * Fault layer: latency (+ seeded jitter), fail modes and per-endpoint
+ * overrides. Overrides are checked before routing, so a test can force any
+ * endpoint — even one the scenario never defined — to answer with a given
+ * status/body, once (`times`) or until cleared — the classic in-bundle mock
+ * "endpoint override" contract, generalised.
+ */
+
+type FailMode = "off" | "data" | "all";
+interface OverrideInput {
+    /** Substring of the path, or `{ regex, flags }`. */
+    matcher: string | {
+        regex: string;
+        flags?: string;
+    };
+    method?: string;
+    status?: number;
+    body?: unknown;
+    /** Auto-expire after N matches. */
+    times?: number;
+    delayMs?: number;
+    malformed?: MalformedKind;
+    name?: string;
+}
+interface Override extends OverrideInput {
+    id: string;
+    remaining: number;
+    hits: number;
+}
+interface FaultSnapshot {
+    latencyMs: number;
+    jitterMs: number;
+    failMode: FailMode;
+    shellPaths: string[];
+    overrides: Override[];
+}
+declare class FaultLayer {
+    private rng;
+    latencyMs: number;
+    jitterMs: number;
+    failMode: FailMode;
+    /** Paths the `data` fail mode leaves alone so the app shell still boots. */
+    shellPaths: Set<string>;
+    private overrides;
+    private nextId;
+    constructor(rng: Rng);
+    configure(patch: Partial<{
+        latencyMs: number;
+        jitterMs: number;
+        failMode: FailMode;
+        shellPaths: string[];
+    }>): void;
+    /** Effective delay for one request (seeded jitter keeps it reproducible). */
+    delayFor(extra?: number): number;
+    setOverride(input: OverrideInput): Override;
+    clearOverride(target: string | OverrideInput["matcher"], method?: string): boolean;
+    clearOverrides(): void;
+    listOverrides(): Override[];
+    /** Find (and consume) the first matching override. */
+    matchOverride(path: string, method: string): Override | null;
+    /** Build the response an override dictates. */
+    overrideResponse(o: Override): Response;
+    /** Fail-mode response, or null when the request should proceed. */
+    failResponse(path: string): Response | null;
+    snapshot(): FaultSnapshot;
+}
+
+interface SetupContext {
+    state: Store;
+    rng: Rng;
+    clock: VirtualClock;
+    streams: StreamHub;
+    run: {
+        id: string;
+        scenario: string;
+        seed: string;
+    };
+    log(message: string, data?: unknown): void;
+}
+interface ActionContext extends SetupContext {
+    args: Record<string, unknown>;
+}
+interface ScenarioDefinition {
+    /** URL-safe identifier. */
+    name: string;
+    label?: string;
+    description?: string;
+    /** Default seed (default: the scenario name). Runs may override. */
+    seed?: string;
+    clock?: {
+        mode?: ClockMode;
+        speed?: number;
+    };
+    faults?: {
+        latencyMs?: number;
+        jitterMs?: number;
+        failMode?: FailMode;
+        shellPaths?: string[];
+    };
+    tags?: string[];
+    /** Seed the store. Runs once per run creation/reset, with the run's RNG. */
+    setup?(ctx: SetupContext): void | Promise<void>;
+    routes?: Route[];
+    streams?: StreamRoute[];
+    /**
+     * Named actions exposed as `POST /__sim/action {name,args}` — and therefore
+     * as `scenario.action` in the pulse panel/CLI. Use them for "emit a burst",
+     * "complete the running job", "drop the stream mid-turn".
+     */
+    actions?: Record<string, (ctx: ActionContext) => unknown | Promise<unknown>>;
+    /** Hints for QA harnesses (routes worth rendering, expected error states…). */
+    qa?: Record<string, unknown>;
+}
+interface RunLogEntry {
+    seq: number;
+    t: number;
+    message: string;
+    data?: unknown;
+}
+declare class Run {
+    readonly id: string;
+    readonly scenario: ScenarioDefinition;
+    readonly seed: string;
+    private readonly sink?;
+    readonly rng: Rng;
+    readonly clock: VirtualClock;
+    readonly state: Store;
+    readonly streams: StreamHub;
+    readonly faults: FaultLayer;
+    readonly routes: CompiledRoute[];
+    readonly wsRoutes: WsRoute[];
+    readonly sseRoutes: SseRoute[];
+    readonly createdWall: number;
+    requests: number;
+    private logEntries;
+    private logSeq;
+    ready: Promise<void>;
+    constructor(id: string, scenario: ScenarioDefinition, seed: string, sink?: ((line: string) => void) | undefined);
+    info(): {
+        id: string;
+        scenario: string;
+        seed: string;
+    };
+    setupContext(): SetupContext;
+    log(message: string, data?: unknown): void;
+    logs(opts?: {
+        since?: number;
+        limit?: number;
+    }): RunLogEntry[];
+    action(name: string, args?: Record<string, unknown>): Promise<unknown>;
+    status(): {
+        run: string;
+        scenario: string;
+        label: string | null;
+        seed: string;
+        createdWall: number;
+        requests: number;
+        clock: {
+            mode: ClockMode;
+            speed: number;
+            now: number;
+            wall: string;
+            pending: {
+                id: number;
+                at: number;
+                label: string;
+            }[];
+        };
+        state: {
+            collections: Record<string, number>;
+            lastSeq: number;
+        };
+        streams: ConnectionSummary[];
+        topics: {
+            topic: string;
+            last: string;
+        }[];
+        faults: FaultSnapshot;
+        routes: {
+            method: Method;
+            path: string;
+            calls: number;
+            name: string | null;
+        }[];
+        streamRoutes: ({
+            kind: string;
+            path: string;
+            protocols: string[];
+        } | {
+            kind: string;
+            path: string;
+            method: "GET" | "POST";
+        })[];
+        actions: string[];
+    };
+    dispose(): void;
+}
+
+interface SimulatorOptions {
+    scenarios: ScenarioDefinition[];
+    defaultScenario?: string;
+    /** Control-plane prefix (default `/__sim`). */
+    controlPath?: string;
+    /** Default run id (default `default`). */
+    defaultRun?: string;
+    /** Add permissive CORS headers (default true — the mock is a dev tool). */
+    cors?: boolean;
+    log?: (line: string) => void;
+}
+/** How an adapter completes a WebSocket upgrade for a matched route. */
+type UpgradeHook = (route: WsRoute, ctx: StreamContext, run: Run, protocol: string | null) => Response | Promise<Response>;
+interface HandleOptions {
+    upgrade?: UpgradeHook;
+}
+declare class Simulator {
+    readonly scenarios: Map<string, ScenarioDefinition>;
+    readonly runs: Map<string, Run>;
+    readonly controlPath: string;
+    readonly defaultRun: string;
+    readonly defaultScenario: string;
+    private readonly cors;
+    private readonly log;
+    constructor(options: SimulatorOptions);
+    private cookie;
+    runIdFor(request: Request, url: URL): string;
+    scenarioNameFor(request: Request, url: URL): string;
+    /** Get or lazily create the run for a request. */
+    runFor(request: Request, url: URL): Promise<Run>;
+    createRun(id: string, scenarioName: string, seed?: string): Run;
+    getRun(id?: string): Run | null;
+    handle(request: Request, options?: HandleOptions): Promise<Response>;
+    private routeContext;
+    streamContext(run: Run, request: Request, url: URL, params: Record<string, string>): StreamContext;
+    private withCors;
+    private control;
+    /** In-process control API — the same operations the HTTP control plane offers. */
+    readonly api: {
+        scenarios: () => {
+            name: string;
+            label: string | null;
+            description: string | null;
+            seed: string;
+            tags: string[];
+            clock: {
+                mode?: ClockMode;
+                speed?: number;
+            };
+            actions: string[];
+            qa: Record<string, unknown> | null;
+        }[];
+        status: (runId?: string) => Promise<{
+            run: string;
+            scenario: null;
+            exists: boolean;
+            defaultScenario: string;
+        } | {
+            run: string;
+            scenario: string;
+            label: string | null;
+            seed: string;
+            createdWall: number;
+            requests: number;
+            clock: {
+                mode: ClockMode;
+                speed: number;
+                now: number;
+                wall: string;
+                pending: {
+                    id: number;
+                    at: number;
+                    label: string;
+                }[];
+            };
+            state: {
+                collections: Record<string, number>;
+                lastSeq: number;
+            };
+            streams: ConnectionSummary[];
+            topics: {
+                topic: string;
+                last: string;
+            }[];
+            faults: FaultSnapshot;
+            routes: {
+                method: Method;
+                path: string;
+                calls: number;
+                name: string | null;
+            }[];
+            streamRoutes: ({
+                kind: string;
+                path: string;
+                protocols: string[];
+            } | {
+                kind: string;
+                path: string;
+                method: "GET" | "POST";
+            })[];
+            actions: string[];
+            exists: boolean;
+            defaultScenario?: undefined;
+        }>;
+        select: (runId: string, scenario: string, seed?: string) => Promise<{
+            run: string;
+            scenario: string;
+            label: string | null;
+            seed: string;
+            createdWall: number;
+            requests: number;
+            clock: {
+                mode: ClockMode;
+                speed: number;
+                now: number;
+                wall: string;
+                pending: {
+                    id: number;
+                    at: number;
+                    label: string;
+                }[];
+            };
+            state: {
+                collections: Record<string, number>;
+                lastSeq: number;
+            };
+            streams: ConnectionSummary[];
+            topics: {
+                topic: string;
+                last: string;
+            }[];
+            faults: FaultSnapshot;
+            routes: {
+                method: Method;
+                path: string;
+                calls: number;
+                name: string | null;
+            }[];
+            streamRoutes: ({
+                kind: string;
+                path: string;
+                protocols: string[];
+            } | {
+                kind: string;
+                path: string;
+                method: "GET" | "POST";
+            })[];
+            actions: string[];
+        }>;
+        reset: (runId: string, seed?: string) => Promise<{
+            run: string;
+            scenario: string;
+            label: string | null;
+            seed: string;
+            createdWall: number;
+            requests: number;
+            clock: {
+                mode: ClockMode;
+                speed: number;
+                now: number;
+                wall: string;
+                pending: {
+                    id: number;
+                    at: number;
+                    label: string;
+                }[];
+            };
+            state: {
+                collections: Record<string, number>;
+                lastSeq: number;
+            };
+            streams: ConnectionSummary[];
+            topics: {
+                topic: string;
+                last: string;
+            }[];
+            faults: FaultSnapshot;
+            routes: {
+                method: Method;
+                path: string;
+                calls: number;
+                name: string | null;
+            }[];
+            streamRoutes: ({
+                kind: string;
+                path: string;
+                protocols: string[];
+            } | {
+                kind: string;
+                path: string;
+                method: "GET" | "POST";
+            })[];
+            actions: string[];
+        }>;
+        step: (runId: string, ms: number) => {
+            pending: {
+                id: number;
+                at: number;
+                label: string;
+            }[];
+            now: number;
+            fired: {
+                id: number;
+                at: number;
+                label: string;
+            }[];
+        };
+        clock: (runId: string, patch: {
+            mode?: "manual" | "realtime";
+            speed?: number;
+        }) => {
+            mode: ClockMode;
+            speed: number;
+            now: number;
+            pending: {
+                id: number;
+                at: number;
+                label: string;
+            }[];
+        };
+        state: (runId: string, collection?: string) => {
+            run: string;
+            collection: string;
+            items: Record_[];
+            counts?: undefined;
+            collections?: undefined;
+        } | {
+            run: string;
+            counts: Record<string, number>;
+            collections: Record<string, Record_[]>;
+            collection?: undefined;
+            items?: undefined;
+        };
+        events: (runId: string, opts: {
+            since?: number;
+            limit?: number;
+            collection?: string;
+        }) => {
+            run: string;
+            last: number;
+            count: number;
+            events: StoreEvent[];
+        };
+        log: (runId: string, opts: {
+            since?: number;
+            limit?: number;
+        }) => {
+            run: string;
+            entries: RunLogEntry[];
+        };
+        streams: (runId: string) => {
+            run: string;
+            connections: ConnectionSummary[];
+            topics: {
+                topic: string;
+                last: string;
+            }[];
+            latencyMs: number;
+        };
+        disconnect: (runId: string, target: {
+            id?: string;
+            topic?: string;
+            path?: string;
+            all?: boolean;
+        }, opts?: {
+            code?: number;
+            reason?: string;
+            drop?: boolean;
+        }) => {
+            closed: string[];
+        };
+        pause: (runId: string, id: string, paused: boolean) => boolean;
+        publish: (runId: string, topic: string, data: Record<string, unknown>) => TopicEvent;
+        overrides: (runId: string) => {
+            run: string;
+            overrides: Override[];
+        };
+        setOverride: (runId: string, input: OverrideInput) => Override;
+        clearOverrides: (runId: string, target?: string, method?: string) => {
+            cleared: boolean;
+        };
+        faults: (runId: string, patch: {
+            latencyMs?: number;
+            jitterMs?: number;
+            failMode?: "off" | "data" | "all";
+            shellPaths?: string[];
+            streamLatencyMs?: number;
+        }) => {
+            streamLatencyMs: number;
+            latencyMs: number;
+            jitterMs: number;
+            failMode: FailMode;
+            shellPaths: string[];
+            overrides: Override[];
+        };
+        action: (runId: string, name: string, args?: Record<string, unknown>) => Promise<unknown>;
+        runs: () => {
+            id: string;
+            scenario: string;
+            seed: string;
+            requests: number;
+            createdWall: number;
+        }[];
+        deleteRun: (runId: string) => boolean;
+    };
+    private require;
+    dispose(): void;
+}
+
+export { Simulator as S, type SimulatorOptions as a, type ScenarioDefinition as b };