@crvouga/mockingbird-service-otel 0.1.0

package/dist/chunk-RQFUL7RM.js

@@ -0,0 +1,3582 @@
+// ../core/dist/clock.js
+var createClock = (source = Date.now) => {
+  let offsetMs = 0;
+  let frozenAt;
+  const now = () => frozenAt ?? source() + offsetMs;
+  return {
+    now,
+    set: (epochMs) => {
+      if (frozenAt !== void 0)
+        frozenAt = epochMs;
+      else
+        offsetMs = epochMs - source();
+    },
+    advance: (deltaMs) => {
+      if (frozenAt !== void 0)
+        frozenAt += deltaMs;
+      else
+        offsetMs += deltaMs;
+    },
+    freeze: () => {
+      frozenAt = now();
+    },
+    unfreeze: () => {
+      if (frozenAt === void 0)
+        return;
+      offsetMs = frozenAt - source();
+      frozenAt = void 0;
+    },
+    reset: () => {
+      offsetMs = 0;
+      frozenAt = void 0;
+    },
+    state: () => ({ now: now(), frozen: frozenAt !== void 0, offsetMs })
+  };
+};
+
+// ../core/dist/collection.js
+var Collection = class {
+  sqlite;
+  namespace;
+  name;
+  constructor(sqlite, namespace, name) {
+    this.sqlite = sqlite;
+    this.namespace = namespace;
+    this.name = name;
+  }
+  bumpCollectionSeq() {
+    const row = this.sqlite.prepare("SELECT value FROM mockingbird_sequences WHERE namespace = ? AND name = ? AND kind = 'collection'").get(this.namespace, this.name);
+    const next = (row?.value ?? 0) + 1;
+    this.sqlite.prepare(`INSERT INTO mockingbird_sequences (namespace, name, kind, value) VALUES (?, ?, 'collection', ?)
+         ON CONFLICT(namespace, name, kind) DO UPDATE SET value = excluded.value`).run(this.namespace, this.name, next);
+    return next;
+  }
+  nextSequence() {
+    return this.sqlite.transaction(() => this.bumpCollectionSeq());
+  }
+  get(id2) {
+    const row = this.sqlite.prepare("SELECT value FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").get(this.namespace, this.name, id2);
+    if (!row)
+      return void 0;
+    return JSON.parse(row.value).value;
+  }
+  has(id2) {
+    const row = this.sqlite.prepare("SELECT 1 AS ok FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").get(this.namespace, this.name, id2);
+    return row !== void 0;
+  }
+  /** Insert a new record, assigning it the next sequence number. */
+  insert(id2, value) {
+    return this.sqlite.transaction(() => {
+      const seq = this.bumpCollectionSeq();
+      const stored = { seq, value };
+      this.sqlite.prepare(`INSERT INTO mockingbird_records (namespace, collection, id, seq, value)
+           VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT(namespace, collection, id) DO UPDATE SET seq = excluded.seq, value = excluded.value`).run(this.namespace, this.name, id2, seq, JSON.stringify(stored));
+      return stored;
+    });
+  }
+  /** Replace an existing record's value, keeping its position. */
+  update(id2, value) {
+    return this.sqlite.transaction(() => {
+      const row = this.sqlite.prepare("SELECT seq, value FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").get(this.namespace, this.name, id2);
+      if (!row)
+        return void 0;
+      const stored = { seq: row.seq, value };
+      this.sqlite.prepare("UPDATE mockingbird_records SET value = ? WHERE namespace = ? AND collection = ? AND id = ?").run(JSON.stringify(stored), this.namespace, this.name, id2);
+      return stored;
+    });
+  }
+  delete(id2) {
+    const result = this.sqlite.prepare("DELETE FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").run(this.namespace, this.name, id2);
+    return result.changes > 0;
+  }
+  /** How many records the collection holds, without reading them. */
+  count() {
+    const row = this.sqlite.prepare("SELECT COUNT(*) AS n FROM mockingbird_records WHERE namespace = ? AND collection = ?").get(this.namespace, this.name);
+    return Number(row?.n ?? 0);
+  }
+  list(options = {}) {
+    const rows = this.sqlite.prepare("SELECT id, seq, value FROM mockingbird_records WHERE namespace = ? AND collection = ?").all(this.namespace, this.name);
+    const out = [];
+    for (const row of rows) {
+      const stored = JSON.parse(row.value);
+      if (options.where && !options.where(stored.value, stored.seq))
+        continue;
+      out.push({ id: row.id, seq: stored.seq, value: stored.value });
+    }
+    out.sort((a, b) => options.order === "oldest" ? a.seq - b.seq : b.seq - a.seq);
+    return out;
+  }
+};
+
+// ../core/dist/control.js
+var HEALTH_PATH = "/health";
+var ADMIN_PREFIX = "/__admin";
+var ADMIN_KEY_HEADER = "x-mockingbird-admin-key";
+var NAMESPACE_HEADER = "x-mockingbird-namespace";
+var json = (status, body) => new Response(JSON.stringify(body), {
+  status,
+  headers: { "content-type": "application/json" }
+});
+var adminError = (status, message) => json(status, { error: { type: "mockingbird_admin", message } });
+var UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+var parseDuration = (value) => {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value !== "string")
+    return void 0;
+  const match = /^(-?\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/.exec(value.trim());
+  if (!match)
+    return void 0;
+  return Number(match[1]) * UNITS[match[2]];
+};
+var parseInstant = (value) => {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value !== "string")
+    return void 0;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+};
+var matchRoute = (pattern, path) => {
+  const want = pattern.split("/").filter(Boolean);
+  const have = path.split("/").filter(Boolean);
+  if (want.length !== have.length)
+    return void 0;
+  const params = {};
+  for (let i = 0; i < want.length; i++) {
+    const segment = want[i];
+    const actual = have[i];
+    if (segment.startsWith(":"))
+      params[segment.slice(1)] = decodeURIComponent(actual);
+    else if (segment !== actual)
+      return void 0;
+  }
+  return params;
+};
+var readJson = async (request) => {
+  const text2 = await request.text();
+  if (text2.trim() === "")
+    return void 0;
+  return JSON.parse(text2);
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var createControlPlane = (context) => {
+  const snapshots = /* @__PURE__ */ new Map();
+  let snapshotCounter = 0;
+  const headerNamespace = (request) => request.headers.get(NAMESPACE_HEADER) ?? context.defaultNamespace;
+  const adminNamespace = (request, url) => url.searchParams.get("namespace") ?? headerNamespace(request);
+  const builtin = {
+    "GET /": () => json(200, {
+      service: context.name,
+      routes: [...Object.keys(builtin), ...Object.keys(context.routes)].sort()
+    }),
+    "POST /reset": async ({ url, namespace }) => {
+      const target = url.searchParams.get("all") === "1" ? "*" : namespace;
+      await context.reset(target);
+      return json(200, { status: "ok", reset: target === "*" ? context.namespaces() : [target] });
+    },
+    "GET /namespaces": () => json(200, { default: context.defaultNamespace, namespaces: context.namespaces() }),
+    "GET /clock": () => json(200, context.clock.state()),
+    "POST /clock": ({ body }) => {
+      if (!isRecord(body))
+        return adminError(400, "expected a JSON object");
+      if (body.reset === true)
+        context.clock.reset();
+      if (body.set !== void 0) {
+        const instant = parseInstant(body.set);
+        if (instant === void 0)
+          return adminError(400, "set: expected epoch ms or ISO-8601");
+        context.clock.set(instant);
+      }
+      if (body.advance !== void 0) {
+        const delta = parseDuration(body.advance);
+        if (delta === void 0)
+          return adminError(400, 'advance: expected ms or "15m"-style');
+        context.clock.advance(delta);
+      }
+      if (body.freeze === true)
+        context.clock.freeze();
+      if (body.freeze === false)
+        context.clock.unfreeze();
+      return json(200, context.clock.state());
+    },
+    "GET /faults": () => json(200, { faults: context.faults.list() }),
+    "POST /faults": ({ body, namespace }) => {
+      if (isRecord(body) && typeof body.preset === "string") {
+        if (!context.applyPreset)
+          return adminError(400, `${context.name} has no fault presets`);
+        const { preset, ...overrides } = body;
+        try {
+          return json(201, {
+            preset,
+            rules: context.applyPreset(preset, namespace, overrides)
+          });
+        } catch (error) {
+          return adminError(404, error instanceof Error ? error.message : String(error));
+        }
+      }
+      if (!isRecord(body) || typeof body.status !== "number" && typeof body.delayMs !== "number" && typeof body.latencyMs !== "number" && body.drop !== true && typeof body.effect !== "string") {
+        return adminError(400, "a fault needs a numeric status, a delayMs/latencyMs, drop: true, an effect, or a preset");
+      }
+      const rule = {
+        // Scoped to the caller's namespace unless it asks for every one, so one worker's
+        // injected failure never lands on another's request.
+        namespace,
+        ...body,
+        id: typeof body.id === "string" ? body.id : `fault_${context.faults.list().length + 1}`
+      };
+      return json(201, context.faults.add(rule));
+    },
+    "DELETE /faults": ({ url }) => {
+      const id2 = url.searchParams.get("id");
+      if (id2 === null) {
+        context.faults.clear();
+        return json(200, { status: "ok" });
+      }
+      return context.faults.remove(id2) ? json(200, { status: "ok" }) : adminError(404, `no fault ${id2}`);
+    },
+    "POST /snapshots": ({ namespace }) => {
+      const point = context.timeTravel.checkpoint(namespace, "main");
+      context.timeTravel.retain(namespace, point.id);
+      snapshotCounter++;
+      const id2 = `snap_${snapshotCounter}`;
+      snapshots.set(id2, { namespace, checkpoint: point.id });
+      return json(201, { id: id2, namespace, records: point.records ?? 0 });
+    },
+    "POST /snapshots/:id/restore": ({ params, namespace }) => {
+      const alias = snapshots.get(params.id);
+      if (!alias)
+        return adminError(404, `no snapshot ${params.id}`);
+      if (alias.namespace !== namespace) {
+        return adminError(409, `snapshot ${params.id} belongs to namespace ${alias.namespace}`);
+      }
+      context.timeTravel.checkout(alias.checkpoint, { namespace, branch: "main" });
+      return json(200, { status: "ok", id: params.id, namespace });
+    },
+    "DELETE /snapshots/:id": ({ params }) => {
+      const id2 = params.id;
+      const alias = snapshots.get(id2);
+      if (!alias)
+        return adminError(404, `no snapshot ${id2}`);
+      snapshots.delete(id2);
+      context.timeTravel.release(alias.namespace, alias.checkpoint);
+      return json(200, { status: "ok" });
+    },
+    "GET /timeline": ({ namespace }) => json(200, context.timeTravel.inspect(namespace)),
+    "POST /checkpoints": ({ body, namespace }) => {
+      const branch = isRecord(body) && typeof body.branch === "string" ? body.branch : "main";
+      try {
+        return json(201, context.timeTravel.checkpoint(namespace, branch));
+      } catch (error) {
+        return adminError(409, error instanceof Error ? error.message : String(error));
+      }
+    },
+    "POST /branches/:name": ({ params, body, namespace }) => {
+      const at = isRecord(body) && typeof body.at === "string" ? body.at : void 0;
+      try {
+        return json(201, context.timeTravel.branch(params.name, {
+          namespace,
+          ...at !== void 0 ? { at } : {}
+        }));
+      } catch (error) {
+        return adminError(409, error instanceof Error ? error.message : String(error));
+      }
+    },
+    "POST /branches/:name/checkout": ({ params, body, namespace }) => {
+      if (!isRecord(body) || typeof body.checkpoint !== "string") {
+        return adminError(400, 'expected {"checkpoint":"cp_..."}');
+      }
+      try {
+        context.timeTravel.checkout(body.checkpoint, {
+          namespace,
+          branch: params.name
+        });
+        return json(200, { status: "ok", branch: params.name, checkpoint: body.checkpoint });
+      } catch (error) {
+        return adminError(409, error instanceof Error ? error.message : String(error));
+      }
+    },
+    "GET /requests": ({ url, namespace }) => {
+      const status = url.searchParams.get("status");
+      const since = url.searchParams.get("since");
+      const limit = url.searchParams.get("limit");
+      const sinceMs = since === null ? void 0 : parseInstant(/^\d+$/.test(since) ? Number(since) : since);
+      if (since !== null && sinceMs === void 0) {
+        return adminError(400, "since: expected epoch ms or ISO-8601");
+      }
+      if (status !== null && !/^\d{3}$/.test(status))
+        return adminError(400, "status: expected an HTTP status");
+      if (limit !== null && !/^\d+$/.test(limit))
+        return adminError(400, "limit: expected a count");
+      const operationId = url.searchParams.get("operationId");
+      const everyNamespace = url.searchParams.get("all") === "1";
+      return json(200, {
+        size: context.journal.size,
+        requests: context.journal.list({
+          ...everyNamespace ? {} : { namespace },
+          ...operationId !== null ? { operationId } : {},
+          ...status !== null ? { status: Number(status) } : {},
+          ...sinceMs !== void 0 ? { since: sinceMs } : {},
+          ...limit !== null ? { limit: Number(limit) } : {}
+        })
+      });
+    },
+    "DELETE /requests": ({ url, namespace }) => {
+      context.journal.clear(url.searchParams.get("all") === "1" ? void 0 : namespace);
+      return json(200, { status: "ok" });
+    },
+    "GET /metrics": () => json(200, context.metrics.report()),
+    "DELETE /metrics": () => {
+      context.metrics.reset();
+      return json(200, { status: "ok" });
+    }
+  };
+  const routes = [...Object.entries(context.routes), ...Object.entries(builtin)].map(([key, handler]) => {
+    const space = key.indexOf(" ");
+    return { method: key.slice(0, space), pattern: key.slice(space + 1), handler };
+  });
+  return {
+    namespaceOf: headerNamespace,
+    async handle(request) {
+      const url = new URL(request.url);
+      if (url.pathname === HEALTH_PATH && request.method === "GET") {
+        return json(200, {
+          status: "ok",
+          service: context.name,
+          uptimeMs: context.wallNow() - context.startedAt,
+          clock: context.clock.state(),
+          namespaces: context.namespaces().length,
+          ...context.describe()
+        });
+      }
+      if (url.pathname !== ADMIN_PREFIX && !url.pathname.startsWith(`${ADMIN_PREFIX}/`)) {
+        return void 0;
+      }
+      if (context.adminKey !== void 0 && request.headers.get(ADMIN_KEY_HEADER) !== context.adminKey) {
+        return adminError(401, `missing or wrong ${ADMIN_KEY_HEADER}`);
+      }
+      const path = url.pathname.slice(ADMIN_PREFIX.length) || "/";
+      for (const route of routes) {
+        if (route.method !== request.method)
+          continue;
+        const params = matchRoute(route.pattern, path);
+        if (!params)
+          continue;
+        let body;
+        try {
+          body = await readJson(request);
+        } catch {
+          return adminError(400, "request body is not valid JSON");
+        }
+        return route.handler({
+          request,
+          url,
+          params,
+          namespace: adminNamespace(request, url),
+          body
+        });
+      }
+      return adminError(404, `no admin route ${request.method} ${path}; GET ${ADMIN_PREFIX} lists them`);
+    }
+  };
+};
+
+// ../core/dist/credentials.js
+var bearerToken = (request) => {
+  const header = request.headers.get("authorization");
+  if (!header)
+    return void 0;
+  const match = /^Bearer\s+(.+)$/i.exec(header.trim());
+  return match?.[1]?.trim() || void 0;
+};
+var basicAuth = (request) => {
+  const header = request.headers.get("authorization");
+  if (!header)
+    return void 0;
+  const match = /^Basic\s+(.+)$/i.exec(header.trim());
+  if (!match?.[1])
+    return void 0;
+  let decoded;
+  try {
+    decoded = atob(match[1].trim());
+  } catch {
+    return void 0;
+  }
+  const colon = decoded.indexOf(":");
+  if (colon < 0)
+    return { username: decoded, password: "" };
+  return { username: decoded.slice(0, colon), password: decoded.slice(colon + 1) };
+};
+var createCredentialRegistry = () => {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    set: (credential, namespace) => {
+      map.set(credential, namespace);
+    },
+    get: (credential) => map.get(credential),
+    remove: (credential) => map.delete(credential),
+    clear: () => map.clear(),
+    entries: () => [...map].map(([credential, namespace]) => ({ credential, namespace })).sort((a, b) => a.credential.localeCompare(b.credential))
+  };
+};
+var maskCredential = (credential) => credential.length <= 8 ? `${credential.slice(0, 2)}\u2026` : `${credential.slice(0, 6)}\u2026${credential.slice(-2)}`;
+
+// ../core/dist/rng.js
+var seedFrom = (value) => {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var createRng = (seed = 0) => {
+  const numeric = typeof seed === "string" ? seedFrom(seed) : seed >>> 0;
+  let state = numeric;
+  const next = () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+  return {
+    next,
+    int: (min, max) => min + Math.floor(next() * (max - min + 1)),
+    reset: () => {
+      state = numeric;
+    },
+    state: () => state,
+    setState: (next2) => {
+      if (!Number.isSafeInteger(next2) || next2 < 0 || next2 > 4294967295) {
+        throw new RangeError("rng state must be an unsigned 32-bit integer");
+      }
+      state = next2 >>> 0;
+    },
+    seed: numeric
+  };
+};
+
+// ../core/dist/faults.js
+var matches = (rule, candidate) => {
+  if (rule.namespace !== void 0 && rule.namespace !== "*" && rule.namespace !== candidate.namespace) {
+    return false;
+  }
+  if (rule.operationId !== void 0 && rule.operationId !== candidate.operationId)
+    return false;
+  if (rule.method !== void 0 && rule.method.toUpperCase() !== candidate.method.toUpperCase()) {
+    return false;
+  }
+  if (rule.pathPrefix !== void 0 && !candidate.path.startsWith(rule.pathPrefix))
+    return false;
+  return true;
+};
+var faultResponse = (rule) => {
+  const status = rule.status ?? 500;
+  const headers = { "content-type": "application/json", ...rule.headers };
+  if (typeof rule.body === "string")
+    return new Response(rule.body, { status, headers });
+  if (rule.body === null)
+    return new Response(null, { status, headers: rule.headers ?? {} });
+  const body = rule.body === void 0 ? { detail: "Injected by Mockingbird" } : rule.body;
+  return new Response(JSON.stringify(body), { status, headers });
+};
+var createFaultRegistry = (rng = createRng(0), sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) => {
+  const entries = [];
+  return {
+    add(rule) {
+      const existing = entries.findIndex((e) => e.rule.id === rule.id);
+      const entry = { rule, remaining: rule.count ?? null, hits: 0 };
+      if (existing >= 0)
+        entries[existing] = entry;
+      else
+        entries.push(entry);
+      return rule;
+    },
+    list: () => entries.map((e) => ({ ...e.rule, remaining: e.remaining, hits: e.hits })),
+    remove(id2) {
+      const index = entries.findIndex((e) => e.rule.id === id2);
+      if (index < 0)
+        return false;
+      entries.splice(index, 1);
+      return true;
+    },
+    clear() {
+      entries.length = 0;
+    },
+    async take(candidate) {
+      const hits = [];
+      for (const entry of entries) {
+        if (entry.remaining === 0)
+          continue;
+        if (!matches(entry.rule, candidate))
+          continue;
+        const rate = entry.rule.rate ?? 1;
+        if (rng.next() >= rate)
+          continue;
+        entry.hits++;
+        if (entry.remaining !== null)
+          entry.remaining--;
+        const delay = entry.rule.delayMs ?? entry.rule.latencyMs;
+        if (delay !== void 0 && delay > 0) {
+          await sleep(delay);
+        }
+        const hit = { id: entry.rule.id };
+        if (entry.rule.effect !== void 0) {
+          hit.effect = { name: entry.rule.effect, params: entry.rule.params ?? {} };
+        }
+        if (entry.rule.drop === true)
+          hit.drop = true;
+        else if (entry.rule.status !== void 0)
+          hit.response = faultResponse(entry.rule);
+        hits.push(hit);
+        if (hit.drop || hit.response)
+          break;
+      }
+      return hits;
+    }
+  };
+};
+
+// ../../openapi/core/dist/refs.js
+var OpenAPIReferenceError = class extends Error {
+  ref;
+  constructor(ref) {
+    super(`unresolvable $ref: ${ref}`);
+    this.ref = ref;
+    this.name = "OpenAPIReferenceError";
+  }
+};
+var unescapePointer = (segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~");
+var isReference = (value) => typeof value === "object" && value !== null && typeof value.$ref === "string";
+var resolveRef = (document2, ref) => {
+  if (!ref.startsWith("#/"))
+    throw new OpenAPIReferenceError(ref);
+  let cursor = document2;
+  for (const raw of ref.slice(2).split("/")) {
+    const segment = unescapePointer(raw);
+    if (typeof cursor !== "object" || cursor === null || !(segment in cursor)) {
+      throw new OpenAPIReferenceError(ref);
+    }
+    cursor = cursor[segment];
+  }
+  if (cursor === void 0)
+    throw new OpenAPIReferenceError(ref);
+  return cursor;
+};
+var deref = (document2, value) => {
+  let current = value;
+  const seen = /* @__PURE__ */ new Set();
+  while (isReference(current)) {
+    if (seen.has(current.$ref))
+      throw new OpenAPIReferenceError(`${current.$ref} (cycle)`);
+    seen.add(current.$ref);
+    current = resolveRef(document2, current.$ref);
+  }
+  return current;
+};
+
+// ../../openapi/core/dist/types.js
+var HTTP_METHODS = [
+  "get",
+  "put",
+  "post",
+  "delete",
+  "options",
+  "head",
+  "patch",
+  "trace"
+];
+
+// ../../openapi/core/dist/document.js
+var mergeParameters = (document2, item, own) => {
+  const merged = /* @__PURE__ */ new Map();
+  for (const raw of item.parameters ?? []) {
+    const parameter = deref(document2, raw);
+    merged.set(`${parameter.in}:${parameter.name}`, parameter);
+  }
+  for (const raw of own ?? []) {
+    const parameter = deref(document2, raw);
+    merged.set(`${parameter.in}:${parameter.name}`, parameter);
+  }
+  return [...merged.values()];
+};
+var listOperations = (document2) => {
+  const operations = [];
+  for (const [path, item] of Object.entries(document2.paths)) {
+    for (const method of HTTP_METHODS) {
+      const operation = item[method];
+      if (operation?.operationId === void 0)
+        continue;
+      const responses = {};
+      for (const [status, response] of Object.entries(operation.responses)) {
+        responses[status] = deref(document2, response);
+      }
+      operations.push({
+        operationId: operation.operationId,
+        method,
+        path,
+        operation,
+        parameters: mergeParameters(document2, item, operation.parameters),
+        requestBody: operation.requestBody === void 0 ? void 0 : deref(document2, operation.requestBody),
+        responses
+      });
+    }
+  }
+  return operations;
+};
+
+// ../../http/codec/dist/form.js
+var parsePath = (rawKey) => {
+  const open = rawKey.indexOf("[");
+  if (open === -1)
+    return [rawKey];
+  const path = [rawKey.slice(0, open)];
+  const rest = rawKey.slice(open);
+  const pattern = /\[([^\]]*)\]/g;
+  let match = pattern.exec(rest);
+  let consumed = 0;
+  while (match !== null) {
+    if (match.index !== consumed)
+      return [rawKey];
+    path.push(match[1] ?? "");
+    consumed = match.index + match[0].length;
+    match = pattern.exec(rest);
+  }
+  if (consumed !== rest.length)
+    return [rawKey];
+  return path;
+};
+var isIndex = (segment) => /^(0|[1-9][0-9]*)$/.test(segment);
+var put = (target, key, value) => {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+    return;
+  }
+  ;
+  target[key] = value;
+};
+var assign = (target, path, value) => {
+  let cursor = target;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    const last = i === path.length - 1;
+    if (Array.isArray(cursor)) {
+      const index = segment === "" ? cursor.length : isIndex(segment) ? Number(segment) : void 0;
+      if (index === void 0)
+        return;
+      if (last) {
+        put(cursor, index, value);
+        return;
+      }
+      const next = Object.hasOwn(cursor, index) ? cursor[index] : void 0;
+      if (next === void 0 || typeof next === "string") {
+        const created = path[i + 1] === "" || isIndex(path[i + 1]) ? [] : {};
+        put(cursor, index, created);
+        cursor = created;
+      } else {
+        cursor = next;
+      }
+      continue;
+    }
+    if (typeof cursor === "string")
+      return;
+    if (last) {
+      put(cursor, segment, value);
+      return;
+    }
+    const nextSegment = path[i + 1];
+    const existing = Object.hasOwn(cursor, segment) ? cursor[segment] : void 0;
+    if (existing === void 0 || typeof existing === "string") {
+      const created = nextSegment === "" || isIndex(nextSegment) ? [] : {};
+      put(cursor, segment, created);
+      cursor = created;
+    } else {
+      cursor = existing;
+    }
+  }
+};
+var decodeFormPairs = (pairs) => {
+  const out = {};
+  for (const [rawKey, value] of pairs)
+    assign(out, parsePath(rawKey), value);
+  return densify(out);
+};
+var densify = (value) => {
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value))
+    return value.filter((item) => item !== void 0).map(densify);
+  const out = {};
+  for (const [key, item] of Object.entries(value))
+    put(out, key, densify(item));
+  return out;
+};
+var decodeForm = (text2) => {
+  const source = text2.startsWith("?") ? text2.slice(1) : text2;
+  return decodeFormPairs(new URLSearchParams(source).entries());
+};
+
+// ../../http/codec/dist/content.js
+var JSON_MEDIA_TYPE = "application/json";
+var FORM_MEDIA_TYPE = "application/x-www-form-urlencoded";
+var mediaTypeOf = (contentType) => {
+  if (!contentType)
+    return void 0;
+  const essence = contentType.split(";")[0]?.trim().toLowerCase();
+  return essence ? essence : void 0;
+};
+var isJsonMediaType = (mediaType2) => mediaType2 === JSON_MEDIA_TYPE || mediaType2.endsWith("+json") || mediaType2 === "text/json";
+var utf8 = new TextDecoder("utf-8", { fatal: false });
+var decodeBody = (contentType, bytes) => {
+  if (bytes.byteLength === 0)
+    return { kind: "empty" };
+  const mediaType2 = mediaTypeOf(contentType);
+  if (mediaType2 === void 0)
+    return { kind: "bytes", value: bytes };
+  if (isJsonMediaType(mediaType2)) {
+    const text2 = utf8.decode(bytes);
+    try {
+      return { kind: "json", value: JSON.parse(text2) };
+    } catch (error) {
+      return {
+        kind: "invalid",
+        mediaType: mediaType2,
+        text: text2,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  if (mediaType2 === FORM_MEDIA_TYPE) {
+    return { kind: "form", value: decodeForm(utf8.decode(bytes)) };
+  }
+  if (mediaType2.startsWith("text/"))
+    return { kind: "text", value: utf8.decode(bytes) };
+  return { kind: "bytes", value: bytes };
+};
+var readBody = async (message) => {
+  const bytes = new Uint8Array(await message.arrayBuffer());
+  return decodeBody(message.headers.get("content-type"), bytes);
+};
+
+// ../core/dist/http.js
+var jsonRes = (status, body, headers = {}) => new Response(JSON.stringify(body), {
+  status,
+  headers: { "content-type": JSON_MEDIA_TYPE, ...headers }
+});
+var HttpError = class extends Error {
+  status;
+  body;
+  headers;
+  constructor(status, body, headers = {}) {
+    super(`HTTP ${status}`);
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+    this.name = "HttpError";
+  }
+  toResponse() {
+    const contentType = this.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+    if (contentType === "text/plain") {
+      return new Response(String(this.body), {
+        status: this.status,
+        headers: this.headers
+      });
+    }
+    return jsonRes(this.status, this.body, this.headers);
+  }
+};
+
+// ../core/dist/journal.js
+var DEFAULT_JOURNAL_SIZE = 1e3;
+var createJournal = (size = DEFAULT_JOURNAL_SIZE) => {
+  const capacity = Math.max(0, Math.floor(size));
+  const rings = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const order = /* @__PURE__ */ new WeakMap();
+  const inOrder = (ring) => ring.entries.length < capacity ? ring.entries : [...ring.entries.slice(ring.next), ...ring.entries.slice(0, ring.next)];
+  return {
+    size: capacity,
+    record(entry) {
+      if (capacity === 0)
+        return;
+      order.set(entry, sequence++);
+      let ring = rings.get(entry.namespace);
+      if (!ring) {
+        ring = { entries: [], next: 0 };
+        rings.set(entry.namespace, ring);
+      }
+      if (ring.entries.length < capacity)
+        ring.entries.push(entry);
+      else {
+        ring.entries[ring.next] = entry;
+        ring.next = (ring.next + 1) % capacity;
+      }
+    },
+    list(query = {}) {
+      const source = query.namespace !== void 0 ? inOrder(rings.get(query.namespace) ?? { entries: [], next: 0 }) : [...rings.values()].flatMap(inOrder).sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+      const matched = source.filter((entry) => (query.operationId === void 0 || entry.operationId === query.operationId) && (query.status === void 0 || entry.status === query.status) && (query.since === void 0 || Date.parse(entry.at) >= query.since));
+      return query.limit !== void 0 ? matched.slice(-Math.max(0, query.limit)) : matched;
+    },
+    clear(namespace) {
+      if (namespace === void 0)
+        rings.clear();
+      else
+        rings.delete(namespace);
+    }
+  };
+};
+var notes = /* @__PURE__ */ new WeakMap();
+var annotateResponse = (response, extra) => {
+  const existing = notes.get(response);
+  notes.set(response, {
+    ...existing,
+    ...extra,
+    ...existing?.ids || extra.ids ? { ids: { ...existing?.ids, ...extra.ids } } : {}
+  });
+  return response;
+};
+var responseNotes = (response) => notes.get(response);
+
+// ../core/dist/metrics.js
+var createMetrics = () => {
+  let requests = 0;
+  let faults = 0;
+  let totalDurationMs = 0;
+  const byOperation = /* @__PURE__ */ new Map();
+  const unmatched = /* @__PURE__ */ new Map();
+  return {
+    record(entry) {
+      requests++;
+      totalDurationMs += entry.durationMs;
+      if (entry.faultId !== void 0)
+        faults++;
+      const key = `${entry.operationId ?? "(unmatched)"} ${entry.status}`;
+      byOperation.set(key, (byOperation.get(key) ?? 0) + 1);
+      if (entry.unmatched) {
+        const route = `${entry.method} ${entry.path}`;
+        unmatched.set(route, (unmatched.get(route) ?? 0) + 1);
+      }
+    },
+    report: () => ({
+      requests,
+      byOperation: Object.fromEntries([...byOperation].sort(([a], [b]) => a.localeCompare(b))),
+      unmatched: [...unmatched].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([route, count]) => {
+        const space = route.indexOf(" ");
+        return { method: route.slice(0, space), path: route.slice(space + 1), count };
+      }),
+      faults,
+      totalDurationMs
+    }),
+    reset() {
+      requests = 0;
+      faults = 0;
+      totalDurationMs = 0;
+      byOperation.clear();
+      unmatched.clear();
+    }
+  };
+};
+
+// ../../core/dist/timeline.js
+var BRANCH_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
+var Timeline = class {
+  maxCheckpoints;
+  now;
+  makeId;
+  nodes = /* @__PURE__ */ new Map();
+  heads = /* @__PURE__ */ new Map();
+  /** Unreferenced nodes in the exact order they became collectible. */
+  evictable = /* @__PURE__ */ new Set();
+  /** Branch heads plus explicit retainers. Absent means zero. */
+  references = /* @__PURE__ */ new Map();
+  explicitPins = /* @__PURE__ */ new Map();
+  sequence = 0;
+  constructor(options = {}) {
+    const max = options.maxCheckpoints ?? 1e3;
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("maxCheckpoints must be a positive integer");
+    this.maxCheckpoints = max;
+    this.now = options.now ?? (() => this.sequence);
+    this.makeId = options.id ?? ((sequence) => `cp_${sequence.toString(36).padStart(8, "0")}`);
+  }
+  /** Capture a new immutable value and move `branch` to it. */
+  commit(value, options = {}) {
+    const branch = options.branch ?? "main";
+    this.assertBranch(branch);
+    const parent = options.parent === void 0 ? this.heads.get(branch) ?? null : options.parent;
+    if (parent !== null && !this.nodes.has(parent))
+      throw new RangeError(`no checkpoint ${parent}`);
+    const id2 = this.makeId(++this.sequence);
+    if (this.nodes.has(id2))
+      throw new RangeError(`duplicate checkpoint id ${id2}`);
+    const checkpoint = Object.freeze({ id: id2, branch, parent, at: this.now(), value });
+    this.nodes.set(id2, checkpoint);
+    this.moveHead(branch, id2);
+    this.collect(this.maxCheckpoints);
+    return checkpoint;
+  }
+  /** Create a branch pointer without copying its checkpoint value. */
+  fork(branch, options = {}) {
+    this.assertBranch(branch);
+    if (this.heads.has(branch))
+      throw new RangeError(`branch already exists: ${branch}`);
+    const from = options.from ?? this.heads.get("main");
+    if (from === void 0)
+      return void 0;
+    const checkpoint = this.get(from);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  /** Move a branch pointer to an existing checkpoint. */
+  checkout(branch, id2) {
+    this.assertBranch(branch);
+    const checkpoint = this.get(id2);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  get(id2) {
+    const checkpoint = this.nodes.get(id2);
+    if (!checkpoint)
+      throw new RangeError(`no checkpoint ${id2}`);
+    return checkpoint;
+  }
+  head(branch = "main") {
+    const id2 = this.heads.get(branch);
+    return id2 === void 0 ? void 0 : this.get(id2);
+  }
+  hasBranch(branch) {
+    return this.heads.has(branch);
+  }
+  branches() {
+    return Object.freeze(Object.fromEntries([...this.heads].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)));
+  }
+  checkpoints() {
+    return [...this.nodes.values()];
+  }
+  /** Number of retained checkpoints without allocating an array. */
+  get size() {
+    return this.nodes.size;
+  }
+  /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
+  retain(id2) {
+    const checkpoint = this.get(id2);
+    this.explicitPins.set(id2, (this.explicitPins.get(id2) ?? 0) + 1);
+    this.addReference(id2);
+    return checkpoint;
+  }
+  /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
+  release(id2) {
+    if (!this.nodes.has(id2))
+      return false;
+    const pins = this.explicitPins.get(id2) ?? 0;
+    if (pins === 0)
+      return false;
+    if (pins === 1)
+      this.explicitPins.delete(id2);
+    else
+      this.explicitPins.set(id2, pins - 1);
+    this.removeReference(id2);
+    this.collect(this.maxCheckpoints);
+    return true;
+  }
+  deleteBranch(branch) {
+    if (branch === "main")
+      throw new RangeError("cannot delete main branch");
+    const previous = this.heads.get(branch);
+    const deleted = this.heads.delete(branch);
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.collect(this.maxCheckpoints);
+    return deleted;
+  }
+  /**
+   * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
+   * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
+   * storage dependency, so a retained node remains usable after pruning.
+   */
+  gc(max = this.maxCheckpoints) {
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("max must be a positive integer");
+    const removed = [];
+    this.collect(max, removed);
+    return removed;
+  }
+  collect(max, removed) {
+    while (this.nodes.size > max && this.evictable.size > 0) {
+      const id2 = this.evictable.values().next().value;
+      this.evictable.delete(id2);
+      this.nodes.delete(id2);
+      removed?.push(id2);
+    }
+  }
+  moveHead(branch, id2) {
+    const previous = this.heads.get(branch);
+    if (previous === id2)
+      return;
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.heads.set(branch, id2);
+    this.addReference(id2);
+  }
+  addReference(id2) {
+    this.references.set(id2, (this.references.get(id2) ?? 0) + 1);
+    this.evictable.delete(id2);
+  }
+  removeReference(id2) {
+    const next = (this.references.get(id2) ?? 0) - 1;
+    if (next > 0)
+      this.references.set(id2, next);
+    else {
+      this.references.delete(id2);
+      if (this.nodes.has(id2))
+        this.evictable.add(id2);
+    }
+  }
+  assertBranch(branch) {
+    if (!BRANCH_PATTERN.test(branch))
+      throw new RangeError(`branch must match ${BRANCH_PATTERN}`);
+  }
+};
+
+// ../../sqlite/dist/default.js
+import { Database } from "@crvouga/mockingbird-service-sqlite";
+var createDefaultSqlite = () => new Database();
+var resolveSqlite = (sqlite) => sqlite ?? createDefaultSqlite();
+
+// ../../sqlite/dist/migrate.js
+var ensureMigrationsTable = (sqlite) => {
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      id TEXT PRIMARY KEY NOT NULL,
+      applied_at INTEGER NOT NULL
+    )
+  `);
+};
+var migrate = (sqlite, migrations) => {
+  ensureMigrationsTable(sqlite);
+  const applied = new Set(sqlite.prepare("SELECT id FROM schema_migrations").all().map((row) => row.id));
+  const pending = migrations.filter((migration) => !applied.has(migration.id));
+  if (pending.length === 0)
+    return;
+  const insert = sqlite.prepare("INSERT INTO schema_migrations (id, applied_at) VALUES (?, ?)");
+  const now = Math.floor(Date.now() / 1e3);
+  sqlite.transaction(() => {
+    for (const migration of pending) {
+      sqlite.exec(migration.sql);
+      insert.run(migration.id, now);
+    }
+  });
+};
+
+// ../../sqlite/dist/schema.js
+var CORE_MIGRATIONS = [
+  {
+    id: "20260322_core_records_sequences",
+    sql: `
+      CREATE TABLE IF NOT EXISTS mockingbird_records (
+        namespace TEXT NOT NULL,
+        collection TEXT NOT NULL,
+        id TEXT NOT NULL,
+        seq INTEGER NOT NULL,
+        value TEXT NOT NULL,
+        PRIMARY KEY (namespace, collection, id)
+      );
+      CREATE INDEX IF NOT EXISTS mockingbird_records_seq
+        ON mockingbird_records (namespace, collection, seq);
+      CREATE TABLE IF NOT EXISTS mockingbird_sequences (
+        namespace TEXT NOT NULL,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        value INTEGER NOT NULL,
+        PRIMARY KEY (namespace, name, kind)
+      );
+    `
+  }
+];
+var migrateCore = (sqlite) => {
+  migrate(sqlite, CORE_MIGRATIONS);
+};
+var clearNamespace = (sqlite, namespace) => {
+  sqlite.transaction(() => {
+    sqlite.prepare("DELETE FROM mockingbird_records WHERE namespace = ?").run(namespace);
+    sqlite.prepare("DELETE FROM mockingbird_sequences WHERE namespace = ?").run(namespace);
+  });
+};
+
+// ../../openapi/metadata/dist/types.js
+var EXTENSION_KEYS = {
+  operation: "x-mockingbird",
+  resource: "x-mockingbird-resource",
+  resourceRef: "x-mockingbird-resource-ref",
+  volatile: "x-mockingbird-volatile",
+  scope: "x-mockingbird-scope",
+  unsupported: "x-mockingbird-unsupported",
+  parityHeader: "x-mockingbird-parity-header"
+};
+
+// ../../openapi/metadata/dist/read.js
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var extensionOf = (holder, key) => holder[key];
+var operationMetadata = (operation) => {
+  const raw = extensionOf(operation, EXTENSION_KEYS.operation);
+  const ext = isRecord2(raw) ? raw : {};
+  const supported = ext.supported ?? true;
+  const parity = ext.parity ?? {};
+  return {
+    supported,
+    reason: typeof ext.reason === "string" ? ext.reason : void 0,
+    parity: {
+      enabled: supported && (parity.enabled ?? true),
+      safe: parity.safe ?? true,
+      reason: typeof parity.reason === "string" ? parity.reason : void 0
+    }
+  };
+};
+
+// ../core/dist/service.js
+import { Hono } from "hono";
+var defineOperations = (handlers) => handlers;
+var OperationRegistryError = class extends Error {
+  problems;
+  constructor(problems) {
+    super(`operation registry is inconsistent:
+${problems.map((p) => `  - ${p}`).join("\n")}`);
+    this.problems = problems;
+    this.name = "OperationRegistryError";
+  }
+};
+var verifyOperations = (document2, handlers) => {
+  const problems = [];
+  const operations = listOperations(document2);
+  const seen = /* @__PURE__ */ new Set();
+  for (const operation of operations) {
+    if (seen.has(operation.operationId))
+      problems.push(`duplicate operationId ${operation.operationId}`);
+    seen.add(operation.operationId);
+    const supported = operationMetadata(operation.operation).supported;
+    const handler = handlers[operation.operationId];
+    if (supported && !handler)
+      problems.push(`supported operation ${operation.operationId} has no handler`);
+    if (!supported && handler)
+      problems.push(`operation ${operation.operationId} is marked unsupported but has a handler`);
+  }
+  for (const id2 of Object.keys(handlers)) {
+    if (!seen.has(id2))
+      problems.push(`handler ${id2} has no OpenAPI operation`);
+  }
+  return problems;
+};
+var honoPath = (template) => template.replace(/\{([^}]+)\}/g, ":$1");
+var routeOrder = (a, b) => {
+  const sa = a.path.split("/");
+  const sb = b.path.split("/");
+  for (let i = 0; i < Math.max(sa.length, sb.length); i++) {
+    const x = sa[i] ?? "";
+    const y = sb[i] ?? "";
+    const px = x.startsWith("{");
+    const py = y.startsWith("{");
+    if (px !== py)
+      return px ? 1 : -1;
+    if (x !== y)
+      return x < y ? -1 : 1;
+  }
+  return 0;
+};
+var queryOf = (url) => decodeFormPairs(url.searchParams.entries());
+var bootSqlite = (sqlite) => {
+  const client = resolveSqlite(sqlite);
+  migrateCore(client);
+  return client;
+};
+var createService = (options) => {
+  const problems = verifyOperations(options.document, options.handlers);
+  if (problems.length > 0)
+    throw new OperationRegistryError(problems);
+  migrateCore(options.sqlite);
+  const now = options.now ?? (() => Date.now());
+  const app = new Hono();
+  app.notFound((c) => options.notFound(c.req.raw));
+  app.onError((error, c) => options.onError(error, c.req.raw));
+  const operations = [...listOperations(options.document)].sort(routeOrder);
+  for (const operation of operations) {
+    const metadata = operationMetadata(operation.operation);
+    const handler = options.handlers[operation.operationId];
+    const route = async (c) => {
+      const request = c.req.raw;
+      if (!metadata.supported || !handler) {
+        return options.unsupported ? options.unsupported(request, operation) : options.notFound(request);
+      }
+      const url = new URL(request.url);
+      const context = {
+        request,
+        url,
+        params: c.req.param(),
+        query: queryOf(url),
+        body: await readBody(request),
+        sqlite: options.sqlite,
+        namespace: options.namespace,
+        operation,
+        document: options.document,
+        now
+      };
+      const short = await options.before?.(context);
+      if (short)
+        return short;
+      return handler(context);
+    };
+    app.on(operation.method.toUpperCase(), honoPath(operation.path), route);
+  }
+  return {
+    app,
+    sqlite: options.sqlite,
+    namespace: options.namespace,
+    fetch: async (request) => app.fetch(request),
+    reset: async () => {
+      clearNamespace(options.sqlite, options.namespace);
+    }
+  };
+};
+
+// ../core/dist/snapshot.js
+var snapshotNamespace = (sqlite, namespace) => ({
+  namespace,
+  records: sqlite.prepare("SELECT collection, id, seq, value FROM mockingbird_records WHERE namespace = ? ORDER BY collection, seq").all(namespace),
+  sequences: sqlite.prepare("SELECT name, kind, value FROM mockingbird_sequences WHERE namespace = ? ORDER BY name, kind").all(namespace)
+});
+var restoreNamespace = (sqlite, namespace, snapshot) => {
+  sqlite.transaction(() => {
+    sqlite.prepare("DELETE FROM mockingbird_records WHERE namespace = ?").run(namespace);
+    sqlite.prepare("DELETE FROM mockingbird_sequences WHERE namespace = ?").run(namespace);
+    const record = sqlite.prepare("INSERT INTO mockingbird_records (namespace, collection, id, seq, value) VALUES (?, ?, ?, ?, ?)");
+    for (const row of snapshot.records) {
+      record.run(namespace, row.collection, row.id, row.seq, row.value);
+    }
+    const sequence = sqlite.prepare("INSERT INTO mockingbird_sequences (namespace, name, kind, value) VALUES (?, ?, ?, ?)");
+    for (const row of snapshot.sequences) {
+      sequence.run(namespace, row.name, row.kind, row.value);
+    }
+  });
+};
+
+// ../core/dist/version.js
+var PACKAGE_VERSION = true ? "0.1.0" : UNRELEASED_VERSION;
+
+// ../core/dist/webhooks.js
+var json2 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminError2 = (status, message) => json2(status, { error: { type: "mockingbird_admin", message } });
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseEndpoint = (value) => {
+  if (!isRecord3(value) || typeof value.url !== "string")
+    return "each endpoint needs a url";
+  try {
+    new URL(value.url);
+  } catch {
+    return `not a URL: ${value.url}`;
+  }
+  const endpoint = { url: value.url };
+  if (typeof value.id === "string")
+    endpoint.id = value.id;
+  if (typeof value.secret === "string")
+    endpoint.secret = value.secret;
+  if (typeof value.signUrl === "string")
+    endpoint.signUrl = value.signUrl;
+  const events = value.events ?? value.enabledEvents;
+  if (Array.isArray(events))
+    endpoint.events = events.map(String);
+  if (isRecord3(value.tags)) {
+    endpoint.tags = Object.fromEntries(Object.entries(value.tags).map(([k, v]) => [k, String(v)]));
+  }
+  if (typeof value.account === "string")
+    endpoint.tags = { ...endpoint.tags, account: value.account };
+  if (isRecord3(value.headers)) {
+    endpoint.headers = Object.fromEntries(Object.entries(value.headers).map(([k, v]) => [k, String(v)]));
+  }
+  return endpoint;
+};
+var webhookAdminRoutes = (hub) => ({
+  "GET /webhooks": ({ url, namespace }) => json2(200, {
+    deliveries: hub.deliveries(url.searchParams.get("all") === "1" ? void 0 : namespace).filter((d) => {
+      const type = url.searchParams.get("type");
+      return type === null || d.type === type;
+    })
+  }),
+  "GET /webhooks/events": ({ url, namespace }) => {
+    const type = url.searchParams.get("type");
+    return json2(200, {
+      events: hub.messages(url.searchParams.get("all") === "1" ? void 0 : namespace).filter((m) => type === null || m.type === type).map((m) => ({ ...m, payload: parsePayload(m) }))
+    });
+  },
+  "POST /webhooks/:id/replay": async ({ params }) => {
+    const replayed = await hub.replay(params.id);
+    return replayed ? json2(200, replayed) : adminError2(404, `no delivery ${params.id}`);
+  },
+  "POST /webhooks/flush": async () => {
+    await hub.flush();
+    return json2(200, { status: "ok" });
+  },
+  "POST /webhooks/faults": ({ body, namespace }) => {
+    if (!isRecord3(body) || !["duplicate", "reorder", "drop"].includes(String(body.mode))) {
+      return adminError2(400, "mode must be duplicate, reorder or drop");
+    }
+    const fault = { mode: body.mode };
+    if (typeof body.count === "number")
+      fault.count = body.count;
+    hub.fault(namespace, fault);
+    return json2(201, { namespace, ...fault });
+  },
+  "GET /webhook-endpoints": ({ namespace }) => json2(200, {
+    endpoints: hub.endpoints(namespace).map(({ secret, ...rest }) => ({
+      ...rest,
+      secret: secret ? "(set)" : null
+    }))
+  }),
+  "PUT /webhook-endpoints": ({ body, namespace }) => {
+    const list2 = Array.isArray(body) ? body : isRecord3(body) ? body.endpoints : void 0;
+    if (!Array.isArray(list2))
+      return adminError2(400, "expected [{url, secret?, events?}]");
+    const parsed = [];
+    for (const each of list2) {
+      const endpoint = parseEndpoint(each);
+      if (typeof endpoint === "string")
+        return adminError2(400, endpoint);
+      parsed.push(endpoint);
+    }
+    const set = hub.setEndpoints(namespace, parsed);
+    return json2(200, { endpoints: set.map((e) => ({ ...e, secret: e.secret ? "(set)" : null })) });
+  },
+  "DELETE /webhook-endpoints": ({ namespace }) => {
+    hub.setEndpoints(namespace, []);
+    return json2(200, { status: "ok" });
+  }
+});
+var parsePayload = (message) => {
+  if (message.contentType.startsWith("application/json")) {
+    try {
+      return JSON.parse(message.body);
+    } catch {
+      return message.body;
+    }
+  }
+  if (message.contentType.startsWith("application/x-www-form-urlencoded")) {
+    return Object.fromEntries(new URLSearchParams(message.body));
+  }
+  return message.body;
+};
+
+// ../core/dist/runtime.js
+var MOCKINGBIRD_HEADER = "x-mockingbird";
+var BRANCH_HEADER = "x-mockingbird-branch";
+var AT_HEADER = "x-mockingbird-at";
+var CHECKPOINT_HEADER = "x-mockingbird-checkpoint";
+var DEFAULT_NAMESPACE = "default";
+var NAMESPACE_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
+var PATH_PREFIX = /^\/ns\/([^/]+)(\/.*)?$/;
+var BRANCH_PATTERN2 = /^[A-Za-z0-9_.-]{1,64}$/;
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var effects = /* @__PURE__ */ new WeakMap();
+var reuseSorted = (fresh, previous, compare2, equal) => {
+  if (!previous || previous.length === 0)
+    return fresh.map((row) => Object.freeze(row));
+  const result = new Array(fresh.length);
+  let unchanged = fresh.length === previous.length;
+  let oldIndex = 0;
+  for (let index = 0; index < fresh.length; index++) {
+    const row = fresh[index];
+    while (oldIndex < previous.length && compare2(previous[oldIndex], row) < 0) {
+      oldIndex++;
+    }
+    const old = previous[oldIndex];
+    result[index] = old !== void 0 && compare2(old, row) === 0 && equal(old, row) ? old : Object.freeze(row);
+    if (result[index] !== previous[index])
+      unchanged = false;
+  }
+  return unchanged ? previous : result;
+};
+var faultEffects = (request) => (effects.get(request) ?? []).filter((e) => e !== void 0);
+var faultEffect = (request, name) => faultEffects(request).find((e) => e.name === name)?.params;
+var DroppedConnectionError = class extends TypeError {
+  code = "MOCKINGBIRD_DROP";
+  constructor() {
+    super("fetch failed: connection dropped by Mockingbird fault");
+    this.name = "TypeError";
+  }
+};
+var operationMatcher = (document2) => {
+  const matchers = listOperations(document2).map((operation) => ({
+    operationId: operation.operationId,
+    method: operation.method.toUpperCase(),
+    pattern: new RegExp(`^${operation.path.split("/").map((segment) => segment.startsWith("{") ? "[^/]+" : segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("/")}/?$`),
+    params: (operation.path.match(/\{/g) ?? []).length
+  })).sort((a, b) => a.params - b.params);
+  return (request, path) => matchers.find((m) => m.method === request.method && m.pattern.test(path))?.operationId;
+};
+var createRuntime = (options) => {
+  const sqlite = bootSqlite(options.sqlite);
+  const clock = options.clock ?? createClock();
+  const rng = createRng(options.seed ?? 0);
+  const wallNow = options.io?.wallNow ?? Date.now;
+  const monotonicNow = options.io?.monotonicNow ?? (() => performance.now());
+  const sleep = options.io?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const faults = createFaultRegistry(createRng(options.seed ?? 0), sleep);
+  const metrics = createMetrics();
+  const journal = createJournal(options.journalSize ?? DEFAULT_JOURNAL_SIZE);
+  const version = options.version ?? PACKAGE_VERSION;
+  const instances = /* @__PURE__ */ new Map();
+  const publicNamespaces = /* @__PURE__ */ new Set();
+  const branchRngs = /* @__PURE__ */ new Map();
+  const timelines = /* @__PURE__ */ new Map();
+  const branchStorage = /* @__PURE__ */ new Map();
+  const captured = /* @__PURE__ */ new Map();
+  const credentials = createCredentialRegistry();
+  const operationIdFor = options.document ? operationMatcher(options.document) : () => void 0;
+  const storageNamespace = (name) => name === DEFAULT_NAMESPACE ? options.name : `${options.name}:${name}`;
+  const instanceFor = (key, publicNamespace = key, isolatedRng) => {
+    const existing = instances.get(key);
+    if (existing)
+      return existing;
+    if (!NAMESPACE_PATTERN.test(key) || !NAMESPACE_PATTERN.test(publicNamespace)) {
+      throw new RangeError(`namespace must match ${NAMESPACE_PATTERN}: ${JSON.stringify(publicNamespace)}`);
+    }
+    const created = options.create({
+      namespace: storageNamespace(key),
+      publicNamespace,
+      sqlite,
+      clock,
+      rng: isolatedRng ?? rng
+    });
+    instances.set(key, created);
+    publicNamespaces.add(publicNamespace);
+    if (isolatedRng)
+      branchRngs.set(key, isolatedRng);
+    return created;
+  };
+  const instance = (name = DEFAULT_NAMESPACE) => instanceFor(name);
+  const capture = (storage) => {
+    const fresh = snapshotNamespace(sqlite, storageNamespace(storage));
+    const previous = captured.get(storage);
+    const snapshot2 = {
+      namespace: fresh.namespace,
+      records: reuseSorted(fresh.records, previous?.records, (left, right) => left.collection < right.collection ? -1 : left.collection > right.collection ? 1 : left.seq - right.seq, (left, right) => left.id === right.id && left.value === right.value),
+      sequences: reuseSorted(fresh.sequences, previous?.sequences, (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : left.kind < right.kind ? -1 : left.kind > right.kind ? 1 : 0, (left, right) => left.value === right.value)
+    };
+    Object.freeze(snapshot2.records);
+    Object.freeze(snapshot2.sequences);
+    Object.freeze(snapshot2);
+    captured.set(storage, snapshot2);
+    return Object.freeze({
+      snapshot: snapshot2,
+      clock: Object.freeze(clock.state()),
+      rngState: (branchRngs.get(storage) ?? rng).state()
+    });
+  };
+  const timeline = (name = DEFAULT_NAMESPACE) => {
+    let found = timelines.get(name);
+    if (found)
+      return found;
+    instance(name);
+    found = new Timeline({
+      now: clock.now,
+      ...options.maxCheckpoints !== void 0 ? { maxCheckpoints: options.maxCheckpoints } : {}
+    });
+    found.commit(capture(name));
+    timelines.set(name, found);
+    return found;
+  };
+  const physicalBranch = (namespace, branch2) => {
+    if (branch2 === "main")
+      return namespace;
+    const mapKey = `${namespace}\0${branch2}`;
+    const existing = branchStorage.get(mapKey);
+    if (existing)
+      return existing;
+    const key = `branch_${seedFrom(`${options.name}\0${namespace}\0${branch2}`).toString(36)}`;
+    branchStorage.set(mapKey, key);
+    return key;
+  };
+  const ensureBranch = (namespace, branch2, at) => {
+    if (!BRANCH_PATTERN2.test(branch2))
+      throw new RangeError(`branch must match ${BRANCH_PATTERN2}`);
+    const history = timeline(namespace);
+    if (branch2 === "main") {
+      if (at !== void 0) {
+        const point = history.checkout("main", at);
+        restoreNamespace(sqlite, storageNamespace(namespace), point.value.snapshot);
+        captured.set(namespace, point.value.snapshot);
+        rng.setState(point.value.rngState);
+        clock.set(point.value.clock.now);
+        if (point.value.clock.frozen)
+          clock.freeze();
+        else
+          clock.unfreeze();
+      }
+      return namespace;
+    }
+    const storage = physicalBranch(namespace, branch2);
+    if (!history.hasBranch(branch2)) {
+      if (at === void 0)
+        history.commit(capture(namespace));
+      const point = history.fork(branch2, at === void 0 ? {} : { from: at });
+      const branchRng = createRng(options.seed ?? 0);
+      if (point)
+        branchRng.setState(point.value.rngState);
+      instanceFor(storage, namespace, branchRng);
+      if (point)
+        restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+      if (point)
+        captured.set(storage, point.value.snapshot);
+    } else if (at !== void 0 && history.head(branch2)?.id !== at) {
+      const point = history.checkout(branch2, at);
+      if (!instances.has(storage)) {
+        const branchRng = createRng(options.seed ?? 0);
+        branchRng.setState(point.value.rngState);
+        instanceFor(storage, namespace, branchRng);
+      }
+      branchRngs.get(storage)?.setState(point.value.rngState);
+      restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+      captured.set(storage, point.value.snapshot);
+    } else {
+      if (!instances.has(storage)) {
+        const point = history.head(branch2);
+        const branchRng = createRng(options.seed ?? 0);
+        if (point)
+          branchRng.setState(point.value.rngState);
+        instanceFor(storage, namespace, branchRng);
+      }
+    }
+    return storage;
+  };
+  const checkpoint = (namespace = DEFAULT_NAMESPACE, branch2 = "main") => {
+    const storage = ensureBranch(namespace, branch2);
+    return timeline(namespace).commit(capture(storage), { branch: branch2 });
+  };
+  const branch = (name, branchOptions = {}) => {
+    const namespace = branchOptions.namespace ?? DEFAULT_NAMESPACE;
+    ensureBranch(namespace, name, branchOptions.at);
+    const head = timeline(namespace).head(name);
+    if (!head)
+      throw new RangeError(`branch ${name} has no checkpoint`);
+    return head;
+  };
+  const checkout = (checkpointId, checkoutOptions = {}) => {
+    const namespace = checkoutOptions.namespace ?? DEFAULT_NAMESPACE;
+    const branchName = checkoutOptions.branch ?? "main";
+    const history = timeline(namespace);
+    const point = history.checkout(branchName, checkpointId);
+    const storage = ensureBranch(namespace, branchName);
+    restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+    captured.set(storage, point.value.snapshot);
+    clock.set(point.value.clock.now);
+    if (point.value.clock.frozen)
+      clock.freeze();
+    else
+      clock.unfreeze();
+    (branchRngs.get(storage) ?? rng).setState(point.value.rngState);
+  };
+  const reset = async (name = DEFAULT_NAMESPACE) => {
+    if (name === "*") {
+      options.webhooks?.clear();
+      for (const each of instances.values())
+        await each.reset();
+      timelines.clear();
+      branchStorage.clear();
+      branchRngs.clear();
+      captured.clear();
+      return;
+    }
+    options.webhooks?.clear(name);
+    const target = instances.get(name);
+    if (target)
+      await target.reset();
+    else
+      clearNamespace(sqlite, storageNamespace(name));
+    for (const [mapping, storage] of branchStorage) {
+      if (!mapping.startsWith(`${name}\0`))
+        continue;
+      const branchInstance = instances.get(storage);
+      if (branchInstance)
+        await branchInstance.reset();
+      else
+        clearNamespace(sqlite, storageNamespace(storage));
+      branchStorage.delete(mapping);
+      branchRngs.delete(storage);
+      captured.delete(storage);
+    }
+    timelines.delete(name);
+    captured.delete(name);
+  };
+  const snapshot = (name = DEFAULT_NAMESPACE) => {
+    return checkpoint(name, "main").value.snapshot;
+  };
+  const restore = (from, name = DEFAULT_NAMESPACE) => {
+    instance(name);
+    restoreNamespace(sqlite, storageNamespace(name), from);
+    captured.set(name, from);
+    const history = timelines.get(name);
+    if (history)
+      history.commit(capture(name), { branch: "main" });
+    else
+      timeline(name);
+  };
+  const runtime = {
+    name: options.name,
+    sqlite,
+    clock,
+    faults,
+    metrics,
+    journal,
+    rng,
+    credentials,
+    webhooks: options.webhooks,
+    applyPreset: (name, namespace = DEFAULT_NAMESPACE, overrides = {}) => {
+      const preset = options.presets?.[name];
+      if (!preset)
+        throw new RangeError(`no fault preset ${JSON.stringify(name)}`);
+      const added = (preset.rules ?? []).map((rule, index) => faults.add({
+        namespace,
+        ...rule,
+        ...overrides,
+        preset: name,
+        id: `${overrides.id ?? name}${(preset.rules ?? []).length > 1 ? `_${index + 1}` : ""}`
+      }));
+      if (preset.webhook && options.webhooks) {
+        options.webhooks.fault(namespace, {
+          ...preset.webhook,
+          ...overrides.count !== void 0 ? { count: overrides.count } : {}
+        });
+      }
+      return added;
+    },
+    instance,
+    namespaces: () => [...publicNamespaces].sort(),
+    reset,
+    snapshot,
+    restore,
+    checkpoint,
+    branch,
+    checkout,
+    timeline,
+    fetch: async (incoming) => {
+      let request = incoming;
+      const prefixed = PATH_PREFIX.exec(new URL(request.url).pathname);
+      if (prefixed) {
+        const url2 = new URL(request.url);
+        url2.pathname = prefixed[2] ?? "/";
+        const headers = new Headers(request.headers);
+        if (!headers.has(NAMESPACE_HEADER)) {
+          headers.set(NAMESPACE_HEADER, decodeURIComponent(prefixed[1]));
+        }
+        const hasBody = request.method !== "GET" && request.method !== "HEAD";
+        request = new Request(url2, {
+          method: request.method,
+          headers,
+          ...hasBody ? { body: await request.arrayBuffer() } : {},
+          signal: request.signal
+        });
+      }
+      let namespace = control.namespaceOf(request);
+      if (!request.headers.has(NAMESPACE_HEADER) && options.credential) {
+        const credential = options.credential(request);
+        const mapped = credential !== void 0 ? credentials.get(credential) : void 0;
+        if (mapped !== void 0)
+          namespace = mapped;
+      }
+      const selectedBranch = request.headers.get(BRANCH_HEADER) ?? "main";
+      const at = request.headers.get(AT_HEADER) ?? void 0;
+      const stamp = (response2) => {
+        const value = NAMESPACE_PATTERN.test(namespace) ? `${options.name}@${version}; ns=${namespace}` : `${options.name}@${version}`;
+        try {
+          response2.headers.set(MOCKINGBIRD_HEADER, value);
+          return response2;
+        } catch {
+          const copy = new Response(response2.body, response2);
+          copy.headers.set(MOCKINGBIRD_HEADER, value);
+          return copy;
+        }
+      };
+      const handled = await control.handle(request);
+      if (handled)
+        return stamp(handled);
+      const started = monotonicNow();
+      const url = new URL(request.url);
+      const operationId = operationIdFor(request, url.pathname);
+      const log = (status, faultId, response2) => {
+        const noted = response2 ? responseNotes(response2) : void 0;
+        const entry = {
+          service: options.name,
+          namespace,
+          operationId,
+          method: request.method,
+          path: url.pathname,
+          status,
+          durationMs: Math.round((monotonicNow() - started) * 100) / 100,
+          unmatched: options.document !== void 0 && operationId === void 0,
+          ...faultId !== void 0 ? { faultId } : {},
+          ...noted?.ids && Object.keys(noted.ids).length > 0 ? { ids: noted.ids } : {},
+          ...noted?.adopted ? { adopted: true } : {}
+        };
+        metrics.record(entry);
+        journal.record({ ...entry, at: new Date(clock.now()).toISOString() });
+        options.onLog?.(entry);
+      };
+      if (!NAMESPACE_PATTERN.test(namespace)) {
+        log(400);
+        return stamp(new Response(JSON.stringify({
+          error: {
+            type: "mockingbird_admin",
+            message: `${NAMESPACE_HEADER} must match ${NAMESPACE_PATTERN}`
+          }
+        }), { status: 400, headers: { "content-type": "application/json" } }));
+      }
+      if (!BRANCH_PATTERN2.test(selectedBranch)) {
+        log(400);
+        return stamp(adminFail(400, `${BRANCH_HEADER} must match ${BRANCH_PATTERN2}`));
+      }
+      let storage;
+      try {
+        if (at !== void 0 && selectedBranch === "main" && !MUTATING_METHODS.has(request.method)) {
+          const point = timeline(namespace).get(at);
+          storage = physicalBranch(namespace, `at_${at}`);
+          let viewRng = branchRngs.get(storage);
+          if (!viewRng) {
+            viewRng = createRng(options.seed ?? 0);
+            instanceFor(storage, namespace, viewRng);
+          }
+          viewRng.setState(point.value.rngState);
+          restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+          captured.set(storage, point.value.snapshot);
+        } else {
+          storage = ensureBranch(namespace, selectedBranch, at);
+        }
+      } catch (error) {
+        log(409);
+        return stamp(adminFail(409, error instanceof Error ? error.message : String(error)));
+      }
+      const hits = await faults.take({
+        operationId,
+        method: request.method,
+        path: url.pathname,
+        namespace
+      });
+      const final = hits.find((hit) => hit.drop || hit.response);
+      if (final?.drop) {
+        log(0, final.id);
+        throw new DroppedConnectionError();
+      }
+      if (final?.response) {
+        log(final.response.status, final.id);
+        return stamp(final.response);
+      }
+      const fired = hits.filter((hit) => hit.effect !== void 0);
+      if (fired.length > 0)
+        effects.set(request, fired.map((hit) => hit.effect));
+      let response = await instanceFor(storage, namespace).fetch(request);
+      if (MUTATING_METHODS.has(request.method) && response.status >= 200 && response.status < 400) {
+        const point = timeline(namespace).commit(capture(storage), { branch: selectedBranch });
+        response = mutableResponse(response);
+        response.headers.set(CHECKPOINT_HEADER, point.id);
+      }
+      if (selectedBranch !== "main") {
+        response = mutableResponse(response);
+        response.headers.set(BRANCH_HEADER, selectedBranch);
+      }
+      if (at !== void 0) {
+        response = mutableResponse(response);
+        response.headers.set(AT_HEADER, at);
+      }
+      log(response.status, fired[0]?.id, response);
+      return stamp(response);
+    }
+  };
+  const control = createControlPlane({
+    name: options.name,
+    startedAt: wallNow(),
+    wallNow,
+    clock,
+    faults,
+    metrics,
+    journal,
+    defaultNamespace: DEFAULT_NAMESPACE,
+    namespaces: runtime.namespaces,
+    reset,
+    timeTravel: {
+      checkpoint: (name, branchName) => {
+        const point = checkpoint(name, branchName);
+        return {
+          id: point.id,
+          branch: point.branch,
+          parent: point.parent,
+          at: point.at,
+          records: point.value.snapshot.records.length
+        };
+      },
+      branch: (branchName, branchOptions) => {
+        const point = branch(branchName, branchOptions);
+        return { id: point.id, branch: point.branch, parent: point.parent, at: point.at };
+      },
+      checkout: (checkpointId, checkoutOptions) => checkout(checkpointId, checkoutOptions),
+      retain: (name, checkpointId) => {
+        timeline(name).retain(checkpointId);
+      },
+      release: (name, checkpointId) => timeline(name).release(checkpointId),
+      inspect: (name) => {
+        const history = timeline(name);
+        return {
+          branches: history.branches(),
+          checkpoints: history.checkpoints().map(({ id: id2, branch: branchName, parent, at }) => ({
+            id: id2,
+            branch: branchName,
+            parent,
+            at
+          }))
+        };
+      }
+    },
+    describe: options.describe ?? (() => ({})),
+    ...options.presets ? {
+      applyPreset: (name, namespace, overrides) => runtime.applyPreset(name, namespace, overrides)
+    } : {},
+    routes: {
+      ...credentialRoutes(credentials),
+      ...options.presets ? presetRoutes(options.presets, runtime) : {},
+      ...options.webhooks ? webhookAdminRoutes(options.webhooks) : {},
+      ...options.admin?.(runtime) ?? {}
+    },
+    adminKey: options.adminKey
+  });
+  return runtime;
+};
+var mutableResponse = (response) => {
+  try {
+    response.headers.set("x-mockingbird-mutable-probe", "1");
+    response.headers.delete("x-mockingbird-mutable-probe");
+    return response;
+  } catch {
+    return new Response(response.body, response);
+  }
+};
+var adminJson = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminFail = (status, message) => adminJson(status, { error: { type: "mockingbird_admin", message } });
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var credentialRoutes = (registry) => ({
+  "GET /credentials": () => adminJson(200, {
+    credentials: registry.entries().map(({ credential, namespace }) => ({
+      credential: maskCredential(credential),
+      namespace
+    }))
+  }),
+  "PUT /credentials": ({ body, namespace }) => {
+    const pairs = [];
+    const list2 = Array.isArray(body) ? body : isObject(body) ? body.credentials : void 0;
+    if (Array.isArray(list2)) {
+      for (const each of list2) {
+        if (typeof each === "string")
+          pairs.push([each, namespace]);
+        else if (isObject(each) && typeof each.credential === "string") {
+          pairs.push([
+            each.credential,
+            typeof each.namespace === "string" ? each.namespace : namespace
+          ]);
+        } else
+          return adminFail(400, "each entry is a credential string or {credential, namespace}");
+      }
+    } else if (isObject(list2)) {
+      for (const [credential, target] of Object.entries(list2)) {
+        if (typeof target !== "string")
+          return adminFail(400, `namespace for ${credential} must be a string`);
+        pairs.push([credential, target]);
+      }
+    } else if (isObject(body) && typeof body.credential === "string") {
+      pairs.push([body.credential, typeof body.namespace === "string" ? body.namespace : namespace]);
+    } else {
+      return adminFail(400, 'expected {"credentials": {"<credential>": "<namespace>"}}');
+    }
+    for (const [credential, target] of pairs) {
+      if (!NAMESPACE_PATTERN.test(target))
+        return adminFail(400, `bad namespace ${JSON.stringify(target)}`);
+      registry.set(credential, target);
+    }
+    return adminJson(200, { mapped: pairs.length });
+  },
+  "DELETE /credentials": ({ url }) => {
+    const credential = url.searchParams.get("credential");
+    if (credential === null)
+      registry.clear();
+    else
+      registry.remove(credential);
+    return adminJson(200, { status: "ok" });
+  }
+});
+var presetRoutes = (presets, runtime) => ({
+  "GET /faults/presets": () => adminJson(200, {
+    presets: Object.entries(presets).map(([name, preset]) => ({ name, ...preset }))
+  }),
+  "POST /faults/presets/:name": ({ params, body, namespace }) => {
+    const name = params.name;
+    if (!presets[name])
+      return adminFail(404, `no fault preset ${name}; GET /__admin/faults/presets`);
+    const overrides = isObject(body) ? body : {};
+    return adminJson(201, { preset: name, rules: runtime.applyPreset(name, namespace, overrides) });
+  }
+});
+
+// src/generated/openapi.ts
+var document = JSON.parse(`{"openapi":"3.1.0","info":{"title":"OTLP/HTTP collector and OpenObserve search (Mockingbird subset)","description":"An OTLP/HTTP receiver (traces, logs, metrics; JSON and protobuf) in front of the\\nOpenObserve (O2) search API, over one store: a test emits a span or a structured \`event\`\\nlog and queries it back with the same SQL our clients send.\\n","version":"1","x-mockingbird-upstream":{"note":"OTLP/HTTP per opentelemetry-proto v1 (https://opentelemetry.io/docs/specs/otlp/); the O2 routes follow OpenObserve's API (/api-doc/openapi.json, v0.92) trimmed to what our clients call."}},"servers":[{"url":"https://otel.gogeviti.com"},{"url":"https://observe.gogeviti.com"}],"security":[{"bearerAuth":[]}],"paths":{"/v1/traces":{"post":{"operationId":"ExportTraces","summary":"OTLP/HTTP trace export (ExportTraceServiceRequest)","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/ExportTraceServiceRequest"}},"application/x-protobuf":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"Accepted. JSON requests get \`{partialSuccess: {}}\`; protobuf requests get an empty protobuf response.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/ExportResponse"}},"application/x-protobuf":{"schema":{"type":"string","format":"binary"}}}},"400":{"description":"Undecodable payload","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"401":{"description":"Missing or unknown bearer token","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"415":{"description":"Neither application/json nor application/x-protobuf","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"429":{"description":"Throttled (retried by the SDK), with retry-after","headers":{"retry-after":{"schema":{"type":"string"}}},"content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"500":{"description":"Collector error (not retried by the SDK)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"502":{"description":"Bad gateway (retried)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"503":{"description":"Unavailable (retried)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"504":{"description":"Gateway timeout (retried)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}}}}},"/v1/logs":{"post":{"operationId":"ExportLogs","summary":"OTLP/HTTP log export (ExportLogsServiceRequest)","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/ExportLogsServiceRequest"}},"application/x-protobuf":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"Accepted. JSON requests get \`{partialSuccess: {}}\`; protobuf requests get an empty protobuf response.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/ExportResponse"}},"application/x-protobuf":{"schema":{"type":"string","format":"binary"}}}},"400":{"description":"Undecodable payload","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"401":{"description":"Missing or unknown bearer token","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"415":{"description":"Neither application/json nor application/x-protobuf","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"429":{"description":"Throttled (retried by the SDK), with retry-after","headers":{"retry-after":{"schema":{"type":"string"}}},"content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"500":{"description":"Collector error (not retried by the SDK)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"502":{"description":"Bad gateway (retried)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"503":{"description":"Unavailable (retried)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"504":{"description":"Gateway timeout (retried)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}}}}},"/v1/metrics":{"post":{"operationId":"ExportMetrics","summary":"OTLP/HTTP metrics export: accepted and counted, never stored","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/ExportMetricsServiceRequest"}},"application/x-protobuf":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"Accepted. JSON requests get \`{partialSuccess: {}}\`; protobuf requests get an empty protobuf response.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/ExportResponse"}},"application/x-protobuf":{"schema":{"type":"string","format":"binary"}}}},"400":{"description":"Undecodable payload","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"401":{"description":"Missing or unknown bearer token","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"415":{"description":"Neither application/json nor application/x-protobuf","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"429":{"description":"Throttled (retried by the SDK), with retry-after","headers":{"retry-after":{"schema":{"type":"string"}}},"content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"500":{"description":"Collector error (not retried by the SDK)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"502":{"description":"Bad gateway (retried)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"503":{"description":"Unavailable (retried)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}},"504":{"description":"Gateway timeout (retried)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RpcStatus"}}}}}}},"/api/organizations":{"get":{"operationId":"ListOrganizations","summary":"O2: the organizations the Basic user belongs to (display name \u2192 identifier)","security":[{"basicAuth":[]}],"x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"responses":{"200":{"description":"Organizations","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Organizations"}}}},"401":{"description":"Bad Basic credentials, or an org the user cannot see \u2014 including an org's display name in place of its identifier","content":{"text/plain":{"schema":{"type":"string"}}}}}}},"/api/{org}/streams":{"parameters":[{"name":"org","in":"path","required":true,"description":"The org **identifier** (not its display name)","schema":{"type":"string","x-mockingbird-resource-ref":{"type":"organization","missing":"no-such-org"}}}],"get":{"operationId":"ListStreams","summary":"O2: the org's streams of one type","security":[{"basicAuth":[]}],"x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"name":"type","in":"query","required":false,"schema":{"type":"string","enum":["logs","traces"]}}],"responses":{"200":{"description":"Streams","content":{"application/json":{"schema":{"$ref":"#/components/schemas/StreamList"}}}},"401":{"description":"Bad Basic credentials, or an org the user cannot see \u2014 including an org's display name in place of its identifier","content":{"text/plain":{"schema":{"type":"string"}}}}}}},"/api/{org}/streams/{stream}/schema":{"parameters":[{"name":"org","in":"path","required":true,"description":"The org **identifier** (not its display name)","schema":{"type":"string","x-mockingbird-resource-ref":{"type":"organization","missing":"no-such-org"}}},{"name":"stream","in":"path","required":true,"schema":{"type":"string","enum":["default","other"]}}],"get":{"operationId":"GetStreamSchema","summary":"O2: a stream's schema (\`schema[].name\` are the queryable, lowercased, flattened fields)","security":[{"basicAuth":[]}],"x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"name":"type","in":"query","required":false,"schema":{"type":"string","enum":["logs","traces"]}}],"responses":{"200":{"description":"Schema","content":{"application/json":{"schema":{"$ref":"#/components/schemas/StreamSchema"}}}},"401":{"description":"Bad Basic credentials, or an org the user cannot see \u2014 including an org's display name in place of its identifier","content":{"text/plain":{"schema":{"type":"string"}}}},"404":{"description":"Nothing has been ingested into this stream","content":{"application/json":{"schema":{"$ref":"#/components/schemas/O2Error"}}}}}}},"/api/{org}/_search":{"parameters":[{"name":"org","in":"path","required":true,"description":"The org **identifier** (not its display name)","schema":{"type":"string","x-mockingbird-resource-ref":{"type":"organization","missing":"no-such-org"}}}],"post":{"operationId":"Search","summary":"O2: SQL search over a stream","security":[{"basicAuth":[]}],"x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"name":"type","in":"query","required":false,"schema":{"type":"string","enum":["logs","traces"]}}],"requestBody":{"required":true,"content":{"application/json":{"schema":{"type":"object","required":["query"],"properties":{"query":{"type":"object","required":["sql"],"properties":{"sql":{"anyOf":[{"type":"string","enum":["SELECT * FROM \\"default\\" WHERE event IS NOT NULL ORDER BY _timestamp DESC","SELECT * FROM \\"default\\" WHERE event IN ('checkout_completed') ORDER BY _timestamp DESC","SELECT service_name, count(*) AS n FROM \\"default\\" GROUP BY service_name ORDER BY n DESC","SELECT * FROM \\"default\\" WHERE severity_text IN ('ERROR', 'FATAL')","SELECT * FROM \\"default\\" WHERE clientUserId = '1'"]},{"type":"string","maxLength":200}]},"start_time":{"type":"integer","minimum":0,"description":"\xB5s since epoch"},"end_time":{"type":"integer","minimum":0,"description":"\xB5s since epoch"},"from":{"type":"integer","minimum":0,"maximum":100},"size":{"type":"integer","minimum":-1,"maximum":1000}}},"search_type":{"type":"string","maxLength":20}}}}}},"responses":{"200":{"description":"Hits","content":{"application/json":{"schema":{"$ref":"#/components/schemas/SearchResponse"}}}},"400":{"description":"Unsupported SQL, or an unknown field (O2 lowercases every field; a camelCase column is unknown)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/O2Error"}}}},"401":{"description":"Bad Basic credentials, or an org the user cannot see \u2014 including an org's display name in place of its identifier","content":{"text/plain":{"schema":{"type":"string"}}}}}}}},"components":{"securitySchemes":{"bearerAuth":{"type":"http","scheme":"bearer"},"basicAuth":{"type":"http","scheme":"basic"}},"schemas":{"KeyValue":{"type":"object","required":["key","value"],"properties":{"key":{"type":"string","enum":["service.name","event","clientUserId","http.method","deployment.environment.name","attempt"]},"value":{"type":"object","properties":{"stringValue":{"type":"string","maxLength":20},"intValue":{"type":["string","integer"]},"boolValue":{"type":"boolean"},"doubleValue":{"type":"number"}}}}},"ExportTraceServiceRequest":{"type":"object","properties":{"resourceSpans":{"type":"array","maxItems":2,"items":{"type":"object","properties":{"resource":{"type":"object","properties":{"attributes":{"type":"array","maxItems":4,"items":{"$ref":"#/components/schemas/KeyValue"}}}},"scopeSpans":{"type":"array","maxItems":2,"items":{"type":"object","properties":{"scope":{"type":"object","properties":{"name":{"type":"string","maxLength":20}}},"spans":{"type":"array","maxItems":3,"items":{"type":"object","required":["traceId","spanId","name"],"properties":{"traceId":{"type":"string","pattern":"^[0-9a-f]{32}$"},"spanId":{"type":"string","pattern":"^[0-9a-f]{16}$"},"parentSpanId":{"type":"string","pattern":"^[0-9a-f]{16}$"},"name":{"type":"string","maxLength":30},"kind":{"type":"integer","minimum":0,"maximum":5},"startTimeUnixNano":{"type":"string","pattern":"^1[0-9]{18}$"},"endTimeUnixNano":{"type":"string","pattern":"^1[0-9]{18}$"},"attributes":{"type":"array","maxItems":4,"items":{"$ref":"#/components/schemas/KeyValue"}},"status":{"type":"object","properties":{"code":{"type":"integer","minimum":0,"maximum":2},"message":{"type":"string","maxLength":40}}}}}}}}}}}}}},"ExportLogsServiceRequest":{"type":"object","properties":{"resourceLogs":{"type":"array","maxItems":2,"items":{"type":"object","properties":{"resource":{"type":"object","properties":{"attributes":{"type":"array","maxItems":4,"items":{"$ref":"#/components/schemas/KeyValue"}}}},"scopeLogs":{"type":"array","maxItems":2,"items":{"type":"object","properties":{"scope":{"type":"object","properties":{"name":{"type":"string","maxLength":20}}},"logRecords":{"type":"array","maxItems":3,"items":{"type":"object","properties":{"timeUnixNano":{"type":"string","pattern":"^1[0-9]{18}$"},"observedTimeUnixNano":{"type":"string","pattern":"^1[0-9]{18}$"},"severityNumber":{"type":"integer","minimum":0,"maximum":24},"severityText":{"type":"string","enum":["TRACE","DEBUG","INFO","WARN","ERROR","FATAL","info","error"]},"body":{"type":"object","properties":{"stringValue":{"type":"string","maxLength":40}}},"attributes":{"type":"array","maxItems":4,"items":{"$ref":"#/components/schemas/KeyValue"}},"traceId":{"type":"string","pattern":"^[0-9a-f]{32}$"},"spanId":{"type":"string","pattern":"^[0-9a-f]{16}$"}}}}}}}}}}}},"ExportMetricsServiceRequest":{"type":"object","properties":{"resourceMetrics":{"type":"array","maxItems":2,"items":{"type":"object","properties":{"resource":{"type":"object","properties":{"attributes":{"type":"array","maxItems":4,"items":{"$ref":"#/components/schemas/KeyValue"}}}},"scopeMetrics":{"type":"array","maxItems":2,"items":{"type":"object","properties":{"metrics":{"type":"array","maxItems":3,"items":{"type":"object","properties":{"name":{"type":"string","maxLength":30},"unit":{"type":"string","maxLength":10}}}}}}}}}}}},"ExportResponse":{"type":"object","required":["partialSuccess"],"properties":{"partialSuccess":{"type":"object","properties":{"rejectedSpans":{"type":["string","integer"]},"rejectedLogRecords":{"type":["string","integer"]},"rejectedDataPoints":{"type":["string","integer"]},"errorMessage":{"type":"string"}}}}},"RpcStatus":{"type":"object","required":["code","message"],"properties":{"code":{"type":"integer"},"message":{"type":"string"}}},"O2Error":{"type":"object","required":["code","message"],"properties":{"code":{"type":"integer"},"message":{"type":"string"},"error_detail":{"type":"string"}}},"Organizations":{"type":"object","required":["data"],"properties":{"data":{"type":"array","items":{"type":"object","required":["identifier","name"],"properties":{"id":{"type":"integer"},"identifier":{"type":"string","x-mockingbird-resource":{"type":"organization","identity":true}},"name":{"type":"string"},"type":{"type":"string"}}}}}},"StreamList":{"type":"object","required":["list"],"properties":{"list":{"type":"array","items":{"type":"object","required":["name","stream_type"],"properties":{"name":{"type":"string"},"stream_type":{"type":"string"},"storage_type":{"type":"string"},"stats":{"type":"object"}}}}}},"StreamSchema":{"type":"object","required":["name","stream_type","schema"],"properties":{"name":{"type":"string"},"stream_type":{"type":"string"},"storage_type":{"type":"string"},"stats":{"type":"object"},"schema":{"type":"array","items":{"type":"object","required":["name","type"],"properties":{"name":{"type":"string"},"type":{"type":"string","enum":["Utf8","Int64","Float64","Boolean"]}}}},"settings":{"type":"object"}}},"SearchResponse":{"type":"object","required":["took","hits","total","from","size"],"properties":{"took":{"type":"integer","x-mockingbird-volatile":{"kind":"opaque"}},"hits":{"type":"array","items":{"type":"object"}},"total":{"type":"integer"},"from":{"type":"integer"},"size":{"type":"integer"},"scan_size":{"type":"integer"},"scan_records":{"type":"integer"},"is_partial":{"type":"boolean"},"cached_ratio":{"type":"integer"}}}}}}`);
+var operationIds = ["ExportTraces", "ExportLogs", "ExportMetrics", "ListOrganizations", "ListStreams", "GetStreamSchema", "Search"];
+var supportedOperationIds = ["ExportTraces", "ExportLogs", "ExportMetrics", "ListOrganizations", "ListStreams", "GetStreamSchema", "Search"];
+
+// src/otlp.ts
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pick = (object, camel) => {
+  if (object[camel] !== void 0) return object[camel];
+  const snake = camel.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+  return object[snake];
+};
+var list = (object, camel) => {
+  const value = pick(object, camel);
+  return Array.isArray(value) ? value.filter(isRecord4) : [];
+};
+var formatKey = (key) => key.toLowerCase().replace(/[^a-z0-9_]/g, "_");
+var nanos = (value) => {
+  try {
+    if (typeof value === "string" && /^\d+$/.test(value)) return BigInt(value);
+    if (typeof value === "number" && Number.isFinite(value)) return BigInt(Math.trunc(value));
+    if (isRecord4(value) && typeof value.low === "number" && typeof value.high === "number") {
+      return BigInt(value.high >>> 0) << 32n | BigInt(value.low >>> 0);
+    }
+  } catch {
+  }
+  return 0n;
+};
+var id = (value, bytes) => {
+  if (typeof value !== "string" || value === "") return void 0;
+  let hex2 = value.toLowerCase();
+  if (!new RegExp(`^[0-9a-f]{${bytes * 2}}$`).test(hex2)) {
+    try {
+      hex2 = Array.from(atob(value), (c) => c.charCodeAt(0).toString(16).padStart(2, "0")).join("");
+    } catch {
+      return void 0;
+    }
+  }
+  return /^0+$/.test(hex2) ? void 0 : hex2;
+};
+var anyValue = (value) => {
+  if (!isRecord4(value)) return null;
+  const string = pick(value, "stringValue");
+  if (typeof string === "string") return string;
+  const bool = pick(value, "boolValue");
+  if (typeof bool === "boolean") return bool;
+  const int = pick(value, "intValue");
+  if (typeof int === "string" || typeof int === "number") return Number(int);
+  const double = pick(value, "doubleValue");
+  if (typeof double === "number") return double;
+  const bytes = pick(value, "bytesValue");
+  if (typeof bytes === "string") return bytes;
+  const array = pick(value, "arrayValue");
+  if (isRecord4(array)) {
+    return JSON.stringify(list(array, "values").map((v) => plain(anyValue(v))));
+  }
+  const kvlist = pick(value, "kvlistValue");
+  if (isRecord4(kvlist)) {
+    const out = {};
+    for (const kv of list(kvlist, "values")) {
+      if (typeof kv.key === "string") out[kv.key] = anyValue(kv.value);
+    }
+    return out;
+  }
+  return null;
+};
+var plain = (value) => value !== null && typeof value === "object" ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, plain(v)])) : value;
+var flattenInto = (row, attributes, prefix = "") => {
+  const put2 = (key, value) => {
+    if (value === null) return;
+    if (typeof value === "object") {
+      for (const [k, v] of Object.entries(value)) put2(`${key}_${formatKey(k)}`, v);
+      return;
+    }
+    row[key] = value;
+  };
+  for (const kv of attributes) {
+    if (typeof kv.key !== "string" || kv.key === "") continue;
+    put2(`${prefix}${formatKey(kv.key)}`, anyValue(kv.value));
+  }
+};
+var resourceColumns = (group) => {
+  const resource = pick(group, "resource");
+  const kvs = isRecord4(resource) ? list(resource, "attributes") : [];
+  const attributes = {};
+  const columns = {};
+  for (const kv of kvs) {
+    if (typeof kv.key !== "string") continue;
+    const value = anyValue(kv.value);
+    if (value !== null && typeof value !== "object") attributes[kv.key] = value;
+    if (kv.key === "service.name") {
+      if (value !== null && typeof value !== "object") columns.service_name = value;
+    } else flattenInto(columns, [kv], "service_");
+  }
+  return { attributes, columns };
+};
+var bodyText = (value) => {
+  if (value === null) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "object") return JSON.stringify(plain(value));
+  return String(value);
+};
+var logRows = (request, options) => {
+  const out = [];
+  for (const group of list(request, "resourceLogs")) {
+    const { attributes, columns } = resourceColumns(group);
+    for (const scoped of list(group, "scopeLogs")) {
+      for (const record of list(scoped, "logRecords")) {
+        const row = { ...columns };
+        flattenInto(row, list(record, "attributes"));
+        const time = nanos(pick(record, "timeUnixNano")) || nanos(pick(record, "observedTimeUnixNano"));
+        row._timestamp = time > 0n ? Number(time / 1000n) : options.nowMs * 1e3;
+        const severityText = pick(record, "severityText");
+        if (typeof severityText === "string" && severityText !== "") {
+          row.severity_text = severityText;
+        }
+        const severityNumber = Number(pick(record, "severityNumber") ?? 0);
+        if (Number.isFinite(severityNumber) && severityNumber > 0) {
+          row.severity_number = severityNumber;
+        }
+        const traceId = id(pick(record, "traceId"), 16);
+        if (traceId) row.trace_id = traceId;
+        const spanId = id(pick(record, "spanId"), 8);
+        if (spanId) row.span_id = spanId;
+        const eventName = pick(record, "eventName");
+        if (typeof eventName === "string" && eventName !== "") row.event_name = eventName;
+        const body = bodyText(anyValue(pick(record, "body")));
+        const hadBody = body !== null && body !== "";
+        if (hadBody && options.keepBodies) row.body = body;
+        out.push({ resource: attributes, row, hadBody });
+      }
+    }
+  }
+  return out;
+};
+var STATUS = ["UNSET", "OK", "ERROR"];
+var spanRows = (request, options) => {
+  const out = [];
+  for (const group of list(request, "resourceSpans")) {
+    const { attributes, columns } = resourceColumns(group);
+    for (const scoped of list(group, "scopeSpans")) {
+      for (const span of list(scoped, "spans")) {
+        const row = { ...columns };
+        flattenInto(row, list(span, "attributes"));
+        const start = nanos(pick(span, "startTimeUnixNano"));
+        const end = nanos(pick(span, "endTimeUnixNano"));
+        const startNs = start > 0n ? start : BigInt(options.nowMs) * 1000000n;
+        const endNs = end > 0n ? end : startNs;
+        row.start_time = Number(startNs);
+        row.end_time = Number(endNs);
+        row.duration = Number((endNs - startNs) / 1000n);
+        row._timestamp = Number(startNs / 1000n);
+        const traceId = id(pick(span, "traceId"), 16);
+        if (traceId) row.trace_id = traceId;
+        const spanId = id(pick(span, "spanId"), 8);
+        if (spanId) row.span_id = spanId;
+        const parent = id(pick(span, "parentSpanId"), 8);
+        if (parent) {
+          row.reference_parent_span_id = parent;
+          row.reference_ref_type = "ChildOf";
+        }
+        const name = pick(span, "name");
+        if (typeof name === "string") row.operation_name = name;
+        row.span_kind = String(Number(pick(span, "kind") ?? 0));
+        const status = pick(span, "status");
+        const code = isRecord4(status) ? Number(pick(status, "code") ?? 0) : 0;
+        row.span_status = STATUS[code] ?? "UNSET";
+        const events = list(span, "events").map((event) => {
+          const flat = {};
+          flattenInto(flat, list(event, "attributes"));
+          return {
+            name: typeof event.name === "string" ? event.name : "",
+            _timestamp: Number(nanos(pick(event, "timeUnixNano")) / 1000n),
+            ...flat
+          };
+        });
+        row.events = JSON.stringify(events);
+        const scope = pick(scoped, "scope");
+        if (isRecord4(scope) && typeof scope.name === "string" && scope.name !== "") {
+          row.instrumentation_library_name = scope.name;
+        }
+        out.push({ resource: attributes, row, hadBody: false });
+      }
+    }
+  }
+  return out;
+};
+var metricCount = (request) => list(request, "resourceMetrics").reduce(
+  (total, group) => total + list(group, "scopeMetrics").reduce((sum, scoped) => sum + list(scoped, "metrics").length, 0),
+  0
+);
+
+// src/protobuf.ts
+var ProtobufError = class extends Error {
+  constructor(message) {
+    super(`invalid protobuf: ${message}`);
+    this.name = "ProtobufError";
+  }
+};
+var utf82 = new TextDecoder("utf-8", { fatal: false });
+var Reader = class {
+  constructor(buf) {
+    this.buf = buf;
+  }
+  buf;
+  pos = 0;
+  get done() {
+    return this.pos >= this.buf.length;
+  }
+  varint() {
+    let result = 0n;
+    let shift = 0n;
+    for (let i = 0; i < 10; i++) {
+      if (this.pos >= this.buf.length) throw new ProtobufError("truncated varint");
+      const byte = this.buf[this.pos++];
+      result |= BigInt(byte & 127) << shift;
+      if ((byte & 128) === 0) return result;
+      shift += 7n;
+    }
+    throw new ProtobufError("varint longer than 10 bytes");
+  }
+  fixed64() {
+    const bytes = this.take(8);
+    let result = 0n;
+    for (let i = 7; i >= 0; i--) result = result << 8n | BigInt(bytes[i]);
+    return result;
+  }
+  fixed32() {
+    const bytes = this.take(4);
+    return new DataView(bytes.buffer, bytes.byteOffset, 4).getUint32(0, true);
+  }
+  double() {
+    const bytes = this.take(8);
+    return new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, true);
+  }
+  bytes() {
+    return this.take(Number(this.varint()));
+  }
+  take(length) {
+    if (length < 0 || this.pos + length > this.buf.length) {
+      throw new ProtobufError("length-delimited field runs past the end");
+    }
+    const out = this.buf.subarray(this.pos, this.pos + length);
+    this.pos += length;
+    return out;
+  }
+  skip(wireType) {
+    if (wireType === 0) this.varint();
+    else if (wireType === 1) this.take(8);
+    else if (wireType === 2) this.bytes();
+    else if (wireType === 5) this.take(4);
+    else throw new ProtobufError(`unsupported wire type ${wireType}`);
+  }
+};
+var walk = (bytes, handler) => {
+  const reader = new Reader(bytes);
+  while (!reader.done) {
+    const key = Number(reader.varint());
+    const field = key >>> 3;
+    const wireType = key & 7;
+    if (field === 0) throw new ProtobufError("field number 0");
+    if (!handler(field, wireType, reader)) reader.skip(wireType);
+  }
+};
+var hex = (bytes) => Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+var base64 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+var int64 = (value) => BigInt.asIntN(64, value).toString();
+var decodeAnyValue = (bytes) => {
+  let out = {};
+  walk(bytes, (field, wire, r) => {
+    if (field === 1 && wire === 2) out = { stringValue: utf82.decode(r.bytes()) };
+    else if (field === 2 && wire === 0) out = { boolValue: r.varint() !== 0n };
+    else if (field === 3 && wire === 0) out = { intValue: int64(r.varint()) };
+    else if (field === 4 && wire === 1) out = { doubleValue: r.double() };
+    else if (field === 5 && wire === 2) out = { arrayValue: { values: decodeValues(r.bytes()) } };
+    else if (field === 6 && wire === 2) {
+      out = { kvlistValue: { values: decodeKeyValues(r.bytes()) } };
+    } else if (field === 7 && wire === 2) out = { bytesValue: base64(r.bytes()) };
+    else return false;
+    return true;
+  });
+  return out;
+};
+var decodeValues = (bytes) => {
+  const values = [];
+  walk(bytes, (field, wire, r) => {
+    if (field !== 1 || wire !== 2) return false;
+    values.push(decodeAnyValue(r.bytes()));
+    return true;
+  });
+  return values;
+};
+var decodeKeyValues = (bytes) => {
+  const values = [];
+  walk(bytes, (field, wire, r) => {
+    if (field !== 1 || wire !== 2) return false;
+    values.push(decodeKeyValue(r.bytes()));
+    return true;
+  });
+  return values;
+};
+var decodeKeyValue = (bytes) => {
+  const kv = { key: "" };
+  walk(bytes, (field, wire, r) => {
+    if (field === 1 && wire === 2) kv.key = utf82.decode(r.bytes());
+    else if (field === 2 && wire === 2) kv.value = decodeAnyValue(r.bytes());
+    else return false;
+    return true;
+  });
+  return kv;
+};
+var decodeResource = (bytes) => {
+  const attributes = [];
+  walk(bytes, (field, wire, r) => {
+    if (field !== 1 || wire !== 2) return false;
+    attributes.push(decodeKeyValue(r.bytes()));
+    return true;
+  });
+  return { attributes };
+};
+var decodeScope = (bytes) => {
+  const scope = {};
+  walk(bytes, (field, wire, r) => {
+    if (field === 1 && wire === 2) scope.name = utf82.decode(r.bytes());
+    else if (field === 2 && wire === 2) scope.version = utf82.decode(r.bytes());
+    else return false;
+    return true;
+  });
+  return scope;
+};
+var decodeEvent = (bytes) => {
+  const event = { attributes: [] };
+  walk(bytes, (field, wire, r) => {
+    if (field === 1 && wire === 1) event.timeUnixNano = r.fixed64().toString();
+    else if (field === 2 && wire === 2) event.name = utf82.decode(r.bytes());
+    else if (field === 3 && wire === 2) {
+      ;
+      event.attributes.push(decodeKeyValue(r.bytes()));
+    } else return false;
+    return true;
+  });
+  return event;
+};
+var decodeStatus = (bytes) => {
+  const status = {};
+  walk(bytes, (field, wire, r) => {
+    if (field === 2 && wire === 2) status.message = utf82.decode(r.bytes());
+    else if (field === 3 && wire === 0) status.code = Number(r.varint());
+    else return false;
+    return true;
+  });
+  return status;
+};
+var decodeSpan = (bytes) => {
+  const span = { attributes: [], events: [] };
+  walk(bytes, (field, wire, r) => {
+    if (field === 1 && wire === 2) span.traceId = hex(r.bytes());
+    else if (field === 2 && wire === 2) span.spanId = hex(r.bytes());
+    else if (field === 3 && wire === 2) span.traceState = utf82.decode(r.bytes());
+    else if (field === 4 && wire === 2) span.parentSpanId = hex(r.bytes());
+    else if (field === 5 && wire === 2) span.name = utf82.decode(r.bytes());
+    else if (field === 6 && wire === 0) span.kind = Number(r.varint());
+    else if (field === 7 && wire === 1) span.startTimeUnixNano = r.fixed64().toString();
+    else if (field === 8 && wire === 1) span.endTimeUnixNano = r.fixed64().toString();
+    else if (field === 9 && wire === 2) {
+      ;
+      span.attributes.push(decodeKeyValue(r.bytes()));
+    } else if (field === 11 && wire === 2) span.events.push(decodeEvent(r.bytes()));
+    else if (field === 15 && wire === 2) span.status = decodeStatus(r.bytes());
+    else if (field === 16 && wire === 5) span.flags = r.fixed32();
+    else return false;
+    return true;
+  });
+  return span;
+};
+var decodeLogRecord = (bytes) => {
+  const log = { attributes: [] };
+  walk(bytes, (field, wire, r) => {
+    if (field === 1 && wire === 1) log.timeUnixNano = r.fixed64().toString();
+    else if (field === 2 && wire === 0) log.severityNumber = Number(r.varint());
+    else if (field === 3 && wire === 2) log.severityText = utf82.decode(r.bytes());
+    else if (field === 5 && wire === 2) log.body = decodeAnyValue(r.bytes());
+    else if (field === 6 && wire === 2) {
+      ;
+      log.attributes.push(decodeKeyValue(r.bytes()));
+    } else if (field === 8 && wire === 5) log.flags = r.fixed32();
+    else if (field === 9 && wire === 2) log.traceId = hex(r.bytes());
+    else if (field === 10 && wire === 2) log.spanId = hex(r.bytes());
+    else if (field === 11 && wire === 1) log.observedTimeUnixNano = r.fixed64().toString();
+    else if (field === 12 && wire === 2) log.eventName = utf82.decode(r.bytes());
+    else return false;
+    return true;
+  });
+  return log;
+};
+var decodeResourceGroup = (bytes, scopeKey, itemsKey, decodeItem) => {
+  const group = { [scopeKey]: [] };
+  walk(bytes, (field, wire, r) => {
+    if (field === 1 && wire === 2) group.resource = decodeResource(r.bytes());
+    else if (field === 2 && wire === 2) {
+      const scoped = { [itemsKey]: [] };
+      walk(r.bytes(), (f, w, inner) => {
+        if (f === 1 && w === 2) scoped.scope = decodeScope(inner.bytes());
+        else if (f === 2 && w === 2) scoped[itemsKey].push(decodeItem(inner.bytes()));
+        else return false;
+        return true;
+      });
+      group[scopeKey].push(scoped);
+    } else return false;
+    return true;
+  });
+  return group;
+};
+var decodeTraceRequest = (bytes) => {
+  const resourceSpans = [];
+  walk(bytes, (field, wire, r) => {
+    if (field !== 1 || wire !== 2) return false;
+    resourceSpans.push(decodeResourceGroup(r.bytes(), "scopeSpans", "spans", decodeSpan));
+    return true;
+  });
+  return { resourceSpans };
+};
+var decodeLogsRequest = (bytes) => {
+  const resourceLogs = [];
+  walk(bytes, (field, wire, r) => {
+    if (field !== 1 || wire !== 2) return false;
+    resourceLogs.push(decodeResourceGroup(r.bytes(), "scopeLogs", "logRecords", decodeLogRecord));
+    return true;
+  });
+  return { resourceLogs };
+};
+var countMetricsRequest = (bytes) => {
+  let count = 0;
+  walk(bytes, (field, wire, r) => {
+    if (field !== 1 || wire !== 2) return false;
+    r.bytes();
+    count++;
+    return true;
+  });
+  return count;
+};
+
+// src/sql.ts
+var SqlError = class extends Error {
+  constructor(message, kind = "syntax") {
+    super(message);
+    this.kind = kind;
+    this.name = "SqlError";
+  }
+  kind;
+};
+var tokenize = (sql) => {
+  const tokens = [];
+  let i = 0;
+  while (i < sql.length) {
+    const c = sql[i];
+    if (/\s/.test(c)) {
+      i++;
+      continue;
+    }
+    if (c === "-" && sql[i + 1] === "-") {
+      while (i < sql.length && sql[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "'") {
+      let value = "";
+      i++;
+      for (; ; ) {
+        if (i >= sql.length) throw new SqlError("unterminated string literal");
+        if (sql[i] === "'") {
+          if (sql[i + 1] === "'") {
+            value += "'";
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        value += sql[i++];
+      }
+      tokens.push({ t: "str", v: value });
+      continue;
+    }
+    if (c === '"') {
+      const end = sql.indexOf('"', i + 1);
+      if (end < 0) throw new SqlError("unterminated quoted identifier");
+      tokens.push({ t: "ident", v: sql.slice(i + 1, end), quoted: true });
+      i = end + 1;
+      continue;
+    }
+    const number = /^\d+(\.\d+)?/.exec(sql.slice(i));
+    if (number) {
+      tokens.push({ t: "num", v: Number(number[0]) });
+      i += number[0].length;
+      continue;
+    }
+    const word = /^[A-Za-z_][A-Za-z0-9_]*/.exec(sql.slice(i));
+    if (word) {
+      tokens.push({ t: "ident", v: word[0], quoted: false });
+      i += word[0].length;
+      continue;
+    }
+    const op = /^(<=|>=|<>|!=|=|<|>|\(|\)|,|\*|;|\+|-)/.exec(sql.slice(i));
+    if (op) {
+      tokens.push({ t: "op", v: op[0] });
+      i += op[0].length;
+      continue;
+    }
+    throw new SqlError(`unexpected character ${JSON.stringify(c)}`);
+  }
+  return tokens;
+};
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "select",
+  "from",
+  "where",
+  "group",
+  "by",
+  "having",
+  "order",
+  "limit",
+  "offset",
+  "and",
+  "or",
+  "not",
+  "is",
+  "null",
+  "in",
+  "like",
+  "ilike",
+  "between",
+  "as",
+  "asc",
+  "desc",
+  "distinct",
+  "true",
+  "false"
+]);
+var AGGREGATES = /* @__PURE__ */ new Set(["count", "min", "max", "sum", "avg"]);
+var FUNCTIONS = /* @__PURE__ */ new Set([
+  ...AGGREGATES,
+  "str_match",
+  "str_match_ignore_case",
+  "match_all",
+  "match_all_ignore_case",
+  "re_match",
+  "lower",
+  "upper",
+  "tostring",
+  "length",
+  "coalesce"
+]);
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  pos = 0;
+  peek(offset = 0) {
+    return this.tokens[this.pos + offset];
+  }
+  isKeyword(word, offset = 0) {
+    const token = this.peek(offset);
+    return token?.t === "ident" && !token.quoted && token.v.toLowerCase() === word;
+  }
+  isOp(op) {
+    const token = this.peek();
+    return token?.t === "op" && token.v === op;
+  }
+  keyword(word) {
+    if (!this.isKeyword(word)) throw new SqlError(`expected ${word.toUpperCase()}`);
+    this.pos++;
+  }
+  op(op) {
+    if (!this.isOp(op)) throw new SqlError(`expected ${op}`);
+    this.pos++;
+  }
+  accept(word) {
+    if (!this.isKeyword(word)) return false;
+    this.pos++;
+    return true;
+  }
+  parse() {
+    this.keyword("select");
+    this.accept("distinct");
+    let star = false;
+    const items = [];
+    do {
+      if (this.isOp("*")) {
+        this.pos++;
+        star = true;
+        continue;
+      }
+      const start = this.pos;
+      const expr = this.expr();
+      const end = this.pos;
+      let alias;
+      if (this.accept("as")) alias = this.identifier();
+      else {
+        const next = this.peek();
+        if (next?.t === "ident" && (next.quoted || !KEYWORDS.has(next.v.toLowerCase()))) {
+          alias = this.identifier();
+        }
+      }
+      items.push({ expr, alias, text: this.text(start, end) });
+    } while (this.isOp(",") && ++this.pos);
+    this.keyword("from");
+    const stream = this.identifier();
+    let where;
+    if (this.accept("where")) where = this.expr();
+    const groupBy = [];
+    if (this.accept("group")) {
+      this.keyword("by");
+      do
+        groupBy.push(this.expr());
+      while (this.isOp(",") && ++this.pos);
+    }
+    let having;
+    if (this.accept("having")) having = this.expr();
+    const orderBy = [];
+    if (this.accept("order")) {
+      this.keyword("by");
+      do {
+        const expr = this.expr();
+        const desc = this.accept("desc");
+        if (!desc) this.accept("asc");
+        orderBy.push({ expr, desc });
+      } while (this.isOp(",") && ++this.pos);
+    }
+    let limit;
+    let offset = 0;
+    if (this.accept("limit")) limit = this.integer();
+    if (this.accept("offset")) offset = this.integer();
+    if (this.isOp(";")) this.pos++;
+    if (this.pos < this.tokens.length) throw new SqlError("unexpected tokens after the query");
+    return { star, items, stream, where, groupBy, having, orderBy, limit, offset };
+  }
+  text(from, to) {
+    return this.tokens.slice(from, to).map((t) => t.t === "str" ? `'${t.v}'` : String(t.v)).join("").toLowerCase();
+  }
+  integer() {
+    const token = this.peek();
+    if (token?.t !== "num" || !Number.isInteger(token.v)) throw new SqlError("expected an integer");
+    this.pos++;
+    return token.v;
+  }
+  identifier() {
+    const token = this.peek();
+    if (token?.t !== "ident") throw new SqlError("expected an identifier");
+    this.pos++;
+    return token.v;
+  }
+  expr() {
+    let left = this.and();
+    while (this.accept("or")) left = { k: "or", l: left, r: this.and() };
+    return left;
+  }
+  and() {
+    let left = this.not();
+    while (this.accept("and")) left = { k: "and", l: left, r: this.not() };
+    return left;
+  }
+  not() {
+    if (this.accept("not")) return { k: "not", e: this.not() };
+    return this.predicate();
+  }
+  predicate() {
+    const e = this.primary();
+    if (this.accept("is")) {
+      const not2 = this.accept("not");
+      this.keyword("null");
+      return { k: "null", e, not: not2 };
+    }
+    const not = this.isKeyword("not") && (this.isKeyword("in", 1) || this.isKeyword("like", 1) || this.isKeyword("ilike", 1) || this.isKeyword("between", 1));
+    if (not) this.pos++;
+    if (this.accept("in")) {
+      this.op("(");
+      const list2 = [];
+      do
+        list2.push(this.primary());
+      while (this.isOp(",") && ++this.pos);
+      this.op(")");
+      return { k: "in", e, list: list2, not };
+    }
+    if (this.isKeyword("like") || this.isKeyword("ilike")) {
+      const ci = this.isKeyword("ilike");
+      this.pos++;
+      return { k: "like", e, pattern: this.primary(), not, ci };
+    }
+    if (this.accept("between")) {
+      const lo = this.primary();
+      this.keyword("and");
+      return { k: "between", e, lo, hi: this.primary(), not };
+    }
+    if (not) throw new SqlError("expected IN, LIKE or BETWEEN after NOT");
+    const token = this.peek();
+    if (token?.t === "op" && ["=", "!=", "<>", "<", "<=", ">", ">="].includes(token.v)) {
+      this.pos++;
+      return { k: "cmp", op: token.v === "<>" ? "!=" : token.v, l: e, r: this.primary() };
+    }
+    return e;
+  }
+  primary() {
+    const token = this.peek();
+    if (!token) throw new SqlError("unexpected end of query");
+    if (token.t === "str") {
+      this.pos++;
+      return { k: "lit", v: token.v };
+    }
+    if (token.t === "num") {
+      this.pos++;
+      return { k: "lit", v: token.v };
+    }
+    if (token.t === "op" && token.v === "-") {
+      this.pos++;
+      const next = this.peek();
+      if (next?.t !== "num") throw new SqlError("expected a number after -");
+      this.pos++;
+      return { k: "lit", v: -next.v };
+    }
+    if (token.t === "op" && token.v === "(") {
+      this.pos++;
+      const inner = this.expr();
+      this.op(")");
+      return inner;
+    }
+    if (token.t === "op" && token.v === "*") {
+      this.pos++;
+      return { k: "star" };
+    }
+    if (token.t === "ident") {
+      this.pos++;
+      if (!token.quoted) {
+        const lower = token.v.toLowerCase();
+        if (lower === "null") return { k: "lit", v: null };
+        if (lower === "true" || lower === "false") return { k: "lit", v: lower === "true" };
+        if (this.isOp("(")) {
+          if (!FUNCTIONS.has(lower)) throw new SqlError(`unsupported function ${token.v}`);
+          this.pos++;
+          const distinct = this.accept("distinct");
+          const args = [];
+          if (!this.isOp(")")) {
+            do
+              args.push(this.expr());
+            while (this.isOp(",") && ++this.pos);
+          }
+          this.op(")");
+          return { k: "fn", name: lower, args, distinct };
+        }
+        if (KEYWORDS.has(lower)) throw new SqlError(`unexpected keyword ${token.v.toUpperCase()}`);
+      }
+      return { k: "col", name: token.v };
+    }
+    throw new SqlError(`unexpected ${token.v}`);
+  }
+};
+var parseSql = (sql) => new Parser(tokenize(sql)).parse();
+var referencedColumns = (query) => {
+  const aliases = new Set(query.items.map((i) => i.alias).filter(Boolean));
+  const out = /* @__PURE__ */ new Set();
+  const visit = (e, aliasOk) => {
+    if (!e) return;
+    switch (e.k) {
+      case "col":
+        if (!(aliasOk && aliases.has(e.name))) out.add(e.name);
+        return;
+      case "fn":
+        for (const a of e.args) visit(a, aliasOk);
+        return;
+      case "not":
+      case "null":
+        visit(e.e, aliasOk);
+        return;
+      case "and":
+      case "or":
+      case "cmp":
+        visit(e.l, aliasOk);
+        visit(e.r, aliasOk);
+        return;
+      case "in":
+        visit(e.e, aliasOk);
+        for (const x of e.list) visit(x, aliasOk);
+        return;
+      case "like":
+        visit(e.e, aliasOk);
+        visit(e.pattern, aliasOk);
+        return;
+      case "between":
+        visit(e.e, aliasOk);
+        visit(e.lo, aliasOk);
+        visit(e.hi, aliasOk);
+        return;
+      default:
+        return;
+    }
+  };
+  for (const item of query.items) visit(item.expr, false);
+  visit(query.where, false);
+  for (const g of query.groupBy) visit(g, true);
+  visit(query.having, true);
+  for (const o of query.orderBy) visit(o.expr, true);
+  return [...out];
+};
+var hasAggregate = (e) => {
+  switch (e.k) {
+    case "fn":
+      return AGGREGATES.has(e.name) || e.args.some(hasAggregate);
+    case "not":
+    case "null":
+      return hasAggregate(e.e);
+    case "and":
+    case "or":
+    case "cmp":
+      return hasAggregate(e.l) || hasAggregate(e.r);
+    default:
+      return false;
+  }
+};
+var asMicros = (value) => {
+  if (/^\d+(\.\d+)?$/.test(value)) return Number(value);
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? void 0 : ms * 1e3;
+};
+var compare = (a, b) => {
+  if (a === null || b === null) return null;
+  if (typeof a === "number" && typeof b === "string") {
+    const n = asMicros(b);
+    return n === void 0 ? String(a).localeCompare(b) : a - n;
+  }
+  if (typeof a === "string" && typeof b === "number") {
+    const n = asMicros(a);
+    return n === void 0 ? a.localeCompare(String(b)) : n - b;
+  }
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "boolean" || typeof b === "boolean") return String(a) === String(b) ? 0 : 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+};
+var likeRegex = (pattern, ci) => new RegExp(
+  `^${pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".")}$`,
+  ci ? "is" : "s"
+);
+var text = (v) => v === null ? null : String(v);
+var truthy = (v) => v === true;
+var evaluate = (e, ctx) => {
+  switch (e.k) {
+    case "lit":
+      return e.v;
+    case "col":
+      if (ctx.aliases && e.name in ctx.aliases) return ctx.aliases[e.name] ?? null;
+      return ctx.row[e.name] ?? null;
+    case "star":
+      return null;
+    case "not": {
+      const v = evaluate(e.e, ctx);
+      return v === null ? null : !truthy(v);
+    }
+    case "and": {
+      const l = evaluate(e.l, ctx);
+      if (l === false) return false;
+      const r = evaluate(e.r, ctx);
+      if (r === false) return false;
+      return l === null || r === null ? null : truthy(l) && truthy(r);
+    }
+    case "or": {
+      const l = evaluate(e.l, ctx);
+      if (truthy(l)) return true;
+      const r = evaluate(e.r, ctx);
+      if (truthy(r)) return true;
+      return l === null || r === null ? null : false;
+    }
+    case "cmp": {
+      const c = compare(evaluate(e.l, ctx), evaluate(e.r, ctx));
+      if (c === null) return null;
+      switch (e.op) {
+        case "=":
+          return c === 0;
+        case "!=":
+          return c !== 0;
+        case "<":
+          return c < 0;
+        case "<=":
+          return c <= 0;
+        case ">":
+          return c > 0;
+        default:
+          return c >= 0;
+      }
+    }
+    case "null": {
+      const isNull = evaluate(e.e, ctx) === null;
+      return e.not ? !isNull : isNull;
+    }
+    case "in": {
+      const v = evaluate(e.e, ctx);
+      if (v === null) return null;
+      const found = e.list.some((x) => compare(v, evaluate(x, ctx)) === 0);
+      return e.not ? !found : found;
+    }
+    case "like": {
+      const v = text(evaluate(e.e, ctx));
+      const p = text(evaluate(e.pattern, ctx));
+      if (v === null || p === null) return null;
+      const matched = likeRegex(p, e.ci).test(v);
+      return e.not ? !matched : matched;
+    }
+    case "between": {
+      const v = evaluate(e.e, ctx);
+      const lo = compare(v, evaluate(e.lo, ctx));
+      const hi = compare(v, evaluate(e.hi, ctx));
+      if (lo === null || hi === null) return null;
+      const inside = lo >= 0 && hi <= 0;
+      return e.not ? !inside : inside;
+    }
+    case "fn":
+      return call(e, ctx);
+  }
+};
+var call = (e, ctx) => {
+  if (AGGREGATES.has(e.name)) {
+    const rows = ctx.group ?? [ctx.row];
+    const arg = e.args[0];
+    if (e.name === "count") {
+      if (!arg || arg.k === "star") return rows.length;
+      const values2 = rows.map((row) => evaluate(arg, { row })).filter((v) => v !== null);
+      return e.distinct ? new Set(values2.map((v) => JSON.stringify(v))).size : values2.length;
+    }
+    if (!arg) throw new SqlError(`${e.name}() needs an argument`);
+    const values = rows.map((row) => evaluate(arg, { row })).filter((v) => v !== null);
+    if (values.length === 0) return null;
+    if (e.name === "min" || e.name === "max") {
+      return values.reduce((best, v) => {
+        const c = compare(v, best) ?? 0;
+        return (e.name === "min" ? c < 0 : c > 0) ? v : best;
+      });
+    }
+    const numbers = values.map(Number).filter((n) => Number.isFinite(n));
+    const sum = numbers.reduce((a2, b2) => a2 + b2, 0);
+    return e.name === "sum" ? sum : numbers.length === 0 ? null : sum / numbers.length;
+  }
+  const args = e.args.map((a2) => evaluate(a2, ctx));
+  const [a, b] = args;
+  switch (e.name) {
+    case "str_match":
+      return a === null || b === null ? false : String(a).includes(String(b));
+    case "str_match_ignore_case":
+      return a === null || b === null ? false : String(a).toLowerCase().includes(String(b).toLowerCase());
+    case "match_all":
+    case "match_all_ignore_case": {
+      if (a === null) return false;
+      const needle = String(a).toLowerCase();
+      return Object.values(ctx.row).some(
+        (v) => typeof v === "string" && v.toLowerCase().includes(needle)
+      );
+    }
+    case "re_match":
+      if (a === null || b === null) return false;
+      try {
+        return new RegExp(String(b)).test(String(a));
+      } catch {
+        throw new SqlError(`invalid regular expression ${String(b)}`);
+      }
+    case "lower":
+      return a === null || a === void 0 ? null : String(a).toLowerCase();
+    case "upper":
+      return a === null || a === void 0 ? null : String(a).toUpperCase();
+    case "tostring":
+      return a === null || a === void 0 ? null : String(a);
+    case "length":
+      return a === null || a === void 0 ? null : [...String(a)].length;
+    case "coalesce":
+      return args.find((v) => v !== null) ?? null;
+    default:
+      throw new SqlError(`unsupported function ${e.name}`);
+  }
+};
+var columnName = (item) => item.alias ?? (item.expr.k === "col" ? item.expr.name : item.text);
+var project = (query, ctx) => {
+  const out = {};
+  if (query.star) Object.assign(out, ctx.row);
+  for (const item of query.items) out[columnName(item)] = evaluate(item.expr, ctx);
+  return out;
+};
+var sortBy = (items, keys) => [...items].sort((x, y) => {
+  for (const key of keys) {
+    const a = key.value(x);
+    const b = key.value(y);
+    if (a === null && b === null) continue;
+    if (a === null) return 1;
+    if (b === null) return -1;
+    const c = compare(a, b) ?? 0;
+    if (c !== 0) return key.desc ? -c : c;
+  }
+  return 0;
+});
+var compact = (row) => {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) if (value !== null) out[key] = value;
+  return out;
+};
+var execute = (query, rows) => {
+  const where = query.where;
+  const matched = where ? rows.filter((row) => truthy(evaluate(where, { row }))) : rows;
+  const aggregated = query.groupBy.length > 0 || query.items.some((item) => hasAggregate(item.expr));
+  let output;
+  if (aggregated) {
+    if (query.star) throw new SqlError("SELECT * cannot be combined with GROUP BY or aggregates");
+    const groups = /* @__PURE__ */ new Map();
+    if (query.groupBy.length === 0) groups.set("", matched);
+    for (const row of query.groupBy.length > 0 ? matched : []) {
+      const key = JSON.stringify(query.groupBy.map((g) => evaluate(g, { row })));
+      groups.set(key, [...groups.get(key) ?? [], row]);
+    }
+    output = [];
+    for (const group of groups.values()) {
+      const ctx = { row: group[0] ?? {}, group };
+      const projected = project(query, ctx);
+      const having = query.having;
+      if (having && !truthy(evaluate(having, { ...ctx, aliases: projected }))) continue;
+      output.push(projected);
+    }
+    output = sortBy(
+      output,
+      query.orderBy.map((o) => ({
+        desc: o.desc,
+        value: (r) => evaluate(o.expr, { row: {}, aliases: r })
+      }))
+    );
+  } else {
+    const aliasExprs = new Map(
+      query.items.filter((i) => i.alias).map((i) => [i.alias, i.expr])
+    );
+    const order = query.orderBy.length > 0 ? query.orderBy : [{ expr: { k: "col", name: "_timestamp" }, desc: true }];
+    const sorted = sortBy(
+      matched,
+      order.map((o) => ({
+        desc: o.desc,
+        value: (row) => evaluate(
+          o.expr.k === "col" && aliasExprs.has(o.expr.name) ? aliasExprs.get(o.expr.name) : o.expr,
+          { row }
+        )
+      }))
+    );
+    output = sorted.map((row) => project(query, { row }));
+  }
+  const start = query.offset;
+  const end = query.limit === void 0 ? void 0 : start + query.limit;
+  return output.slice(start, end).map(compact);
+};
+
+// src/state.ts
+var DEFAULT_ORGANIZATIONS = [
+  { identifier: "default", name: "default" },
+  { identifier: "30rBqcDevOrg7Hn2KmQ4xW9sLtY", name: "development" },
+  { identifier: "3HSzeProdOrg5Jd8VpN1cR6gTfB", name: "production" }
+];
+var DEFAULT_SETTINGS = {
+  ingestTokens: [],
+  searchUsers: [],
+  organizations: [...DEFAULT_ORGANIZATIONS],
+  routing: { byEnvironment: { production: "production" }, default: "development" },
+  keepBodies: false
+};
+var typeOf = (value) => typeof value === "boolean" ? "Boolean" : typeof value === "number" ? Number.isInteger(value) ? "Int64" : "Float64" : "Utf8";
+var OtelState = class {
+  constructor(sqlite, namespace, seed) {
+    this.seed = seed;
+    this.rows = new Collection(sqlite, namespace, "rows");
+    this.schemas = new Collection(sqlite, namespace, "schemas");
+    this.counters = new Collection(sqlite, namespace, "counters");
+    this.settings = new Collection(sqlite, namespace, "settings");
+    this.ensureSeeded();
+  }
+  seed;
+  rows;
+  schemas;
+  counters;
+  settings;
+  ensureSeeded() {
+    if (!this.settings.has("settings")) {
+      this.settings.insert("settings", { ...DEFAULT_SETTINGS, ...this.seed.settings });
+    }
+  }
+  current() {
+    return this.settings.get("settings") ?? DEFAULT_SETTINGS;
+  }
+  update(patch) {
+    const next = { ...this.current(), ...patch };
+    this.settings.insert("settings", next);
+    return next;
+  }
+  /** The org an export lands in, from its resource attributes. */
+  routeOrg(resource) {
+    const settings = this.current();
+    const environment = String(
+      resource["deployment.environment.name"] ?? resource["deployment.environment"] ?? ""
+    );
+    const name = settings.routing.byEnvironment[environment] ?? settings.routing.default;
+    const org = settings.organizations.find((o) => o.name === name || o.identifier === name);
+    return org?.identifier ?? name;
+  }
+  schemaKey(org, stream, type) {
+    return `${org}|${stream}|${type}`;
+  }
+  schema(org, stream, type) {
+    return this.schemas.get(this.schemaKey(org, stream, type));
+  }
+  streams(org, type) {
+    return this.schemas.list({ order: "oldest" }).map((r) => r.id.split("|")).filter(([o, , t]) => o === org && t === type).map(([, stream]) => stream);
+  }
+  /** Store a row and widen its stream's schema (null-valued fields never appear). */
+  ingest(row, extraFields = {}) {
+    this.rows.insert(`${row.type}:${this.rows.nextSequence()}`, row);
+    const key = this.schemaKey(row.org, row.stream, row.type);
+    const fields = { ...this.schemas.get(key) ?? { _timestamp: "Int64" } };
+    let changed = !this.schemas.has(key);
+    for (const [name, value] of Object.entries({ ...row.row })) {
+      if (!(name in fields)) {
+        fields[name] = typeOf(value);
+        changed = true;
+      }
+    }
+    for (const [name, type] of Object.entries(extraFields)) {
+      if (!(name in fields)) {
+        fields[name] = type;
+        changed = true;
+      }
+    }
+    if (changed) this.schemas.insert(key, fields);
+  }
+  list(filter) {
+    return this.rows.list({ order: "oldest", where: (value) => filter(value) }).map((stored) => stored.value);
+  }
+  count(metrics, bytes) {
+    const current = this.counters.get("metrics") ?? { requests: 0, bytes: 0, metrics: 0 };
+    const next = {
+      requests: current.requests + 1,
+      bytes: current.bytes + bytes,
+      metrics: current.metrics + metrics
+    };
+    this.counters.insert("metrics", next);
+    return next;
+  }
+  metrics() {
+    return this.counters.get("metrics") ?? { requests: 0, bytes: 0, metrics: 0 };
+  }
+};
+
+// src/runtime.ts
+var rpc = (code, message) => ({ code, message });
+var OTEL_PRESETS = {
+  rate_limited: {
+    description: "Exports answer 429 with retry-after: 1 (the SDK retries)",
+    rules: [
+      {
+        pathPrefix: "/v1/",
+        status: 429,
+        headers: { "retry-after": "1" },
+        body: rpc(8, "rate limited")
+      }
+    ]
+  },
+  bad_gateway: {
+    description: "Exports answer 502 (the SDK retries)",
+    rules: [{ pathPrefix: "/v1/", status: 502, body: rpc(14, "bad gateway") }]
+  },
+  unavailable: {
+    description: "Exports answer 503 (the SDK retries)",
+    rules: [{ pathPrefix: "/v1/", status: 503, body: rpc(14, "unavailable") }]
+  },
+  gateway_timeout: {
+    description: "Exports answer 504 (the SDK retries)",
+    rules: [{ pathPrefix: "/v1/", status: 504, body: rpc(4, "deadline exceeded") }]
+  },
+  server_error: {
+    description: "Exports answer 500 (the SDK drops the batch: not retryable)",
+    rules: [{ pathPrefix: "/v1/", status: 500, body: rpc(13, "internal error") }]
+  },
+  unauthorized: {
+    description: "Exports answer 401 as if OTEL_AUTH_TOKEN were wrong (dropped, never retried)",
+    rules: [{ pathPrefix: "/v1/", status: 401, body: rpc(16, "Unauthenticated") }]
+  },
+  partial_success: {
+    description: "Exports answer 200 with partialSuccess rejecting every item (JSON only); nothing is stored",
+    rules: [{ pathPrefix: "/v1/", effect: "partial_success" }]
+  },
+  search_unavailable: {
+    description: "O2 search answers 503 (our clients degrade: empty hops, error result)",
+    rules: [
+      { operationId: "Search", status: 503, body: { code: 503, message: "Service Unavailable" } }
+    ]
+  }
+};
+var json3 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminError3 = (status, message) => json3(status, { error: { type: "mockingbird_admin", message } });
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var same = (a, b) => a !== void 0 && a !== null && String(a) === String(b);
+var matchesWhere = (row, where) => Object.entries(where).every(([key, value]) => {
+  if (key in row) return same(row[key], value);
+  const formatted = formatKey(key);
+  if (formatted in row) return same(row[formatted], value);
+  return same(row[`service_${formatted}`], value);
+});
+var WAIT_POLL_MS = 20;
+var MAX_WAIT_MS = 6e4;
+var adminRoutes = (runtime) => {
+  const select = (namespace, kind, where, org) => {
+    const api = runtime.instance(namespace);
+    return (kind === "log" ? api.logs() : api.spans()).filter(
+      (stored) => (org === void 0 || org === null || stored.org === org) && matchesWhere(stored.row, where)
+    );
+  };
+  return {
+    "GET /logs": ({ url, namespace }) => {
+      const where = {};
+      const service = url.searchParams.get("service");
+      const event = url.searchParams.get("event");
+      const trace = url.searchParams.get("trace_id");
+      if (service !== null) where.service_name = service;
+      if (event !== null) where.event = event;
+      if (trace !== null) where.trace_id = trace;
+      const severity = url.searchParams.get("severity")?.toLowerCase();
+      const logs = select(namespace, "log", where, url.searchParams.get("org")).filter(
+        (stored) => severity === void 0 || String(stored.row.severity_text ?? "").toLowerCase() === severity
+      );
+      return json3(200, { logs: logs.map(adminRow) });
+    },
+    "GET /spans": ({ url, namespace }) => {
+      const where = {};
+      const service = url.searchParams.get("service");
+      const name = url.searchParams.get("name");
+      const trace = url.searchParams.get("trace_id");
+      if (service !== null) where.service_name = service;
+      if (name !== null) where.operation_name = name;
+      if (trace !== null) where.trace_id = trace;
+      return json3(200, {
+        spans: select(namespace, "span", where, url.searchParams.get("org")).map(adminRow)
+      });
+    },
+    /**
+     * `{kind: "log"|"span", where: {event: "…"}, count?: 1, timeoutMs?: 5000, org?}`:
+     * long-polls until `count` rows match, then answers them; 408 with what matched so far.
+     */
+    "POST /wait": async ({ body, namespace }) => {
+      if (!isRecord5(body)) return adminError3(400, 'expected {"kind": "log", "where": {...}}');
+      const kind = body.kind ?? "log";
+      if (kind !== "log" && kind !== "span") return adminError3(400, 'kind must be "log" or "span"');
+      const where = body.where ?? {};
+      if (!isRecord5(where)) return adminError3(400, "where must be an object of column: value");
+      const count = typeof body.count === "number" && body.count > 0 ? body.count : 1;
+      const timeoutMs = Math.min(
+        typeof body.timeoutMs === "number" && body.timeoutMs >= 0 ? body.timeoutMs : 5e3,
+        MAX_WAIT_MS
+      );
+      const org = typeof body.org === "string" ? body.org : void 0;
+      const deadline = Date.now() + timeoutMs;
+      for (; ; ) {
+        const matched = select(namespace, kind, where, org);
+        if (matched.length >= count) {
+          return json3(200, { matched: matched.map(adminRow), count: matched.length });
+        }
+        if (Date.now() >= deadline) {
+          return json3(408, {
+            error: {
+              type: "mockingbird_admin",
+              message: `timed out after ${timeoutMs} ms: ${matched.length}/${count} ${kind}s matched`
+            },
+            matched: matched.map(adminRow),
+            count: matched.length
+          });
+        }
+        await new Promise((resolve) => setTimeout(resolve, WAIT_POLL_MS));
+      }
+    },
+    "GET /otlp-metrics": ({ namespace }) => json3(200, runtime.instance(namespace).state.metrics()),
+    "GET /settings": ({ namespace }) => json3(200, runtime.instance(namespace).state.current()),
+    "PUT /settings": ({ body, namespace }) => {
+      if (!isRecord5(body)) return adminError3(400, "expected a JSON object");
+      const patch = {};
+      if (body.ingestTokens !== void 0) {
+        if (!Array.isArray(body.ingestTokens)) return adminError3(400, "ingestTokens: string[]");
+        patch.ingestTokens = body.ingestTokens.map(String);
+      }
+      if (body.searchUsers !== void 0) {
+        if (!Array.isArray(body.searchUsers) || !body.searchUsers.every(isRecord5)) {
+          return adminError3(400, "searchUsers: [{username, password}]");
+        }
+        patch.searchUsers = body.searchUsers.map((u) => ({
+          username: String(u.username),
+          password: String(u.password ?? "")
+        }));
+      }
+      if (body.organizations !== void 0) {
+        if (!Array.isArray(body.organizations) || !body.organizations.every(
+          (o) => isRecord5(o) && typeof o.identifier === "string" && typeof o.name === "string"
+        )) {
+          return adminError3(400, "organizations: [{identifier, name}]");
+        }
+        patch.organizations = body.organizations;
+      }
+      if (body.routing !== void 0) {
+        const routing = body.routing;
+        if (!isRecord5(routing) || typeof routing.default !== "string" || !isRecord5(routing.byEnvironment)) {
+          return adminError3(
+            400,
+            "routing: {byEnvironment: {<env>: <org name>}, default: <org name>}"
+          );
+        }
+        patch.routing = {
+          default: routing.default,
+          byEnvironment: Object.fromEntries(
+            Object.entries(routing.byEnvironment).map(([k, v]) => [k, String(v)])
+          )
+        };
+      }
+      if (body.keepBodies !== void 0) {
+        if (typeof body.keepBodies !== "boolean") return adminError3(400, "keepBodies: boolean");
+        patch.keepBodies = body.keepBodies;
+      }
+      return json3(200, runtime.instance(namespace).state.update(patch));
+    }
+  };
+};
+var createRuntime2 = (options = {}) => createRuntime({
+  name: OTEL_NAMESPACE,
+  document,
+  ...options.sqlite ? { sqlite: options.sqlite } : {},
+  ...options.clock ? { clock: options.clock } : {},
+  ...options.seed !== void 0 ? { seed: options.seed } : {},
+  ...options.adminKey !== void 0 ? { adminKey: options.adminKey } : {},
+  ...options.onLog ? { onLog: options.onLog } : {},
+  credential: otelCredential,
+  presets: OTEL_PRESETS,
+  create: ({ sqlite, namespace, clock }) => new OtelAPI({
+    sqlite,
+    namespace,
+    now: clock.now,
+    ...options.settings ? { settings: options.settings } : {}
+  }),
+  describe: () => ({ keepBodies: options.settings?.keepBodies === true }),
+  admin: adminRoutes
+});
+
+// src/index.ts
+var OTEL_NAMESPACE = "otel";
+var PROTOBUF = "application/x-protobuf";
+var otelCredential = (request) => bearerToken(request) ?? basicAuth(request)?.username;
+var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var mediaType = (request) => request.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() ?? "";
+var rpcStatus = (status, code, message) => jsonRes(status, { code, message });
+var unauthorized = () => new Response("Unauthorized Access", {
+  status: 401,
+  headers: { "content-type": "text/plain; charset=utf-8" }
+});
+var o2Error = (status, message) => jsonRes(status, { code: status, message });
+var OtelAPI = class {
+  app;
+  sqlite;
+  state;
+  service;
+  now;
+  constructor(options = {}) {
+    const sqlite = bootSqlite(options.sqlite);
+    const namespace = options.namespace ?? OTEL_NAMESPACE;
+    this.now = options.now ?? (() => Date.now());
+    this.state = new OtelState(sqlite, namespace, { settings: options.settings ?? {} });
+    const handlers = defineOperations({
+      ExportTraces: (context) => this.export(context, "traces"),
+      ExportLogs: (context) => this.export(context, "logs"),
+      ExportMetrics: (context) => this.export(context, "metrics"),
+      ListOrganizations: () => this.organizations(),
+      ListStreams: (context) => this.streams(context),
+      GetStreamSchema: (context) => this.schema(context),
+      Search: (context) => this.search(context)
+    });
+    this.service = createService({
+      document,
+      handlers,
+      sqlite,
+      namespace,
+      now: this.now,
+      notFound: () => jsonRes(404, { code: 404, message: "Not Found" }),
+      onError: (error) => {
+        if (error instanceof HttpError) return error.toResponse();
+        throw error;
+      },
+      before: (context) => this.gate(context)
+    });
+    this.app = this.service.app;
+    this.sqlite = this.service.sqlite;
+  }
+  /** Inflate `content-encoding: gzip` bodies (the exporters' `compression: "gzip"`). */
+  async fetch(request) {
+    const encoding = request.headers.get("content-encoding")?.toLowerCase();
+    if (encoding !== "gzip" || request.body === null) return this.service.fetch(request);
+    let inflated;
+    try {
+      inflated = await new Response(
+        request.body.pipeThrough(new DecompressionStream("gzip"))
+      ).arrayBuffer();
+    } catch {
+      return rpcStatus(400, 3, "invalid gzip body");
+    }
+    const headers = new Headers(request.headers);
+    headers.delete("content-encoding");
+    headers.delete("content-length");
+    return this.service.fetch(
+      new Request(request.url, { method: request.method, headers, body: inflated })
+    );
+  }
+  async reset() {
+    await this.service.reset();
+    this.state.ensureSeeded();
+  }
+  /** Every stored log row (with its org and stream), oldest first. */
+  logs() {
+    return this.state.list((r) => r.type === "logs");
+  }
+  /** Every stored span row, oldest first. */
+  spans() {
+    return this.state.list((r) => r.type === "traces");
+  }
+  settings() {
+    return this.state.current();
+  }
+  gate(context) {
+    const operationId = context.operation.operationId;
+    if (operationId.startsWith("Export")) {
+      const token = bearerToken(context.request);
+      const accepted = this.settings().ingestTokens;
+      if (!token || accepted.length > 0 && !accepted.includes(token)) {
+        return rpcStatus(401, 16, "Unauthenticated");
+      }
+      return void 0;
+    }
+    const credentials = basicAuth(context.request);
+    if (!credentials) return unauthorized();
+    const users = this.settings().searchUsers;
+    if (users.length > 0 && !users.some((u) => u.username === credentials.username && u.password === credentials.password)) {
+      return unauthorized();
+    }
+    const org = context.params.org;
+    if (org !== void 0 && !this.settings().organizations.some((o) => o.identifier === org)) {
+      return unauthorized();
+    }
+    return void 0;
+  }
+  decode(context, kind) {
+    const type = mediaType(context.request);
+    const body = context.body;
+    if (type === PROTOBUF) {
+      const bytes = body.kind === "bytes" ? body.value : new Uint8Array(0);
+      try {
+        const payload = kind === "traces" ? decodeTraceRequest(bytes) : kind === "logs" ? decodeLogsRequest(bytes) : { resourceMetrics: new Array(countMetricsRequest(bytes)).fill({}) };
+        return { payload, protobuf: true, bytes: bytes.length };
+      } catch (error) {
+        if (error instanceof ProtobufError) return rpcStatus(400, 3, error.message);
+        throw error;
+      }
+    }
+    if (type !== "application/json") {
+      return rpcStatus(415, 3, `unsupported content type ${type || "(none)"}`);
+    }
+    if (body.kind === "empty") return { payload: {}, protobuf: false, bytes: 0 };
+    if (body.kind !== "json" || !isRecord6(body.value)) {
+      return rpcStatus(400, 3, "request body is not an OTLP/JSON export request");
+    }
+    return { payload: body.value, protobuf: false, bytes: JSON.stringify(body.value).length };
+  }
+  export(context, kind) {
+    const decoded = this.decode(context, kind);
+    if (decoded instanceof Response) return decoded;
+    const { payload, protobuf } = decoded;
+    const ok = (partial = {}) => protobuf ? new Response(new Uint8Array(0), { status: 200, headers: { "content-type": PROTOBUF } }) : jsonRes(200, { partialSuccess: partial });
+    if (kind === "metrics") {
+      const count = protobuf && Array.isArray(payload.resourceMetrics) ? payload.resourceMetrics.length : metricCount(payload);
+      this.state.count(count, decoded.bytes);
+      return ok();
+    }
+    const nowMs = this.now();
+    const rows = kind === "traces" ? spanRows(payload, { nowMs }) : logRows(payload, { keepBodies: this.settings().keepBodies, nowMs });
+    const rejected = faultEffect(context.request, "partial_success");
+    if (rejected !== void 0) {
+      const key = kind === "traces" ? "rejectedSpans" : "rejectedLogRecords";
+      return ok({
+        [key]: String(rows.length),
+        errorMessage: String(rejected.message ?? "rejected by Mockingbird partial_success")
+      });
+    }
+    const stream = context.request.headers.get("stream-name")?.trim() || "default";
+    const type = kind === "traces" ? "traces" : "logs";
+    const orgs = /* @__PURE__ */ new Set();
+    this.sqlite.transaction(() => {
+      for (const ingested of rows) {
+        const org = this.state.routeOrg(ingested.resource);
+        orgs.add(org);
+        this.state.ingest(
+          { org, stream, type, row: ingested.row },
+          ingested.hadBody ? { body: "Utf8" } : {}
+        );
+      }
+    });
+    return annotateResponse(ok(), {
+      ids: {
+        accepted: String(rows.length),
+        ...orgs.size > 0 ? { org: [...orgs].join(",") } : {}
+      }
+    });
+  }
+  organizations() {
+    return jsonRes(200, {
+      data: this.settings().organizations.map((org, index) => ({
+        id: index + 1,
+        identifier: org.identifier,
+        name: org.name,
+        type: org.identifier === "default" ? "default" : "custom"
+      }))
+    });
+  }
+  streamType(context) {
+    return context.url.searchParams.get("type") === "traces" ? "traces" : "logs";
+  }
+  streams(context) {
+    const org = context.params.org;
+    const type = this.streamType(context);
+    return jsonRes(200, {
+      list: this.state.streams(org, type).map((name) => ({
+        name,
+        stream_type: type,
+        storage_type: "disk",
+        stats: {
+          doc_num: this.state.list((r) => r.org === org && r.stream === name && r.type === type).length
+        }
+      }))
+    });
+  }
+  schema(context) {
+    const org = context.params.org;
+    const stream = context.params.stream;
+    const type = this.streamType(context);
+    const fields = this.state.schema(org, stream, type);
+    if (!fields) return o2Error(404, `stream ${stream} not found`);
+    const names = Object.keys(fields).sort(
+      (a, b) => a === "_timestamp" ? -1 : b === "_timestamp" ? 1 : a.localeCompare(b)
+    );
+    return jsonRes(200, {
+      name: stream,
+      stream_type: type,
+      storage_type: "disk",
+      stats: {
+        doc_num: this.state.list((r) => r.org === org && r.stream === stream && r.type === type).length
+      },
+      schema: names.map((name) => ({ name, type: fields[name] })),
+      settings: { partition_keys: {}, full_text_search_keys: [], data_retention: 30 }
+    });
+  }
+  search(context) {
+    const org = context.params.org;
+    const body = context.body.kind === "json" ? context.body.value : void 0;
+    const query = isRecord6(body) && isRecord6(body.query) ? body.query : void 0;
+    if (!query || typeof query.sql !== "string") {
+      return o2Error(400, "Search SQL not supported: query.sql is required");
+    }
+    let parsed;
+    try {
+      parsed = parseSql(query.sql);
+    } catch (error) {
+      if (error instanceof SqlError)
+        return o2Error(400, `Search SQL not supported: ${error.message}`);
+      throw error;
+    }
+    const type = this.streamType(context);
+    const from = typeof query.from === "number" && query.from > 0 ? query.from : 0;
+    const size = typeof query.size === "number" ? query.size : -1;
+    const empty = (hits2, total, scanned) => annotateResponse(
+      jsonRes(200, {
+        took: 1,
+        hits: hits2,
+        total,
+        from,
+        size,
+        cached_ratio: 0,
+        scan_size: 0,
+        scan_records: scanned,
+        is_partial: false
+      }),
+      { ids: { org } }
+    );
+    const fields = this.state.schema(org, parsed.stream, type);
+    if (!fields) return empty([], 0, 0);
+    const unknown = referencedColumns(parsed).find((name) => !(name in fields));
+    if (unknown !== void 0) {
+      return o2Error(
+        400,
+        `Search SQL execute error: Schema error: No field named ${unknown}. Valid fields are ${Object.keys(fields).sort().join(", ")}.`
+      );
+    }
+    const start = typeof query.start_time === "number" ? query.start_time : 0;
+    const end = typeof query.end_time === "number" && query.end_time > 0 ? query.end_time : Infinity;
+    const rows = this.state.list((r) => r.org === org && r.stream === parsed.stream && r.type === type).map((r) => r.row).filter((row) => {
+      const ts = Number(row._timestamp);
+      return ts >= start && ts <= end;
+    });
+    let hits;
+    try {
+      hits = execute(parsed, rows);
+    } catch (error) {
+      if (error instanceof SqlError)
+        return o2Error(400, `Search SQL not supported: ${error.message}`);
+      throw error;
+    }
+    const page = size < 0 ? hits.slice(from) : hits.slice(from, from + size);
+    return empty(page, hits.length, rows.length);
+  }
+};
+var adminRow = (stored) => ({
+  _org: stored.org,
+  _stream: stored.stream,
+  ...stored.row
+});
+
+export {
+  document,
+  operationIds,
+  supportedOperationIds,
+  formatKey,
+  logRows,
+  spanRows,
+  ProtobufError,
+  decodeTraceRequest,
+  decodeLogsRequest,
+  SqlError,
+  parseSql,
+  referencedColumns,
+  execute,
+  DEFAULT_ORGANIZATIONS,
+  DEFAULT_SETTINGS,
+  OTEL_PRESETS,
+  createRuntime2 as createRuntime,
+  OTEL_NAMESPACE,
+  otelCredential,
+  OtelAPI,
+  adminRow
+};
+//# sourceMappingURL=chunk-RQFUL7RM.js.map