@crvouga/mockingbird-service-odx 0.1.0

package/dist/chunk-OYDT3HEE.js

@@ -0,0 +1,3242 @@
+// ../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(id) {
+    const row = this.sqlite.prepare("SELECT value FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").get(this.namespace, this.name, id);
+    if (!row)
+      return void 0;
+    return JSON.parse(row.value).value;
+  }
+  has(id) {
+    const row = this.sqlite.prepare("SELECT 1 AS ok FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").get(this.namespace, this.name, id);
+    return row !== void 0;
+  }
+  /** Insert a new record, assigning it the next sequence number. */
+  insert(id, 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, id, seq, JSON.stringify(stored));
+      return stored;
+    });
+  }
+  /** Replace an existing record's value, keeping its position. */
+  update(id, 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, id);
+      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, id);
+      return stored;
+    });
+  }
+  delete(id) {
+    const result = this.sqlite.prepare("DELETE FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").run(this.namespace, this.name, id);
+    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, message2) => json(status, { error: { type: "mockingbird_admin", message: message2 } });
+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 id = url.searchParams.get("id");
+      if (id === null) {
+        context.faults.clear();
+        return json(200, { status: "ok" });
+      }
+      return context.faults.remove(id) ? json(200, { status: "ok" }) : adminError(404, `no fault ${id}`);
+    },
+    "POST /snapshots": ({ namespace }) => {
+      const point = context.timeTravel.checkpoint(namespace, "main");
+      context.timeTravel.retain(namespace, point.id);
+      snapshotCounter++;
+      const id = `snap_${snapshotCounter}`;
+      snapshots.set(id, { namespace, checkpoint: point.id });
+      return json(201, { id, 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 id = params.id;
+      const alias = snapshots.get(id);
+      if (!alias)
+        return adminError(404, `no snapshot ${id}`);
+      snapshots.delete(id);
+      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 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(id) {
+      const index = entries.findIndex((e) => e.rule.id === id);
+      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 = (mediaType) => mediaType === JSON_MEDIA_TYPE || mediaType.endsWith("+json") || mediaType === "text/json";
+var utf8 = new TextDecoder("utf-8", { fatal: false });
+var decodeBody = (contentType, bytes) => {
+  if (bytes.byteLength === 0)
+    return { kind: "empty" };
+  const mediaType = mediaTypeOf(contentType);
+  if (mediaType === void 0)
+    return { kind: "bytes", value: bytes };
+  if (isJsonMediaType(mediaType)) {
+    const text2 = utf8.decode(bytes);
+    try {
+      return { kind: "json", value: JSON.parse(text2) };
+    } catch (error) {
+      return {
+        kind: "invalid",
+        mediaType,
+        text: text2,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  if (mediaType === FORM_MEDIA_TYPE) {
+    return { kind: "form", value: decodeForm(utf8.decode(bytes)) };
+  }
+  if (mediaType.startsWith("text/"))
+    return { kind: "text", value: utf8.decode(bytes) };
+  return { kind: "bytes", value: bytes };
+};
+var readBody = async (message2) => {
+  const bytes = new Uint8Array(await message2.arrayBuffer());
+  return decodeBody(message2.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 }
+});
+
+// ../core/dist/ids.js
+var ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+var mix = (input) => {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  hash ^= hash >>> 16;
+  hash = Math.imul(hash, 2246822507) >>> 0;
+  hash ^= hash >>> 13;
+  return hash >>> 0;
+};
+var opaqueToken = (input, length) => {
+  let out = "";
+  let round2 = 0;
+  while (out.length < length) {
+    let hash = mix(`${input}:${round2++}`);
+    for (let i = 0; i < 5 && out.length < length; i++) {
+      out += ALPHABET.charAt(hash % ALPHABET.length);
+      hash = Math.floor(hash / ALPHABET.length);
+    }
+  }
+  return out;
+};
+
+// ../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 id = this.makeId(++this.sequence);
+    if (this.nodes.has(id))
+      throw new RangeError(`duplicate checkpoint id ${id}`);
+    const checkpoint = Object.freeze({ id, branch, parent, at: this.now(), value });
+    this.nodes.set(id, checkpoint);
+    this.moveHead(branch, id);
+    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, id) {
+    this.assertBranch(branch);
+    const checkpoint = this.get(id);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  get(id) {
+    const checkpoint = this.nodes.get(id);
+    if (!checkpoint)
+      throw new RangeError(`no checkpoint ${id}`);
+    return checkpoint;
+  }
+  head(branch = "main") {
+    const id = this.heads.get(branch);
+    return id === void 0 ? void 0 : this.get(id);
+  }
+  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(id) {
+    const checkpoint = this.get(id);
+    this.explicitPins.set(id, (this.explicitPins.get(id) ?? 0) + 1);
+    this.addReference(id);
+    return checkpoint;
+  }
+  /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
+  release(id) {
+    if (!this.nodes.has(id))
+      return false;
+    const pins = this.explicitPins.get(id) ?? 0;
+    if (pins === 0)
+      return false;
+    if (pins === 1)
+      this.explicitPins.delete(id);
+    else
+      this.explicitPins.set(id, pins - 1);
+    this.removeReference(id);
+    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 id = this.evictable.values().next().value;
+      this.evictable.delete(id);
+      this.nodes.delete(id);
+      removed?.push(id);
+    }
+  }
+  moveHead(branch, id) {
+    const previous = this.heads.get(branch);
+    if (previous === id)
+      return;
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.heads.set(branch, id);
+    this.addReference(id);
+  }
+  addReference(id) {
+    this.references.set(id, (this.references.get(id) ?? 0) + 1);
+    this.evictable.delete(id);
+  }
+  removeReference(id) {
+    const next = (this.references.get(id) ?? 0) - 1;
+    if (next > 0)
+      this.references.set(id, next);
+    else {
+      this.references.delete(id);
+      if (this.nodes.has(id))
+        this.evictable.add(id);
+    }
+  }
+  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 id of Object.keys(handlers)) {
+    if (!seen.has(id))
+      problems.push(`handler ${id} 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/signing.js
+var encoder = new TextEncoder();
+var toBase64 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+};
+var fromBase64 = (value) => Uint8Array.from(atob(value), (char) => char.charCodeAt(0));
+var toHex = (bytes) => [...bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+var keyBytes = (key) => typeof key === "string" ? encoder.encode(key) : key;
+var hmac = async (algorithm, key, message2, encoding = "hex") => {
+  const imported = await crypto.subtle.importKey("raw", keyBytes(key), { name: "HMAC", hash: algorithm }, false, ["sign"]);
+  const signed = await crypto.subtle.sign("HMAC", imported, typeof message2 === "string" ? encoder.encode(message2) : message2);
+  return encoding === "hex" ? toHex(signed) : toBase64(signed);
+};
+var svixSecretBytes = (secret) => {
+  const raw = secret.replace(/^f?whsec_/, "");
+  try {
+    return fromBase64(raw);
+  } catch {
+    throw new TypeError("webhook secret must be whsec_<base64> (as Svix issues it)");
+  }
+};
+var signSvix = async (secret, messageId, timestampSeconds, body) => `v1,${await hmac("SHA-256", svixSecretBytes(secret), `${messageId}.${timestampSeconds}.${body}`, "base64")}`;
+var signTimestamped = async (secret, timestampSeconds, body) => `t=${timestampSeconds},v1=${await hmac("SHA-256", secret, `${timestampSeconds}.${body}`, "hex")}`;
+var signTwilio = async (authToken, url, params) => {
+  const payload = url + Object.keys(params).sort().map((key) => `${key}${params[key]}`).join("");
+  return hmac("SHA-1", authToken, payload, "base64");
+};
+
+// ../core/dist/webhooks.js
+var signers = {
+  /** No signature. */
+  none: () => () => ({}),
+  /** Svix (`svix-id`, `svix-timestamp`, `svix-signature: v1,<b64>`): Junction, Flex, Resend. */
+  svix: (options = {}) => async ({ messageId, body, timestampSeconds, secret }) => {
+    if (!secret)
+      return {};
+    const prefix = options.prefix ?? "svix";
+    return {
+      [`${prefix}-id`]: messageId,
+      [`${prefix}-timestamp`]: String(timestampSeconds),
+      [`${prefix}-signature`]: await signSvix(secret, messageId, timestampSeconds, body)
+    };
+  },
+  /** `<header>: t=<unix>,v1=<hex HMAC-SHA256(secret, "t.body")>`: Stripe, Persona, Fullscript. */
+  timestamped: (header = "Stripe-Signature") => async ({ body, timestampSeconds, secret }) => secret ? { [header]: await signTimestamped(secret, timestampSeconds, body) } : {},
+  /** `X-Twilio-Signature` over the public URL plus the sorted form parameters. */
+  twilio: () => async ({ signUrl, form, secret }) => secret ? { "X-Twilio-Signature": await signTwilio(secret, signUrl, form ?? {}) } : {},
+  /** The secret itself in a header (optionally templated): RxVortex, Pharmetika, AHA `Token <s>`. */
+  header: (header, format = (s) => s) => ({ secret }) => secret ? { [header]: format(secret) } : {},
+  /** Anything else: the service computes the headers itself. */
+  custom: (sign) => sign
+};
+var DEFAULT_DELAYS = [0, 5e3, 3e5, 18e5, 72e5];
+var unref = (timer) => {
+  ;
+  timer.unref?.();
+};
+var randomId = (prefix) => `${prefix}${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+var matchesEndpoint = (endpoint, message2) => {
+  const events = endpoint.events ?? ["*"];
+  if (!events.includes("*") && !events.includes(message2.type))
+    return false;
+  for (const [key, value] of Object.entries(endpoint.tags ?? {})) {
+    if (message2.tags[key] !== value)
+      return false;
+  }
+  return true;
+};
+var createWebhookHub = (options) => {
+  const delays = options.retryDelaysMs ?? DEFAULT_DELAYS;
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const delivered = options.delivered ?? ((status) => status >= 200 && status < 300);
+  const send = options.fetch ?? ((request) => fetch(request));
+  const keep = options.keep ?? 500;
+  const now = options.now ?? Date.now;
+  const id = options.id ?? randomId;
+  const scheduleTimer = options.schedule ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+  const cancel = options.cancel ?? ((handle) => clearTimeout(handle));
+  const global = (options.endpoints ?? []).map((e, i) => ({ ...e, id: e.id ?? `we_global_${i}` }));
+  const own = /* @__PURE__ */ new Map();
+  const messages = [];
+  const deliveries = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const payloads = /* @__PURE__ */ new Map();
+  const faults = /* @__PURE__ */ new Map();
+  const held = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Set();
+  const track = (work) => {
+    inFlight.add(work);
+    void work.finally(() => inFlight.delete(work));
+  };
+  const attempt = async (delivery) => {
+    const entry = payloads.get(delivery.id);
+    if (!entry)
+      return false;
+    const { message: message2, endpoint } = entry;
+    const timestampSeconds = Math.floor(now() / 1e3);
+    const started = now();
+    const record = {
+      attempt: delivery.attempts.length + 1,
+      at: new Date(started).toISOString(),
+      status: null,
+      error: null,
+      durationMs: 0,
+      responseBody: null
+    };
+    const controller = new AbortController();
+    const timer = scheduleTimer(() => controller.abort(), timeoutMs);
+    try {
+      const signed = await options.signer({
+        messageId: message2.id,
+        body: message2.body,
+        timestampSeconds,
+        url: endpoint.url,
+        secret: endpoint.secret,
+        signUrl: endpoint.signUrl ?? endpoint.url,
+        form: message2.contentType.startsWith("application/x-www-form-urlencoded") ? Object.fromEntries(new URLSearchParams(message2.body)) : void 0,
+        type: message2.type,
+        tags: message2.tags
+      });
+      const response = await send(new Request(endpoint.url, {
+        method: "POST",
+        headers: {
+          "content-type": message2.contentType,
+          ...endpoint.headers,
+          ...message2.headers,
+          ...signed
+        },
+        body: message2.body,
+        signal: controller.signal
+      }));
+      record.status = response.status;
+      record.responseBody = await response.text();
+    } catch (error) {
+      record.error = controller.signal.aborted ? `timed out after ${timeoutMs}ms` : error instanceof Error ? error.message : String(error);
+    } finally {
+      cancel(timer);
+      record.durationMs = now() - started;
+      delivery.attempts.push(record);
+    }
+    return record.status !== null && delivered(record.status);
+  };
+  const schedule = (delivery) => {
+    const index = delivery.attempts.length;
+    if (index >= delays.length) {
+      delivery.state = "failed";
+      pending.delete(delivery.id);
+      return;
+    }
+    const run = () => {
+      pending.delete(delivery.id);
+      track(attempt(delivery).then((ok) => {
+        if (ok)
+          delivery.state = "delivered";
+        else
+          schedule(delivery);
+      }));
+    };
+    const delay = delays[index] ?? 0;
+    if (delay <= 0) {
+      pending.set(delivery.id, void 0);
+      run();
+      return;
+    }
+    const timer = scheduleTimer(run, delay);
+    unref(timer);
+    pending.set(delivery.id, timer);
+  };
+  const endpointsFor = (namespace) => [...own.get(namespace) ?? [], ...global];
+  const fanOut = (message2, state = "pending") => {
+    for (const endpoint of endpointsFor(message2.namespace)) {
+      if (!matchesEndpoint(endpoint, message2))
+        continue;
+      const delivery = {
+        id: id("dlv_"),
+        messageId: message2.id,
+        namespace: message2.namespace,
+        type: message2.type,
+        endpointId: endpoint.id ?? "we_unknown",
+        url: endpoint.url,
+        state,
+        attempts: []
+      };
+      deliveries.set(delivery.id, delivery);
+      payloads.set(delivery.id, { message: message2, endpoint });
+      if (state === "pending")
+        schedule(delivery);
+    }
+  };
+  const takeFault = (namespace) => {
+    const queue = faults.get(namespace);
+    const head = queue?.[0];
+    if (!queue || !head)
+      return void 0;
+    head.remaining--;
+    if (head.remaining <= 0)
+      queue.shift();
+    return head.mode;
+  };
+  const releaseHeld = (namespace) => {
+    const waiting = held.get(namespace);
+    if (!waiting)
+      return;
+    held.delete(namespace);
+    for (const message2 of waiting)
+      fanOut(message2);
+  };
+  const hub = {
+    publish(input) {
+      const contentType = input.contentType ?? (input.form ? "application/x-www-form-urlencoded" : "application/json");
+      const body = typeof input.body === "string" ? input.body : input.form ? new URLSearchParams(input.form).toString() : JSON.stringify(input.body);
+      const message2 = {
+        id: input.id ?? id("msg_"),
+        namespace: input.namespace,
+        type: input.type,
+        body,
+        contentType,
+        tags: input.tags ?? {},
+        headers: input.headers ?? {},
+        publishedAt: new Date(now()).toISOString()
+      };
+      messages.push(message2);
+      const ofNamespace = messages.filter((m) => m.namespace === message2.namespace);
+      const oldest = ofNamespace[0];
+      if (ofNamespace.length > keep && oldest)
+        messages.splice(messages.indexOf(oldest), 1);
+      options.onMessage?.(message2);
+      const fault = takeFault(message2.namespace);
+      if (fault === "drop") {
+        fanOut(message2, "dropped");
+        return message2;
+      }
+      if (fault === "reorder") {
+        held.set(message2.namespace, [...held.get(message2.namespace) ?? [], message2]);
+        return message2;
+      }
+      fanOut(message2);
+      if (fault === "duplicate")
+        fanOut(message2);
+      releaseHeld(message2.namespace);
+      return message2;
+    },
+    setEndpoints(namespace, endpoints) {
+      const withIds = endpoints.map((e, i) => ({ ...e, id: e.id ?? `we_${namespace}_${i}` }));
+      own.set(namespace, withIds);
+      return withIds;
+    },
+    endpoints: endpointsFor,
+    messages: (namespace) => namespace === void 0 ? [...messages] : messages.filter((m) => m.namespace === namespace),
+    deliveries: (namespace) => [...deliveries.values()].filter((d) => namespace === void 0 || d.namespace === namespace),
+    async replay(id2) {
+      const delivery = deliveries.get(id2);
+      if (!delivery)
+        return void 0;
+      const ok = await attempt(delivery);
+      if (ok)
+        delivery.state = "delivered";
+      return delivery;
+    },
+    async flush() {
+      for (const namespace of [...held.keys()])
+        releaseHeld(namespace);
+      const waiting = [...pending.entries()];
+      for (const [id2, timer] of waiting) {
+        if (timer === void 0)
+          continue;
+        cancel(timer);
+        pending.delete(id2);
+        const delivery = deliveries.get(id2);
+        if (!delivery)
+          continue;
+        track(attempt(delivery).then((ok) => {
+          if (ok)
+            delivery.state = "delivered";
+          else
+            schedule(delivery);
+        }));
+      }
+      await hub.idle();
+    },
+    async idle() {
+      while (inFlight.size > 0)
+        await Promise.allSettled([...inFlight]);
+    },
+    fault(namespace, fault) {
+      const queue = faults.get(namespace) ?? [];
+      queue.push({ mode: fault.mode, remaining: Math.max(1, fault.count ?? 1) });
+      faults.set(namespace, queue);
+    },
+    clear(namespace) {
+      for (const [id2, delivery] of deliveries) {
+        if (namespace !== void 0 && delivery.namespace !== namespace)
+          continue;
+        const timer = pending.get(id2);
+        if (timer !== void 0)
+          cancel(timer);
+        pending.delete(id2);
+        deliveries.delete(id2);
+        payloads.delete(id2);
+      }
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (namespace === void 0 || messages[i]?.namespace === namespace)
+          messages.splice(i, 1);
+      }
+      if (namespace === void 0) {
+        held.clear();
+        faults.clear();
+        own.clear();
+      } else {
+        held.delete(namespace);
+        faults.delete(namespace);
+        own.delete(namespace);
+      }
+    }
+  };
+  return hub;
+};
+var json2 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminError2 = (status, message2) => json2(status, { error: { type: "mockingbird_admin", message: message2 } });
+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 list = Array.isArray(body) ? body : isRecord3(body) ? body.endpoints : void 0;
+    if (!Array.isArray(list))
+      return adminError2(400, "expected [{url, secret?, events?}]");
+    const parsed = [];
+    for (const each of list) {
+      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 = (message2) => {
+  if (message2.contentType.startsWith("application/json")) {
+    try {
+      return JSON.parse(message2.body);
+    } catch {
+      return message2.body;
+    }
+  }
+  if (message2.contentType.startsWith("application/x-www-form-urlencoded")) {
+    return Object.fromEntries(new URLSearchParams(message2.body));
+  }
+  return message2.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, compare, 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 && compare(previous[oldIndex], row) < 0) {
+      oldIndex++;
+    }
+    const old = previous[oldIndex];
+    result[index] = old !== void 0 && compare(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, branch: branchName, parent, at }) => ({
+            id,
+            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, message2) => adminJson(status, { error: { type: "mockingbird_admin", message: message2 } });
+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 list = Array.isArray(body) ? body : isObject(body) ? body.credentials : void 0;
+    if (Array.isArray(list)) {
+      for (const each of list) {
+        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(list)) {
+      for (const [credential, target] of Object.entries(list)) {
+        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/catalog.ts
+var LABS = [
+  { labId: 1, name: "Access Health Alliance (AHA)", isCurrentLab: true },
+  { labId: 2, name: "Quest Diagnostics", isCurrentLab: false },
+  { labId: 3, name: "LabCorp", isCurrentLab: false }
+];
+var ELEMENTS = [
+  {
+    elementId: 460,
+    elementName: "Total Cholesterol",
+    elementGenderType: "Both",
+    cuUnit: "mg/dL",
+    siUnit: "mmol/L",
+    cuToSiConversionFactor: 0.0259,
+    codes: ["2093-3"],
+    optimal: [160, 199],
+    standard: [125, 199]
+  },
+  {
+    elementId: 494,
+    elementName: "Glucose Fasting",
+    elementGenderType: "Both",
+    cuUnit: "mg/dL",
+    siUnit: "mmol/L",
+    cuToSiConversionFactor: 0.0555,
+    codes: ["2345-7", "1558-6"],
+    optimal: [75, 86],
+    standard: [65, 99]
+  },
+  {
+    elementId: 496,
+    elementName: "Creatinine",
+    elementGenderType: "Both",
+    cuUnit: "mg/dL",
+    siUnit: "\xB5mol/L",
+    cuToSiConversionFactor: 88.4,
+    codes: ["2160-0"],
+    optimal: [0.8, 1.1],
+    standard: [0.6, 1.3]
+  },
+  {
+    elementId: 506,
+    elementName: "Albumin",
+    elementGenderType: "Both",
+    cuUnit: "g/dL",
+    siUnit: "g/L",
+    cuToSiConversionFactor: 10,
+    codes: ["1751-7"],
+    optimal: [4, 5],
+    standard: [3.5, 5.5]
+  },
+  {
+    elementId: 511,
+    elementName: "Alk Phos",
+    elementGenderType: "Both",
+    cuUnit: "U/L",
+    siUnit: "U/L",
+    cuToSiConversionFactor: 1,
+    codes: ["6768-6"],
+    optimal: [70, 100],
+    standard: [40, 129]
+  },
+  {
+    elementId: 537,
+    elementName: "Hs CRP - Male",
+    elementGenderType: "Male",
+    cuUnit: "mg/L",
+    siUnit: "mg/L",
+    cuToSiConversionFactor: 1,
+    codes: ["30522-7"],
+    optimal: [0, 0.55],
+    standard: [0, 3]
+  },
+  {
+    elementId: 538,
+    elementName: "Hs CRP - Female",
+    elementGenderType: "Female",
+    cuUnit: "mg/L",
+    siUnit: "mg/L",
+    cuToSiConversionFactor: 1,
+    codes: ["30522-7"],
+    optimal: [0, 1.5],
+    standard: [0, 3]
+  },
+  {
+    elementId: 556,
+    elementName: "Total WBCs",
+    elementGenderType: "Both",
+    cuUnit: "k/cumm",
+    siUnit: "10E9/L",
+    cuToSiConversionFactor: 1,
+    codes: ["6690-2"],
+    optimal: [5, 8],
+    standard: [3.8, 10.8]
+  },
+  {
+    elementId: 564,
+    elementName: "MCV",
+    elementGenderType: "Both",
+    cuUnit: "fL",
+    siUnit: "fL",
+    cuToSiConversionFactor: 1,
+    codes: ["787-2"],
+    optimal: [82, 89.9],
+    standard: [80, 100]
+  },
+  {
+    elementId: 568,
+    elementName: "RDW",
+    elementGenderType: "Both",
+    cuUnit: "%",
+    siUnit: "%",
+    cuToSiConversionFactor: 1,
+    codes: ["788-0"],
+    optimal: [11.7, 13],
+    standard: [11, 15]
+  },
+  {
+    elementId: 571,
+    elementName: "Lymphocytes - %",
+    elementGenderType: "Both",
+    cuUnit: "%",
+    siUnit: "%",
+    cuToSiConversionFactor: 1,
+    codes: ["736-9"],
+    optimal: [25, 40],
+    standard: [20, 40]
+  },
+  {
+    elementId: 580,
+    elementName: "Testosterone Total - Male",
+    elementGenderType: "Male",
+    cuUnit: "ng/dL",
+    siUnit: "nmol/L",
+    cuToSiConversionFactor: 0.0347,
+    codes: ["2986-8"],
+    optimal: [600, 900],
+    standard: [250, 1100]
+  },
+  {
+    elementId: 590,
+    elementName: "TSH",
+    elementGenderType: "Both",
+    cuUnit: "\xB5IU/mL",
+    siUnit: "mIU/L",
+    cuToSiConversionFactor: 1,
+    codes: ["3016-3", "11580-8"],
+    optimal: [1, 2],
+    standard: [0.4, 4.5]
+  }
+];
+var labElement = (labId, element) => ({
+  labId,
+  elementId: element.elementId,
+  elementName: element.elementName,
+  elementGenderType: element.elementGenderType,
+  cuUnit: element.cuUnit,
+  siUnit: element.siUnit,
+  cuToSiConversionFactor: element.cuToSiConversionFactor,
+  elementReferences: element.codes.map((code) => ({
+    elementCode: code,
+    elementName: element.elementName
+  }))
+});
+
+// src/generated/openapi.ts
+var document = JSON.parse(`{"openapi":"3.1.0","info":{"title":"Optimal DX partner API (Mockingbird subset)","description":"Stateful mock of the Optimal DX (ODX) partner API our backend calls: partner labs and their\\nbiomarker elements, practice patients (create, update, delete, partner link, search), lab\\nresults (structured and HL7 v2 ORU imports), the Functional Health Report (JSON or PDF), and\\nwebhook registrations whose signing keys verify the PatientTest webhooks the mock posts.\\nODX publishes no spec; the contract is hand-authored from our consumer's wire shapes. The\\nvendor was retired 2026-07-22 but queue paths still call it while \`geviti-pdf-enabled\` is off.\\n","version":"1","x-mockingbird-upstream":{"note":"Hand-authored from optimal.dx.service.ts / optimal.dx.types.ts, the webhook guard and DTO (odx-signature.guard.ts, odx-webhook-data.dto.ts) and the QA harness (packages/qa odx-client.ts)."}},"servers":[{"url":"https://odxinstanceresource.azure-api.net/geviti"}],"security":[{"apiKey":[]}],"paths":{"/v1/partner/labs":{"get":{"operationId":"ListPartnerLabs","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"responses":{"200":{"description":"Labs this partner can import from","content":{"application/json":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/Lab"}}}}},"401":{"$ref":"#/components/responses/Unauthorized"}}}},"/v1/elements/{labId}":{"parameters":[{"name":"labId","in":"path","required":true,"schema":{"type":"string","enum":["1","2","3","999"]}}],"get":{"operationId":"ListElements","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"responses":{"200":{"description":"The lab's biomarker elements (with the codes HL7 OBX-3 is mapped by)","content":{"application/json":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/LabElement"}}}}},"401":{"$ref":"#/components/responses/Unauthorized"},"404":{"$ref":"#/components/responses/NotFound"}}}},"/v1/practice/{practiceId}/patient":{"parameters":[{"$ref":"#/components/parameters/PracticeId"}],"post":{"operationId":"CreatePatient","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/PatientRequest"}}}},"responses":{"200":{"description":"Created patient","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Patient"}}}},"400":{"$ref":"#/components/responses/ValidationProblem"},"401":{"$ref":"#/components/responses/Unauthorized"}}}},"/v1/practice/{practiceId}/patient/{patientId}":{"parameters":[{"$ref":"#/components/parameters/PracticeId"},{"$ref":"#/components/parameters/PatientId"}],"put":{"operationId":"UpdatePatient","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/PatientRequest"}}}},"responses":{"200":{"description":"Updated patient","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Patient"}}}},"400":{"$ref":"#/components/responses/ValidationProblem"},"401":{"$ref":"#/components/responses/Unauthorized"},"404":{"$ref":"#/components/responses/NotFound"}}},"delete":{"operationId":"DeletePatient","description":"Used by the QA harness teardown (via the send-odx-api-request dev tool).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"responses":{"204":{"description":"Deleted"},"401":{"$ref":"#/components/responses/Unauthorized"},"404":{"$ref":"#/components/responses/NotFound"}}}},"/v1/practice/{practiceId}/patient/{patientId}/partner/{localUserId}":{"parameters":[{"$ref":"#/components/parameters/PracticeId"},{"$ref":"#/components/parameters/PatientId"},{"name":"localUserId","in":"path","required":true,"description":"Our user id, stored as the patient's partner (external) id.","schema":{"type":"string","pattern":"^[0-9]{1,9}$"}}],"post":{"operationId":"LinkPartnerUser","description":"Our client posts the literal body \`false\`.","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":false,"content":{"application/json":{"schema":{"type":"boolean"}}}},"responses":{"200":{"description":"Linked","content":{"application/json":{"schema":{"type":"boolean"}}}},"401":{"$ref":"#/components/responses/Unauthorized"},"404":{"$ref":"#/components/responses/NotFound"}}}},"/v1/practice/{practiceId}/patients":{"parameters":[{"$ref":"#/components/parameters/PracticeId"},{"name":"email","in":"query","schema":{"type":"string","enum":["ada@example.com","nobody@example.com"]}},{"name":"firstName","in":"query","schema":{"type":"string","enum":["Ada","Grace"]}},{"name":"lastName","in":"query","schema":{"type":"string","enum":["Lovelace","Hopper"]}},{"name":"dateOfBirth","in":"query","schema":{"type":"string","enum":["1985-12-10","1906-12-09"]}}],"get":{"operationId":"ListPatients","description":"All patients, or a search when any filter is given (404 when nothing matches).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"responses":{"200":{"description":"Matching patients","content":{"application/json":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/Patient"}}}}},"401":{"$ref":"#/components/responses/Unauthorized"},"404":{"$ref":"#/components/responses/NotFound"}}}},"/v1/practice/{practiceId}/patient/{patientId}/testresults":{"parameters":[{"$ref":"#/components/parameters/PracticeId"},{"$ref":"#/components/parameters/PatientId"}],"post":{"operationId":"CreateTestResults","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/TestResultsRequest"}}}},"responses":{"200":{"description":"The imported patient test","content":{"application/json":{"schema":{"$ref":"#/components/schemas/PatientTest"}}}},"400":{"$ref":"#/components/responses/ValidationProblem"},"401":{"$ref":"#/components/responses/Unauthorized"},"404":{"$ref":"#/components/responses/NotFound"}}}},"/v1/practice/{practiceId}/patient/{patientId}/test":{"parameters":[{"$ref":"#/components/parameters/PracticeId"},{"$ref":"#/components/parameters/PatientId"}],"post":{"operationId":"CreatePatientTest","description":"Import an HL7 v2 ORU^R01 message; OBX-3 codes map to elements by their elementReferences.","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/Hl7Request"}}}},"responses":{"200":{"description":"The imported patient test","content":{"application/json":{"schema":{"$ref":"#/components/schemas/PatientTest"}}}},"400":{"$ref":"#/components/responses/ValidationProblem"},"401":{"$ref":"#/components/responses/Unauthorized"},"404":{"$ref":"#/components/responses/NotFound"}}}},"/v1/practice/{practiceId}/patient/{patientId}/test/{patientTestId}":{"parameters":[{"$ref":"#/components/parameters/PracticeId"},{"$ref":"#/components/parameters/PatientId"},{"name":"patientTestId","in":"path","required":true,"schema":{"type":"string","description":"Ids are assigned sequentially from 700001 (parity walks reuse them).","enum":["700001","700002","999999"]}}],"put":{"operationId":"UpdatePatientTest","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/Hl7Request"}}}},"responses":{"200":{"description":"The re-imported patient test","content":{"application/json":{"schema":{"$ref":"#/components/schemas/PatientTest"}}}},"400":{"$ref":"#/components/responses/ValidationProblem"},"401":{"$ref":"#/components/responses/Unauthorized"},"404":{"$ref":"#/components/responses/NotFound"}}}},"/v1/practice/{practiceId}/patient/{patientId}/tests":{"parameters":[{"$ref":"#/components/parameters/PracticeId"},{"$ref":"#/components/parameters/PatientId"}],"get":{"operationId":"ListPatientTests","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"responses":{"200":{"description":"The patient's tests, oldest first","content":{"application/json":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/PatientTest"}}}}},"401":{"$ref":"#/components/responses/Unauthorized"},"404":{"$ref":"#/components/responses/NotFound"}}}},"/v1/reports/FunctionalHealthReport":{"post":{"operationId":"GenerateFunctionalHealthReport","description":"\`outputType: Json\` answers the report as JSON; \`Pdf\` answers application/pdf bytes.","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/ReportRequest"}}}},"responses":{"200":{"description":"The report","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Report"}},"application/pdf":{"schema":{"type":"string","format":"binary"}}}},"400":{"$ref":"#/components/responses/ValidationProblem"},"401":{"$ref":"#/components/responses/Unauthorized"},"404":{"$ref":"#/components/responses/NotFound"}}}},"/v1/webhooks":{"get":{"operationId":"ListWebhooks","description":"Our webhook guard calls this on every inbound webhook to fetch the signing key.","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"responses":{"200":{"description":"Registered webhooks, with their signing keys","content":{"application/json":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/Webhook"}}}}},"401":{"$ref":"#/components/responses/Unauthorized"}}}},"/v1/webhook":{"post":{"operationId":"RegisterWebhook","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/WebhookRequest"}}}},"responses":{"200":{"description":"Registered","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Webhook"}}}},"400":{"$ref":"#/components/responses/ValidationProblem"},"401":{"$ref":"#/components/responses/Unauthorized"}}}},"/v1/webhook/{partnerWebhookId}":{"parameters":[{"name":"partnerWebhookId","in":"path","required":true,"schema":{"type":"string","description":"Ids are assigned sequentially from 1.","enum":["1","2","999999"]}}],"put":{"operationId":"UpdateWebhook","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/WebhookRequest"}}}},"responses":{"200":{"description":"Updated","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Webhook"}}}},"400":{"$ref":"#/components/responses/ValidationProblem"},"401":{"$ref":"#/components/responses/Unauthorized"},"404":{"$ref":"#/components/responses/NotFound"}}}}},"components":{"securitySchemes":{"apiKey":{"type":"apiKey","in":"header","name":"ApiKey"}},"parameters":{"PracticeId":{"name":"practiceId","in":"path","required":true,"description":"OPTIMAL_PRACTICE_ID. Parity walks use one fixed practice.","schema":{"type":"string","enum":["3f0c0c43-7d2b-4b8e-9a50-9c1f0c6c0001"]}},"PatientId":{"name":"patientId","in":"path","required":true,"schema":{"type":"string","description":"Ids are assigned sequentially from 100001 (parity walks reuse them).","enum":["100001","100002","999999"]}}},"responses":{"Unauthorized":{"description":"Missing or invalid ApiKey (Azure API Management's answer)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"NotFound":{"description":"Unknown patient, test, lab or webhook","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"ValidationProblem":{"description":"ASP.NET validation problem details","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}}},"schemas":{"Error":{"type":"object","description":"\`{Message}\` (ODX), \`{statusCode, message}\` (API Management) or ASP.NET problem details.","properties":{"Message":{"type":"string"},"message":{"type":"string"},"statusCode":{"type":"integer"},"type":{"type":"string"},"title":{"type":"string"},"status":{"type":"integer"},"errors":{"type":"object","additionalProperties":{"type":"array","items":{"type":"string"}}}}},"Lab":{"type":"object","required":["labId","name"],"properties":{"labId":{"type":"integer"},"name":{"type":"string"},"isCurrentLab":{"type":"boolean"}}},"LabElement":{"type":"object","required":["labId","elementId","elementName","elementReferences"],"properties":{"labId":{"type":"integer"},"elementId":{"type":"integer"},"elementName":{"type":"string"},"elementGenderType":{"type":"string"},"cuUnit":{"type":"string"},"siUnit":{"type":"string"},"cuToSiConversionFactor":{"type":"number"},"elementReferences":{"type":"array","items":{"type":"object","required":["elementCode","elementName"],"properties":{"elementCode":{"type":"string"},"elementName":{"type":"string"}}}}}},"PatientRequest":{"type":"object","required":["firstName","lastName","gender","email"],"properties":{"firstName":{"type":"string","minLength":1,"maxLength":60,"enum":["Ada","Grace","Katherine"]},"lastName":{"type":"string","minLength":1,"maxLength":60,"enum":["Lovelace","Hopper","Johnson"]},"nickname":{"type":["string","null"],"maxLength":60},"dateOfBirth":{"type":["string","null"],"enum":["1985-12-10","1906-12-09",null]},"gender":{"type":"string","enum":["Male","Female"]},"email":{"type":"string","enum":["ada@example.com","grace@example.com"]},"userId":{"type":"string","maxLength":40},"workspaceId":{"type":"integer","minimum":0,"maximum":10}}},"Patient":{"type":"object","required":["patientId","practiceId","firstName","lastName","gender","email","createdDate","lastUpdatedDate"],"properties":{"patientId":{"type":"integer"},"practiceId":{"type":"string"},"createdDate":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}},"lastUpdatedDate":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}},"userTitle":{"type":["string","null"]},"userFirstName":{"type":["string","null"]},"userLastName":{"type":["string","null"]},"firstName":{"type":"string"},"lastName":{"type":"string"},"nickname":{"type":["string","null"]},"dateOfBirth":{"type":["string","null"]},"gender":{"type":"string"},"homePhone":{"type":["string","null"]},"workPhone":{"type":["string","null"]},"mobile":{"type":["string","null"]},"email":{"type":"string"},"address":{"type":["string","null"]},"address2":{"type":["string","null"]},"address3":{"type":["string","null"]},"city":{"type":["string","null"]},"province":{"type":["string","null"]},"postalCode":{"type":["string","null"]},"country":{"type":["string","null"]},"userId":{"type":["string","null"]},"workspaceId":{"type":"integer"}}},"TestResultsRequest":{"type":"object","required":["labProfileId","labId","testDate","unitType","results"],"properties":{"labProfileId":{"type":"integer","enum":[1,2]},"labId":{"type":"string","enum":["1","2"]},"testDate":{"type":"string","enum":["2025-01-15T00:00:00.000Z","2025-06-15T00:00:00.000Z"]},"unitType":{"type":"string","enum":["ConventionalUS","SI"]},"userId":{"type":"string","maxLength":40},"menstrualPhase":{"type":"string","enum":["Unknown","Follicular","Ovulation","Luteal","PostMenopausal"]},"isFasting":{"type":"boolean"},"results":{"type":"array","maxItems":5,"items":{"type":"object","required":["elementId"],"properties":{"elementId":{"type":"integer","enum":[494,496,506,537,999]},"value":{"type":"number","minimum":0,"maximum":500},"comparison":{"type":["string","null"],"enum":["<",">","",null]},"observationDateTime":{"type":"string","maxLength":40}}}}}},"Hl7Request":{"type":"object","required":["labProfileId","labId","testDate","unitType","hl7"],"properties":{"labProfileId":{"type":"integer","enum":[1,2]},"labId":{"type":"integer","enum":[1,2,999]},"testDate":{"type":"string","enum":["2025-01-15T00:00:00.000Z","2025-06-15T00:00:00.000Z"]},"unitType":{"type":"string","enum":["ConventionalUS","SI"]},"userId":{"type":"string","maxLength":40},"externalReference":{"type":["string","null"],"maxLength":60},"externalMessageControlId":{"type":["string","null"],"maxLength":60},"externalPatientTestId":{"type":["string","null"],"maxLength":60},"menstrualPhase":{"type":"string","enum":["Unknown","Follicular","Ovulation","Luteal","PostMenopausal"]},"isFasting":{"type":"boolean"},"hl7":{"type":"string","enum":["MSH|^~\\\\&|LAB|AHA|GEVITI|GEVITI|20250115000000||ORU^R01|BL-001|P|2.3\\rPID|1||E2E-1||Test^Patient||19800101|M\\rOBR|1|||^^^Geviti|||20250115\\rOBX|1|NM|1751-7^Albumin||4.2|g/dL|3.5-5.5|N|||F|||20250115\\rOBX|2|NM|2160-0^Creatinine||1.1|mg/dL|0.6-1.3|N|||F|||20250115\\r","MSH|^~\\\\&|LAB|AHA|GEVITI|GEVITI|20250615000000||ORU^R01|IM-001|P|2.3\\rPID|1||E2E-1||Test^Patient||19800101|F\\rOBR|1|||^^^Geviti|||20250615\\rOBX|1|NM|30522-7^hs-CRP||<0.2|mg/L|0-3|N|||F|||20250615\\rOBX|2|NM|ZZZ-1^Unmapped Marker||12|U/L||N|||F|||20250615\\r","not an hl7 message"]}}},"PatientTestElement":{"type":"object","required":["elementId","elementName","unit","comparison"],"properties":{"elementValue":{"type":"number"},"comparison":{"type":"string"},"unit":{"type":"string"},"elementId":{"type":"integer"},"elementName":{"type":"string"},"optimalRangeLow":{"type":"number"},"optimalRangeHigh":{"type":"number"},"standardRangeLow":{"type":"number"},"standardRangeHigh":{"type":"number"}}},"PatientTest":{"type":"object","required":["patientTestId","patientId","labProfileId","testDate","unitType","createdDate","lastUpdatedDate","practiceId","labId","results","menstrualPhase","isFasting"],"properties":{"patientTestId":{"type":"integer"},"patientId":{"type":"integer"},"labProfileId":{"type":"integer"},"testDate":{"type":"string"},"unitType":{"type":"string"},"createdDate":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}},"lastUpdatedDate":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}},"userId":{"type":["string","null"]},"practiceId":{"type":"string"},"labId":{"type":"integer"},"externalReference":{"type":["string","null"]},"externalMessageControlId":{"type":["string","null"]},"externalPatientTestId":{"type":["string","null"]},"results":{"type":"array","items":{"$ref":"#/components/schemas/PatientTestElement"}},"importLogs":{"type":["array","null"],"items":{"type":"object","properties":{"observationIdentifier":{"type":["string","null"]},"observationIdentifierText":{"type":["string","null"]},"status":{"type":["string","null"]}}}},"menstrualPhase":{"type":"string"},"isFasting":{"type":"boolean"}}},"ReportRequest":{"type":"object","required":["patientTestId","patientId","outputType"],"properties":{"patientTestId":{"type":"integer","enum":[700001,999999]},"patientId":{"type":"integer","enum":[100001,999999]},"unitType":{"type":"string","enum":["ConventionalUS"]},"practiceId":{"type":"string","enum":["3f0c0c43-7d2b-4b8e-9a50-9c1f0c6c0001"]},"outputType":{"type":"string","enum":["Json","Pdf","Xml"]},"theme":{"type":"string","enum":["Geviti"]},"themeId":{"type":"integer","enum":[21]},"recipientId":{"type":"string","enum":["15","0"]},"cultureCode":{"type":"string","enum":["en-US"]},"reports":{"type":"array","maxItems":3,"items":{"type":"string","enum":["1","2","3"]}},"addMarginForBinding":{"type":"boolean"},"userId":{"type":"string","maxLength":40}}},"Report":{"type":"object","required":["metadata","labs","elements","sections"],"properties":{"metadata":{"type":"object","required":["practiceId","patientId","patientTestId","recipient","reports","unitType"],"properties":{"practiceId":{"type":"string"},"patientId":{"type":"integer"},"patientTestId":{"type":"integer"},"recipient":{"type":"string"},"reports":{"type":"array","items":{"type":"string"}},"unitType":{"type":"string"}}},"labs":{"type":"array","items":{"$ref":"#/components/schemas/Lab"}},"elements":{"type":"array","items":{"$ref":"#/components/schemas/PatientTestElement"}},"sections":{"type":"array","items":{"type":"object","required":["name","reports"],"properties":{"name":{"type":"string"},"reports":{"type":"array","items":{"type":"object","required":["reportId","name","content"],"properties":{"reportId":{"type":"integer"},"name":{"type":"string"},"content":{"type":"object"}}}}}}}}},"WebhookRequest":{"type":"object","required":["entityEvents","webhookUrl"],"properties":{"entityEvents":{"type":"object","required":["PatientTest"],"properties":{"PatientTest":{"type":"array","minItems":1,"items":{"type":"string","enum":["Created","Updated","Deleted"]}}}},"webhookUrl":{"type":"string","enum":["https://backend.example.test/odx/webhook","https://staging.example.test/odx/webhook"]}}},"Webhook":{"type":"object","required":["partnerWebhookId","signingKey","createDate","entityEvents","webhookUrl"],"properties":{"partnerWebhookId":{"type":"integer"},"signingKey":{"type":"string","x-mockingbird-volatile":{"kind":"token"}},"createDate":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}},"entityEvents":{"type":"object","properties":{"PatientTest":{"type":"array","items":{"type":"string"}}}},"webhookUrl":{"type":"string"}}}}}}`);
+var operationIds = ["ListPartnerLabs", "ListElements", "CreatePatient", "UpdatePatient", "DeletePatient", "LinkPartnerUser", "ListPatients", "CreateTestResults", "CreatePatientTest", "UpdatePatientTest", "ListPatientTests", "GenerateFunctionalHealthReport", "ListWebhooks", "RegisterWebhook", "UpdateWebhook"];
+var supportedOperationIds = ["ListPartnerLabs", "ListElements", "CreatePatient", "UpdatePatient", "DeletePatient", "LinkPartnerUser", "ListPatients", "CreateTestResults", "CreatePatientTest", "UpdatePatientTest", "ListPatientTests", "GenerateFunctionalHealthReport", "ListWebhooks", "RegisterWebhook", "UpdateWebhook"];
+
+// src/results.ts
+var parseObservations = (hl7) => {
+  const segments = hl7.split(/\r\n|\r|\n/).filter((s) => s.trim() !== "");
+  if (!segments[0]?.startsWith("MSH|")) return void 0;
+  return segments.filter((segment) => segment.startsWith("OBX|")).map((segment) => {
+    const fields = segment.split("|");
+    const [code = "", text2 = ""] = (fields[3] ?? "").split("^");
+    return {
+      code: code.trim(),
+      text: text2.trim(),
+      value: (fields[5] ?? "").trim(),
+      units: (fields[6] ?? "").trim(),
+      range: (fields[7] ?? "").trim()
+    };
+  });
+};
+var VALUE = /^(<=|>=|<|>)?\s*(-?\d+(?:\.\d+)?)$/;
+var matchElement = (code, text2, gender2) => {
+  const byCode = ELEMENTS.filter(
+    (e) => e.codes.some((c) => c.toLowerCase() === code.toLowerCase()) || `EL${e.elementId}` === code.toUpperCase()
+  );
+  const candidates = byCode.length > 0 ? byCode : ELEMENTS.filter((e) => e.elementName.toLowerCase() === text2.toLowerCase());
+  if (candidates.length <= 1) return candidates[0];
+  const sex = gender2.toLowerCase() === "female" ? "Female" : "Male";
+  return candidates.find((e) => e.elementGenderType === sex) ?? candidates[0];
+};
+var round = (n) => Math.round(n * 1e3) / 1e3;
+var resultFor = (element, value, comparison, unitType) => {
+  const si = unitType.toUpperCase() === "SI";
+  const k = si ? element.cuToSiConversionFactor : 1;
+  return {
+    elementValue: value,
+    comparison,
+    unit: si ? element.siUnit : element.cuUnit,
+    elementId: element.elementId,
+    elementName: element.elementName,
+    optimalRangeLow: round(element.optimal[0] * k),
+    optimalRangeHigh: round(element.optimal[1] * k),
+    standardRangeLow: round(element.standard[0] * k),
+    standardRangeHigh: round(element.standard[1] * k)
+  };
+};
+var importObservations = (observations, gender2, unitType) => {
+  const results = [];
+  const importLogs = [];
+  for (const obs of observations) {
+    const log = (status) => importLogs.push({
+      observationIdentifier: obs.code || null,
+      observationIdentifierText: obs.text || null,
+      status
+    });
+    const element = matchElement(obs.code, obs.text, gender2);
+    if (!element) {
+      log("NotMapped");
+      continue;
+    }
+    const parsed = VALUE.exec(obs.value);
+    if (!parsed) {
+      log("InvalidValue");
+      continue;
+    }
+    results.push(resultFor(element, Number(parsed[2]), parsed[1] ?? "", unitType));
+    log("Imported");
+  }
+  return { results, importLogs };
+};
+var band = (r) => {
+  if (r.elementValue < r.standardRangeLow) return "low";
+  if (r.elementValue > r.standardRangeHigh) return "high";
+  if (r.elementValue < r.optimalRangeLow) return "belowOptimal";
+  if (r.elementValue > r.optimalRangeHigh) return "aboveOptimal";
+  return "optimal";
+};
+
+// src/report.ts
+var RECIPIENTS = {
+  "15": "Patient (Geviti)",
+  "16": "Practitioner (Geviti)",
+  "1": "Patient",
+  "2": "Practitioner"
+};
+var describe = (r) => `${r.elementName} ${r.elementValue} ${r.unit} is outside the optimal range ${r.optimalRangeLow}-${r.optimalRangeHigh}`;
+var jsonReport = (test, request) => {
+  const results = test.results;
+  const outside = results.filter((r) => band(r) !== "optimal");
+  const above = results.filter((r) => ["aboveOptimal", "high"].includes(band(r)));
+  const below = results.filter((r) => ["belowOptimal", "low"].includes(band(r)));
+  const lab = LABS.find((l) => l.labId === test.labId) ?? {
+    labId: test.labId,
+    name: `Lab ${test.labId}`,
+    isCurrentLab: false
+  };
+  const alarm = (r) => band(r) === "low" || band(r) === "high";
+  const rationale = (r) => ({
+    elementId: r.elementId,
+    status: ["aboveOptimal", "high"].includes(band(r)) ? "Above Optimal" : "Below Optimal"
+  });
+  const probability = results.length === 0 ? 0 : Math.round(outside.length / results.length * 100);
+  return {
+    metadata: {
+      practiceId: test.practiceId,
+      patientId: test.patientId,
+      patientTestId: test.patientTestId,
+      recipient: RECIPIENTS[String(request.recipientId ?? "")] ?? "0",
+      reports: Array.isArray(request.reports) ? request.reports.map(String) : [],
+      unitType: typeof request.unitType === "string" ? request.unitType : test.unitType
+    },
+    labs: [lab],
+    elements: results,
+    sections: [
+      {
+        name: "Blood Test Results",
+        reports: [
+          {
+            reportId: 1,
+            name: "Blood Test Results",
+            content: {
+              tests: [{ labId: String(test.labId), testDate: test.testDate }],
+              groups: [
+                {
+                  name: "Results",
+                  results: results.map((r) => ({
+                    elementId: r.elementId,
+                    values: [{ comparison: r.comparison, value: r.elementValue, alarm: alarm(r) }]
+                  }))
+                }
+              ],
+              aboveOptimal: above.map((r) => ({
+                elementId: r.elementId,
+                value: r.elementValue,
+                alarm: alarm(r),
+                description: describe(r)
+              })),
+              belowOptimal: below.map((r) => ({
+                elementId: r.elementId,
+                value: r.elementValue,
+                alarm: alarm(r),
+                description: describe(r)
+              }))
+            }
+          }
+        ]
+      },
+      {
+        name: "Functional Health",
+        reports: [
+          {
+            reportId: 2,
+            name: "Functional Body Systems",
+            content: {
+              conditions: [
+                {
+                  conditionId: 1,
+                  name: "Overall Functional Health",
+                  probabilityOfDysfunction: probability,
+                  description: null,
+                  rationales: outside.map(rationale),
+                  elementIdsConsidered: results.map((r) => r.elementId),
+                  elementIdsMissing: []
+                }
+              ]
+            }
+          },
+          {
+            reportId: 3,
+            name: "Health Concerns",
+            content: {
+              healthConcerns: outside.length ? [
+                {
+                  healthConcernId: 1,
+                  name: "Biomarkers outside optimal range",
+                  description: `${outside.length} of ${results.length} results are outside their optimal range.`,
+                  needOfSupportProbability: probability,
+                  rationales: outside.map(rationale)
+                }
+              ] : []
+            }
+          }
+        ]
+      }
+    ]
+  };
+};
+var pdfReport = (test) => {
+  const text2 = `Functional Health Report - patient test ${test.patientTestId} (${test.results.length} results)`.replace(
+    /[()\\]/g,
+    ""
+  );
+  const stream = `BT /F1 12 Tf 72 720 Td (${text2}) Tj ET`;
+  const objects = [
+    "<< /Type /Catalog /Pages 2 0 R >>",
+    "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+    "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >>",
+    `<< /Length ${stream.length} >>
+stream
+${stream}
+endstream`,
+    "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>"
+  ];
+  let body = "%PDF-1.4\n";
+  const offsets = [];
+  objects.forEach((object, i) => {
+    offsets.push(body.length);
+    body += `${i + 1} 0 obj
+${object}
+endobj
+`;
+  });
+  const xref = body.length;
+  body += `xref
+0 ${objects.length + 1}
+0000000000 65535 f 
+`;
+  for (const offset of offsets) body += `${String(offset).padStart(10, "0")} 00000 n 
+`;
+  body += `trailer
+<< /Size ${objects.length + 1} /Root 1 0 R >>
+startxref
+${xref}
+%%EOF
+`;
+  return new TextEncoder().encode(body);
+};
+
+// src/state.ts
+var DEFAULT_SETTINGS = { apiKeys: [], presetWebhook: null };
+var ID_BASES = { patient: 1e5, test: 7e5, webhook: 0, message: 0 };
+var OdxState = class {
+  constructor(sqlite, namespace, seed) {
+    this.namespace = namespace;
+    this.seed = seed;
+    this.patients = new Collection(sqlite, namespace, "patients");
+    this.tests = new Collection(sqlite, namespace, "tests");
+    this.webhooks = new Collection(sqlite, namespace, "webhooks");
+    this.settings = new Collection(sqlite, namespace, "settings");
+    this.counters = new Collection(sqlite, namespace, "counters");
+    this.ensureSeeded();
+  }
+  namespace;
+  seed;
+  patients;
+  tests;
+  webhooks;
+  settings;
+  counters;
+  /** Numeric ids per kind: patients 100001…, tests 700001…, webhooks 1…. */
+  nextId(kind) {
+    const next = (this.counters.get(kind) ?? 0) + 1;
+    this.counters.insert(kind, next);
+    return ID_BASES[kind] + next;
+  }
+  current() {
+    return this.settings.get("settings") ?? { ...DEFAULT_SETTINGS, ...this.seed.settings };
+  }
+  update(patch) {
+    const next = { ...this.current(), ...patch };
+    this.settings.insert("settings", next);
+    return next;
+  }
+  ensureSeeded() {
+    if (!this.settings.has("settings")) {
+      this.settings.insert("settings", { ...DEFAULT_SETTINGS, ...this.seed.settings });
+    }
+    const preset = this.current().presetWebhook;
+    if (preset && this.webhooks.count() === 0) {
+      this.addWebhook(preset.url, ["Created", "Updated", "Deleted"], preset.signingKey);
+    }
+  }
+  addWebhook(url, events, signingKey) {
+    const id = this.nextId("webhook");
+    const webhook = {
+      partnerWebhookId: id,
+      signingKey: signingKey ?? opaqueToken(`odx:signing-key:${this.namespace}:${id}`, 44),
+      createDate: this.seed.timestamp(),
+      entityEvents: { PatientTest: events },
+      webhookUrl: url
+    };
+    this.webhooks.insert(String(id), webhook);
+    return webhook;
+  }
+  patient(practiceId, patientId) {
+    const found = this.patients.get(String(patientId));
+    return found && found.practiceId === practiceId ? found : void 0;
+  }
+};
+
+// src/runtime.ts
+var SIGNATURE_HEADER = "optimaldx-signature";
+var signOdx = async (signingKey, body) => (await hmac("SHA-256", signingKey, body, "hex")).toUpperCase();
+var EMITTERS = ["CreatePatientTest", "UpdatePatientTest", "CreateTestResults"];
+var ODX_PRESETS = {
+  wrong_length_signature: {
+    description: "The webhook for the next test import carries a short signature: our guard's timingSafeEqual throws (a 500, known consumer bug)",
+    rules: EMITTERS.map((operationId) => ({ operationId, effect: "wrong_length_signature" }))
+  },
+  bad_signature: {
+    description: "The webhook for the next test import is signed with the wrong key (same length): our guard rejects it (403)",
+    rules: EMITTERS.map((operationId) => ({ operationId, effect: "bad_signature" }))
+  },
+  empty_success: {
+    description: "Calls answer 200 with an empty body (our client throws 'Empty success response received')",
+    rules: [{ effect: "empty_success" }]
+  },
+  no_content: {
+    description: "Calls answer 204 No Content (our client throws on 204)",
+    rules: [{ effect: "no_content" }]
+  },
+  not_found: {
+    description: "Every call answers 404 {Message}",
+    rules: [{ status: 404, body: { Message: "Not Found" } }]
+  },
+  server_error: {
+    description: "Every call answers 500 {Message: 'An error has occurred.'}",
+    rules: [{ status: 500, body: { Message: "An error has occurred." } }]
+  },
+  slow: {
+    description: "Every call is held back 3 s",
+    rules: [{ latencyMs: 3e3 }]
+  },
+  webhook_duplicate: {
+    description: "The next webhook is delivered twice (ODX's rapid-fire duplicates)",
+    webhook: { mode: "duplicate" }
+  },
+  webhook_reorder: {
+    description: "The next two webhooks arrive swapped",
+    webhook: { mode: "reorder" }
+  },
+  webhook_drop: {
+    description: "The next webhook is never delivered",
+    webhook: { mode: "drop" }
+  }
+};
+var json3 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminError3 = (status, message2) => json3(status, { error: { type: "mockingbird_admin", message: message2 } });
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var EVENTS = ["Created", "Updated", "Deleted"];
+var SIGNATURES = ["valid", "short", "bad"];
+var adminRoutes = (runtime) => ({
+  "GET /patients": ({ namespace }) => json3(200, { patients: runtime.instance(namespace).patients() }),
+  "GET /tests": ({ namespace }) => json3(200, {
+    // Results are the mock's own output; no HL7 (PHI) is ever stored.
+    tests: runtime.instance(namespace).tests()
+  }),
+  "POST /tests/:id/webhook": ({ params, body, namespace }) => {
+    const input = isRecord4(body) ? body : {};
+    const eventType = String(input.eventType ?? "Updated");
+    const signature = String(input.signature ?? "valid");
+    if (!EVENTS.includes(eventType))
+      return adminError3(400, "eventType must be Created, Updated or Deleted");
+    if (!SIGNATURES.includes(signature))
+      return adminError3(400, "signature must be valid, short or bad");
+    const event = runtime.instance(namespace).emit(params.id, eventType, signature);
+    return event ? json3(202, event) : adminError3(404, `no patient test ${params.id}`);
+  },
+  "DELETE /tests/:id": ({ params, namespace }) => {
+    const event = runtime.instance(namespace).emit(params.id, "Deleted");
+    return event ? json3(200, event) : adminError3(404, `no patient test ${params.id}`);
+  },
+  "GET /settings": ({ namespace }) => json3(200, runtime.instance(namespace).state.current()),
+  "PUT /settings": ({ body, namespace }) => {
+    if (!isRecord4(body)) return adminError3(400, "expected a JSON object");
+    const patch = {};
+    if (body.apiKeys !== void 0) {
+      if (!Array.isArray(body.apiKeys)) return adminError3(400, "apiKeys: string[]");
+      patch.apiKeys = body.apiKeys.map(String);
+    }
+    return json3(200, runtime.instance(namespace).state.update(patch));
+  }
+});
+var createRuntime2 = (options = {}) => {
+  const hub = createWebhookHub({
+    // The message id carries the signature mode a fault preset asked for (`~short`, `~bad`).
+    signer: signers.custom(async ({ messageId, body, secret }) => {
+      if (!secret) return {};
+      const signature = await signOdx(secret, body);
+      if (messageId.endsWith("~short")) return { [SIGNATURE_HEADER]: signature.slice(0, 32) };
+      if (messageId.endsWith("~bad")) {
+        return { [SIGNATURE_HEADER]: await signOdx(`${secret}-wrong`, body) };
+      }
+      return { [SIGNATURE_HEADER]: signature };
+    }),
+    ...options.retryDelaysMs ? { retryDelaysMs: options.retryDelaysMs } : {},
+    ...options.fetch ? { fetch: options.fetch } : {}
+  });
+  const presetWebhook = options.webhook ? {
+    url: options.webhook.url,
+    signingKey: options.webhook.signingKey ?? `odx_${opaqueToken(String(options.seed ?? 0), 32)}`
+  } : null;
+  let sequence = 0;
+  const runtime = createRuntime({
+    name: ODX_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: apiKeyCredential,
+    presets: ODX_PRESETS,
+    webhooks: hub,
+    create: ({ sqlite, namespace, publicNamespace, clock }) => {
+      const api = new OdxAPI({
+        sqlite,
+        namespace,
+        now: clock.now,
+        settings: { ...options.settings, ...presetWebhook ? { presetWebhook } : {} },
+        onWebhook: (event, signature) => {
+          hub.setEndpoints(
+            publicNamespace,
+            api.state.webhooks.list({ order: "oldest" }).map(({ value }) => ({
+              id: `odx_webhook_${value.partnerWebhookId}`,
+              url: value.webhookUrl,
+              secret: value.signingKey,
+              events: value.entityEvents.PatientTest
+            }))
+          );
+          const suffix = signature === "valid" ? "" : `~${signature}`;
+          hub.publish({
+            namespace: publicNamespace,
+            type: event.eventType,
+            body: event,
+            id: `${event.data.patientTestId}:${event.eventType}:${++sequence}${suffix}`
+          });
+        }
+      });
+      return api;
+    },
+    describe: () => ({ webhooks: presetWebhook ? "preset" : "registered" }),
+    admin: adminRoutes
+  });
+  return Object.assign(runtime, { webhooks: hub });
+};
+
+// src/index.ts
+var ODX_NAMESPACE = "odx";
+var apiKeyCredential = (request) => request.headers.get("apikey") ?? void 0;
+var MISSING_KEY = "Access denied due to missing subscription key. Make sure to include subscription key when making requests to an API.";
+var INVALID_KEY = "Access denied due to invalid subscription key. Make sure to provide a valid key for an active subscription.";
+var message = (status, text2) => jsonRes(status, { Message: text2 });
+var problem = (errors) => jsonRes(400, {
+  type: "https://tools.ietf.org/html/rfc7231#section-6.5.1",
+  title: "One or more validation errors occurred.",
+  status: 400,
+  errors
+});
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var text = (value) => typeof value === "string" ? value : typeof value === "number" ? String(value) : null;
+var jsonBody = (context) => context.body.kind === "json" && isRecord5(context.body.value) ? context.body.value : void 0;
+var dotnetDate = (value) => {
+  const raw = text(value);
+  if (!raw) return null;
+  const match = /^(\d{4}-\d{2}-\d{2})(?:[T ](\d{2}:\d{2}:\d{2}))?/.exec(raw);
+  return match ? `${match[1]}T${match[2] ?? "00:00:00"}` : null;
+};
+var gender = (value) => {
+  const raw = (text(value) ?? "").toLowerCase();
+  return raw === "male" || raw === "m" ? "Male" : raw === "female" || raw === "f" ? "Female" : "Unknown";
+};
+var PHASES = ["Unknown", "Follicular", "Ovulation", "Luteal", "PostMenopausal"];
+var OdxAPI = class {
+  app;
+  sqlite;
+  state;
+  service;
+  now;
+  onWebhook;
+  constructor(options = {}) {
+    const sqlite = bootSqlite(options.sqlite);
+    const namespace = options.namespace ?? ODX_NAMESPACE;
+    this.now = options.now ?? (() => Date.now());
+    this.onWebhook = options.onWebhook;
+    this.state = new OdxState(sqlite, namespace, {
+      settings: options.settings ?? {},
+      timestamp: () => this.iso()
+    });
+    const handlers = defineOperations({
+      ListPartnerLabs: () => jsonRes(200, LABS),
+      ListElements: (context) => this.listElements(context),
+      CreatePatient: (context) => this.savePatient(context, void 0),
+      UpdatePatient: (context) => this.savePatient(context, context.params.patientId),
+      DeletePatient: (context) => this.deletePatient(context),
+      LinkPartnerUser: (context) => this.linkPartner(context),
+      ListPatients: (context) => this.listPatients(context),
+      CreateTestResults: (context) => this.createTestResults(context),
+      CreatePatientTest: (context) => this.saveHl7Test(context, void 0),
+      UpdatePatientTest: (context) => this.saveHl7Test(context, context.params.patientTestId),
+      ListPatientTests: (context) => this.listTests(context),
+      GenerateFunctionalHealthReport: (context) => this.report(context),
+      ListWebhooks: () => jsonRes(
+        200,
+        this.state.webhooks.list({ order: "oldest" }).map((row) => row.value)
+      ),
+      RegisterWebhook: (context) => this.saveWebhook(context, void 0),
+      UpdateWebhook: (context) => this.saveWebhook(context, context.params.partnerWebhookId)
+    });
+    this.service = createService({
+      document,
+      handlers,
+      sqlite,
+      namespace,
+      now: this.now,
+      notFound: () => jsonRes(404, { statusCode: 404, message: "Resource not found" }),
+      onError: (error) => {
+        throw error;
+      },
+      before: (context) => {
+        const key = apiKeyCredential(context.request);
+        if (!key) return jsonRes(401, { statusCode: 401, message: MISSING_KEY });
+        const keys = this.state.current().apiKeys;
+        if (keys.length > 0 && !keys.includes(key)) {
+          return jsonRes(401, { statusCode: 401, message: INVALID_KEY });
+        }
+        const effect = (name) => faultEffect(context.request, name) !== void 0;
+        if (effect("no_content")) return new Response(null, { status: 204 });
+        if (effect("empty_success")) return new Response("", { status: 200 });
+        return void 0;
+      }
+    });
+    this.app = this.service.app;
+    this.sqlite = this.service.sqlite;
+  }
+  fetch(request) {
+    return this.service.fetch(request);
+  }
+  async reset() {
+    await this.service.reset();
+    this.state.ensureSeeded();
+  }
+  iso() {
+    return new Date(this.now()).toISOString();
+  }
+  listElements(context) {
+    const labId = Number(context.params.labId);
+    if (!LABS.some((lab) => lab.labId === labId))
+      return message(404, `Lab ${context.params.labId} not found.`);
+    return jsonRes(
+      200,
+      ELEMENTS.map((element) => labElement(labId, element))
+    );
+  }
+  savePatient(context, patientId) {
+    const practiceId = context.params.practiceId;
+    const existing = patientId === void 0 ? void 0 : this.state.patient(practiceId, patientId);
+    if (patientId !== void 0 && !existing) return message(404, "Patient not found.");
+    const body = jsonBody(context);
+    if (!body) return problem({ "": ["A non-empty request body is required."] });
+    const errors = {};
+    for (const [key, label] of [
+      ["firstName", "FirstName"],
+      ["lastName", "LastName"],
+      ["email", "Email"]
+    ]) {
+      if (!text(body[key])?.trim()) errors[label] = [`The ${label} field is required.`];
+    }
+    if (body.dateOfBirth !== void 0 && body.dateOfBirth !== null && !dotnetDate(body.dateOfBirth)) {
+      errors.DateOfBirth = ["The value is not a valid date."];
+    }
+    if (Object.keys(errors).length > 0) return problem(errors);
+    const now = this.iso();
+    const patient = {
+      patientId: existing?.patientId ?? this.state.nextId("patient"),
+      practiceId,
+      createdDate: existing?.createdDate ?? now,
+      lastUpdatedDate: now,
+      userTitle: null,
+      userFirstName: null,
+      userLastName: null,
+      firstName: text(body.firstName),
+      lastName: text(body.lastName),
+      nickname: text(body.nickname),
+      dateOfBirth: dotnetDate(body.dateOfBirth),
+      gender: gender(body.gender),
+      homePhone: null,
+      workPhone: null,
+      mobile: null,
+      email: text(body.email),
+      address: null,
+      address2: null,
+      address3: null,
+      city: null,
+      province: null,
+      postalCode: null,
+      country: null,
+      userId: text(body.userId),
+      workspaceId: typeof body.workspaceId === "number" ? body.workspaceId : 0,
+      partnerUserId: existing?.partnerUserId ?? null
+    };
+    this.state.patients.insert(String(patient.patientId), patient);
+    return annotateResponse(jsonRes(200, publicPatient(patient)), {
+      ids: { patientId: String(patient.patientId) }
+    });
+  }
+  deletePatient(context) {
+    const patient = this.state.patient(
+      context.params.practiceId,
+      context.params.patientId
+    );
+    if (!patient) return message(404, "Patient not found.");
+    this.state.patients.delete(String(patient.patientId));
+    for (const row of this.state.tests.list({ where: (t) => t.patientId === patient.patientId })) {
+      this.state.tests.delete(row.id);
+    }
+    return annotateResponse(new Response(null, { status: 204 }), {
+      ids: { patientId: String(patient.patientId) }
+    });
+  }
+  linkPartner(context) {
+    const patient = this.state.patient(
+      context.params.practiceId,
+      context.params.patientId
+    );
+    if (!patient) return message(404, "Patient not found.");
+    this.state.patients.update(String(patient.patientId), {
+      ...patient,
+      partnerUserId: context.params.localUserId,
+      lastUpdatedDate: this.iso()
+    });
+    return annotateResponse(jsonRes(200, true), { ids: { patientId: String(patient.patientId) } });
+  }
+  listPatients(context) {
+    const practiceId = context.params.practiceId;
+    const q = context.url.searchParams;
+    const filters = {
+      email: q.get("email"),
+      firstName: q.get("firstName"),
+      lastName: q.get("lastName"),
+      dateOfBirth: q.get("dateOfBirth")
+    };
+    const searching = Object.values(filters).some((v) => v);
+    const eq = (a, b) => !b || (a ?? "").toLowerCase() === b.toLowerCase();
+    const rows = this.state.patients.list({ where: (p) => p.practiceId === practiceId, order: "oldest" }).map((row) => row.value).filter(
+      (p) => eq(p.email, filters.email) && eq(p.firstName, filters.firstName) && eq(p.lastName, filters.lastName) && (!filters.dateOfBirth || p.dateOfBirth?.slice(0, 10) === dotnetDate(filters.dateOfBirth)?.slice(0, 10))
+    );
+    if (searching && rows.length === 0) return message(404, "No patients found.");
+    return jsonRes(200, rows.map(publicPatient));
+  }
+  listTests(context) {
+    const patient = this.state.patient(
+      context.params.practiceId,
+      context.params.patientId
+    );
+    if (!patient) return message(404, "Patient not found.");
+    return jsonRes(
+      200,
+      this.state.tests.list({ where: (t) => t.patientId === patient.patientId, order: "oldest" }).map((row) => row.value)
+    );
+  }
+  testBase(body, errors) {
+    const labId = Number(body.labId);
+    if (!Number.isInteger(labId) || !LABS.some((lab) => lab.labId === labId)) {
+      errors.LabId = [`Lab ${text(body.labId) ?? ""} is not available to this partner.`];
+    }
+    if (typeof body.labProfileId !== "number")
+      errors.LabProfileId = ["The LabProfileId field is required."];
+    const testDate = dotnetDate(body.testDate);
+    if (!testDate) errors.TestDate = ["The TestDate field is required."];
+    const unitType = text(body.unitType) ?? "";
+    if (!["ConventionalUS", "SI"].includes(unitType))
+      errors.UnitType = ["The UnitType field is invalid."];
+    const phase = text(body.menstrualPhase) ?? "Unknown";
+    if (!PHASES.includes(phase)) errors.MenstrualPhase = ["The MenstrualPhase field is invalid."];
+    return { labId, testDate: testDate ?? "", unitType, phase };
+  }
+  createTestResults(context) {
+    const practiceId = context.params.practiceId;
+    const patient = this.state.patient(practiceId, context.params.patientId);
+    if (!patient) return message(404, "Patient not found.");
+    const body = jsonBody(context);
+    if (!body) return problem({ "": ["A non-empty request body is required."] });
+    const errors = {};
+    const base = this.testBase(body, errors);
+    if (!Array.isArray(body.results)) errors.Results = ["The Results field is required."];
+    if (Object.keys(errors).length > 0) return problem(errors);
+    const results = [];
+    const importLogs = [];
+    for (const raw of body.results) {
+      const item = isRecord5(raw) ? raw : {};
+      const element = ELEMENTS.find((e) => e.elementId === item.elementId);
+      if (!element || typeof item.value !== "number") {
+        importLogs.push({
+          observationIdentifier: text(item.elementId),
+          observationIdentifierText: null,
+          status: element ? "InvalidValue" : "NotMapped"
+        });
+        continue;
+      }
+      results.push(resultFor(element, item.value, text(item.comparison) ?? "", base.unitType));
+      importLogs.push({
+        observationIdentifier: String(element.elementId),
+        observationIdentifierText: element.elementName,
+        status: "Imported"
+      });
+    }
+    const test = this.storeTest(patient, body, base, { results, importLogs }, void 0);
+    return this.testResponse(context, test, "Created");
+  }
+  saveHl7Test(context, patientTestId) {
+    const practiceId = context.params.practiceId;
+    const patient = this.state.patient(practiceId, context.params.patientId);
+    if (!patient) return message(404, "Patient not found.");
+    const existing = patientTestId === void 0 ? void 0 : this.state.tests.get(patientTestId);
+    if (patientTestId !== void 0 && (!existing || existing.patientId !== patient.patientId)) {
+      return message(404, "Patient test not found.");
+    }
+    const body = jsonBody(context);
+    if (!body) return problem({ "": ["A non-empty request body is required."] });
+    const errors = {};
+    const base = this.testBase(body, errors);
+    const observations = parseObservations(text(body.hl7) ?? "");
+    if (!observations) errors.Hl7 = ["The HL7 message could not be parsed (missing MSH segment)."];
+    else if (observations.length === 0) errors.Hl7 = ["The HL7 message contains no OBX segments."];
+    if (Object.keys(errors).length > 0) return problem(errors);
+    const imported = importObservations(observations ?? [], patient.gender, base.unitType);
+    const test = this.storeTest(patient, body, base, imported, existing);
+    return this.testResponse(context, test, existing ? "Updated" : "Created");
+  }
+  storeTest(patient, body, base, imported, existing) {
+    const now = this.iso();
+    const test = {
+      patientTestId: existing?.patientTestId ?? this.state.nextId("test"),
+      patientId: patient.patientId,
+      labProfileId: body.labProfileId,
+      testDate: base.testDate,
+      unitType: base.unitType,
+      createdDate: existing?.createdDate ?? now,
+      lastUpdatedDate: now,
+      userId: text(body.userId),
+      practiceId: patient.practiceId,
+      labId: base.labId,
+      externalReference: text(body.externalReference),
+      externalMessageControlId: text(body.externalMessageControlId),
+      externalPatientTestId: text(body.externalPatientTestId),
+      results: imported.results,
+      importLogs: imported.importLogs,
+      menstrualPhase: base.phase,
+      isFasting: body.isFasting === true
+    };
+    this.state.tests.insert(String(test.patientTestId), test);
+    return test;
+  }
+  testResponse(context, test, eventType) {
+    const signature = faultEffect(context.request, "wrong_length_signature") !== void 0 ? "short" : faultEffect(context.request, "bad_signature") !== void 0 ? "bad" : "valid";
+    this.emit(test.patientTestId, eventType, signature);
+    return annotateResponse(jsonRes(200, test), {
+      ids: { patientId: String(test.patientId), patientTestId: String(test.patientTestId) }
+    });
+  }
+  /** Emit a PatientTest webhook for a stored test (tests, the admin route, `Deleted`). */
+  emit(patientTestId, eventType, signature = "valid") {
+    const test = this.state.tests.get(String(patientTestId));
+    if (!test) return void 0;
+    const event = { entityType: "PatientTest", eventType, data: test };
+    this.onWebhook?.(event, signature);
+    if (eventType === "Deleted") this.state.tests.delete(String(test.patientTestId));
+    return event;
+  }
+  report(context) {
+    const body = jsonBody(context);
+    if (!body) return problem({ "": ["A non-empty request body is required."] });
+    const output = (text(body.outputType) ?? "").toLowerCase();
+    if (output !== "json" && output !== "pdf") {
+      return problem({
+        OutputType: [`The value '${text(body.outputType) ?? ""}' is not valid for OutputType.`]
+      });
+    }
+    const test = this.state.tests.get(String(body.patientTestId));
+    if (!test || body.patientId !== void 0 && test.patientId !== Number(body.patientId)) {
+      return message(404, "Patient test not found.");
+    }
+    const ids = { patientId: String(test.patientId), patientTestId: String(test.patientTestId) };
+    if (output === "pdf") {
+      const pdf = pdfReport(test);
+      return annotateResponse(
+        new Response(pdf, {
+          status: 200,
+          headers: { "content-type": "application/pdf", "content-length": String(pdf.byteLength) }
+        }),
+        { ids }
+      );
+    }
+    return annotateResponse(jsonRes(200, jsonReport(test, body)), { ids });
+  }
+  saveWebhook(context, id) {
+    const existing = id === void 0 ? void 0 : this.state.webhooks.get(id);
+    if (id !== void 0 && !existing) return message(404, "Webhook not found.");
+    const body = jsonBody(context);
+    const url = text(body?.webhookUrl);
+    const events = isRecord5(body?.entityEvents) ? body.entityEvents.PatientTest : void 0;
+    const errors = {};
+    let valid = false;
+    try {
+      valid = url !== null && ["http:", "https:"].includes(new URL(url).protocol);
+    } catch {
+      valid = false;
+    }
+    if (!valid) errors.WebhookUrl = ["The WebhookUrl field is not a valid URL."];
+    if (!Array.isArray(events) || events.length === 0 || events.some((e) => !["Created", "Updated", "Deleted"].includes(String(e)))) {
+      errors["EntityEvents.PatientTest"] = [
+        "PatientTest events must be Created, Updated or Deleted."
+      ];
+    }
+    if (Object.keys(errors).length > 0) return problem(errors);
+    const webhook = existing ? {
+      ...existing,
+      webhookUrl: url,
+      entityEvents: { PatientTest: events.map(String) }
+    } : this.state.addWebhook(url, events.map(String));
+    this.state.webhooks.insert(String(webhook.partnerWebhookId), webhook);
+    return annotateResponse(jsonRes(200, webhook), {
+      ids: { partnerWebhookId: String(webhook.partnerWebhookId) }
+    });
+  }
+  patients() {
+    return this.state.patients.list({ order: "oldest" }).map((row) => row.value);
+  }
+  tests() {
+    return this.state.tests.list({ order: "oldest" }).map((row) => row.value);
+  }
+};
+var publicPatient = ({ partnerUserId: _partner, ...patient }) => patient;
+
+export {
+  LABS,
+  ELEMENTS,
+  document,
+  operationIds,
+  supportedOperationIds,
+  parseObservations,
+  matchElement,
+  DEFAULT_SETTINGS,
+  SIGNATURE_HEADER,
+  signOdx,
+  ODX_PRESETS,
+  createRuntime2 as createRuntime,
+  ODX_NAMESPACE,
+  apiKeyCredential,
+  OdxAPI
+};
+//# sourceMappingURL=chunk-OYDT3HEE.js.map