@omniaura/scenario-sim 0.1.0

package/dist/scenario--CvzkzX_.d.ts

@@ -0,0 +1,637 @@
+/**
+ * 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;
+}
+/** 2026-01-01T00:00:00Z — the virtual epoch every run starts at. */
+declare const VIRTUAL_EPOCH: number;
+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;
+declare const ws: (path: string, def: Omit<WsRoute, "kind" | "path">) => WsRoute;
+declare const sse: (path: string, onOpen: SseRoute["onOpen"], def?: Omit<SseRoute, "kind" | "path" | "onOpen">) => 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;
+}
+declare function json(body: unknown, init?: ResponseInit & {
+    status?: number;
+}): Response;
+declare function text(body: string, init?: ResponseInit): Response;
+declare function empty(status?: number, init?: ResponseInit): Response;
+/** RFC 9457 problem details, the shape most APIs use for errors. */
+declare function problem(status: number, detail: string, extra?: Record<string, unknown>): Response;
+type MalformedKind = "invalid-json" | "wrong-content-type" | "truncated" | "empty-200" | "html-500" | "schema-drift";
+/** Deliberately broken responses for exercising client validation paths. */
+declare function malformed(kind: MalformedKind, extra?: unknown): Response;
+/**
+ * Cycle through responses call by call: `sequence([ok, fail, ok])` answers
+ * ok, fail, ok, then repeats the last unless `loop` is set. Each entry may be a
+ * Response factory or a handler.
+ */
+declare function sequence(steps: Array<Handler | Response>, opts?: {
+    loop?: boolean;
+}): Handler;
+/** Wrap a handler so it answers after `ms` virtual milliseconds. */
+declare function delayed(ms: number | ((ctx: RouteContext) => number), handler: Handler): Handler;
+declare function compileRoute(route: Route): CompiledRoute;
+declare function statusText(status: number): string;
+/** Route helpers so scenario files read like a table. */
+declare const route: {
+    get: (path: string, handler: Handler, name?: string) => Route;
+    post: (path: string, handler: Handler, name?: string) => Route;
+    put: (path: string, handler: Handler, name?: string) => Route;
+    patch: (path: string, handler: Handler, name?: string) => Route;
+    delete: (path: string, handler: Handler, name?: string) => Route;
+    any: (path: string, handler: Handler, name?: string) => Route;
+};
+/**
+ * A full CRUD resource in one line:
+ *   crud("/api/notes", "notes", { create: (body, ctx) => ({ id: ctx.rng.id("note"), ...body }) })
+ * Emits store events on every mutation, which stream routes can forward.
+ */
+declare function crud<T extends Record<string, unknown> & {
+    id: string;
+}>(path: string, collection: string, opts: {
+    create: (body: Record<string, unknown>, ctx: RouteContext) => T;
+    update?: (current: T, body: Record<string, unknown>, ctx: RouteContext) => T;
+    list?: (items: T[], ctx: RouteContext) => unknown;
+    sort?: (a: T, b: T) => number;
+    validate?: (body: Record<string, unknown>, ctx: RouteContext) => string | null;
+}): Route[];
+
+/**
+ * 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>;
+}
+declare function defineScenario(def: ScenarioDefinition): ScenarioDefinition;
+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;
+}
+
+export { type ActionContext as A, compileRoute as B, type ClockMode as C, crud as D, defineScenario as E, type FaultSnapshot as F, delayed as G, type Handler as H, empty as I, json as J, malformed as K, problem as L, type Method as M, route as N, type Override as O, sequence as P, sse as Q, Run as R, type ScenarioDefinition as S, type TopicEvent as T, statusText as U, VIRTUAL_EPOCH as V, type WsRoute as W, text as X, ws as Y, type StreamContext as a, type ConnectionSummary as b, type Record_ as c, type StoreEvent as d, type RunLogEntry as e, type OverrideInput as f, type FailMode as g, type ClockTimer as h, FaultLayer as i, type MalformedKind as j, Rng as k, type Route as l, type RouteContext as m, type Serializer as n, type SetupContext as o, type SimSocket as p, type SimSseStream as q, type SocketTransport as r, type SseRoute as s, Store as t, type StoreEventKind as u, type StoreListener as v, StreamHub as w, type StreamRoute as x, TopicLog as y, VirtualClock as z };

package/dist/server.d.ts

@@ -0,0 +1,29 @@
+import * as ws from 'ws';
+import { WebSocket } from 'ws';
+import { Server, IncomingMessage, ServerResponse } from 'node:http';
+import { S as Simulator } from './engine-2w32ngB2.js';
+
+declare function toWebRequest(req: IncomingMessage, base: string): Request;
+declare function sendWebResponse(res: ServerResponse, response: Response): Promise<undefined>;
+/**
+ * Wire WebSocket upgrades on an http server to the simulator's ws routes.
+ * Returns the UpgradeHook to pass into `sim.handle(request, { upgrade })`.
+ */
+declare function attachWebSockets(sim: Simulator, server: Server, opts?: {
+    base: () => string;
+    match?: (pathname: string) => boolean;
+}): ws.Server<typeof WebSocket, typeof IncomingMessage>;
+interface ServeOptions {
+    port?: number;
+    host?: string;
+    log?: (line: string) => void;
+}
+declare function serveSimulator(sim: Simulator, options?: ServeOptions): Promise<{
+    server: Server<typeof IncomingMessage, typeof ServerResponse>;
+    port: number;
+    url: string;
+    controlUrl: string;
+    close: () => Promise<void>;
+}>;
+
+export { type ServeOptions, attachWebSockets, sendWebResponse, serveSimulator, toWebRequest };

package/dist/server.js

@@ -0,0 +1,14 @@
+import {
+  attachWebSockets,
+  sendWebResponse,
+  serveSimulator,
+  toWebRequest
+} from "./chunk-7HBAY3QY.js";
+import "./chunk-KU4W4SKO.js";
+export {
+  attachWebSockets,
+  sendWebResponse,
+  serveSimulator,
+  toWebRequest
+};
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}