@crvouga/mockingbird-service-edamam 0.1.0

package/dist/chunk-DWHV3RH2.js

@@ -0,0 +1,3485 @@
+// ../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, message) => json(status, { error: { type: "mockingbird_admin", message } });
+var UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+var parseDuration = (value) => {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value !== "string")
+    return void 0;
+  const match = /^(-?\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/.exec(value.trim());
+  if (!match)
+    return void 0;
+  return Number(match[1]) * UNITS[match[2]];
+};
+var parseInstant = (value) => {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value !== "string")
+    return void 0;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+};
+var matchRoute = (pattern, path) => {
+  const want = pattern.split("/").filter(Boolean);
+  const have = path.split("/").filter(Boolean);
+  if (want.length !== have.length)
+    return void 0;
+  const params = {};
+  for (let i = 0; i < want.length; i++) {
+    const segment = want[i];
+    const actual = have[i];
+    if (segment.startsWith(":"))
+      params[segment.slice(1)] = decodeURIComponent(actual);
+    else if (segment !== actual)
+      return void 0;
+  }
+  return params;
+};
+var readJson = async (request) => {
+  const text = await request.text();
+  if (text.trim() === "")
+    return void 0;
+  return JSON.parse(text);
+};
+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 basicAuth = (request) => {
+  const header = request.headers.get("authorization");
+  if (!header)
+    return void 0;
+  const match = /^Basic\s+(.+)$/i.exec(header.trim());
+  if (!match?.[1])
+    return void 0;
+  let decoded;
+  try {
+    decoded = atob(match[1].trim());
+  } catch {
+    return void 0;
+  }
+  const colon = decoded.indexOf(":");
+  if (colon < 0)
+    return { username: decoded, password: "" };
+  return { username: decoded.slice(0, colon), password: decoded.slice(colon + 1) };
+};
+var createCredentialRegistry = () => {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    set: (credential, namespace) => {
+      map.set(credential, namespace);
+    },
+    get: (credential) => map.get(credential),
+    remove: (credential) => map.delete(credential),
+    clear: () => map.clear(),
+    entries: () => [...map].map(([credential, namespace]) => ({ credential, namespace })).sort((a, b) => a.credential.localeCompare(b.credential))
+  };
+};
+var maskCredential = (credential) => credential.length <= 8 ? `${credential.slice(0, 2)}\u2026` : `${credential.slice(0, 6)}\u2026${credential.slice(-2)}`;
+
+// ../core/dist/rng.js
+var seedFrom = (value) => {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var createRng = (seed = 0) => {
+  const numeric = typeof seed === "string" ? seedFrom(seed) : seed >>> 0;
+  let state = numeric;
+  const next = () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+  return {
+    next,
+    int: (min, max) => min + Math.floor(next() * (max - min + 1)),
+    reset: () => {
+      state = numeric;
+    },
+    state: () => state,
+    setState: (next2) => {
+      if (!Number.isSafeInteger(next2) || next2 < 0 || next2 > 4294967295) {
+        throw new RangeError("rng state must be an unsigned 32-bit integer");
+      }
+      state = next2 >>> 0;
+    },
+    seed: numeric
+  };
+};
+
+// ../core/dist/faults.js
+var matches = (rule, candidate) => {
+  if (rule.namespace !== void 0 && rule.namespace !== "*" && rule.namespace !== candidate.namespace) {
+    return false;
+  }
+  if (rule.operationId !== void 0 && rule.operationId !== candidate.operationId)
+    return false;
+  if (rule.method !== void 0 && rule.method.toUpperCase() !== candidate.method.toUpperCase()) {
+    return false;
+  }
+  if (rule.pathPrefix !== void 0 && !candidate.path.startsWith(rule.pathPrefix))
+    return false;
+  return true;
+};
+var faultResponse = (rule) => {
+  const status = rule.status ?? 500;
+  const headers = { "content-type": "application/json", ...rule.headers };
+  if (typeof rule.body === "string")
+    return new Response(rule.body, { status, headers });
+  if (rule.body === null)
+    return new Response(null, { status, headers: rule.headers ?? {} });
+  const body = rule.body === void 0 ? { detail: "Injected by Mockingbird" } : rule.body;
+  return new Response(JSON.stringify(body), { status, headers });
+};
+var createFaultRegistry = (rng = createRng(0), sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) => {
+  const entries = [];
+  return {
+    add(rule) {
+      const existing = entries.findIndex((e) => e.rule.id === rule.id);
+      const entry = { rule, remaining: rule.count ?? null, hits: 0 };
+      if (existing >= 0)
+        entries[existing] = entry;
+      else
+        entries.push(entry);
+      return rule;
+    },
+    list: () => entries.map((e) => ({ ...e.rule, remaining: e.remaining, hits: e.hits })),
+    remove(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;
+};
+
+// ../../openapi/core/dist/schema.js
+var resolveSchema = (document2, schema) => {
+  let current = schema;
+  const seen = /* @__PURE__ */ new Set();
+  while (typeof current.$ref === "string") {
+    const ref = current.$ref;
+    if (seen.has(ref))
+      break;
+    seen.add(ref);
+    const { $ref: _ignored, ...siblings } = current;
+    const target = resolveRef(document2, ref);
+    current = { ...target, ...siblings };
+  }
+  if (current.nullable === true) {
+    const { nullable: _nullable, ...rest } = current;
+    const types = schemaTypes(rest);
+    if (types.length > 0 && !types.includes("null"))
+      current = { ...rest, type: [...types, "null"] };
+    else
+      current = rest;
+  }
+  return current;
+};
+var schemaTypes = (schema) => {
+  if (Array.isArray(schema.type))
+    return schema.type;
+  if (schema.type !== void 0)
+    return [schema.type];
+  const inferred = [];
+  if (schema.properties || schema.required || schema.additionalProperties !== void 0)
+    inferred.push("object");
+  if (schema.items || schema.prefixItems || schema.minItems !== void 0 || schema.maxItems !== void 0)
+    inferred.push("array");
+  if (schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern !== void 0)
+    inferred.push("string");
+  if (schema.minimum !== void 0 || schema.maximum !== void 0 || schema.multipleOf !== void 0)
+    inferred.push("number");
+  return inferred;
+};
+var jsonTypeOf = (value) => {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "number":
+      return Number.isInteger(value) ? "integer" : "number";
+    case "object":
+      return "object";
+    default:
+      return "undefined";
+  }
+};
+var deepEqual = (a, b) => {
+  if (a === b)
+    return true;
+  if (typeof a !== typeof b || a === null || b === null)
+    return false;
+  if (Array.isArray(a)) {
+    return Array.isArray(b) && a.length === b.length && a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object" && !Array.isArray(b)) {
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    return ka.length === kb.length && ka.every((k) => deepEqual(a[k], b[k]));
+  }
+  return false;
+};
+var FORMAT_PATTERNS = {
+  uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  date: /^\d{4}-\d{2}-\d{2}$/,
+  "date-time": /^\d{4}-\d{2}-\d{2}[Tt ]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/,
+  email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  uri: /^[a-zA-Z][a-zA-Z0-9+.-]*:[^\s]*$/,
+  ipv4: /^(25[0-5]|2[0-4]\d|1?\d?\d)(\.(25[0-5]|2[0-4]\d|1?\d?\d)){3}$/
+};
+var graphemeLength = (value) => [...value].length;
+var validateValue = (document2, schema, value, path = []) => {
+  const errors = [];
+  const s = resolveSchema(document2, schema);
+  const fail = (message) => errors.push({ path, message });
+  const actual = jsonTypeOf(value);
+  if (actual === "undefined") {
+    fail("value is undefined");
+    return errors;
+  }
+  const types = schemaTypes(s);
+  if (types.length > 0) {
+    const ok = types.some((t) => t === actual || t === "number" && actual === "integer");
+    if (!ok) {
+      fail(`expected type ${types.join("|")}, got ${actual}`);
+      return errors;
+    }
+  }
+  if (s.enum && !(value === null && types.includes("null")) && !s.enum.some((candidate) => deepEqual(candidate, value))) {
+    fail("value not in enum");
+  }
+  if (s.const !== void 0 && !deepEqual(s.const, value))
+    fail("value does not equal const");
+  if (typeof value === "string") {
+    const length = graphemeLength(value);
+    if (s.minLength !== void 0 && length < s.minLength)
+      fail(`length ${length} < minLength ${s.minLength}`);
+    if (s.maxLength !== void 0 && length > s.maxLength)
+      fail(`length ${length} > maxLength ${s.maxLength}`);
+    if (s.pattern !== void 0) {
+      try {
+        if (!new RegExp(s.pattern, "u").test(value))
+          fail(`does not match pattern ${s.pattern}`);
+      } catch {
+      }
+    }
+    if (s.format !== void 0) {
+      const pattern = FORMAT_PATTERNS[s.format];
+      if (pattern && !pattern.test(value))
+        fail(`does not match format ${s.format}`);
+    }
+  }
+  if (typeof value === "number") {
+    if (s.minimum !== void 0 && value < s.minimum)
+      fail(`${value} < minimum ${s.minimum}`);
+    if (s.maximum !== void 0 && value > s.maximum)
+      fail(`${value} > maximum ${s.maximum}`);
+    if (s.exclusiveMinimum !== void 0 && value <= s.exclusiveMinimum)
+      fail(`${value} <= exclusiveMinimum ${s.exclusiveMinimum}`);
+    if (s.exclusiveMaximum !== void 0 && value >= s.exclusiveMaximum)
+      fail(`${value} >= exclusiveMaximum ${s.exclusiveMaximum}`);
+    if (s.multipleOf !== void 0 && Math.abs(value / s.multipleOf - Math.round(value / s.multipleOf)) > 1e-9) {
+      fail(`${value} is not a multiple of ${s.multipleOf}`);
+    }
+  }
+  if (Array.isArray(value)) {
+    if (s.minItems !== void 0 && value.length < s.minItems)
+      fail(`${value.length} items < minItems ${s.minItems}`);
+    if (s.maxItems !== void 0 && value.length > s.maxItems)
+      fail(`${value.length} items > maxItems ${s.maxItems}`);
+    if (s.uniqueItems && value.some((item, i) => value.slice(0, i).some((prev) => deepEqual(prev, item))))
+      fail("items are not unique");
+    value.forEach((item, i) => {
+      const itemSchema = s.prefixItems?.[i] ?? s.items;
+      if (itemSchema)
+        errors.push(...validateValue(document2, itemSchema, item, [...path, i]));
+    });
+  }
+  if (actual === "object") {
+    const record = value;
+    const keys = Object.keys(record);
+    for (const name of s.required ?? [])
+      if (!(name in record))
+        fail(`missing required property ${name}`);
+    if (s.minProperties !== void 0 && keys.length < s.minProperties)
+      fail(`${keys.length} properties < minProperties ${s.minProperties}`);
+    if (s.maxProperties !== void 0 && keys.length > s.maxProperties)
+      fail(`${keys.length} properties > maxProperties ${s.maxProperties}`);
+    for (const key of keys) {
+      const property = s.properties?.[key];
+      if (property) {
+        errors.push(...validateValue(document2, property, record[key], [...path, key]));
+        continue;
+      }
+      if (s.additionalProperties === false)
+        fail(`unexpected property ${key}`);
+      else if (typeof s.additionalProperties === "object") {
+        errors.push(...validateValue(document2, s.additionalProperties, record[key], [...path, key]));
+      }
+      if (s.propertyNames) {
+        const nameErrors = validateValue(document2, s.propertyNames, key, [...path, key]);
+        if (nameErrors.length > 0)
+          fail(`property name ${key} is invalid: ${nameErrors[0]?.message}`);
+      }
+    }
+  }
+  if (s.allOf)
+    for (const branch of s.allOf)
+      errors.push(...validateValue(document2, branch, value, path));
+  if (s.anyOf && !s.anyOf.some((branch) => validateValue(document2, branch, value).length === 0))
+    fail("matches no anyOf branch");
+  if (s.oneOf) {
+    const matches2 = s.oneOf.filter((branch) => validateValue(document2, branch, value).length === 0).length;
+    if (matches2 !== 1)
+      fail(`matches ${matches2} oneOf branches, expected exactly 1`);
+  }
+  if (s.not && validateValue(document2, s.not, value).length === 0)
+    fail("matches forbidden `not` schema");
+  return errors;
+};
+
+// ../../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 = (text) => {
+  const source = text.startsWith("?") ? text.slice(1) : text;
+  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 text = utf8.decode(bytes);
+    try {
+      return { kind: "json", value: JSON.parse(text) };
+    } catch (error) {
+      return {
+        kind: "invalid",
+        mediaType,
+        text,
+        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 (message) => {
+  const bytes = new Uint8Array(await message.arrayBuffer());
+  return decodeBody(message.headers.get("content-type"), bytes);
+};
+
+// ../core/dist/http.js
+var jsonRes = (status, body, headers = {}) => new Response(JSON.stringify(body), {
+  status,
+  headers: { "content-type": JSON_MEDIA_TYPE, ...headers }
+});
+var HttpError = class extends Error {
+  status;
+  body;
+  headers;
+  constructor(status, body, headers = {}) {
+    super(`HTTP ${status}`);
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+    this.name = "HttpError";
+  }
+  toResponse() {
+    const contentType = this.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+    if (contentType === "text/plain") {
+      return new Response(String(this.body), {
+        status: this.status,
+        headers: this.headers
+      });
+    }
+    return jsonRes(this.status, this.body, this.headers);
+  }
+};
+
+// ../core/dist/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));
+
+// ../core/dist/webhooks.js
+var json2 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminError2 = (status, message) => json2(status, { error: { type: "mockingbird_admin", message } });
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseEndpoint = (value) => {
+  if (!isRecord3(value) || typeof value.url !== "string")
+    return "each endpoint needs a url";
+  try {
+    new URL(value.url);
+  } catch {
+    return `not a URL: ${value.url}`;
+  }
+  const endpoint = { url: value.url };
+  if (typeof value.id === "string")
+    endpoint.id = value.id;
+  if (typeof value.secret === "string")
+    endpoint.secret = value.secret;
+  if (typeof value.signUrl === "string")
+    endpoint.signUrl = value.signUrl;
+  const events = value.events ?? value.enabledEvents;
+  if (Array.isArray(events))
+    endpoint.events = events.map(String);
+  if (isRecord3(value.tags)) {
+    endpoint.tags = Object.fromEntries(Object.entries(value.tags).map(([k, v]) => [k, String(v)]));
+  }
+  if (typeof value.account === "string")
+    endpoint.tags = { ...endpoint.tags, account: value.account };
+  if (isRecord3(value.headers)) {
+    endpoint.headers = Object.fromEntries(Object.entries(value.headers).map(([k, v]) => [k, String(v)]));
+  }
+  return endpoint;
+};
+var webhookAdminRoutes = (hub) => ({
+  "GET /webhooks": ({ url, namespace }) => json2(200, {
+    deliveries: hub.deliveries(url.searchParams.get("all") === "1" ? void 0 : namespace).filter((d) => {
+      const type = url.searchParams.get("type");
+      return type === null || d.type === type;
+    })
+  }),
+  "GET /webhooks/events": ({ url, namespace }) => {
+    const type = url.searchParams.get("type");
+    return json2(200, {
+      events: hub.messages(url.searchParams.get("all") === "1" ? void 0 : namespace).filter((m2) => type === null || m2.type === type).map((m2) => ({ ...m2, payload: parsePayload(m2) }))
+    });
+  },
+  "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 = (message) => {
+  if (message.contentType.startsWith("application/json")) {
+    try {
+      return JSON.parse(message.body);
+    } catch {
+      return message.body;
+    }
+  }
+  if (message.contentType.startsWith("application/x-www-form-urlencoded")) {
+    return Object.fromEntries(new URLSearchParams(message.body));
+  }
+  return message.body;
+};
+
+// ../core/dist/runtime.js
+var MOCKINGBIRD_HEADER = "x-mockingbird";
+var BRANCH_HEADER = "x-mockingbird-branch";
+var AT_HEADER = "x-mockingbird-at";
+var CHECKPOINT_HEADER = "x-mockingbird-checkpoint";
+var DEFAULT_NAMESPACE = "default";
+var NAMESPACE_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
+var PATH_PREFIX = /^\/ns\/([^/]+)(\/.*)?$/;
+var BRANCH_PATTERN2 = /^[A-Za-z0-9_.-]{1,64}$/;
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var effects = /* @__PURE__ */ new WeakMap();
+var reuseSorted = (fresh, previous, 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((m2) => m2.method === request.method && m2.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, message) => adminJson(status, { error: { type: "mockingbird_admin", message } });
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var credentialRoutes = (registry) => ({
+  "GET /credentials": () => adminJson(200, {
+    credentials: registry.entries().map(({ credential, namespace }) => ({
+      credential: maskCredential(credential),
+      namespace
+    }))
+  }),
+  "PUT /credentials": ({ body, namespace }) => {
+    const pairs = [];
+    const 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) });
+  }
+});
+
+// ../core/dist/validation.js
+var bodyIssues = (context, contentType = "application/json") => {
+  const requestBody = context.operation.operation.requestBody;
+  if (!requestBody)
+    return [];
+  const resolved = deref(context.document, requestBody);
+  const schema = resolved.content?.[contentType]?.schema;
+  if (!schema)
+    return [];
+  const value = context.body.kind === "json" || context.body.kind === "form" ? context.body.value : void 0;
+  if (context.body.kind === "invalid") {
+    return [{ path: "", message: `request body is not valid ${context.body.mediaType}` }];
+  }
+  if (value === void 0) {
+    return resolved.required ? [{ path: "", message: "request body is required" }] : [];
+  }
+  return validateValue(context.document, resolveSchema(context.document, schema), value).map((issue) => ({ path: issue.path.join("."), message: issue.message }));
+};
+
+// src/corpus.ts
+var MEASURE_URI = "http://www.edamam.com/ontologies/edamam.owl#Measure_";
+var RECIPE_URI = "http://www.edamam.com/ontologies/edamam.owl#recipe_";
+var NUTRIENTS = {
+  ENERC_KCAL: { label: "Energy", unit: "kcal", daily: 2e3 },
+  PROCNT: { label: "Protein", unit: "g", daily: 50 },
+  FAT: { label: "Fat", unit: "g", daily: 78 },
+  CHOCDF: { label: "Carbs", unit: "g", daily: 275 },
+  FIBTG: { label: "Fiber", unit: "g", daily: 28 },
+  SUGAR: { label: "Sugars", unit: "g", daily: 50 }
+};
+var m = (label, weight, name = label) => ({
+  uri: `${MEASURE_URI}${name.toLowerCase().replace(/\s+/g, "_")}`,
+  label,
+  weight
+});
+var gram = m("Gram", 1);
+var ounce = m("Ounce", 28.349523125);
+var pound = m("Pound", 453.59237);
+var kilogram = m("Kilogram", 1e3);
+var weights = [gram, ounce, pound, kilogram];
+var food = (id, label, nutrients, measures, extra = {}) => ({
+  foodId: `food_${id}`,
+  label,
+  knownAs: label.toLowerCase(),
+  nutrients,
+  category: "Generic foods",
+  categoryLabel: "food",
+  image: `https://www.edamam.com/food-img/${id}.jpg`,
+  measures: [...measures, ...weights],
+  healthLabels: [],
+  ...extra
+});
+var VEG = ["VEGETARIAN", "PESCATARIAN", "GLUTEN_FREE", "DAIRY_FREE"];
+var VEGAN = [...VEG, "VEGAN"];
+var DEFAULT_FOODS = [
+  food(
+    "egg",
+    "Egg",
+    { ENERC_KCAL: 143, PROCNT: 12.6, FAT: 9.5, CHOCDF: 0.7, FIBTG: 0, SUGAR: 0.4 },
+    [
+      m("Whole", 50, "unit"),
+      m("Serving", 50),
+      m("Large", 50),
+      m("Medium", 44),
+      m("Small", 38),
+      m("Cup", 243)
+    ],
+    { healthLabels: ["VEGETARIAN", "GLUTEN_FREE", "DAIRY_FREE"] }
+  ),
+  food(
+    "chicken_breast",
+    "Chicken Breast",
+    { ENERC_KCAL: 165, PROCNT: 31, FAT: 3.6, CHOCDF: 0, FIBTG: 0, SUGAR: 0 },
+    [m("Whole", 174, "unit"), m("Serving", 120), m("Breast", 174), m("Cup", 140)],
+    { healthLabels: ["GLUTEN_FREE", "DAIRY_FREE"] }
+  ),
+  food(
+    "rice_cooked",
+    "Cooked White Rice",
+    { ENERC_KCAL: 130, PROCNT: 2.7, FAT: 0.3, CHOCDF: 28.2, FIBTG: 0.4, SUGAR: 0.1 },
+    [m("Serving", 158), m("Cup", 158), m("Tablespoon", 10)],
+    { knownAs: "rice", healthLabels: VEGAN }
+  ),
+  food(
+    "banana",
+    "Banana",
+    { ENERC_KCAL: 89, PROCNT: 1.1, FAT: 0.3, CHOCDF: 22.8, FIBTG: 2.6, SUGAR: 12.2 },
+    [m("Whole", 118, "unit"), m("Serving", 118), m("Medium", 118), m("Cup", 150)],
+    { healthLabels: VEGAN }
+  ),
+  food(
+    "apple",
+    "Apple",
+    { ENERC_KCAL: 52, PROCNT: 0.3, FAT: 0.2, CHOCDF: 13.8, FIBTG: 2.4, SUGAR: 10.4 },
+    [m("Whole", 182, "unit"), m("Serving", 182), m("Cup", 125)],
+    { healthLabels: VEGAN }
+  ),
+  food(
+    "oats",
+    "Oats",
+    { ENERC_KCAL: 389, PROCNT: 16.9, FAT: 6.9, CHOCDF: 66.3, FIBTG: 10.6, SUGAR: 1 },
+    [m("Serving", 40), m("Cup", 81), m("Tablespoon", 5)],
+    { knownAs: "oatmeal", healthLabels: VEGAN }
+  ),
+  food(
+    "milk",
+    "Whole Milk",
+    { ENERC_KCAL: 61, PROCNT: 3.2, FAT: 3.3, CHOCDF: 4.8, FIBTG: 0, SUGAR: 5.1 },
+    [m("Serving", 244), m("Cup", 244), m("Fluid ounce", 30.5)],
+    { knownAs: "milk", healthLabels: ["VEGETARIAN", "GLUTEN_FREE"] }
+  ),
+  food(
+    "greek_yogurt",
+    "Greek Yogurt",
+    { ENERC_KCAL: 59, PROCNT: 10.2, FAT: 0.4, CHOCDF: 3.6, FIBTG: 0, SUGAR: 3.2 },
+    [m("Container", 170), m("Serving", 170), m("Cup", 245)],
+    { knownAs: "yogurt", healthLabels: ["VEGETARIAN", "GLUTEN_FREE"] }
+  ),
+  food(
+    "salmon",
+    "Salmon",
+    { ENERC_KCAL: 208, PROCNT: 20.4, FAT: 13.4, CHOCDF: 0, FIBTG: 0, SUGAR: 0 },
+    [m("Fillet", 198), m("Serving", 113)],
+    { healthLabels: ["PESCATARIAN", "GLUTEN_FREE", "DAIRY_FREE"] }
+  ),
+  food(
+    "avocado",
+    "Avocado",
+    { ENERC_KCAL: 160, PROCNT: 2, FAT: 14.7, CHOCDF: 8.5, FIBTG: 6.7, SUGAR: 0.7 },
+    [m("Whole", 201, "unit"), m("Serving", 50), m("Cup", 150)],
+    { healthLabels: VEGAN }
+  ),
+  food(
+    "almonds",
+    "Almonds",
+    { ENERC_KCAL: 579, PROCNT: 21.2, FAT: 49.9, CHOCDF: 21.6, FIBTG: 12.5, SUGAR: 4.4 },
+    [m("Serving", 28), m("Cup", 143), m("Almond", 1.2)],
+    { healthLabels: VEGAN }
+  ),
+  food(
+    "bread",
+    "Whole Wheat Bread",
+    { ENERC_KCAL: 247, PROCNT: 13, FAT: 3.4, CHOCDF: 41, FIBTG: 7, SUGAR: 6 },
+    [m("Slice", 32), m("Serving", 32)],
+    { knownAs: "bread", healthLabels: ["VEGETARIAN", "VEGAN", "DAIRY_FREE"] }
+  ),
+  food(
+    "spinach",
+    "Spinach",
+    { ENERC_KCAL: 23, PROCNT: 2.9, FAT: 0.4, CHOCDF: 3.6, FIBTG: 2.2, SUGAR: 0.4 },
+    [m("Cup", 30), m("Serving", 30), m("Bunch", 340)],
+    { healthLabels: VEGAN }
+  ),
+  food(
+    "olive_oil",
+    "Olive Oil",
+    { ENERC_KCAL: 884, PROCNT: 0, FAT: 100, CHOCDF: 0, FIBTG: 0, SUGAR: 0 },
+    [m("Tablespoon", 13.5), m("Teaspoon", 4.5), m("Serving", 13.5)],
+    { knownAs: "oil", healthLabels: VEGAN }
+  ),
+  food(
+    "chicken_salad",
+    "Chicken Salad",
+    { ENERC_KCAL: 229, PROCNT: 13.2, FAT: 18, CHOCDF: 3.3, FIBTG: 0.4, SUGAR: 1.9 },
+    [m("Serving", 226), m("Cup", 226)],
+    {
+      category: "Generic meals",
+      categoryLabel: "meal",
+      foodContentsLabel: "chicken; mayonnaise; celery; onion",
+      healthLabels: ["GLUTEN_FREE"]
+    }
+  ),
+  food(
+    "protein_bar",
+    "Protein Bar",
+    { ENERC_KCAL: 350, PROCNT: 30, FAT: 10, CHOCDF: 40, FIBTG: 12, SUGAR: 5 },
+    [m("Serving", 60), m("Package", 60)],
+    {
+      category: "Packaged foods",
+      brand: "Mockingbird Foods",
+      foodContentsLabel: "protein blend; almonds; chicory root fiber; cocoa",
+      servingSizes: [{ uri: `${MEASURE_URI}gram`, label: "Gram", quantity: 60 }],
+      upc: "850000000012",
+      healthLabels: ["VEGETARIAN", "GLUTEN_FREE"]
+    }
+  ),
+  food("mystery_snack", "Mystery Snack", {}, [m("Package", 40)], {
+    category: "Packaged foods",
+    brand: "Mockingbird Foods",
+    upc: "850000000029"
+  }),
+  food(
+    "plain_greek_yogurt",
+    "Plain Greek Yogurt",
+    { ENERC_KCAL: 59, PROCNT: 10, FAT: 0.4, CHOCDF: 3.5, FIBTG: 0, SUGAR: 3.3 },
+    [m("Container", 170), m("Serving", 170)],
+    {
+      category: "Packaged foods",
+      brand: "Mockingbird Dairy",
+      foodContentsLabel: "cultured pasteurized nonfat milk",
+      servingSizes: [{ uri: `${MEASURE_URI}container`, label: "Container", quantity: 1 }],
+      upc: "850000000036",
+      healthLabels: ["VEGETARIAN", "GLUTEN_FREE"]
+    }
+  )
+];
+var ing = (foodId, quantity, measure, text) => ({
+  foodId: `food_${foodId}`,
+  quantity,
+  measure,
+  text
+});
+var DEFAULT_RECIPES = [
+  {
+    id: "overnight_oats",
+    label: "Banana Overnight Oats",
+    yield: 2,
+    totalTime: 5,
+    mealType: ["breakfast"],
+    dishType: ["cereals"],
+    cuisineType: ["american"],
+    dietLabels: ["High-Fiber"],
+    healthLabels: ["VEGETARIAN", "PESCATARIAN", "GLUTEN_FREE"],
+    cautions: [],
+    ingredients: [
+      ing("oats", 1, "Cup", "1 cup rolled oats"),
+      ing("milk", 1, "Cup", "1 cup milk"),
+      ing("banana", 1, "Whole", "1 banana, sliced"),
+      ing("greek_yogurt", 0.5, "Cup", "1/2 cup greek yogurt")
+    ]
+  },
+  {
+    id: "veggie_omelette",
+    label: "Spinach Omelette",
+    yield: 1,
+    totalTime: 10,
+    mealType: ["breakfast"],
+    dishType: ["egg"],
+    cuisineType: ["french"],
+    dietLabels: ["Low-Carb", "High-Protein"],
+    healthLabels: ["VEGETARIAN", "PESCATARIAN", "GLUTEN_FREE", "DAIRY_FREE"],
+    cautions: [],
+    ingredients: [
+      ing("egg", 3, "Large", "3 large eggs"),
+      ing("spinach", 1, "Cup", "1 cup spinach"),
+      ing("olive_oil", 1, "Teaspoon", "1 tsp olive oil")
+    ]
+  },
+  {
+    id: "avocado_toast",
+    label: "Avocado Toast",
+    yield: 1,
+    totalTime: 5,
+    mealType: ["breakfast", "lunch/dinner"],
+    dishType: ["sandwiches"],
+    cuisineType: ["american"],
+    dietLabels: ["High-Fiber"],
+    healthLabels: ["VEGAN", "VEGETARIAN", "PESCATARIAN", "DAIRY_FREE"],
+    cautions: [],
+    ingredients: [
+      ing("bread", 2, "Slice", "2 slices whole wheat bread"),
+      ing("avocado", 1, "Whole", "1 avocado"),
+      ing("olive_oil", 1, "Teaspoon", "1 tsp olive oil")
+    ]
+  },
+  {
+    id: "chicken_rice_bowl",
+    label: "Chicken and Rice Bowl",
+    yield: 2,
+    totalTime: 30,
+    mealType: ["lunch/dinner"],
+    dishType: ["main course"],
+    cuisineType: ["asian"],
+    dietLabels: ["High-Protein"],
+    healthLabels: ["GLUTEN_FREE", "DAIRY_FREE"],
+    cautions: [],
+    ingredients: [
+      ing("chicken_breast", 2, "Breast", "2 chicken breasts"),
+      ing("rice_cooked", 2, "Cup", "2 cups cooked rice"),
+      ing("spinach", 2, "Cup", "2 cups spinach"),
+      ing("olive_oil", 1, "Tablespoon", "1 tbsp olive oil")
+    ]
+  },
+  {
+    id: "baked_salmon",
+    label: "Lemon Baked Salmon",
+    yield: 2,
+    totalTime: 25,
+    mealType: ["lunch/dinner"],
+    dishType: ["main course"],
+    cuisineType: ["mediterranean"],
+    dietLabels: ["Low-Carb", "High-Protein"],
+    healthLabels: ["PESCATARIAN", "GLUTEN_FREE", "DAIRY_FREE"],
+    cautions: ["FODMAP"],
+    ingredients: [
+      ing("salmon", 2, "Fillet", "2 salmon fillets"),
+      ing("olive_oil", 1, "Tablespoon", "1 tbsp olive oil"),
+      ing("spinach", 2, "Cup", "2 cups spinach")
+    ]
+  },
+  {
+    id: "chicken_salad_plate",
+    label: "Chicken Salad Plate",
+    yield: 1,
+    totalTime: 10,
+    mealType: ["lunch/dinner"],
+    dishType: ["salad"],
+    cuisineType: ["american"],
+    dietLabels: ["Low-Carb"],
+    healthLabels: ["GLUTEN_FREE"],
+    cautions: ["Eggs"],
+    ingredients: [
+      ing("chicken_salad", 1, "Cup", "1 cup chicken salad"),
+      ing("spinach", 1, "Cup", "1 cup spinach")
+    ]
+  },
+  {
+    id: "yogurt_parfait",
+    label: "Greek Yogurt Parfait",
+    yield: 1,
+    totalTime: 5,
+    mealType: ["snack", "breakfast"],
+    dishType: ["desserts"],
+    cuisineType: ["american"],
+    dietLabels: ["High-Protein"],
+    healthLabels: ["VEGETARIAN", "PESCATARIAN", "GLUTEN_FREE"],
+    cautions: [],
+    ingredients: [
+      ing("greek_yogurt", 1, "Container", "1 container greek yogurt"),
+      ing("almonds", 1, "Serving", "1 oz almonds"),
+      ing("banana", 0.5, "Whole", "1/2 banana")
+    ]
+  },
+  {
+    id: "apple_almonds",
+    label: "Apple with Almonds",
+    yield: 1,
+    totalTime: 2,
+    mealType: ["snack"],
+    dishType: ["starter"],
+    cuisineType: ["american"],
+    dietLabels: ["Balanced"],
+    healthLabels: ["VEGAN", "VEGETARIAN", "PESCATARIAN", "GLUTEN_FREE", "DAIRY_FREE"],
+    cautions: [],
+    ingredients: [
+      ing("apple", 1, "Whole", "1 apple"),
+      ing("almonds", 1, "Serving", "1 oz almonds")
+    ]
+  }
+];
+
+// src/generated/openapi.ts
+var document = JSON.parse(`{"openapi":"3.1.0","info":{"title":"Edamam APIs (Mockingbird subset)","description":"Stateful mock subset of Edamam's Food Database v2 (parser, nutrients, image), Nutrition Analysis (nutrition-data, nutrition-details), Recipe Search v2 (search, by-uri, by id), Meal Planner v1 (select) and Shopping List v2, over a built-in corpus. Hand-authored from Edamam's docs and the consumers (edamam-nutrition.adapter.ts, edamam-meal-planning.adapter.ts, makor chat tools/nutrition/client.py).\\n","version":"2","x-mockingbird-upstream":{"note":"Edamam publishes per-API docs, no single OpenAPI; shapes trimmed to the fields our consumers read (zod schemas in edamam-nutrition.adapter.ts and edamam-meal-planning.schemas.ts)."}},"servers":[{"url":"https://api.edamam.com"}],"paths":{"/api/food-database/v2/parser":{"get":{"operationId":"FoodParser","description":"Parse a food description (\`ingr\`) or look up a barcode (\`upc\`): \`parsed\` (the best match with quantity and measure) and \`hints\` (every related food with its measures).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/AppId"},{"$ref":"#/components/parameters/AppKey"},{"name":"ingr","in":"query","required":false,"schema":{"type":"string","enum":["2 large eggs","1 cup cooked rice","banana","chicken breast","greek yogurt","3 slices bread","salmon fillet","chicken salad","xyzzy"]},"description":"Parity vocabulary; the mock parses any text."},{"name":"upc","in":"query","required":false,"schema":{"type":"string","enum":["850000000012","850000000029","850000000036","000000000000"]}},{"name":"nutrition-type","in":"query","required":false,"schema":{"type":"string","enum":["cooking","logging"]}},{"name":"categoryLabel","in":"query","required":false,"schema":{"type":"string","enum":["food","meal"]}},{"name":"category","in":"query","required":false,"schema":{"type":"string","enum":["generic-foods","packaged-foods","generic-meals"]}},{"name":"health","in":"query","required":false,"schema":{"type":"string","enum":["vegan","vegetarian","gluten-free","dairy-free"]}},{"name":"calories","in":"query","required":false,"schema":{"type":"string","enum":["50-200","300+","100"]}}],"responses":{"200":{"description":"Parser result","content":{"application/json":{"schema":{"$ref":"#/components/schemas/ParserResponse"}}}},"400":{"description":"Neither ingr nor upc","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"401":{"description":"Unknown app_id / app_key","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"404":{"description":"Unknown UPC","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"429":{"description":"Usage limits are exceeded","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}}}}},"/api/food-database/v2/nutrients":{"post":{"operationId":"FoodNutrients","description":"Full nutrition for foods at given measures.","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/AppId"},{"$ref":"#/components/parameters/AppKey"}],"responses":{"200":{"description":"Nutrition","content":{"application/json":{"schema":{"$ref":"#/components/schemas/NutritionAnalysis"}}}},"401":{"description":"Unknown app_id / app_key","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"422":{"description":"Unknown food or measure","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"429":{"description":"Usage limits are exceeded","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/NutrientsRequest"}}}}}},"/api/food-database/nutrients-from-image":{"post":{"operationId":"FoodFromImage","description":"Recognise a plated meal from an image (beta).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/AppId"},{"$ref":"#/components/parameters/AppKey"},{"name":"beta","in":"query","required":false,"schema":{"type":"string","enum":["true"]}}],"responses":{"200":{"description":"Recognition","content":{"application/json":{"schema":{"$ref":"#/components/schemas/VisionResponse"}}}},"400":{"description":"Not an image","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"401":{"description":"Unknown app_id / app_key","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"429":{"description":"Usage limits are exceeded","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/ImageRequest"}}}}}},"/api/nutrition-data":{"get":{"operationId":"NutritionData","description":"Nutrition analysis of one ingredient line.","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/AppId"},{"$ref":"#/components/parameters/AppKey"},{"name":"ingr","in":"query","required":true,"schema":{"type":"string","enum":["1 cup cooked rice","2 large eggs","1 banana","xyzzy"]},"description":"Parity vocabulary; the mock parses any text."},{"name":"nutrition-type","in":"query","required":false,"schema":{"type":"string","enum":["cooking","logging"]}}],"responses":{"200":{"description":"Nutrition","content":{"application/json":{"schema":{"$ref":"#/components/schemas/NutritionAnalysis"}}}},"401":{"description":"Unknown app_id / app_key","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"422":{"description":"Could not parse the ingredient","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"429":{"description":"Usage limits are exceeded","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}}}}},"/api/nutrition-details":{"post":{"operationId":"NutritionDetails","description":"Nutrition analysis of a recipe (ingredient lines).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/AppId"},{"$ref":"#/components/parameters/AppKey"}],"responses":{"200":{"description":"Nutrition","content":{"application/json":{"schema":{"$ref":"#/components/schemas/NutritionAnalysis"}}}},"401":{"description":"Unknown app_id / app_key","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"422":{"description":"No ingredients","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"429":{"description":"Usage limits are exceeded","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}},"555":{"description":"Insufficient quality","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FoodError"}}}}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeAnalysisRequest"}}}}}},"/api/recipes/v2":{"get":{"operationId":"RecipeSearch","description":"Recipe search v2 (20 per page, \`_links.next\` carries \`_cont\`).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/AppId"},{"$ref":"#/components/parameters/AppKey"},{"name":"Edamam-Account-User","in":"header","required":false,"schema":{"type":"string","pattern":"^[a-f0-9]{1,30}$","description":"The first 30 hex chars of sha256(user id), as our meal adapter sends it."}},{"name":"type","in":"query","required":true,"schema":{"type":"string","enum":["public","user","any"]}},{"name":"q","in":"query","required":false,"schema":{"type":"string","enum":["chicken","salmon","oats","yogurt","toast","xyzzy"]},"description":"Parity vocabulary; the mock parses any text."},{"name":"health","in":"query","required":false,"schema":{"type":"string","enum":["vegan","vegetarian","gluten-free","dairy-free","pescatarian"]}},{"name":"diet","in":"query","required":false,"schema":{"type":"string","enum":["high-protein","low-carb","high-fiber","balanced"]}},{"name":"mealType","in":"query","required":false,"schema":{"type":"string","enum":["Breakfast","Lunch","Dinner","Snack"]}},{"name":"dishType","in":"query","required":false,"schema":{"type":"string","enum":["Main course","Salad","Cereals","Egg"]}},{"name":"cuisineType","in":"query","required":false,"schema":{"type":"string","enum":["American","Asian","Mediterranean","French"]}},{"name":"calories","in":"query","required":false,"schema":{"type":"string","enum":["100-400","500+","300"]}},{"name":"time","in":"query","required":false,"schema":{"type":"string","enum":["1-10","30","20+"]}},{"name":"excluded","in":"query","required":false,"schema":{"type":"string","enum":["spinach","almonds"]}},{"name":"imageSize","in":"query","required":false,"schema":{"type":"string","enum":["REGULAR","SMALL","THUMBNAIL","LARGE"]}},{"name":"random","in":"query","required":false,"schema":{"type":"string","enum":["true","false"]}}],"responses":{"200":{"description":"Hits","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeSearchResponse"}}}},"400":{"description":"Illegal parameter","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}},"401":{"description":"Unknown app_id / app_key","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}},"429":{"description":"Usage limits are exceeded","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}}}}},"/api/recipes/v2/by-uri":{"get":{"operationId":"RecipesByUri","description":"Recipes by URI (up to 20 \`uri\` parameters).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/AppId"},{"$ref":"#/components/parameters/AppKey"},{"name":"Edamam-Account-User","in":"header","required":false,"schema":{"type":"string","pattern":"^[a-f0-9]{1,30}$","description":"The first 30 hex chars of sha256(user id), as our meal adapter sends it."}},{"name":"type","in":"query","required":true,"schema":{"type":"string","enum":["public"]}},{"name":"uri","in":"query","required":true,"schema":{"type":"string","enum":["http://www.edamam.com/ontologies/edamam.owl#recipe_overnight_oats","http://www.edamam.com/ontologies/edamam.owl#recipe_baked_salmon","http://www.edamam.com/ontologies/edamam.owl#recipe_missing"]}}],"responses":{"200":{"description":"Hits","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeSearchResponse"}}}},"400":{"description":"Illegal parameter","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}},"401":{"description":"Unknown app_id / app_key","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}},"429":{"description":"Usage limits are exceeded","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}}}}},"/api/recipes/v2/{id}":{"get":{"operationId":"RecipeById","description":"One recipe (the \`_links.self\` target).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/AppId"},{"$ref":"#/components/parameters/AppKey"},{"name":"Edamam-Account-User","in":"header","required":false,"schema":{"type":"string","pattern":"^[a-f0-9]{1,30}$","description":"The first 30 hex chars of sha256(user id), as our meal adapter sends it."}},{"name":"id","in":"path","required":true,"schema":{"type":"string","enum":["overnight_oats","veggie_omelette","chicken_rice_bowl","missing"]}},{"name":"type","in":"query","required":true,"schema":{"type":"string","enum":["public"]}}],"responses":{"200":{"description":"The recipe","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeHit"}}}},"401":{"description":"Unknown app_id / app_key","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}},"404":{"description":"Unknown recipe","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}},"429":{"description":"Usage limits are exceeded","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}}}}},"/api/meal-planner/v1/{app_id}/select":{"post":{"operationId":"MealPlanSelect","description":"Select recipes for \`size\` days of a plan (Basic auth plus app_id/app_key).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/AppId"},{"$ref":"#/components/parameters/AppKey"},{"name":"Edamam-Account-User","in":"header","required":false,"schema":{"type":"string","pattern":"^[a-f0-9]{1,30}$","description":"The first 30 hex chars of sha256(user id), as our meal adapter sends it."}},{"name":"app_id","in":"path","required":true,"schema":{"type":"string","enum":["parity"]}},{"name":"type","in":"query","required":false,"schema":{"type":"string","enum":["public"]}}],"responses":{"200":{"description":"Selection","content":{"application/json":{"schema":{"$ref":"#/components/schemas/MealPlanResponse"}}}},"400":{"description":"Illegal plan","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}},"401":{"description":"Unknown app_id / app_key","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}},"429":{"description":"Usage limits are exceeded","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/MealPlanRequest"}}}}}},"/api/shopping-list/v2":{"post":{"operationId":"ShoppingList","description":"Aggregate the ingredients of recipes into a shopping list (optionally a cart link).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/AppId"},{"$ref":"#/components/parameters/AppKey"},{"name":"Edamam-Account-User","in":"header","required":false,"schema":{"type":"string","pattern":"^[a-f0-9]{1,30}$","description":"The first 30 hex chars of sha256(user id), as our meal adapter sends it."}},{"name":"shopping-cart","in":"query","required":false,"schema":{"type":"string","enum":["true"]}},{"name":"beta","in":"query","required":false,"schema":{"type":"string","enum":["true"]}}],"responses":{"200":{"description":"Shopping list","content":{"application/json":{"schema":{"$ref":"#/components/schemas/ShoppingListResponse"}}}},"400":{"description":"Unknown recipe","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}},"401":{"description":"Unknown app_id / app_key","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}},"429":{"description":"Usage limits are exceeded","content":{"application/json":{"schema":{"$ref":"#/components/schemas/RecipeErrors"}}}}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/ShoppingListRequest"}}}}}}},"components":{"parameters":{"AppId":{"name":"app_id","in":"query","required":true,"description":"Edamam application id (any value unless \`apps\` is set). The parity vocabulary is fixed.","schema":{"type":"string","enum":["parity"]}},"AppKey":{"name":"app_key","in":"query","required":true,"schema":{"type":"string","enum":["parity-key"]}}},"schemas":{"Measure":{"type":"object","required":["uri","label","weight"],"properties":{"uri":{"type":"string"},"label":{"type":"string"},"weight":{"type":"number"}}},"Food":{"type":"object","required":["foodId","label","category","categoryLabel"],"properties":{"foodId":{"type":"string"},"label":{"type":"string"},"knownAs":{"type":"string"},"nutrients":{"type":"object","additionalProperties":{"type":"number"}},"brand":{"type":"string"},"category":{"type":"string"},"categoryLabel":{"type":"string"},"foodContentsLabel":{"type":"string"},"image":{"type":"string"},"servingSizes":{"type":"array","items":{"type":"object"}},"servingsPerContainer":{"type":"number"}}},"Recipe":{"type":"object","required":["uri","label","url","yield","ingredientLines","ingredients","totalNutrients","cautions","dietLabels","healthLabels"],"properties":{"uri":{"type":"string"},"label":{"type":"string"},"image":{"type":"string"},"source":{"type":"string"},"url":{"type":"string"},"shareAs":{"type":"string"},"yield":{"type":"number"},"dietLabels":{"type":"array","items":{"type":"string"}},"healthLabels":{"type":"array","items":{"type":"string"}},"cautions":{"type":"array","items":{"type":"string"}},"ingredientLines":{"type":"array","items":{"type":"string"}},"ingredients":{"type":"array","items":{"type":"object","required":["food","quantity"],"properties":{"text":{"type":"string"},"quantity":{"type":"number"},"measure":{"type":["string","null"]},"food":{"type":"string"},"weight":{"type":"number"},"foodCategory":{"type":["string","null"]},"foodId":{"type":"string"},"image":{"type":["string","null"]}}}},"calories":{"type":"number"},"totalWeight":{"type":"number"},"totalTime":{"type":"number"},"cuisineType":{"type":"array","items":{"type":"string"}},"mealType":{"type":"array","items":{"type":"string"}},"dishType":{"type":"array","items":{"type":"string"}},"totalNutrients":{"type":"object","additionalProperties":{"type":"object","required":["label","quantity","unit"],"properties":{"label":{"type":"string"},"quantity":{"type":"number"},"unit":{"type":"string"}}}},"totalDaily":{"type":"object","additionalProperties":{"type":"object","required":["label","quantity","unit"],"properties":{"label":{"type":"string"},"quantity":{"type":"number"},"unit":{"type":"string"}}}}}},"Link":{"type":"object","required":["href"],"properties":{"href":{"type":"string","x-mockingbird-volatile":{"kind":"url"}},"title":{"type":"string"}}},"ParserResponse":{"type":"object","required":["text","parsed","hints"],"properties":{"text":{"type":"string"},"parsed":{"type":"array","items":{"type":"object","required":["food"],"properties":{"food":{"$ref":"#/components/schemas/Food"},"quantity":{"type":"number"},"measure":{"$ref":"#/components/schemas/Measure"}}}},"hints":{"type":"array","items":{"type":"object","required":["food","measures"],"properties":{"food":{"$ref":"#/components/schemas/Food"},"measures":{"type":"array","items":{"$ref":"#/components/schemas/Measure"}}}}},"_links":{"type":"object"}}},"NutrientsRequest":{"type":"object","required":["ingredients"],"properties":{"ingredients":{"type":"array","minItems":1,"maxItems":3,"items":{"type":"object","required":["quantity","measureURI","foodId"],"properties":{"quantity":{"type":"number","exclusiveMinimum":0,"maximum":20},"measureURI":{"type":"string","examples":["http://www.edamam.com/ontologies/edamam.owl#Measure_unit","http://www.edamam.com/ontologies/edamam.owl#Measure_cup","http://www.edamam.com/ontologies/edamam.owl#Measure_gram"]},"foodId":{"type":"string","examples":["food_egg","food_banana","food_rice_cooked"]},"qualifiers":{"type":"array","items":{"type":"string"}}}}}}},"NutritionAnalysis":{"type":"object","required":["calories","totalWeight","dietLabels","healthLabels","cautions","totalNutrients","totalDaily"],"properties":{"uri":{"type":"string","x-mockingbird-volatile":{"kind":"id"}},"calories":{"type":"number"},"totalWeight":{"type":"number"},"dietLabels":{"type":"array","items":{"type":"string"}},"healthLabels":{"type":"array","items":{"type":"string"}},"cautions":{"type":"array","items":{"type":"string"}},"totalNutrients":{"type":"object","additionalProperties":{"type":"object","required":["label","quantity","unit"],"properties":{"label":{"type":"string"},"quantity":{"type":"number"},"unit":{"type":"string"}}}},"totalDaily":{"type":"object","additionalProperties":{"type":"object","required":["label","quantity","unit"],"properties":{"label":{"type":"string"},"quantity":{"type":"number"},"unit":{"type":"string"}}}},"ingredients":{"type":"array","items":{"type":"object"}},"yield":{"type":"number"}}},"ImageRequest":{"type":"object","required":["image"],"properties":{"image":{"type":"string","minLength":1,"maxLength":200,"examples":["data:image/jpeg;base64,/9j/4AAQSkZJRgABAQ==","data:image/png;base64,iVBORw0KGgo="]}}},"VisionResponse":{"type":"object","properties":{"parsed":{"type":"object","properties":{"food":{"$ref":"#/components/schemas/Food"},"quantity":{"type":"number"},"measure":{"$ref":"#/components/schemas/Measure"}}},"recipe":{"type":"object","properties":{"label":{"type":"string"},"calories":{"type":"number"},"totalNutrients":{"type":"object","additionalProperties":{"type":"object","required":["label","quantity","unit"],"properties":{"label":{"type":"string"},"quantity":{"type":"number"},"unit":{"type":"string"}}}}}}}},"RecipeAnalysisRequest":{"type":"object","required":["ingr"],"properties":{"title":{"type":"string","maxLength":80},"yield":{"type":"integer","minimum":1,"maximum":8},"ingr":{"type":"array","maxItems":4,"items":{"type":"string","minLength":1,"maxLength":60,"examples":["2 large eggs","1 cup cooked rice","1 banana","1 slice bread","xyzzy"]}}}},"RecipeHit":{"type":"object","required":["recipe"],"properties":{"recipe":{"$ref":"#/components/schemas/Recipe"},"_links":{"type":"object","properties":{"self":{"$ref":"#/components/schemas/Link"}}}}},"RecipeSearchResponse":{"type":"object","required":["from","to","count","hits"],"properties":{"from":{"type":"integer"},"to":{"type":"integer"},"count":{"type":"integer"},"_links":{"type":"object","properties":{"next":{"$ref":"#/components/schemas/Link"}}},"hits":{"type":"array","items":{"$ref":"#/components/schemas/RecipeHit"}}}},"MealPlanRequest":{"type":"object","required":["size","plan"],"properties":{"size":{"type":"integer","minimum":1,"maximum":7},"plan":{"$ref":"#/components/schemas/PlanSection"}}},"PlanSection":{"type":"object","properties":{"accept":{"type":"object","required":["all"],"properties":{"all":{"type":"array","maxItems":2,"items":{"type":"object","properties":{"health":{"type":"array","maxItems":2,"items":{"type":"string","enum":["VEGAN","VEGETARIAN","GLUTEN_FREE","DAIRY_FREE","PESCATARIAN"]}},"meal":{"type":"array","maxItems":2,"items":{"type":"string","enum":["breakfast","lunch/dinner","snack"]}},"dish":{"type":"array","maxItems":2,"items":{"type":"string","enum":["main course","salad","cereals","egg"]}}}}}}},"fit":{"type":"object","properties":{"ENERC_KCAL":{"type":"object","properties":{"min":{"type":"number","minimum":0},"max":{"type":"number","minimum":0},"mark":{"type":"number","minimum":0}}},"PROCNT":{"type":"object","properties":{"min":{"type":"number","minimum":0},"max":{"type":"number","minimum":0},"mark":{"type":"number","minimum":0}}},"CHOCDF":{"type":"object","properties":{"min":{"type":"number","minimum":0},"max":{"type":"number","minimum":0},"mark":{"type":"number","minimum":0}}},"FAT":{"type":"object","properties":{"min":{"type":"number","minimum":0},"max":{"type":"number","minimum":0},"mark":{"type":"number","minimum":0}}},"FIBTG":{"type":"object","properties":{"min":{"type":"number","minimum":0},"max":{"type":"number","minimum":0},"mark":{"type":"number","minimum":0}}}}},"exclude":{"type":"array","maxItems":2,"items":{"type":"string","enum":["http://www.edamam.com/ontologies/edamam.owl#recipe_overnight_oats","http://www.edamam.com/ontologies/edamam.owl#recipe_baked_salmon"]}},"sections":{"type":"object","maxProperties":4,"additionalProperties":{"$ref":"#/components/schemas/PlanSection"},"examples":[{"Breakfast":{},"Lunch":{},"Dinner":{}}]}}},"MealPlanResponse":{"type":"object","properties":{"status":{"type":"string","enum":["OK","INCOMPLETE","TIME_OUT"]},"selection":{"type":"array","items":{"type":"object","required":["sections"],"properties":{"sections":{"type":"object","additionalProperties":{"type":"object","properties":{"assigned":{"type":"string"},"_links":{"type":"object","properties":{"self":{"$ref":"#/components/schemas/Link"}}},"sections":{"type":"object"}}}}}}}}},"ShoppingListRequest":{"type":"object","required":["entries"],"properties":{"entries":{"type":"array","minItems":1,"maxItems":3,"items":{"type":"object","required":["quantity","item"],"properties":{"quantity":{"type":"number","exclusiveMinimum":0,"maximum":10},"measure":{"type":"string","enum":["http://www.edamam.com/ontologies/edamam.owl#Measure_serving"]},"item":{"type":"string","examples":["http://www.edamam.com/ontologies/edamam.owl#recipe_overnight_oats","http://www.edamam.com/ontologies/edamam.owl#recipe_chicken_rice_bowl","http://www.edamam.com/ontologies/edamam.owl#recipe_missing"]}}}}}},"ShoppingListResponse":{"type":"object","required":["entries"],"properties":{"entries":{"type":"array","items":{"type":"object","required":["foodId","food","quantities"],"properties":{"foodId":{"type":"string"},"food":{"type":"string"},"quantities":{"type":"array","items":{"type":"object","required":["quantity","measure"],"properties":{"quantity":{"type":"number"},"measure":{"type":"string"},"qualifiers":{"type":"array","items":{"type":"string"}}}}}}}},"_links":{"type":"object","properties":{"shopping-cart":{"$ref":"#/components/schemas/Link"}}}}},"FoodError":{"type":"object","required":["status","message"],"properties":{"status":{"type":"string","enum":["error"]},"message":{"type":"string"},"error":{"type":"string"}}},"RecipeErrors":{"type":"array","items":{"type":"object","required":["errorCode","message"],"properties":{"errorCode":{"type":"string"},"message":{"type":"string"},"params":{"type":"array","items":{"type":"string"}}}}}}}}`);
+var operationIds = ["FoodParser", "FoodNutrients", "FoodFromImage", "NutritionData", "NutritionDetails", "RecipeSearch", "RecipesByUri", "RecipeById", "MealPlanSelect", "ShoppingList"];
+var supportedOperationIds = ["FoodParser", "FoodNutrients", "FoodFromImage", "NutritionData", "NutritionDetails", "RecipeSearch", "RecipesByUri", "RecipeById", "MealPlanSelect", "ShoppingList"];
+
+// src/logic.ts
+var round = (value, digits = 3) => Math.round(value * 10 ** digits) / 10 ** digits;
+var CODES = Object.keys(NUTRIENTS);
+var WORD_NUMBERS = {
+  a: 1,
+  an: 1,
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  half: 0.5
+};
+var MEASURE_ALIASES = {
+  g: "gram",
+  gr: "gram",
+  grams: "gram",
+  oz: "ounce",
+  lb: "pound",
+  lbs: "pound",
+  kg: "kilogram",
+  tbsp: "tablespoon",
+  tbs: "tablespoon",
+  tsp: "teaspoon",
+  whole: "whole",
+  fillets: "fillet"
+};
+var STOP = /* @__PURE__ */ new Set(["of", "and", "with", "the", "fresh", "cooked", "raw", "sliced"]);
+var tokens = (text) => text.toLowerCase().replace(/[^a-z0-9./ ]+/g, " ").split(/\s+/).filter(Boolean).map((t) => t.length > 3 && t.endsWith("ies") ? `${t.slice(0, -3)}y` : t).map((t) => t.length > 3 && /(ch|sh|s|x)es$/.test(t) ? t.slice(0, -2) : t).map((t) => t.length > 2 && t.endsWith("s") && !t.endsWith("ss") ? t.slice(0, -1) : t);
+var quantityOf = (token) => {
+  if (!token) return void 0;
+  if (token in WORD_NUMBERS) return WORD_NUMBERS[token];
+  if (/^\d+(\.\d+)?$/.test(token)) return Number(token);
+  const fraction = /^(\d+)\/(\d+)$/.exec(token);
+  if (fraction) return Number(fraction[1]) / Number(fraction[2]);
+  return void 0;
+};
+var foodTokens = (food2) => [tokens(food2.label), tokens(food2.knownAs)];
+var parseLine = (text, foods) => {
+  const words = tokens(text);
+  let index = 0;
+  let quantity;
+  const first = quantityOf(words[0]);
+  if (first !== void 0) {
+    quantity = first;
+    index = 1;
+    const second = quantityOf(words[1]);
+    if (second !== void 0 && second < 1 && words[1]?.includes("/")) {
+      quantity += second;
+      index = 2;
+    }
+  }
+  const rest = words.slice(index).filter((w) => !STOP.has(w));
+  let best;
+  for (const food3 of foods) {
+    for (const candidate of foodTokens(food3)) {
+      if (candidate.length > 0 && candidate.every((t) => rest.includes(t))) {
+        if (!best || candidate.length > best.score) best = { food: food3, score: candidate.length };
+      }
+    }
+  }
+  if (!best) return void 0;
+  const food2 = best.food;
+  const labelTokens = new Set(foodTokens(food2).flat());
+  const measureWord = rest.find((w) => !labelTokens.has(w));
+  const wanted = measureWord ? MEASURE_ALIASES[measureWord] ?? measureWord : void 0;
+  const explicit = wanted ? food2.measures.find(
+    (m2) => tokens(m2.label).join(" ") === wanted || m2.label.toLowerCase() === wanted
+  ) : void 0;
+  if (quantity === void 0 && !explicit) return { food: food2 };
+  const fallback = food2.measures.find((m2) => m2.label === "Whole") ?? food2.measures.find((m2) => m2.label === "Serving");
+  const measure = explicit ?? fallback;
+  return { food: food2, quantity: quantity ?? 1, ...measure ? { measure } : {} };
+};
+var relatedFoods = (text, foods) => {
+  const words = new Set(tokens(text).filter((w) => !STOP.has(w) && quantityOf(w) === void 0));
+  return foods.filter(
+    (food2) => foodTokens(food2).flat().some((t) => words.has(t))
+  );
+};
+var parseRange = (value) => {
+  const both = /^(\d+(?:\.\d+)?)-(\d+(?:\.\d+)?)$/.exec(value);
+  if (both) return { min: Number(both[1]), max: Number(both[2]) };
+  const plus = /^(\d+(?:\.\d+)?)\+$/.exec(value);
+  if (plus) return { min: Number(plus[1]), max: Number.POSITIVE_INFINITY };
+  if (/^\d+(\.\d+)?$/.test(value)) return { min: 0, max: Number(value) };
+  return void 0;
+};
+var publicFood = (food2) => ({
+  foodId: food2.foodId,
+  label: food2.label,
+  knownAs: food2.knownAs,
+  nutrients: food2.nutrients,
+  ...food2.brand ? { brand: food2.brand } : {},
+  category: food2.category,
+  categoryLabel: food2.categoryLabel,
+  ...food2.foodContentsLabel ? { foodContentsLabel: food2.foodContentsLabel } : {},
+  image: food2.image,
+  ...food2.servingSizes ? { servingSizes: food2.servingSizes } : {}
+});
+var nutrientMap = (totals) => Object.fromEntries(
+  CODES.filter((code) => totals[code] !== void 0).map((code) => [
+    code,
+    {
+      label: NUTRIENTS[code].label,
+      quantity: round(totals[code] ?? 0),
+      unit: NUTRIENTS[code].unit
+    }
+  ])
+);
+var dailyMap = (totals) => Object.fromEntries(
+  CODES.filter((code) => totals[code] !== void 0 && code !== "SUGAR").map((code) => [
+    code,
+    {
+      label: NUTRIENTS[code].label,
+      quantity: round((totals[code] ?? 0) / NUTRIENTS[code].daily * 100),
+      unit: "%"
+    }
+  ])
+);
+var scaled = (food2, grams) => Object.fromEntries(
+  Object.entries(food2.nutrients).map(([code, per100]) => [code, (per100 ?? 0) * grams / 100])
+);
+var add = (a, b) => {
+  const out = { ...a };
+  for (const code of CODES) {
+    if (b[code] !== void 0) out[code] = (out[code] ?? 0) + (b[code] ?? 0);
+  }
+  return out;
+};
+var dietLabels = (totals) => {
+  const kcal = totals.ENERC_KCAL ?? 0;
+  if (kcal <= 0) return [];
+  const labels = [];
+  if ((totals.PROCNT ?? 0) * 4 / kcal >= 0.3) labels.push("HIGH_PROTEIN");
+  if ((totals.CHOCDF ?? 0) * 4 / kcal <= 0.2) labels.push("LOW_CARB");
+  if ((totals.FIBTG ?? 0) >= 5) labels.push("HIGH_FIBER");
+  return labels.length > 0 ? labels : ["BALANCED"];
+};
+var analysis = (portions, opts) => {
+  let totals = {};
+  let weight = 0;
+  const ingredients = portions.map((p) => {
+    const grams = p.quantity * p.measure.weight;
+    weight += grams;
+    const nutrients = scaled(p.food, grams);
+    totals = add(totals, nutrients);
+    return {
+      ...p.text !== void 0 ? { text: p.text } : {},
+      parsed: [
+        {
+          quantity: p.quantity,
+          measure: p.measure.label.toLowerCase(),
+          foodMatch: p.food.knownAs,
+          food: p.food.knownAs,
+          foodId: p.food.foodId,
+          weight: round(grams),
+          retainedWeight: round(grams),
+          nutrients: nutrientMap(nutrients),
+          measureURI: p.measure.uri,
+          status: "OK"
+        }
+      ]
+    };
+  });
+  const health = portions.length === 0 ? [] : portions.map((p) => p.food.healthLabels).reduce((acc, labels) => acc.filter((l) => labels.includes(l)));
+  return {
+    uri: `http://www.edamam.com/ontologies/edamam.owl#${opaqueToken(opts.seed, 24)}`,
+    ...opts.yield !== void 0 ? { yield: opts.yield } : {},
+    calories: Math.round(totals.ENERC_KCAL ?? 0),
+    totalWeight: round(weight),
+    dietLabels: dietLabels(totals),
+    healthLabels: health,
+    cautions: [],
+    totalNutrients: nutrientMap(totals),
+    totalDaily: dailyMap(totals),
+    ingredients
+  };
+};
+var titleCase = (s) => s.replace(/\b\w/g, (c) => c.toUpperCase());
+var buildRecipe = (seed, foods) => {
+  let totals = {};
+  let weight = 0;
+  const ingredients = seed.ingredients.map((i) => {
+    const food2 = foods.find((f) => f.foodId === i.foodId);
+    const measure = food2?.measures.find((mm) => mm.label === i.measure);
+    const grams = i.quantity * (measure?.weight ?? 100);
+    weight += grams;
+    if (food2) totals = add(totals, scaled(food2, grams));
+    return {
+      text: i.text,
+      quantity: i.quantity,
+      measure: i.measure.toLowerCase(),
+      food: food2?.knownAs ?? i.foodId,
+      weight: round(grams),
+      foodCategory: food2?.category.toLowerCase() ?? null,
+      foodId: i.foodId,
+      image: food2?.image ?? null
+    };
+  });
+  const slug = seed.label.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  return {
+    uri: `${RECIPE_URI}${seed.id}`,
+    label: seed.label,
+    image: `https://edamam-product-images.s3.amazonaws.com/web-img/${seed.id}.jpg`,
+    source: "Mockingbird Kitchen",
+    url: `https://kitchen.mockingbird.dev/recipes/${slug}`,
+    shareAs: `http://www.edamam.com/recipe/${slug}/${seed.id}`,
+    yield: seed.yield,
+    dietLabels: seed.dietLabels,
+    healthLabels: seed.healthLabels.map((l) => titleCase(l.toLowerCase().replace(/_/g, "-"))),
+    cautions: seed.cautions,
+    ingredientLines: seed.ingredients.map((i) => i.text),
+    ingredients,
+    calories: round(totals.ENERC_KCAL ?? 0),
+    totalWeight: round(weight),
+    totalTime: seed.totalTime,
+    cuisineType: seed.cuisineType,
+    mealType: seed.mealType,
+    dishType: seed.dishType,
+    totalNutrients: nutrientMap(totals),
+    totalDaily: dailyMap(totals)
+  };
+};
+var perServing = (recipe, code) => (recipe.totalNutrients[code]?.quantity ?? 0) / Math.max(1, recipe.yield);
+var norm = (s) => s.toLowerCase().replace(/[\s_]+/g, "-");
+var mealMatches = (recipeMeals, wanted) => {
+  const w = wanted.toLowerCase();
+  return recipeMeals.some((m2) => m2 === w || m2.split("/").includes(w) || w.split("/").includes(m2));
+};
+var matchesFilters = (recipe, seed, f) => {
+  if (f.q) {
+    const haystack = /* @__PURE__ */ new Set([
+      ...tokens(recipe.label),
+      ...recipe.ingredients.flatMap((i) => tokens(i.food))
+    ]);
+    if (!tokens(f.q).every((t) => haystack.has(t))) return false;
+  }
+  const health = seed.healthLabels.map(norm);
+  if (!f.health.every((h) => health.includes(norm(h)))) return false;
+  const diets = recipe.dietLabels.map(norm);
+  if (!f.diet.every((d) => diets.includes(norm(d)))) return false;
+  if (f.mealType.length > 0 && !f.mealType.some((m2) => mealMatches(recipe.mealType, m2)))
+    return false;
+  if (f.dishType.length > 0 && !f.dishType.some((d) => recipe.dishType.includes(d.toLowerCase())))
+    return false;
+  if (f.cuisineType.length > 0 && !f.cuisineType.some((c) => recipe.cuisineType.includes(c.toLowerCase())))
+    return false;
+  if (f.excluded.some((x) => recipe.ingredients.some((i) => i.food.includes(x.toLowerCase()))))
+    return false;
+  const kcal = perServing(recipe, "ENERC_KCAL");
+  if (f.calories && (kcal < f.calories.min || kcal > f.calories.max)) return false;
+  if (f.time && (recipe.totalTime < f.time.min || recipe.totalTime > f.time.max)) return false;
+  for (const [code, range] of Object.entries(f.nutrients)) {
+    const value = perServing(recipe, code);
+    if (range && (value < range.min || value > range.max)) return false;
+  }
+  return true;
+};
+var shuffle = (items, seed) => items.map((item, i) => ({ item, key: opaqueToken(`${seed}:${i}`, 8) })).sort((a, b) => a.key < b.key ? -1 : 1).map((x) => x.item);
+var MEASURE_SERVING = `${MEASURE_URI}serving`;
+var MEASURE_GRAM = `${MEASURE_URI}gram`;
+
+// src/state.ts
+var DEFAULT_SETTINGS = { apps: [], requireAccountUser: false, vision: null };
+var EdamamState = class {
+  constructor(sqlite, namespace, seed) {
+    this.seed = seed;
+    this.foods = new Collection(sqlite, namespace, "foods");
+    this.recipes = new Collection(sqlite, namespace, "recipes");
+    this.settings = new Collection(sqlite, namespace, "settings");
+    this.ensureSeeded();
+  }
+  seed;
+  foods;
+  recipes;
+  settings;
+  ensureSeeded() {
+    if (this.foods.count() === 0) {
+      for (const food2 of this.seed.foods.length > 0 ? this.seed.foods : DEFAULT_FOODS) {
+        this.foods.insert(food2.foodId, food2);
+      }
+    }
+    if (this.recipes.count() === 0) {
+      for (const recipe of this.seed.recipes.length > 0 ? this.seed.recipes : DEFAULT_RECIPES) {
+        this.recipes.insert(recipe.id, recipe);
+      }
+    }
+    if (!this.settings.has("settings")) {
+      this.settings.insert("settings", { ...DEFAULT_SETTINGS, ...this.seed.settings });
+    }
+  }
+  current() {
+    return this.settings.get("settings") ?? DEFAULT_SETTINGS;
+  }
+  update(patch) {
+    const next = { ...this.current(), ...patch };
+    this.settings.insert("settings", next);
+    return next;
+  }
+  allFoods() {
+    return this.foods.list({ order: "oldest" }).map((r) => r.value);
+  }
+  allRecipes() {
+    return this.recipes.list({ order: "oldest" }).map((r) => r.value);
+  }
+};
+
+// src/runtime.ts
+var FOOD_PREFIXES = ["/api/food-database", "/api/nutrition-data", "/api/nutrition-details"];
+var RECIPE_PREFIXES = ["/api/recipes", "/api/meal-planner", "/api/shopping-list"];
+var everywhere = (status, error, message) => [
+  ...FOOD_PREFIXES.map((pathPrefix) => ({
+    pathPrefix,
+    status,
+    body: { status: "error", error, message }
+  })),
+  ...RECIPE_PREFIXES.map((pathPrefix) => ({
+    pathPrefix,
+    status,
+    body: [{ errorCode: error, message, params: [] }]
+  }))
+];
+var EDAMAM_PRESETS = {
+  rate_limited: {
+    description: "Every API answers 429 Usage limits are exceeded (the meal adapter flags rateLimited)",
+    rules: everywhere(429, "usage_limits", "Usage limits are exceeded")
+  },
+  payment_required: {
+    description: "Every API answers 402 (plan quota exhausted; makor chat treats it as a rate limit)",
+    rules: everywhere(402, "payment_required", "Payment required: plan limits reached")
+  },
+  unauthorized: {
+    description: "Every API answers 401 (keys revoked)",
+    rules: everywhere(401, "unauthorized", "Unauthorized app_id")
+  },
+  server_error: {
+    description: "Every API answers 500",
+    rules: everywhere(500, "internal_error", "Internal server error")
+  },
+  parser_schema_drift: {
+    description: "The food parser answers `parsed` as a string (our zod schema rejects it)",
+    rules: [{ operationId: "FoodParser", effect: "parser_schema_drift" }]
+  },
+  recipe_quality: {
+    description: "nutrition-details answers 555 Recipe with insufficient quality",
+    rules: [{ operationId: "NutritionDetails", effect: "recipe_quality" }]
+  },
+  vision_not_found: {
+    description: "nutrients-from-image recognises nothing (an empty object)",
+    rules: [{ operationId: "FoodFromImage", effect: "vision_not_found" }]
+  },
+  meal_plan_incomplete: {
+    description: "The meal planner leaves each day's last section unassigned (status INCOMPLETE)",
+    rules: [{ operationId: "MealPlanSelect", effect: "meal_plan_incomplete" }]
+  },
+  meal_plan_timeout: {
+    description: "The meal planner answers status TIME_OUT with no selection",
+    rules: [{ operationId: "MealPlanSelect", effect: "meal_plan_timeout" }]
+  },
+  slow: {
+    description: "Every call answers after 12 s (past our 10 s parser and recipe timeouts)",
+    rules: [...FOOD_PREFIXES, ...RECIPE_PREFIXES].map((pathPrefix) => ({
+      pathPrefix,
+      latencyMs: 12e3
+    }))
+  },
+  connection_drop: {
+    description: "The connection drops before any answer (fetch rejects)",
+    rules: [...FOOD_PREFIXES, ...RECIPE_PREFIXES].map((pathPrefix) => ({ pathPrefix, drop: true }))
+  }
+};
+var json3 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminError3 = (status, message) => json3(status, { error: { type: "mockingbird_admin", message } });
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var adminRoutes = (runtime) => ({
+  "GET /foods": ({ namespace }) => json3(200, { foods: runtime.instance(namespace).state.allFoods() }),
+  "POST /foods": ({ body, namespace }) => {
+    if (!isRecord4(body) || typeof body.foodId !== "string" || typeof body.label !== "string" || !Array.isArray(body.measures)) {
+      return adminError3(
+        400,
+        "expected a food {foodId, label, nutrients, measures: [{uri, label, weight}], \u2026}"
+      );
+    }
+    const defaults = {
+      knownAs: body.label.toLowerCase(),
+      nutrients: {},
+      category: "Generic foods",
+      categoryLabel: "food",
+      image: "",
+      healthLabels: []
+    };
+    const food2 = { ...defaults, ...body };
+    return json3(201, runtime.instance(namespace).addFood(food2));
+  },
+  "GET /recipes": ({ namespace }) => json3(200, { recipes: runtime.instance(namespace).recipes() }),
+  "POST /recipes": ({ body, namespace }) => {
+    if (!isRecord4(body) || typeof body.id !== "string" || typeof body.label !== "string" || !Array.isArray(body.ingredients)) {
+      return adminError3(
+        400,
+        "expected a recipe seed {id, label, yield, ingredients: [{foodId, quantity, measure, text}], \u2026}"
+      );
+    }
+    const defaults = {
+      yield: 1,
+      totalTime: 0,
+      mealType: [],
+      dishType: [],
+      cuisineType: [],
+      dietLabels: [],
+      healthLabels: [],
+      cautions: []
+    };
+    const seed = { ...defaults, ...body };
+    return json3(201, runtime.instance(namespace).addRecipe(seed));
+  },
+  "PUT /vision": ({ body, namespace }) => {
+    if (body === null) return json3(200, runtime.instance(namespace).state.update({ vision: null }));
+    if (!isRecord4(body) || typeof body.foodId !== "string" && body.notFound !== true) {
+      return adminError3(
+        400,
+        'expected {"foodId", "quantity"?, "measure"?}, {"notFound": true} or null'
+      );
+    }
+    const vision = body.notFound === true ? { notFound: true } : {
+      foodId: String(body.foodId),
+      ...typeof body.quantity === "number" ? { quantity: body.quantity } : {},
+      ...typeof body.measure === "string" ? { measure: body.measure } : {}
+    };
+    return json3(200, runtime.instance(namespace).state.update({ vision }));
+  },
+  "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.apps !== void 0) {
+      if (!Array.isArray(body.apps)) return adminError3(400, "apps: [{appId, appKey}]");
+      patch.apps = body.apps.filter(isRecord4).map((a) => ({ appId: String(a.appId), appKey: String(a.appKey) }));
+    }
+    if (body.requireAccountUser !== void 0) {
+      if (typeof body.requireAccountUser !== "boolean")
+        return adminError3(400, "requireAccountUser: boolean");
+      patch.requireAccountUser = body.requireAccountUser;
+    }
+    return json3(200, runtime.instance(namespace).state.update(patch));
+  }
+});
+var createRuntime2 = (options = {}) => createRuntime({
+  name: EDAMAM_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: appIdCredential,
+  presets: EDAMAM_PRESETS,
+  create: ({ sqlite, namespace, clock }) => new EdamamAPI({
+    sqlite,
+    namespace,
+    now: clock.now,
+    ...options.foods ? { foods: options.foods } : {},
+    ...options.recipes ? { recipes: options.recipes } : {},
+    ...options.settings ? { settings: options.settings } : {}
+  }),
+  admin: adminRoutes
+});
+
+// src/index.ts
+var EDAMAM_NAMESPACE = "edamam";
+var ACCOUNT_USER_HEADER = "edamam-account-user";
+var PAGE_SIZE = 20;
+var foodError = (status, error, message) => jsonRes(status, { status: "error", error, message });
+var recipeErrors = (status, errorCode, message, params = []) => jsonRes(status, [{ errorCode, message, params }]);
+var appIdCredential = (request) => new URL(request.url).searchParams.get("app_id") ?? basicAuth(request)?.username ?? void 0;
+var RECIPE_FAMILY = /* @__PURE__ */ new Set([
+  "RecipeSearch",
+  "RecipesByUri",
+  "RecipeById",
+  "MealPlanSelect",
+  "ShoppingList"
+]);
+var many = (url, key) => url.searchParams.getAll(key).filter((v) => v.length > 0);
+var base64url = (value) => toBase64(new TextEncoder().encode(value)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+var EdamamAPI = class {
+  app;
+  sqlite;
+  state;
+  service;
+  now;
+  constructor(options = {}) {
+    const sqlite = bootSqlite(options.sqlite);
+    const namespace = options.namespace ?? EDAMAM_NAMESPACE;
+    this.now = options.now ?? (() => Date.now());
+    this.state = new EdamamState(sqlite, namespace, {
+      foods: options.foods ?? [],
+      recipes: options.recipes ?? [],
+      settings: options.settings ?? {}
+    });
+    const handlers = defineOperations({
+      FoodParser: (context) => this.parser(context),
+      FoodNutrients: (context) => this.nutrients(context),
+      FoodFromImage: (context) => this.vision(context),
+      NutritionData: (context) => this.nutritionData(context),
+      NutritionDetails: (context) => this.nutritionDetails(context),
+      RecipeSearch: (context) => this.recipeSearch(context),
+      RecipesByUri: (context) => this.recipesByUri(context),
+      RecipeById: (context) => {
+        const seed = this.state.recipes.get(context.params.id ?? "");
+        if (!seed) return recipeErrors(404, "not_found", `Recipe ${context.params.id} not found`);
+        return jsonRes(200, this.hit(this.recipe(seed), context.url.origin));
+      },
+      MealPlanSelect: (context) => this.mealPlan(context),
+      ShoppingList: (context) => this.shoppingList(context)
+    });
+    this.service = createService({
+      document,
+      handlers,
+      sqlite,
+      namespace,
+      now: this.now,
+      notFound: () => foodError(404, "not_found", "Not Found"),
+      onError: (error) => {
+        if (error instanceof HttpError) return error.toResponse();
+        throw error;
+      },
+      before: (context) => this.authenticate(context)
+    });
+    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();
+  }
+  authenticate(context) {
+    const recipeFamily = RECIPE_FAMILY.has(context.operation.operationId);
+    const fail = (message) => recipeFamily ? recipeErrors(401, "unauthorized", message) : foodError(401, "unauthorized", message);
+    const basic = basicAuth(context.request);
+    const appId = context.url.searchParams.get("app_id") ?? basic?.username;
+    const appKey = context.url.searchParams.get("app_key") ?? basic?.password;
+    if (!appId || !appKey) return fail("Missing app_id or app_key");
+    const apps = this.state.current().apps;
+    if (apps.length > 0 && !apps.some((a) => a.appId === appId && a.appKey === appKey)) {
+      return fail(`Unauthorized app_id = ${appId}. This app_id is not configured for this API.`);
+    }
+    if (recipeFamily && this.state.current().requireAccountUser && !context.request.headers.get(ACCOUNT_USER_HEADER)) {
+      return fail("Edamam-Account-User header is required for this application");
+    }
+    return void 0;
+  }
+  foods() {
+    return this.state.allFoods();
+  }
+  recipe(seed) {
+    return buildRecipe(seed, this.foods());
+  }
+  hit(recipe, origin) {
+    const id = recipe.uri.slice(RECIPE_URI.length);
+    return {
+      recipe,
+      _links: { self: { title: "Self", href: `${origin}/api/recipes/v2/${id}?type=public` } }
+    };
+  }
+  jsonBody(context, recipeFamily = false, invalidStatus = recipeFamily ? 400 : 422) {
+    const issues = bodyIssues(context);
+    if (issues.length > 0) {
+      const message = `Invalid request body: ${issues.map((i) => `${i.path || "body"} ${i.message}`).join("; ")}`;
+      throw new HttpError(
+        invalidStatus,
+        recipeFamily ? [{ errorCode: "illegal_param", message, params: issues.map((i) => i.path) }] : { status: "error", error: "bad_request", message }
+      );
+    }
+    return context.body.kind === "json" ? context.body.value : {};
+  }
+  foodFilter(url) {
+    const categoryLabel = url.searchParams.get("categoryLabel");
+    const category = url.searchParams.get("category");
+    const health = many(url, "health").map((h) => h.toUpperCase().replace(/-/g, "_"));
+    const caloriesParam = url.searchParams.get("calories");
+    const calories = caloriesParam ? parseRange(caloriesParam) : void 0;
+    if (caloriesParam && !calories) {
+      return foodError(400, "bad_request", `Illegal value for calories: ${caloriesParam}`);
+    }
+    const categories = {
+      "generic-foods": "Generic foods",
+      "packaged-foods": "Packaged foods",
+      "generic-meals": "Generic meals"
+    };
+    return (food2) => (!categoryLabel || food2.categoryLabel === categoryLabel) && (!category || food2.category === categories[category]) && health.every((h) => food2.healthLabels.includes(h)) && (!calories || food2.nutrients.ENERC_KCAL !== void 0 && food2.nutrients.ENERC_KCAL >= calories.min && food2.nutrients.ENERC_KCAL <= calories.max);
+  }
+  parser(context) {
+    const url = context.url;
+    const ingr = url.searchParams.get("ingr");
+    const upc = url.searchParams.get("upc");
+    const filter = this.foodFilter(url);
+    if (filter instanceof Response) return filter;
+    const foods = this.foods().filter(filter);
+    if (upc) {
+      const food2 = this.foods().find((f) => f.upc === upc);
+      if (!food2) return foodError(404, "not_found", `No food found for UPC ${upc}`);
+      return annotateResponse(
+        jsonRes(200, {
+          text: upc,
+          parsed: [],
+          hints: [{ food: publicFood(food2), measures: food2.measures }]
+        }),
+        { ids: { foodId: food2.foodId } }
+      );
+    }
+    if (!ingr) return foodError(400, "bad_request", "Missing required parameter: ingr or upc");
+    if (faultEffect(context.request, "parser_schema_drift") !== void 0) {
+      return jsonRes(200, { text: ingr, parsed: "unavailable", hints: [] });
+    }
+    const parsedLine = parseLine(ingr, foods);
+    const hints = relatedFoods(ingr, foods);
+    const ordered = parsedLine ? [parsedLine.food, ...hints.filter((f) => f !== parsedLine.food)] : hints;
+    return jsonRes(200, {
+      text: ingr,
+      parsed: parsedLine ? [
+        {
+          food: publicFood(parsedLine.food),
+          ...parsedLine.quantity !== void 0 ? { quantity: parsedLine.quantity } : {},
+          ...parsedLine.measure ? { measure: parsedLine.measure } : {}
+        }
+      ] : [],
+      hints: ordered.map((food2) => ({ food: publicFood(food2), measures: food2.measures })),
+      _links: {}
+    });
+  }
+  nutrients(context) {
+    const body = this.jsonBody(context);
+    const lines = body.ingredients;
+    const portions = [];
+    for (const line of lines) {
+      const food2 = this.state.foods.get(line.foodId);
+      const measure = food2?.measures.find((m2) => m2.uri === line.measureURI);
+      if (!food2 || !measure) {
+        return foodError(
+          422,
+          "low_quality",
+          `Unknown food ${line.foodId} or measure ${line.measureURI}`
+        );
+      }
+      portions.push({ food: food2, quantity: line.quantity, measure });
+    }
+    return jsonRes(200, analysis(portions, { seed: JSON.stringify(lines) }));
+  }
+  vision(context) {
+    const body = this.jsonBody(context, false, 400);
+    const image = String(body.image);
+    if (!/^(data:image\/[a-z+]+;base64,|https?:\/\/)/.test(image)) {
+      return foodError(400, "bad_request", "The image must be a data URL or an http(s) URL");
+    }
+    const override = this.state.current().vision;
+    if (faultEffect(context.request, "vision_not_found") !== void 0 || override && "notFound" in override) {
+      return jsonRes(200, {});
+    }
+    const candidates = this.foods().filter(
+      (f) => f.categoryLabel === "meal" || f.foodId === "food_salmon"
+    );
+    const pick = override && "foodId" in override ? this.state.foods.get(override.foodId) : candidates[Number.parseInt(opaqueToken(image, 4), 36) % Math.max(1, candidates.length)];
+    if (!pick) return jsonRes(200, {});
+    const measure = pick.measures.find(
+      (m2) => m2.label === (override && "measure" in override ? override.measure : "Serving")
+    ) ?? pick.measures[0];
+    const quantity = override && "quantity" in override && override.quantity ? override.quantity : 1;
+    const result = analysis(measure ? [{ food: pick, quantity, measure }] : [], { seed: image });
+    return jsonRes(200, {
+      parsed: { food: publicFood(pick), quantity, ...measure ? { measure } : {} },
+      recipe: {
+        label: pick.label,
+        calories: result.calories,
+        totalNutrients: result.totalNutrients
+      }
+    });
+  }
+  portionOf(text) {
+    const line = parseLine(text, this.foods());
+    if (!line?.measure) {
+      if (!line) return void 0;
+      const measure = line.food.measures.find((m2) => m2.label === "Serving") ?? line.food.measures[0];
+      return measure ? { food: line.food, quantity: 1, measure, text } : void 0;
+    }
+    return { food: line.food, quantity: line.quantity ?? 1, measure: line.measure, text };
+  }
+  nutritionData(context) {
+    const ingr = context.url.searchParams.get("ingr") ?? "";
+    const portion = this.portionOf(ingr);
+    if (!portion) return foodError(422, "low_quality", `Could not parse ingredient: ${ingr}`);
+    return jsonRes(200, analysis([portion], { seed: ingr }));
+  }
+  nutritionDetails(context) {
+    const body = this.jsonBody(context);
+    const lines = body.ingr ?? [];
+    if (lines.length === 0) return foodError(422, "low_quality", "No ingredients to analyse");
+    if (faultEffect(context.request, "recipe_quality") !== void 0) {
+      return foodError(555, "low_quality", "Recipe with insufficient quality to process correctly");
+    }
+    const portions = lines.map((line) => this.portionOf(line));
+    if (portions.some((p) => p === void 0)) {
+      return foodError(555, "low_quality", "Recipe with insufficient quality to process correctly");
+    }
+    return jsonRes(
+      200,
+      analysis(portions, {
+        seed: JSON.stringify(body),
+        yield: typeof body.yield === "number" ? body.yield : 1
+      })
+    );
+  }
+  recipeFilters(url) {
+    const range = (key) => {
+      const value = url.searchParams.get(key);
+      if (value === null) return void 0;
+      const parsed = parseRange(value);
+      if (!parsed)
+        throw new HttpError(400, [
+          {
+            errorCode: "illegal_param",
+            message: `Illegal value for ${key}: ${value}`,
+            params: [key]
+          }
+        ]);
+      return parsed;
+    };
+    try {
+      const nutrients = {};
+      for (const code of [
+        "ENERC_KCAL",
+        "PROCNT",
+        "FAT",
+        "CHOCDF",
+        "FIBTG",
+        "SUGAR"
+      ]) {
+        const r = range(`nutrients[${code}]`);
+        if (r) nutrients[code] = r;
+      }
+      const calories = range("calories");
+      const time = range("time");
+      const q = url.searchParams.get("q");
+      return {
+        ...q ? { q } : {},
+        health: many(url, "health"),
+        diet: many(url, "diet"),
+        mealType: many(url, "mealType"),
+        dishType: many(url, "dishType"),
+        cuisineType: many(url, "cuisineType"),
+        excluded: many(url, "excluded"),
+        ...calories ? { calories } : {},
+        ...time ? { time } : {},
+        nutrients
+      };
+    } catch (error) {
+      if (error instanceof HttpError) return error.toResponse();
+      throw error;
+    }
+  }
+  recipeSearch(context) {
+    const url = context.url;
+    if (!url.searchParams.get("type")) {
+      return recipeErrors(400, "illegal_param", "Parameter 'type' is required", ["type"]);
+    }
+    const filters = this.recipeFilters(url);
+    if (filters instanceof Response) return filters;
+    let matches2 = this.state.allRecipes().map((seed) => ({ seed, recipe: this.recipe(seed) })).filter(({ seed, recipe }) => matchesFilters(recipe, seed, filters)).map(({ recipe }) => recipe);
+    if (url.searchParams.get("random") === "true") matches2 = shuffle(matches2, url.search);
+    const cont = url.searchParams.get("_cont");
+    let offset = 0;
+    if (cont) {
+      try {
+        offset = Number(
+          new TextDecoder().decode(fromBase64(cont.replace(/-/g, "+").replace(/_/g, "/")))
+        );
+      } catch {
+        offset = Number.NaN;
+      }
+      if (!Number.isInteger(offset) || offset < 0) {
+        return recipeErrors(400, "illegal_param", "Invalid _cont token", ["_cont"]);
+      }
+    }
+    const page = matches2.slice(offset, offset + PAGE_SIZE);
+    const next = new URL(`${url.origin}${url.pathname}`);
+    for (const [key, value] of url.searchParams)
+      if (key !== "_cont") next.searchParams.append(key, value);
+    next.searchParams.set("_cont", base64url(String(offset + PAGE_SIZE)));
+    return jsonRes(200, {
+      from: page.length > 0 ? offset + 1 : 0,
+      to: offset + page.length,
+      count: matches2.length,
+      _links: offset + PAGE_SIZE < matches2.length ? { next: { href: next.toString(), title: "Next page" } } : {},
+      hits: page.map((recipe) => this.hit(recipe, url.origin))
+    });
+  }
+  recipesByUri(context) {
+    const url = context.url;
+    const uris = many(url, "uri");
+    if (uris.length === 0 || uris.length > 20) {
+      return recipeErrors(400, "illegal_param", "Between 1 and 20 uri parameters are required", [
+        "uri"
+      ]);
+    }
+    const hits = uris.map(
+      (uri) => this.state.recipes.get(uri.startsWith(RECIPE_URI) ? uri.slice(RECIPE_URI.length) : uri)
+    ).filter((seed) => seed !== void 0).map((seed) => this.hit(this.recipe(seed), url.origin));
+    return jsonRes(200, {
+      from: hits.length > 0 ? 1 : 0,
+      to: hits.length,
+      count: hits.length,
+      _links: {},
+      hits
+    });
+  }
+  /** Whether a recipe satisfies a plan section's `accept` predicates and per-serving `fit`. */
+  fits(recipe, seed, section, inherited) {
+    const predicates = [...inherited.accept?.all ?? [], ...section.accept?.all ?? []];
+    for (const p of predicates) {
+      if (p.health && !p.health.every((h) => seed.healthLabels.includes(h.toUpperCase().replace(/-/g, "_"))))
+        return false;
+      if (p.meal && !p.meal.some((meal) => recipe.mealType.includes(meal.toLowerCase())))
+        return false;
+      if (p.dish && !p.dish.some((dish) => recipe.dishType.includes(dish.toLowerCase())))
+        return false;
+    }
+    if ([...inherited.exclude ?? [], ...section.exclude ?? []].includes(recipe.uri))
+      return false;
+    for (const [code, band] of Object.entries(section.fit ?? {})) {
+      const value = perServing(recipe, code);
+      if (band?.min !== void 0 && value < band.min) return false;
+      if (band?.max !== void 0 && value > band.max) return false;
+    }
+    return true;
+  }
+  mealPlan(context) {
+    const url = context.url;
+    const appId = url.searchParams.get("app_id") ?? basicAuth(context.request)?.username;
+    if (context.params.app_id !== appId) {
+      return recipeErrors(
+        401,
+        "unauthorized",
+        "The app_id in the path does not match the credentials"
+      );
+    }
+    const body = this.jsonBody(context, true);
+    const size = Number(body.size);
+    const plan = body.plan ?? {};
+    const sections = plan.sections ?? {};
+    if (Object.keys(sections).length === 0) {
+      return recipeErrors(400, "illegal_param", "The plan must define at least one section", [
+        "plan.sections"
+      ]);
+    }
+    if (faultEffect(context.request, "meal_plan_timeout") !== void 0) {
+      return jsonRes(200, { status: "TIME_OUT", selection: [] });
+    }
+    const all = this.state.allRecipes().map((seed) => ({ seed, recipe: this.recipe(seed) }));
+    let complete = true;
+    const selection = Array.from({ length: size }, (_, day) => {
+      const used = /* @__PURE__ */ new Set();
+      const out = {};
+      let dayTotals = 0;
+      for (const [name, section] of Object.entries(sections)) {
+        const candidates = all.filter(
+          ({ seed, recipe }) => !used.has(recipe.uri) && this.fits(recipe, seed, section, plan)
+        );
+        const chosen = candidates.length > 0 ? candidates[day % candidates.length] : void 0;
+        if (!chosen) {
+          complete = false;
+          out[name] = {};
+          continue;
+        }
+        used.add(chosen.recipe.uri);
+        dayTotals += perServing(chosen.recipe, "ENERC_KCAL");
+        const id = chosen.recipe.uri.slice(RECIPE_URI.length);
+        out[name] = {
+          assigned: chosen.recipe.uri,
+          _links: {
+            self: {
+              title: "Recipe details",
+              href: `${url.origin}/api/recipes/v2/${id}?type=public`
+            }
+          }
+        };
+      }
+      const kcal = plan.fit?.ENERC_KCAL;
+      if (kcal && (kcal.min !== void 0 && dayTotals < kcal.min || kcal.max !== void 0 && dayTotals > kcal.max)) {
+        complete = false;
+      }
+      return { sections: out };
+    });
+    if (faultEffect(context.request, "meal_plan_incomplete") !== void 0) {
+      complete = false;
+      for (const day of selection) {
+        const last = Object.keys(day.sections).at(-1);
+        if (last) day.sections[last] = {};
+      }
+    }
+    return jsonRes(200, { status: complete ? "OK" : "INCOMPLETE", selection });
+  }
+  shoppingList(context) {
+    const url = context.url;
+    const body = this.jsonBody(context, true);
+    const entries = body.entries;
+    const totals = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const id = entry.item.startsWith(RECIPE_URI) ? entry.item.slice(RECIPE_URI.length) : entry.item;
+      const seed = this.state.recipes.get(id);
+      if (!seed)
+        return recipeErrors(400, "not_found", `Unknown recipe ${entry.item}`, ["entries.item"]);
+      const recipe = this.recipe(seed);
+      const factor = entry.measure === MEASURE_SERVING ? entry.quantity / Math.max(1, recipe.yield) : entry.quantity;
+      for (const ingredient of recipe.ingredients) {
+        const current = totals.get(ingredient.foodId) ?? { food: ingredient.food, grams: 0 };
+        current.grams += ingredient.weight * factor;
+        totals.set(ingredient.foodId, current);
+      }
+    }
+    const cart = url.searchParams.get("shopping-cart") === "true" && url.searchParams.get("beta") === "true";
+    return jsonRes(200, {
+      entries: [...totals.entries()].map(([foodId, { food: food2, grams }]) => ({
+        foodId,
+        food: food2,
+        quantities: [
+          { quantity: Math.round(grams * 10) / 10, measure: MEASURE_GRAM, qualifiers: [] }
+        ]
+      })),
+      _links: cart ? {
+        "shopping-cart": {
+          title: "Shopping cart",
+          href: `${url.origin}/shopping-cart/${opaqueToken(JSON.stringify(entries), 16)}`
+        }
+      } : {}
+    });
+  }
+  addFood(food2) {
+    this.state.foods.insert(food2.foodId, food2);
+    return food2;
+  }
+  addRecipe(seed) {
+    this.state.recipes.insert(seed.id, seed);
+    return this.recipe(seed);
+  }
+  recipes() {
+    return this.state.allRecipes().map((seed) => this.recipe(seed));
+  }
+};
+
+export {
+  MEASURE_URI,
+  RECIPE_URI,
+  NUTRIENTS,
+  DEFAULT_FOODS,
+  DEFAULT_RECIPES,
+  document,
+  operationIds,
+  supportedOperationIds,
+  parseLine,
+  buildRecipe,
+  perServing,
+  EDAMAM_PRESETS,
+  createRuntime2 as createRuntime,
+  EDAMAM_NAMESPACE,
+  ACCOUNT_USER_HEADER,
+  foodError,
+  recipeErrors,
+  appIdCredential,
+  EdamamAPI
+};
+//# sourceMappingURL=chunk-DWHV3RH2.js.map