@omniaura/scenario-sim 0.1.0

package/dist/chunk-KU4W4SKO.js

@@ -0,0 +1,1236 @@
+// src/core/rng.ts
+var Rng = class _Rng {
+  constructor(seed) {
+    this.seed = seed;
+    const h = hashSeed(String(seed));
+    this.a = h[0];
+    this.b = h[1];
+    this.c = h[2];
+    this.d = h[3];
+    for (let i = 0; i < 12; i++) this.next();
+    this.draws = 0;
+  }
+  seed;
+  a;
+  b;
+  c;
+  d;
+  /** Draws so far; useful when asserting determinism across runs. */
+  draws = 0;
+  /** Uniform in [0, 1). */
+  next() {
+    this.draws++;
+    this.a |= 0;
+    this.b |= 0;
+    this.c |= 0;
+    this.d |= 0;
+    const t = (this.a + this.b | 0) + this.d | 0;
+    this.d = this.d + 1 | 0;
+    this.a = this.b ^ this.b >>> 9;
+    this.b = this.c + (this.c << 3) | 0;
+    this.c = this.c << 21 | this.c >>> 11;
+    this.c = this.c + t | 0;
+    return (t >>> 0) / 4294967296;
+  }
+  /** Integer in [min, max] inclusive. */
+  int(min, max) {
+    if (max < min) [min, max] = [max, min];
+    return min + Math.floor(this.next() * (max - min + 1));
+  }
+  float(min = 0, max = 1) {
+    return min + this.next() * (max - min);
+  }
+  chance(probability) {
+    return this.next() < probability;
+  }
+  pick(items) {
+    if (items.length === 0) throw new RangeError("pick() from an empty list");
+    return items[this.int(0, items.length - 1)];
+  }
+  shuffle(items) {
+    const out = [...items];
+    for (let i = out.length - 1; i > 0; i--) {
+      const j = this.int(0, i);
+      [out[i], out[j]] = [out[j], out[i]];
+    }
+    return out;
+  }
+  /** Deterministic opaque id: `<prefix>_<8 base36 chars>`. */
+  id(prefix = "id") {
+    let s = "";
+    while (s.length < 8) s += Math.floor(this.next() * 36 ** 4).toString(36).padStart(4, "0");
+    return `${prefix}_${s.slice(0, 8)}`;
+  }
+  /** RFC-4122-shaped id (version 4 bits set) from the seeded stream. */
+  uuid() {
+    const hex = () => Math.floor(this.next() * 65536).toString(16).padStart(4, "0");
+    const v = hex();
+    return `${hex()}${hex()}-${hex()}-4${hex().slice(1)}-${(parseInt(v[0], 16) & 3 | 8).toString(16)}${v.slice(1)}-${hex()}${hex()}${hex()}`;
+  }
+  /** Fork a child generator with a derived seed (stable across runs). */
+  fork(label) {
+    return new _Rng(`${this.seed}/${label}`);
+  }
+};
+function hashSeed(str) {
+  let h1 = 1779033703, h2 = 3144134277, h3 = 1013904242, h4 = 2773480762;
+  for (let i = 0; i < str.length; i++) {
+    const k = str.charCodeAt(i);
+    h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
+    h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
+    h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
+    h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
+  }
+  h1 = Math.imul(h3 ^ h1 >>> 18, 597399067);
+  h2 = Math.imul(h4 ^ h2 >>> 22, 2869860233);
+  h3 = Math.imul(h1 ^ h3 >>> 17, 951274213);
+  h4 = Math.imul(h2 ^ h4 >>> 19, 2716044179);
+  return [(h1 ^ h2 ^ h3 ^ h4) >>> 0, (h2 ^ h1) >>> 0, (h3 ^ h1) >>> 0, (h4 ^ h1) >>> 0];
+}
+
+// src/core/clock.ts
+var VIRTUAL_EPOCH = Date.UTC(2026, 0, 1);
+var VirtualClock = class {
+  constructor(mode = "realtime", speed = 1, epoch = VIRTUAL_EPOCH) {
+    this.mode = mode;
+    this.speed = speed;
+    this.epoch = epoch;
+  }
+  mode;
+  speed;
+  epoch;
+  entries = /* @__PURE__ */ new Map();
+  nextId = 1;
+  base = 0;
+  startedReal = typeof performance !== "undefined" ? performance.now() : Date.now();
+  manualNow = 0;
+  /** Virtual ms since the run started. */
+  now() {
+    if (this.mode === "manual") return this.manualNow;
+    const real = (typeof performance !== "undefined" ? performance.now() : Date.now()) - this.startedReal;
+    return this.base + real * this.speed;
+  }
+  /** Virtual wall-clock ms (epoch + now). */
+  wall() {
+    return this.epoch + Math.round(this.now());
+  }
+  iso(offsetMs = 0) {
+    return new Date(this.wall() + offsetMs).toISOString();
+  }
+  after(ms, fn, label = "timer") {
+    const id = this.nextId++;
+    const at = this.now() + Math.max(0, ms);
+    const entry = { id, at, label, fn, handle: null };
+    this.entries.set(id, entry);
+    if (this.mode === "realtime") {
+      entry.handle = setTimeout(() => this.fire(entry), Math.max(0, ms) / (this.speed || 1));
+    }
+    return { id, at, label, cancel: () => this.cancel(id) };
+  }
+  /** Promise that resolves after `ms` virtual milliseconds. */
+  sleep(ms, label = "sleep") {
+    return new Promise((resolve) => void this.after(ms, resolve, label));
+  }
+  cancel(id) {
+    const e = this.entries.get(id);
+    if (!e) return;
+    if (e.handle) clearTimeout(e.handle);
+    this.entries.delete(id);
+  }
+  /** Manual mode: advance by `ms`, firing due timers in order. Returns what fired. */
+  step(ms) {
+    if (this.mode !== "manual") throw new Error("step() requires manual clock mode");
+    const target = this.manualNow + Math.max(0, ms);
+    const fired = [];
+    for (; ; ) {
+      let next = null;
+      for (const e of this.entries.values()) if (e.at <= target && (!next || e.at < next.at || e.at === next.at && e.id < next.id)) next = e;
+      if (!next) break;
+      this.manualNow = Math.max(this.manualNow, next.at);
+      fired.push({ id: next.id, at: next.at, label: next.label });
+      this.fire(next);
+    }
+    this.manualNow = target;
+    return { now: this.manualNow, fired };
+  }
+  /** Switch modes; pending timers are re-armed (realtime) or parked (manual). */
+  setMode(mode) {
+    if (mode === this.mode) return;
+    const now = this.now();
+    this.mode = mode;
+    if (mode === "manual") {
+      this.manualNow = now;
+      for (const e of this.entries.values()) {
+        if (e.handle) clearTimeout(e.handle);
+        e.handle = null;
+      }
+    } else {
+      this.base = now;
+      this.startedReal = typeof performance !== "undefined" ? performance.now() : Date.now();
+      for (const e of this.entries.values()) e.handle = setTimeout(() => this.fire(e), Math.max(0, e.at - now) / (this.speed || 1));
+    }
+  }
+  pending() {
+    return [...this.entries.values()].sort((a, b) => a.at - b.at || a.id - b.id).map(({ id, at, label }) => ({ id, at, label }));
+  }
+  clear() {
+    for (const e of this.entries.values()) if (e.handle) clearTimeout(e.handle);
+    this.entries.clear();
+  }
+  fire(e) {
+    if (!this.entries.has(e.id)) return;
+    this.entries.delete(e.id);
+    try {
+      e.fn();
+    } catch (err) {
+      console.warn(`[scenario-sim] timer "${e.label}" threw`, err);
+    }
+  }
+};
+
+// src/core/store.ts
+var Store = class {
+  constructor(now, logLimit = 5e3) {
+    this.now = now;
+    this.logLimit = logLimit;
+  }
+  now;
+  logLimit;
+  collections = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  log = [];
+  seq = 0;
+  collection(name) {
+    let c = this.collections.get(name);
+    if (!c) {
+      c = /* @__PURE__ */ new Map();
+      this.collections.set(name, c);
+    }
+    return c;
+  }
+  collections_() {
+    return [...this.collections.keys()];
+  }
+  insert(collection, record) {
+    const c = this.collection(collection);
+    if (c.has(record.id)) throw new Error(`duplicate id ${record.id} in ${collection}`);
+    c.set(record.id, record);
+    this.emit({ kind: "insert", collection, id: record.id, record });
+    return record;
+  }
+  upsert(collection, record) {
+    const c = this.collection(collection);
+    const previous = c.get(record.id);
+    c.set(record.id, record);
+    this.emit(previous ? { kind: "update", collection, id: record.id, record, previous } : { kind: "insert", collection, id: record.id, record });
+    return record;
+  }
+  get(collection, id) {
+    return this.collections.get(collection)?.get(id);
+  }
+  list(collection, opts = {}) {
+    let out = [...this.collections.get(collection)?.values() ?? []];
+    if (opts.where) out = out.filter(opts.where);
+    if (opts.sort) out.sort(opts.sort);
+    if (opts.offset) out = out.slice(opts.offset);
+    if (opts.limit !== void 0) out = out.slice(0, opts.limit);
+    return out;
+  }
+  count(collection) {
+    return this.collections.get(collection)?.size ?? 0;
+  }
+  update(collection, id, patch) {
+    const c = this.collection(collection);
+    const previous = c.get(id);
+    if (!previous) return void 0;
+    const next = typeof patch === "function" ? patch(previous) : { ...previous, ...patch, id };
+    c.set(id, next);
+    this.emit({ kind: "update", collection, id, record: next, previous });
+    return next;
+  }
+  remove(collection, id) {
+    const c = this.collection(collection);
+    const previous = c.get(id);
+    if (!previous) return void 0;
+    c.delete(id);
+    this.emit({ kind: "remove", collection, id, previous });
+    return previous;
+  }
+  clear(collection) {
+    if (collection) this.collection(collection).clear();
+    else this.collections.clear();
+    this.emit({ kind: "clear", collection: collection ?? "*" });
+  }
+  /** Application-level event (not tied to a record), e.g. "job.progress". */
+  custom(collection, name, data, id) {
+    this.emit({ kind: "custom", collection, name, data, id });
+  }
+  on(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  events(opts = {}) {
+    const out = this.log.filter((e) => e.seq > (opts.since ?? 0) && (!opts.collection || e.collection === opts.collection));
+    const limit = opts.limit ?? 200;
+    return out.length > limit ? out.slice(out.length - limit) : out;
+  }
+  get lastSeq() {
+    return this.seq;
+  }
+  snapshot() {
+    const out = {};
+    for (const [name, c] of this.collections) out[name] = [...c.values()];
+    return out;
+  }
+  counts() {
+    const out = {};
+    for (const [name, c] of this.collections) out[name] = c.size;
+    return out;
+  }
+  emit(partial) {
+    const event = { seq: ++this.seq, t: this.now(), ...partial };
+    this.log.push(event);
+    if (this.log.length > this.logLimit) this.log.splice(0, this.log.length - this.logLimit);
+    for (const l of this.listeners) {
+      try {
+        l(event);
+      } catch (err) {
+        console.warn("[scenario-sim] store listener threw", err);
+      }
+    }
+  }
+};
+
+// src/core/streams.ts
+var TopicLog = class {
+  constructor(now, retain = 500) {
+    this.now = now;
+    this.retain = retain;
+  }
+  now;
+  retain;
+  seqs = /* @__PURE__ */ new Map();
+  logs = /* @__PURE__ */ new Map();
+  publish(topic, data) {
+    const seq = (this.seqs.get(topic) ?? 0) + 1;
+    this.seqs.set(topic, seq);
+    const event = { topic, eventID: String(seq), t: this.now(), data };
+    const log = this.logs.get(topic) ?? [];
+    log.push(event);
+    if (log.length > this.retain) log.splice(0, log.length - this.retain);
+    this.logs.set(topic, log);
+    return event;
+  }
+  last(topic) {
+    return String(this.seqs.get(topic) ?? 0);
+  }
+  /**
+   * 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, since) {
+    if (since === null || since === void 0 || since === "") return { events: [], missed: false };
+    const s = Number(since);
+    const log = this.logs.get(topic) ?? [];
+    const oldest = log[0] ? Number(log[0].eventID) : (this.seqs.get(topic) ?? 0) + 1;
+    const missed = s > 0 && s < oldest - 1;
+    return { events: log.filter((e) => Number(e.eventID) > s), missed };
+  }
+  topics() {
+    return [...this.seqs.keys()];
+  }
+  clear() {
+    this.seqs.clear();
+    this.logs.clear();
+  }
+};
+var defaultSerializer = (e) => JSON.stringify({ ...e.data, topic: e.topic, eventID: e.eventID });
+var StreamHub = class {
+  constructor(clock, log) {
+    this.clock = clock;
+    this.log = log;
+    this.topics = new TopicLog(() => clock.now());
+  }
+  clock;
+  log;
+  topics;
+  connections = /* @__PURE__ */ new Map();
+  nextId = 1;
+  /** Extra virtual latency applied to every outgoing stream message. */
+  latencyMs = 0;
+  /** Publish to a topic: appended to the replay log and fanned out to subscribers. */
+  publish(topic, data) {
+    const event = this.topics.publish(topic, data);
+    for (const conn of this.connections.values()) {
+      const sub = conn.subscriptions.get(topic);
+      if (!sub) continue;
+      if (conn.kind === "ws") this.deliver(conn, sub.serialize(event));
+      else this.deliverSse(conn, event, sub.serialize);
+    }
+    return event;
+  }
+  deliver(conn, payload) {
+    if (conn.readyState !== "open") return;
+    const doSend = () => {
+      if (conn.readyState !== "open") return;
+      if (conn.paused) {
+        conn.meta.__queued?.push(payload) ?? (conn.meta.__queued = [payload]);
+        return;
+      }
+      conn.send(payload);
+    };
+    if (this.latencyMs > 0) this.clock.after(this.latencyMs, doSend, `ws latency ${conn.id}`);
+    else doSend();
+  }
+  deliverSse(conn, event, eventName) {
+    const doSend = () => conn.send(event.data, { event: eventName(event), id: event.eventID });
+    if (this.latencyMs > 0) this.clock.after(this.latencyMs, doSend, `sse latency ${conn.id}`);
+    else doSend();
+  }
+  /** Called by a transport adapter once the WebSocket handshake completed. */
+  openSocket(route, ctx, transport, protocol) {
+    const id = `ws_${this.nextId++}`;
+    const closeCbs = [];
+    const hub = this;
+    const socket = {
+      id,
+      kind: "ws",
+      path: route.path,
+      url: ctx.url,
+      openedAt: this.clock.now(),
+      sent: 0,
+      received: 0,
+      paused: false,
+      subscriptions: /* @__PURE__ */ new Map(),
+      meta: {},
+      protocol,
+      readyState: "open",
+      send(data) {
+        if (socket.readyState !== "open") return;
+        socket.sent++;
+        transport.send(typeof data === "string" || data instanceof ArrayBuffer ? data : JSON.stringify(data));
+      },
+      close(code = 1e3, reason = "") {
+        if (socket.readyState !== "open") return;
+        socket.readyState = "closed";
+        transport.close(code, reason);
+        hub.finish(socket, code, reason, closeCbs);
+      },
+      drop() {
+        if (socket.readyState !== "open") return;
+        socket.readyState = "closed";
+        transport.drop();
+        hub.finish(socket, 1006, "dropped", closeCbs);
+      },
+      subscribe(topic, opts = {}) {
+        const serialize = opts.serialize ?? defaultSerializer;
+        socket.subscriptions.set(topic, { topic, serialize });
+        const { events, missed } = hub.topics.replay(topic, opts.since);
+        for (const e of events) hub.deliver(socket, serialize(e));
+        return { replayed: events.length, missed, last: hub.topics.last(topic) };
+      },
+      unsubscribe(topic) {
+        socket.subscriptions.delete(topic);
+      },
+      onClose(cb) {
+        closeCbs.push(cb);
+      }
+    };
+    this.connections.set(id, socket);
+    this.log(`ws open ${id} ${route.path}`, { protocol });
+    void Promise.resolve(route.onOpen?.(ctx, socket)).catch((err) => this.log(`ws onOpen threw ${id}`, String(err)));
+    return socket;
+  }
+  /** Transport → hub: a client frame arrived. */
+  receive(route, ctx, socket, data) {
+    if (socket.readyState !== "open") return;
+    socket.received++;
+    void Promise.resolve(route.onMessage?.(ctx, socket, data)).catch((err) => this.log(`ws onMessage threw ${socket.id}`, String(err)));
+  }
+  /** Transport → hub: the client closed. */
+  clientClosed(route, ctx, socket, code, reason) {
+    if (socket.readyState !== "open") return;
+    socket.readyState = "closed";
+    this.connections.delete(socket.id);
+    this.log(`ws closed by client ${socket.id}`, { code, reason });
+    route.onClose?.(ctx, socket, code, reason);
+  }
+  finish(conn, code, reason, cbs) {
+    this.connections.delete(conn.id);
+    this.log(`ws closed ${conn.id}`, { code, reason });
+    for (const cb of cbs) cb(code, reason);
+  }
+  /** Build the SSE Response for a route; the adapter just returns it. */
+  openSse(route, ctx) {
+    const id = `sse_${this.nextId++}`;
+    const encoder = new TextEncoder();
+    let controller = null;
+    let closed = false;
+    const closeCbs = [];
+    const hub = this;
+    const lastEventId = ctx.request.headers.get("last-event-id") ?? ctx.query.get("lastEventId") ?? ctx.query.get("sinceEventID");
+    let keepalive = null;
+    const teardown = () => {
+      if (closed) return;
+      closed = true;
+      keepalive?.cancel();
+      hub.connections.delete(id);
+      hub.log(`sse closed ${id}`);
+      for (const cb of closeCbs) cb();
+    };
+    const write = (chunk) => {
+      if (closed || !controller) return;
+      try {
+        controller.enqueue(encoder.encode(chunk));
+      } catch {
+        teardown();
+      }
+    };
+    const body = new ReadableStream({
+      start(c) {
+        controller = c;
+      },
+      cancel() {
+        teardown();
+      }
+    });
+    const stream = {
+      id,
+      kind: "sse",
+      path: route.path,
+      url: ctx.url,
+      openedAt: this.clock.now(),
+      sent: 0,
+      received: 0,
+      paused: false,
+      subscriptions: /* @__PURE__ */ new Map(),
+      meta: {},
+      lastEventId,
+      send(data, opts = {}) {
+        if (closed) return;
+        const payload = typeof data === "string" ? data : JSON.stringify(data);
+        const frame = [
+          opts.event ? `event: ${opts.event}` : null,
+          opts.id !== void 0 ? `id: ${opts.id}` : null,
+          opts.retry !== void 0 ? `retry: ${opts.retry}` : null,
+          ...payload.split("\n").map((line) => `data: ${line}`)
+        ].filter((l) => l !== null).join("\n");
+        if (stream.paused) {
+          stream.meta.__queued?.push(frame + "\n\n") ?? (stream.meta.__queued = [frame + "\n\n"]);
+          return;
+        }
+        stream.sent++;
+        write(frame + "\n\n");
+      },
+      comment(text) {
+        write(`: ${text}
+
+`);
+      },
+      close() {
+        if (closed) return;
+        try {
+          controller?.close();
+        } catch {
+        }
+        teardown();
+      },
+      drop() {
+        if (closed) return;
+        try {
+          controller?.error(new Error("connection dropped"));
+        } catch {
+        }
+        teardown();
+      },
+      subscribe(topic, opts = {}) {
+        const eventName = opts.event ?? ((e) => String(e.data.type ?? "message"));
+        stream.subscriptions.set(topic, { topic, serialize: eventName });
+        const { events, missed } = hub.topics.replay(topic, opts.since ?? lastEventId);
+        for (const e of events) stream.send(e.data, { event: eventName(e), id: e.eventID });
+        return { replayed: events.length, missed, last: hub.topics.last(topic) };
+      },
+      unsubscribe(topic) {
+        stream.subscriptions.delete(topic);
+      },
+      onClose(cb) {
+        closeCbs.push(cb);
+      },
+      response: new Response(body, { status: 200, headers: { "content-type": "text/event-stream", "cache-control": "no-store", connection: "keep-alive", "x-accel-buffering": "no" } })
+    };
+    this.connections.set(id, stream);
+    this.log(`sse open ${id} ${route.path}`, { lastEventId });
+    write(`: scenario-sim ${id}
+
+`);
+    const ka = route.keepaliveMs ?? 15e3;
+    if (ka > 0) {
+      const tick = () => {
+        if (closed) return;
+        write(":keepalive\n\n");
+        keepalive = hub.clock.after(ka, tick, `sse keepalive ${id}`);
+      };
+      keepalive = hub.clock.after(ka, tick, `sse keepalive ${id}`);
+    }
+    void Promise.resolve(route.onOpen(ctx, stream)).catch((err) => hub.log(`sse onOpen threw ${id}`, String(err)));
+    return stream;
+  }
+  // ── control plane ────────────────────────────────────────────────
+  list() {
+    return [...this.connections.values()].map((c) => ({
+      id: c.id,
+      kind: c.kind,
+      path: c.path,
+      openedAt: c.openedAt,
+      sent: c.sent,
+      received: c.received,
+      paused: c.paused,
+      topics: [...c.subscriptions.keys()],
+      ...c.kind === "ws" ? { protocol: c.protocol } : {},
+      meta: Object.fromEntries(Object.entries(c.meta).filter(([k]) => !k.startsWith("__")))
+    }));
+  }
+  get(id) {
+    return this.connections.get(id) ?? 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, opts = {}) {
+    const hit = [];
+    for (const c of [...this.connections.values()]) {
+      const matches = target.all || target.id && c.id === target.id || target.topic && c.subscriptions.has(target.topic) || target.path && c.path === target.path;
+      if (!matches) continue;
+      hit.push(c.id);
+      if (opts.drop) c.drop();
+      else if (c.kind === "ws") c.close(opts.code ?? 1001, opts.reason ?? "disconnected by scenario control");
+      else c.close();
+    }
+    return hit;
+  }
+  /** Pause delivery on a connection (messages queue); resume flushes them in order. */
+  pause(id, paused) {
+    const c = this.connections.get(id);
+    if (!c) return false;
+    c.paused = paused;
+    if (!paused) {
+      const queued = c.meta.__queued ?? [];
+      c.meta.__queued = [];
+      for (const payload of queued) {
+        if (c.kind === "ws") c.send(payload);
+        else {
+          c.sent++;
+          c.__raw?.(payload);
+        }
+      }
+    }
+    return true;
+  }
+  closeAll() {
+    for (const c of [...this.connections.values()]) c.close();
+    this.connections.clear();
+  }
+};
+
+// src/core/router.ts
+var JSON_HEADERS = { "content-type": "application/json", "cache-control": "no-store" };
+function json(body, init = {}) {
+  return new Response(body === void 0 ? null : JSON.stringify(body), { ...init, status: init.status ?? 200, headers: { ...JSON_HEADERS, ...init.headers } });
+}
+function problem(status, detail, extra = {}) {
+  return json({ type: "about:blank", title: statusText(status), status, detail, ...extra }, { status, headers: { "content-type": "application/problem+json" } });
+}
+function malformed(kind, extra) {
+  switch (kind) {
+    case "invalid-json":
+      return new Response('{"items": [1, 2,', { status: 200, headers: JSON_HEADERS });
+    case "wrong-content-type":
+      return new Response(JSON.stringify(extra ?? { ok: true }), { status: 200, headers: { "content-type": "text/html" } });
+    case "truncated":
+      return new Response(JSON.stringify(extra ?? { items: [{ id: "a" }] }).slice(0, -6), { status: 200, headers: JSON_HEADERS });
+    case "empty-200":
+      return new Response("", { status: 200, headers: JSON_HEADERS });
+    case "html-500":
+      return new Response("<html><body><h1>502 Bad Gateway</h1></body></html>", { status: 502, headers: { "content-type": "text/html" } });
+    case "schema-drift":
+      return json(extra ?? { data: { items: "not-an-array" }, meta: null });
+  }
+}
+function compileRoute(route) {
+  const keys = [];
+  const pattern = route.path.split("/").map((seg) => {
+    if (seg === "*") return "(?:.*)";
+    if (seg.startsWith(":")) {
+      keys.push(seg.slice(1));
+      return "([^/]+)";
+    }
+    return seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }).join("/");
+  const re = new RegExp(`^${pattern}/?$`);
+  return {
+    ...route,
+    calls: 0,
+    match(pathname) {
+      const m = re.exec(pathname);
+      if (!m) return null;
+      const params = {};
+      keys.forEach((k, i) => params[k] = decodeURIComponent(m[i + 1] ?? ""));
+      return params;
+    }
+  };
+}
+function statusText(status) {
+  return {
+    400: "Bad Request",
+    401: "Unauthorized",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    409: "Conflict",
+    422: "Unprocessable Content",
+    429: "Too Many Requests",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout"
+  }[status] ?? "Error";
+}
+
+// src/core/faults.ts
+var FaultLayer = class {
+  constructor(rng) {
+    this.rng = rng;
+  }
+  rng;
+  latencyMs = 0;
+  jitterMs = 0;
+  failMode = "off";
+  /** Paths the `data` fail mode leaves alone so the app shell still boots. */
+  shellPaths = /* @__PURE__ */ new Set();
+  overrides = [];
+  nextId = 1;
+  configure(patch) {
+    if (patch.latencyMs !== void 0) this.latencyMs = Math.max(0, patch.latencyMs);
+    if (patch.jitterMs !== void 0) this.jitterMs = Math.max(0, patch.jitterMs);
+    if (patch.failMode !== void 0) this.failMode = patch.failMode;
+    if (patch.shellPaths !== void 0) this.shellPaths = new Set(patch.shellPaths);
+  }
+  /** Effective delay for one request (seeded jitter keeps it reproducible). */
+  delayFor(extra = 0) {
+    const jitter = this.jitterMs > 0 ? this.rng.int(0, this.jitterMs) : 0;
+    return this.latencyMs + jitter + extra;
+  }
+  setOverride(input) {
+    const key = matcherKey(input.matcher, input.method);
+    this.overrides = this.overrides.filter((o2) => matcherKey(o2.matcher, o2.method) !== key);
+    const o = { ...input, id: `ov_${this.nextId++}`, remaining: input.times ?? Infinity, hits: 0 };
+    this.overrides.unshift(o);
+    return o;
+  }
+  clearOverride(target, method) {
+    const before = this.overrides.length;
+    this.overrides = this.overrides.filter((o) => o.id !== target && matcherKey(o.matcher, o.method) !== matcherKey(target, method));
+    return this.overrides.length !== before;
+  }
+  clearOverrides() {
+    this.overrides = [];
+  }
+  listOverrides() {
+    return this.overrides.map((o) => ({ ...o }));
+  }
+  /** Find (and consume) the first matching override. */
+  matchOverride(path, method) {
+    for (const o of this.overrides) {
+      if (o.method && o.method.toUpperCase() !== method.toUpperCase()) continue;
+      const hit = typeof o.matcher === "string" ? path.includes(o.matcher) : new RegExp(o.matcher.regex, o.matcher.flags).test(path);
+      if (!hit) continue;
+      o.hits++;
+      o.remaining--;
+      if (o.remaining <= 0) this.overrides = this.overrides.filter((x) => x !== o);
+      return o;
+    }
+    return null;
+  }
+  /** Build the response an override dictates. */
+  overrideResponse(o) {
+    if (o.malformed) return malformed(o.malformed, o.body);
+    const status = o.status ?? 500;
+    if (status === 204 || o.body === void 0 && status >= 200 && status < 300) return new Response(null, { status });
+    if (o.body === void 0) return problem(status, `forced by override ${o.id}`);
+    return json(o.body, { status });
+  }
+  /** Fail-mode response, or null when the request should proceed. */
+  failResponse(path) {
+    if (this.failMode === "off") return null;
+    if (this.failMode === "data" && this.shellPaths.has(path)) return null;
+    return problem(503, `scenario fail mode "${this.failMode}"`);
+  }
+  snapshot() {
+    return { latencyMs: this.latencyMs, jitterMs: this.jitterMs, failMode: this.failMode, shellPaths: [...this.shellPaths], overrides: this.listOverrides() };
+  }
+};
+function matcherKey(matcher, method) {
+  const m = typeof matcher === "string" ? `str:${matcher}` : `re:${matcher.regex}:${matcher.flags ?? ""}`;
+  return `${(method ?? "*").toUpperCase()} ${m}`;
+}
+
+// src/core/scenario.ts
+var Run = class {
+  constructor(id, scenario, seed, sink) {
+    this.id = id;
+    this.scenario = scenario;
+    this.seed = seed;
+    this.sink = sink;
+    this.rng = new Rng(seed);
+    this.clock = new VirtualClock(scenario.clock?.mode ?? "realtime", scenario.clock?.speed ?? 1);
+    this.state = new Store(() => this.clock.now());
+    this.streams = new StreamHub(this.clock, (m, d) => this.log(m, d));
+    this.faults = new FaultLayer(this.rng.fork("faults"));
+    if (scenario.faults) this.faults.configure(scenario.faults);
+    this.routes = (scenario.routes ?? []).map(compileRoute);
+    this.wsRoutes = (scenario.streams ?? []).filter((s) => s.kind === "ws");
+    this.sseRoutes = (scenario.streams ?? []).filter((s) => s.kind === "sse");
+    this.ready = Promise.resolve(scenario.setup?.(this.setupContext())).then(() => this.log(`run ready (${scenario.name}, seed ${seed})`));
+  }
+  id;
+  scenario;
+  seed;
+  sink;
+  rng;
+  clock;
+  state;
+  streams;
+  faults;
+  routes;
+  wsRoutes;
+  sseRoutes;
+  createdWall = Date.now();
+  requests = 0;
+  logEntries = [];
+  logSeq = 0;
+  ready;
+  info() {
+    return { id: this.id, scenario: this.scenario.name, seed: this.seed };
+  }
+  setupContext() {
+    return { state: this.state, rng: this.rng, clock: this.clock, streams: this.streams, run: this.info(), log: (m, d) => this.log(m, d) };
+  }
+  log(message, data) {
+    const entry = { seq: ++this.logSeq, t: Math.round(this.clock.now()), message, ...data !== void 0 ? { data } : {} };
+    this.logEntries.push(entry);
+    if (this.logEntries.length > 2e3) this.logEntries.splice(0, this.logEntries.length - 2e3);
+    this.sink?.(`[sim ${this.id}] ${message}`);
+  }
+  logs(opts = {}) {
+    const out = this.logEntries.filter((e) => e.seq > (opts.since ?? 0));
+    const limit = opts.limit ?? 200;
+    return out.length > limit ? out.slice(out.length - limit) : out;
+  }
+  async action(name, args = {}) {
+    const fn = this.scenario.actions?.[name];
+    if (!fn) throw new Error(`unknown action "${name}" (available: ${Object.keys(this.scenario.actions ?? {}).join(", ") || "none"})`);
+    this.log(`action ${name}`, args);
+    return fn({ ...this.setupContext(), args });
+  }
+  status() {
+    return {
+      run: this.id,
+      scenario: this.scenario.name,
+      label: this.scenario.label ?? null,
+      seed: this.seed,
+      createdWall: this.createdWall,
+      requests: this.requests,
+      clock: { mode: this.clock.mode, speed: this.clock.speed, now: Math.round(this.clock.now()), wall: this.clock.iso(), pending: this.clock.pending() },
+      state: { collections: this.state.counts(), lastSeq: this.state.lastSeq },
+      streams: this.streams.list(),
+      topics: this.streams.topics.topics().map((t) => ({ topic: t, last: this.streams.topics.last(t) })),
+      faults: this.faults.snapshot(),
+      routes: this.routes.map((r) => ({ method: r.method, path: r.path, calls: r.calls, name: r.name ?? null })),
+      streamRoutes: [...this.wsRoutes.map((r) => ({ kind: "ws", path: r.path, protocols: r.protocols ?? [] })), ...this.sseRoutes.map((r) => ({ kind: "sse", path: r.path, method: r.method ?? "GET" }))],
+      actions: Object.keys(this.scenario.actions ?? {})
+    };
+  }
+  dispose() {
+    this.streams.closeAll();
+    this.clock.clear();
+    this.log("run disposed");
+  }
+};
+
+// src/core/engine.ts
+var UPGRADED_HEADER = "x-sim-upgraded";
+var upgradedResponse = () => new Response(null, { status: 200, headers: { [UPGRADED_HEADER]: "1" } });
+var isUpgraded = (response) => response.headers.get(UPGRADED_HEADER) === "1";
+var Simulator = class {
+  scenarios = /* @__PURE__ */ new Map();
+  runs = /* @__PURE__ */ new Map();
+  controlPath;
+  defaultRun;
+  defaultScenario;
+  cors;
+  log;
+  constructor(options) {
+    if (options.scenarios.length === 0) throw new Error("at least one scenario is required");
+    for (const s of options.scenarios) {
+      if (this.scenarios.has(s.name)) throw new Error(`duplicate scenario ${s.name}`);
+      this.scenarios.set(s.name, s);
+    }
+    this.defaultScenario = options.defaultScenario ?? options.scenarios[0].name;
+    if (!this.scenarios.has(this.defaultScenario)) throw new Error(`unknown default scenario ${this.defaultScenario}`);
+    this.controlPath = (options.controlPath ?? "/__sim").replace(/\/$/, "");
+    this.defaultRun = options.defaultRun ?? "default";
+    this.cors = options.cors ?? true;
+    this.log = options.log ?? (() => {
+    });
+  }
+  // ── runs ─────────────────────────────────────────────────────────
+  cookie(request, name) {
+    const header = request.headers.get("cookie") ?? "";
+    for (const part of header.split(";")) {
+      const [k, ...rest] = part.trim().split("=");
+      if (k === name) return decodeURIComponent(rest.join("="));
+    }
+    return null;
+  }
+  runIdFor(request, url) {
+    return request.headers.get("x-sim-run") ?? this.cookie(request, "sim_run") ?? url.searchParams.get("__run") ?? this.defaultRun;
+  }
+  scenarioNameFor(request, url) {
+    return request.headers.get("x-sim-scenario") ?? this.cookie(request, "sim_scenario") ?? url.searchParams.get("__scenario") ?? url.searchParams.get("scenario") ?? this.defaultScenario;
+  }
+  /** Get or lazily create the run for a request. */
+  async runFor(request, url) {
+    const id = this.runIdFor(request, url);
+    let run = this.runs.get(id);
+    if (!run) {
+      const name = this.scenarioNameFor(request, url);
+      run = this.createRun(id, name);
+    }
+    await run.ready;
+    return run;
+  }
+  createRun(id, scenarioName, seed) {
+    const scenario = this.scenarios.get(scenarioName);
+    if (!scenario) throw new Error(`unknown scenario "${scenarioName}" (available: ${[...this.scenarios.keys()].join(", ")})`);
+    this.runs.get(id)?.dispose();
+    const run = new Run(id, scenario, seed ?? scenario.seed ?? scenario.name, this.log);
+    this.runs.set(id, run);
+    return run;
+  }
+  getRun(id = this.defaultRun) {
+    return this.runs.get(id) ?? null;
+  }
+  // ── request handling ─────────────────────────────────────────────
+  async handle(request, options = {}) {
+    const url = new URL(request.url);
+    try {
+      if (request.method === "OPTIONS" && this.cors) return this.withCors(request, new Response(null, { status: 204 }));
+      if (url.pathname === this.controlPath || url.pathname.startsWith(`${this.controlPath}/`)) {
+        return this.withCors(request, await this.control(request, url));
+      }
+      const run = await this.runFor(request, url);
+      run.requests++;
+      const path = url.pathname;
+      const method = request.method.toUpperCase();
+      const latencyHeader = request.headers.get("x-sim-latency");
+      const failHeader = request.headers.get("x-sim-fail");
+      const extraLatency = latencyHeader !== null && latencyHeader !== "" && Number.isFinite(Number(latencyHeader)) ? Math.max(0, Number(latencyHeader)) : 0;
+      const failOverride = failHeader === "off" || failHeader === "data" || failHeader === "all" ? failHeader : null;
+      const failResponse = (p) => {
+        if (failOverride === null) return run.faults.failResponse(p);
+        if (failOverride === "off") return null;
+        if (failOverride === "data" && run.faults.shellPaths.has(p)) return null;
+        return problem(503, `scenario fail mode "${failOverride}" (X-Sim-Fail)`);
+      };
+      const override = run.faults.matchOverride(path, method);
+      if (override) {
+        run.log(`${method} ${path} \u2192 override ${override.id}`, { status: override.status ?? null, malformed: override.malformed ?? null });
+        await run.clock.sleep(run.faults.delayFor(override.delayMs ?? 0), `override ${override.id}`);
+        return this.withCors(request, run.faults.overrideResponse(override));
+      }
+      const upgradeHeader = request.headers.get("upgrade") ?? request.headers.get("x-sim-upgrade");
+      if (upgradeHeader?.toLowerCase() === "websocket") {
+        for (const route of run.wsRoutes) {
+          const params = matchPath(route.path, path);
+          if (!params) continue;
+          if (!options.upgrade) return this.withCors(request, problem(426, "WebSocket upgrade requires a transport adapter"));
+          const requested = (request.headers.get("sec-websocket-protocol") ?? request.headers.get("x-sim-websocket-protocol") ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+          const protocol = route.protocols?.find((p) => requested.includes(p)) ?? null;
+          if (route.protocols?.length && requested.length && !protocol) return this.withCors(request, problem(400, `unsupported subprotocol (server offers ${route.protocols.join(", ")})`));
+          const failed2 = failResponse(path);
+          if (failed2) return this.withCors(request, failed2);
+          return options.upgrade(route, this.streamContext(run, request, url, params), run, protocol);
+        }
+        return this.withCors(request, problem(404, `no WebSocket route matches ${path}`));
+      }
+      const failed = failResponse(path);
+      if (failed) {
+        run.log(`${method} ${path} \u2192 fail mode ${failOverride ?? run.faults.failMode}`);
+        await run.clock.sleep(run.faults.delayFor(extraLatency), "fail-mode latency");
+        return this.withCors(request, failed);
+      }
+      for (const route of run.sseRoutes) {
+        if ((route.method ?? "GET") !== method) continue;
+        const params = matchPath(route.path, path);
+        if (!params) continue;
+        await run.clock.sleep(run.faults.delayFor(extraLatency), "sse open latency");
+        const stream = run.streams.openSse(route, this.streamContext(run, request, url, params));
+        return this.withCors(request, stream.response);
+      }
+      for (const route of run.routes) {
+        if (route.method !== "*" && route.method !== method) continue;
+        const params = route.match(path);
+        if (!params) continue;
+        route.calls++;
+        const ctx = this.routeContext(run, request, url, params, route.calls);
+        const started = run.clock.now();
+        await run.clock.sleep(run.faults.delayFor(extraLatency), `latency ${method} ${path}`);
+        const response = await route.handler(ctx);
+        run.log(`${method} ${path} \u2192 ${response.status}`, { route: route.name ?? route.path, ms: Math.round(run.clock.now() - started) });
+        return this.withCors(request, response);
+      }
+      run.log(`${method} ${path} \u2192 404 (no route)`);
+      return this.withCors(request, problem(404, `scenario "${run.scenario.name}" has no route for ${method} ${path}`, { hint: `${this.controlPath}/status lists routes; set an override to force an answer` }));
+    } catch (err) {
+      this.log(`[sim] error handling ${request.method} ${url.pathname}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
+      return this.withCors(request, problem(500, `simulator error: ${err instanceof Error ? err.message : String(err)}`));
+    }
+  }
+  routeContext(run, request, url, params, calls) {
+    let parsed = null;
+    return {
+      request,
+      url,
+      method: request.method.toUpperCase(),
+      params,
+      query: url.searchParams,
+      body: () => {
+        parsed ??= request.clone().text().then((t) => t ? JSON.parse(t) : {}).catch(() => ({}));
+        return parsed;
+      },
+      state: run.state,
+      rng: run.rng,
+      clock: run.clock,
+      streams: run.streams,
+      run: run.info(),
+      calls,
+      log: (m, d) => run.log(m, d)
+    };
+  }
+  streamContext(run, request, url, params) {
+    return { request, url, params, query: url.searchParams, state: run.state, rng: run.rng, clock: run.clock, streams: run.streams, run: run.info(), log: (m, d) => run.log(m, d) };
+  }
+  withCors(request, response) {
+    if (!this.cors) return response;
+    const origin = request.headers.get("origin");
+    if (!origin) return response;
+    const headers = new Headers(response.headers);
+    headers.set("access-control-allow-origin", origin);
+    headers.set("access-control-allow-credentials", "true");
+    headers.set("access-control-allow-methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS");
+    headers.set("access-control-allow-headers", request.headers.get("access-control-request-headers") ?? "*");
+    headers.set("access-control-expose-headers", "*");
+    headers.set("vary", "origin");
+    return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+  }
+  // ── control plane ────────────────────────────────────────────────
+  async control(request, url) {
+    const route = url.pathname.slice(this.controlPath.length).replace(/\/$/, "") || "/";
+    const method = request.method.toUpperCase();
+    const body = method === "GET" || method === "DELETE" ? {} : await request.clone().text().then((t) => t ? JSON.parse(t) : {}).catch(() => ({}));
+    const runId = String(body.run ?? url.searchParams.get("run") ?? request.headers.get("x-sim-run") ?? this.cookie(request, "sim_run") ?? this.defaultRun);
+    const api = this.api;
+    const q = (k) => url.searchParams.get(k);
+    const num = (v, d) => v === void 0 || v === null || v === "" ? d : Number(v);
+    switch (`${method} ${route}`) {
+      case "GET /":
+        return json({ tool: "@omniaura/scenario-sim", controlPath: this.controlPath, defaultRun: this.defaultRun, defaultScenario: this.defaultScenario, runs: [...this.runs.keys()] });
+      case "GET /scenarios":
+        return json({ default: this.defaultScenario, scenarios: api.scenarios() });
+      case "GET /status":
+        return json(await api.status(runId));
+      case "POST /select": {
+        const b = body;
+        if (!b.scenario) return problem(400, "scenario is required");
+        return json(await api.select(runId, b.scenario, b.seed), { headers: { "set-cookie": `sim_scenario=${encodeURIComponent(b.scenario)}; Path=/; SameSite=Lax` } });
+      }
+      case "POST /reset":
+        return json(await api.reset(runId, body.seed));
+      case "POST /step":
+        return json(api.step(runId, num(body.ms ?? q("ms"), 1e3)));
+      case "POST /clock":
+        return json(api.clock(runId, body));
+      case "GET /state":
+        return json(api.state(runId, q("collection") ?? void 0));
+      case "GET /events":
+        return json(api.events(runId, { since: num(q("since"), 0), limit: num(q("limit"), 200), collection: q("collection") ?? void 0 }));
+      case "GET /log":
+        return json(api.log(runId, { since: num(q("since"), 0), limit: num(q("limit"), 200) }));
+      case "GET /streams":
+        return json(api.streams(runId));
+      case "POST /streams/disconnect": {
+        const b = body;
+        return json(api.disconnect(runId, b, b));
+      }
+      case "POST /streams/pause": {
+        const b = body;
+        if (!b.id) return problem(400, "id is required");
+        return json({ ok: api.pause(runId, b.id, b.paused ?? true) });
+      }
+      case "POST /publish": {
+        const b = body;
+        if (!b.topic) return problem(400, "topic is required");
+        return json(api.publish(runId, b.topic, b.data ?? {}));
+      }
+      case "GET /overrides":
+        return json(api.overrides(runId));
+      case "POST /overrides": {
+        const b = body;
+        if (!b.matcher) return problem(400, "matcher is required");
+        return json(api.setOverride(runId, b));
+      }
+      case "DELETE /overrides": {
+        const matcher = q("matcher");
+        const id = q("id");
+        return json(api.clearOverrides(runId, id ?? matcher ?? void 0, q("method") ?? void 0));
+      }
+      case "POST /faults":
+        return json(api.faults(runId, body));
+      case "POST /action": {
+        const b = body;
+        if (!b.name) return problem(400, "name is required");
+        return json({ result: await api.action(runId, b.name, b.args ?? {}) });
+      }
+      case "GET /runs":
+        return json(api.runs());
+      case "DELETE /runs":
+        return json({ deleted: api.deleteRun(runId) });
+      default:
+        return problem(404, `unknown control route ${method} ${route}`);
+    }
+  }
+  /** In-process control API — the same operations the HTTP control plane offers. */
+  api = {
+    scenarios: () => [...this.scenarios.values()].map((s) => ({ name: s.name, label: s.label ?? null, description: s.description ?? null, seed: s.seed ?? s.name, tags: s.tags ?? [], clock: s.clock ?? { mode: "realtime" }, actions: Object.keys(s.actions ?? {}), qa: s.qa ?? null })),
+    status: async (runId = this.defaultRun) => {
+      const run = this.runs.get(runId);
+      if (!run) return { run: runId, scenario: null, exists: false, defaultScenario: this.defaultScenario };
+      await run.ready;
+      return { exists: true, ...run.status() };
+    },
+    select: async (runId, scenario, seed) => {
+      const run = this.createRun(runId, scenario, seed);
+      await run.ready;
+      return run.status();
+    },
+    reset: async (runId, seed) => {
+      const existing = this.runs.get(runId);
+      const run = this.createRun(runId, existing?.scenario.name ?? this.defaultScenario, seed ?? existing?.seed);
+      await run.ready;
+      return run.status();
+    },
+    step: (runId, ms) => {
+      const run = this.require(runId);
+      if (run.clock.mode !== "manual") run.clock.setMode("manual");
+      const r = run.clock.step(ms);
+      run.log(`step ${ms}ms \u2192 now ${r.now}`, { fired: r.fired.length });
+      return { ...r, pending: run.clock.pending() };
+    },
+    clock: (runId, patch) => {
+      const run = this.require(runId);
+      if (patch.speed !== void 0) run.clock.speed = Math.max(0.01, Number(patch.speed));
+      if (patch.mode) run.clock.setMode(patch.mode);
+      return { mode: run.clock.mode, speed: run.clock.speed, now: Math.round(run.clock.now()), pending: run.clock.pending() };
+    },
+    state: (runId, collection) => {
+      const run = this.require(runId);
+      const snap = run.state.snapshot();
+      return collection ? { run: runId, collection, items: snap[collection] ?? [] } : { run: runId, counts: run.state.counts(), collections: snap };
+    },
+    events: (runId, opts) => {
+      const run = this.require(runId);
+      const events = run.state.events(opts);
+      return { run: runId, last: run.state.lastSeq, count: events.length, events };
+    },
+    log: (runId, opts) => ({ run: runId, entries: this.require(runId).logs(opts) }),
+    streams: (runId) => {
+      const run = this.require(runId);
+      return { run: runId, connections: run.streams.list(), topics: run.streams.topics.topics().map((t) => ({ topic: t, last: run.streams.topics.last(t) })), latencyMs: run.streams.latencyMs };
+    },
+    disconnect: (runId, target, opts = {}) => {
+      const run = this.require(runId);
+      const closed = run.streams.disconnect(target, opts);
+      run.log(`disconnect ${JSON.stringify(target)}`, { closed, drop: opts.drop ?? false });
+      return { closed };
+    },
+    pause: (runId, id, paused) => this.require(runId).streams.pause(id, paused),
+    publish: (runId, topic, data) => this.require(runId).streams.publish(topic, data),
+    overrides: (runId) => ({ run: runId, overrides: this.require(runId).faults.listOverrides() }),
+    setOverride: (runId, input) => {
+      const run = this.require(runId);
+      const o = run.faults.setOverride(input);
+      run.log(`override set ${o.id}`, { matcher: o.matcher, method: o.method ?? "*", status: o.status ?? null, times: o.times ?? null });
+      return o;
+    },
+    clearOverrides: (runId, target, method) => {
+      const run = this.require(runId);
+      if (target) return { cleared: run.faults.clearOverride(target, method) };
+      run.faults.clearOverrides();
+      return { cleared: true };
+    },
+    faults: (runId, patch) => {
+      const run = this.require(runId);
+      run.faults.configure(patch);
+      if (patch.streamLatencyMs !== void 0) run.streams.latencyMs = Math.max(0, patch.streamLatencyMs);
+      run.log("faults configured", patch);
+      return { ...run.faults.snapshot(), streamLatencyMs: run.streams.latencyMs };
+    },
+    action: (runId, name, args = {}) => this.require(runId).action(name, args),
+    runs: () => [...this.runs.values()].map((r) => ({ id: r.id, scenario: r.scenario.name, seed: r.seed, requests: r.requests, createdWall: r.createdWall })),
+    deleteRun: (runId) => {
+      const run = this.runs.get(runId);
+      if (!run) return false;
+      run.dispose();
+      this.runs.delete(runId);
+      return true;
+    }
+  };
+  require(runId = this.defaultRun) {
+    const run = this.runs.get(runId) ?? this.createRun(runId, this.defaultScenario);
+    return run;
+  }
+  dispose() {
+    for (const run of this.runs.values()) run.dispose();
+    this.runs.clear();
+  }
+};
+function matchPath(pattern, pathname) {
+  const keys = [];
+  const re = new RegExp(
+    "^" + pattern.split("/").map((seg) => {
+      if (seg === "*") return "(?:.*)";
+      if (seg.startsWith(":")) {
+        keys.push(seg.slice(1));
+        return "([^/]+)";
+      }
+      return seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }).join("/") + "/?$"
+  );
+  const m = re.exec(pathname);
+  if (!m) return null;
+  const params = {};
+  keys.forEach((k, i) => params[k] = decodeURIComponent(m[i + 1] ?? ""));
+  return params;
+}
+
+export {
+  UPGRADED_HEADER,
+  upgradedResponse,
+  isUpgraded,
+  Simulator,
+  matchPath
+};
+//# sourceMappingURL=chunk-KU4W4SKO.js.map