@omniaura/scenario-sim 0.1.0

package/dist/chunk-44ZHRYG6.js

@@ -0,0 +1,959 @@
+// 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/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 text(body, init = {}) {
+  return new Response(body, { ...init, headers: { "content-type": "text/plain; charset=utf-8", ...init.headers } });
+}
+function empty(status = 204, init = {}) {
+  return new Response(null, { ...init, status });
+}
+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 sequence(steps, opts = {}) {
+  let i = 0;
+  return async (ctx) => {
+    const idx = opts.loop ? i % steps.length : Math.min(i, steps.length - 1);
+    i++;
+    const step = steps[idx];
+    if (step instanceof Response) return step.clone();
+    return step(ctx);
+  };
+}
+function delayed(ms, handler) {
+  return async (ctx) => {
+    await ctx.clock.sleep(typeof ms === "function" ? ms(ctx) : ms, `delay ${ctx.method} ${ctx.url.pathname}`);
+    return handler(ctx);
+  };
+}
+function compileRoute(route2) {
+  const keys = [];
+  const pattern = route2.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 {
+    ...route2,
+    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";
+}
+var route = {
+  get: (path, handler, name) => ({ method: "GET", path, handler, name }),
+  post: (path, handler, name) => ({ method: "POST", path, handler, name }),
+  put: (path, handler, name) => ({ method: "PUT", path, handler, name }),
+  patch: (path, handler, name) => ({ method: "PATCH", path, handler, name }),
+  delete: (path, handler, name) => ({ method: "DELETE", path, handler, name }),
+  any: (path, handler, name) => ({ method: "*", path, handler, name })
+};
+function crud(path, collection, opts) {
+  const wrap = opts.list ?? ((items) => ({ items }));
+  return [
+    route.get(path, (ctx) => json(wrap(ctx.state.list(collection, { sort: opts.sort }), ctx)), `${collection}.list`),
+    route.post(path, async (ctx) => {
+      const body = await ctx.body();
+      const invalid = opts.validate?.(body, ctx);
+      if (invalid) return problem(422, invalid);
+      const record = opts.create(body, ctx);
+      ctx.state.insert(collection, record);
+      return json(record, { status: 201 });
+    }, `${collection}.create`),
+    route.get(`${path}/:id`, (ctx) => {
+      const rec = ctx.state.get(collection, ctx.params.id);
+      return rec ? json(rec) : problem(404, `${collection} ${ctx.params.id} not found`);
+    }, `${collection}.read`),
+    route.patch(`${path}/:id`, async (ctx) => {
+      const body = await ctx.body();
+      const invalid = opts.validate?.(body, ctx);
+      if (invalid) return problem(422, invalid);
+      const next = ctx.state.update(collection, ctx.params.id, (cur) => opts.update ? opts.update(cur, body, ctx) : { ...cur, ...body, id: cur.id });
+      return next ? json(next) : problem(404, `${collection} ${ctx.params.id} not found`);
+    }, `${collection}.update`),
+    route.put(`${path}/:id`, async (ctx) => {
+      const body = await ctx.body();
+      const invalid = opts.validate?.(body, ctx);
+      if (invalid) return problem(422, invalid);
+      const next = ctx.state.update(collection, ctx.params.id, (cur) => opts.update ? opts.update(cur, body, ctx) : { ...cur, ...body, id: cur.id });
+      return next ? json(next) : problem(404, `${collection} ${ctx.params.id} not found`);
+    }, `${collection}.replace`),
+    route.delete(`${path}/:id`, (ctx) => {
+      const removed = ctx.state.remove(collection, ctx.params.id);
+      return removed ? empty(204) : problem(404, `${collection} ${ctx.params.id} not found`);
+    }, `${collection}.delete`)
+  ];
+}
+
+// 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 ws = (path, def) => ({ kind: "ws", path, ...def });
+var sse = (path, onOpen, def = {}) => ({ kind: "sse", path, onOpen, ...def });
+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(route2, ctx, transport, protocol) {
+    const id = `ws_${this.nextId++}`;
+    const closeCbs = [];
+    const hub = this;
+    const socket = {
+      id,
+      kind: "ws",
+      path: route2.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} ${route2.path}`, { protocol });
+    void Promise.resolve(route2.onOpen?.(ctx, socket)).catch((err) => this.log(`ws onOpen threw ${id}`, String(err)));
+    return socket;
+  }
+  /** Transport → hub: a client frame arrived. */
+  receive(route2, ctx, socket, data) {
+    if (socket.readyState !== "open") return;
+    socket.received++;
+    void Promise.resolve(route2.onMessage?.(ctx, socket, data)).catch((err) => this.log(`ws onMessage threw ${socket.id}`, String(err)));
+  }
+  /** Transport → hub: the client closed. */
+  clientClosed(route2, 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 });
+    route2.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(route2, 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: route2.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(text2) {
+        write(`: ${text2}
+
+`);
+      },
+      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} ${route2.path}`, { lastEventId });
+    write(`: scenario-sim ${id}
+
+`);
+    const ka = route2.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(route2.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/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
+function defineScenario(def) {
+  if (!/^[a-zA-Z0-9._-]+$/.test(def.name)) throw new Error(`scenario name must be URL-safe: ${def.name}`);
+  return def;
+}
+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");
+  }
+};
+
+export {
+  Rng,
+  VIRTUAL_EPOCH,
+  VirtualClock,
+  Store,
+  json,
+  text,
+  empty,
+  problem,
+  malformed,
+  sequence,
+  delayed,
+  compileRoute,
+  statusText,
+  route,
+  crud,
+  TopicLog,
+  ws,
+  sse,
+  StreamHub,
+  FaultLayer,
+  defineScenario,
+  Run
+};
+//# sourceMappingURL=chunk-44ZHRYG6.js.map