@crvouga/mockingbird-service-twilio 0.1.0

package/dist/chunk-VOBVFMYN.js

@@ -0,0 +1,3642 @@
+// ../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 header2 = request.headers.get("authorization");
+  if (!header2)
+    return void 0;
+  const match = /^Basic\s+(.+)$/i.exec(header2.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;
+};
+
+// ../../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 round = 0;
+  while (out.length < length) {
+    let hash = mix(`${input}:${round++}`);
+    for (let i = 0; i < 5 && out.length < length; i++) {
+      out += ALPHABET.charAt(hash % ALPHABET.length);
+      hash = Math.floor(hash / ALPHABET.length);
+    }
+  }
+  return out;
+};
+var IdSequence = class {
+  sqlite;
+  namespace;
+  salt;
+  constructor(sqlite, namespace, salt = "mockingbird") {
+    this.sqlite = sqlite;
+    this.namespace = namespace;
+    this.salt = salt;
+  }
+  next(prefix, length = 14) {
+    return this.sqlite.transaction(() => {
+      const row = this.sqlite.prepare("SELECT value FROM mockingbird_sequences WHERE namespace = ? AND name = ? AND kind = 'id'").get(this.namespace, prefix);
+      const value = (row?.value ?? 0) + 1;
+      this.sqlite.prepare(`INSERT INTO mockingbird_sequences (namespace, name, kind, value) VALUES (?, ?, 'id', ?)
+           ON CONFLICT(namespace, name, kind) DO UPDATE SET value = excluded.value`).run(this.namespace, prefix, value);
+      return `${prefix}${opaqueToken(`${this.salt}:${prefix}:${value}`, length)}`;
+    });
+  }
+};
+
+// ../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/outbox.js
+var OutboxStore = class {
+  items;
+  constructor(sqlite, namespace, name = "outbox") {
+    this.items = new Collection(sqlite, namespace, name);
+  }
+  record(item) {
+    this.items.insert(item.id, item);
+    return item;
+  }
+  get(id) {
+    return this.items.get(id);
+  }
+  update(id, item) {
+    this.items.update(id, item);
+  }
+  /** Oldest first, so a suite reads messages in the order they were sent. */
+  list(query = {}) {
+    const to = query.to?.toLowerCase();
+    const matched = this.items.list({ order: "oldest" }).map((row) => row.value).filter((item) => {
+      if (to !== void 0) {
+        const recipients = Array.isArray(item.to) ? item.to : [item.to];
+        if (!recipients.some((r) => r.toLowerCase() === to))
+          return false;
+      }
+      if (query.since !== void 0 && Date.parse(item.createdAt) < query.since)
+        return false;
+      if (query.where && !query.where(item))
+        return false;
+      return true;
+    });
+    return query.limit !== void 0 ? matched.slice(-Math.max(0, query.limit)) : matched;
+  }
+};
+var json2 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var parseSince = (value) => {
+  if (value === null)
+    return void 0;
+  const parsed = /^\d+$/.test(value) ? Number(value) : Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+var outboxAdminRoutes = (runtime, pick, filter) => ({
+  "GET /outbox": ({ url, namespace }) => {
+    const since = parseSince(url.searchParams.get("since"));
+    if (since === null) {
+      return json2(400, {
+        error: { type: "mockingbird_admin", message: "since: expected epoch ms or ISO-8601" }
+      });
+    }
+    const limit = url.searchParams.get("limit");
+    const where = filter?.(url.searchParams);
+    const to = url.searchParams.get("to");
+    return json2(200, {
+      messages: pick(runtime.instance(namespace)).list({
+        ...to !== null ? { to } : {},
+        ...since !== void 0 ? { since } : {},
+        ...where ? { where } : {},
+        ...limit !== null && /^\d+$/.test(limit) ? { limit: Number(limit) } : {}
+      })
+    });
+  },
+  "GET /outbox/:id": ({ params, namespace }) => {
+    const item = pick(runtime.instance(namespace)).get(params.id);
+    return item ? json2(200, item) : json2(404, { error: { type: "mockingbird_admin", message: `no message ${params.id}` } });
+  }
+});
+
+// ../../core/dist/timeline.js
+var BRANCH_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
+var Timeline = class {
+  maxCheckpoints;
+  now;
+  makeId;
+  nodes = /* @__PURE__ */ new Map();
+  heads = /* @__PURE__ */ new Map();
+  /** Unreferenced nodes in the exact order they became collectible. */
+  evictable = /* @__PURE__ */ new Set();
+  /** Branch heads plus explicit retainers. Absent means zero. */
+  references = /* @__PURE__ */ new Map();
+  explicitPins = /* @__PURE__ */ new Map();
+  sequence = 0;
+  constructor(options = {}) {
+    const max = options.maxCheckpoints ?? 1e3;
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("maxCheckpoints must be a positive integer");
+    this.maxCheckpoints = max;
+    this.now = options.now ?? (() => this.sequence);
+    this.makeId = options.id ?? ((sequence) => `cp_${sequence.toString(36).padStart(8, "0")}`);
+  }
+  /** Capture a new immutable value and move `branch` to it. */
+  commit(value, options = {}) {
+    const branch = options.branch ?? "main";
+    this.assertBranch(branch);
+    const parent = options.parent === void 0 ? this.heads.get(branch) ?? null : options.parent;
+    if (parent !== null && !this.nodes.has(parent))
+      throw new RangeError(`no checkpoint ${parent}`);
+    const id = this.makeId(++this.sequence);
+    if (this.nodes.has(id))
+      throw new RangeError(`duplicate checkpoint id ${id}`);
+    const checkpoint = Object.freeze({ id, branch, parent, at: this.now(), value });
+    this.nodes.set(id, checkpoint);
+    this.moveHead(branch, id);
+    this.collect(this.maxCheckpoints);
+    return checkpoint;
+  }
+  /** Create a branch pointer without copying its checkpoint value. */
+  fork(branch, options = {}) {
+    this.assertBranch(branch);
+    if (this.heads.has(branch))
+      throw new RangeError(`branch already exists: ${branch}`);
+    const from = options.from ?? this.heads.get("main");
+    if (from === void 0)
+      return void 0;
+    const checkpoint = this.get(from);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  /** Move a branch pointer to an existing checkpoint. */
+  checkout(branch, id) {
+    this.assertBranch(branch);
+    const checkpoint = this.get(id);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  get(id) {
+    const checkpoint = this.nodes.get(id);
+    if (!checkpoint)
+      throw new RangeError(`no checkpoint ${id}`);
+    return checkpoint;
+  }
+  head(branch = "main") {
+    const id = this.heads.get(branch);
+    return id === void 0 ? void 0 : this.get(id);
+  }
+  hasBranch(branch) {
+    return this.heads.has(branch);
+  }
+  branches() {
+    return Object.freeze(Object.fromEntries([...this.heads].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)));
+  }
+  checkpoints() {
+    return [...this.nodes.values()];
+  }
+  /** Number of retained checkpoints without allocating an array. */
+  get size() {
+    return this.nodes.size;
+  }
+  /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
+  retain(id) {
+    const checkpoint = this.get(id);
+    this.explicitPins.set(id, (this.explicitPins.get(id) ?? 0) + 1);
+    this.addReference(id);
+    return checkpoint;
+  }
+  /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
+  release(id) {
+    if (!this.nodes.has(id))
+      return false;
+    const pins = this.explicitPins.get(id) ?? 0;
+    if (pins === 0)
+      return false;
+    if (pins === 1)
+      this.explicitPins.delete(id);
+    else
+      this.explicitPins.set(id, pins - 1);
+    this.removeReference(id);
+    this.collect(this.maxCheckpoints);
+    return true;
+  }
+  deleteBranch(branch) {
+    if (branch === "main")
+      throw new RangeError("cannot delete main branch");
+    const previous = this.heads.get(branch);
+    const deleted = this.heads.delete(branch);
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.collect(this.maxCheckpoints);
+    return deleted;
+  }
+  /**
+   * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
+   * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
+   * storage dependency, so a retained node remains usable after pruning.
+   */
+  gc(max = this.maxCheckpoints) {
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("max must be a positive integer");
+    const removed = [];
+    this.collect(max, removed);
+    return removed;
+  }
+  collect(max, removed) {
+    while (this.nodes.size > max && this.evictable.size > 0) {
+      const id = this.evictable.values().next().value;
+      this.evictable.delete(id);
+      this.nodes.delete(id);
+      removed?.push(id);
+    }
+  }
+  moveHead(branch, id) {
+    const previous = this.heads.get(branch);
+    if (previous === id)
+      return;
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.heads.set(branch, id);
+    this.addReference(id);
+  }
+  addReference(id) {
+    this.references.set(id, (this.references.get(id) ?? 0) + 1);
+    this.evictable.delete(id);
+  }
+  removeReference(id) {
+    const next = (this.references.get(id) ?? 0) - 1;
+    if (next > 0)
+      this.references.set(id, next);
+    else {
+      this.references.delete(id);
+      if (this.nodes.has(id))
+        this.evictable.add(id);
+    }
+  }
+  assertBranch(branch) {
+    if (!BRANCH_PATTERN.test(branch))
+      throw new RangeError(`branch must match ${BRANCH_PATTERN}`);
+  }
+};
+
+// ../../sqlite/dist/default.js
+import { Database } from "@crvouga/mockingbird-service-sqlite";
+var createDefaultSqlite = () => new Database();
+var resolveSqlite = (sqlite) => sqlite ?? createDefaultSqlite();
+
+// ../../sqlite/dist/migrate.js
+var ensureMigrationsTable = (sqlite) => {
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      id TEXT PRIMARY KEY NOT NULL,
+      applied_at INTEGER NOT NULL
+    )
+  `);
+};
+var migrate = (sqlite, migrations) => {
+  ensureMigrationsTable(sqlite);
+  const applied = new Set(sqlite.prepare("SELECT id FROM schema_migrations").all().map((row) => row.id));
+  const pending = migrations.filter((migration) => !applied.has(migration.id));
+  if (pending.length === 0)
+    return;
+  const insert = sqlite.prepare("INSERT INTO schema_migrations (id, applied_at) VALUES (?, ?)");
+  const now = Math.floor(Date.now() / 1e3);
+  sqlite.transaction(() => {
+    for (const migration of pending) {
+      sqlite.exec(migration.sql);
+      insert.run(migration.id, now);
+    }
+  });
+};
+
+// ../../sqlite/dist/schema.js
+var CORE_MIGRATIONS = [
+  {
+    id: "20260322_core_records_sequences",
+    sql: `
+      CREATE TABLE IF NOT EXISTS mockingbird_records (
+        namespace TEXT NOT NULL,
+        collection TEXT NOT NULL,
+        id TEXT NOT NULL,
+        seq INTEGER NOT NULL,
+        value TEXT NOT NULL,
+        PRIMARY KEY (namespace, collection, id)
+      );
+      CREATE INDEX IF NOT EXISTS mockingbird_records_seq
+        ON mockingbird_records (namespace, collection, seq);
+      CREATE TABLE IF NOT EXISTS mockingbird_sequences (
+        namespace TEXT NOT NULL,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        value INTEGER NOT NULL,
+        PRIMARY KEY (namespace, name, kind)
+      );
+    `
+  }
+];
+var migrateCore = (sqlite) => {
+  migrate(sqlite, CORE_MIGRATIONS);
+};
+var clearNamespace = (sqlite, namespace) => {
+  sqlite.transaction(() => {
+    sqlite.prepare("DELETE FROM mockingbird_records WHERE namespace = ?").run(namespace);
+    sqlite.prepare("DELETE FROM mockingbird_sequences WHERE namespace = ?").run(namespace);
+  });
+};
+
+// ../../openapi/metadata/dist/types.js
+var EXTENSION_KEYS = {
+  operation: "x-mockingbird",
+  resource: "x-mockingbird-resource",
+  resourceRef: "x-mockingbird-resource-ref",
+  volatile: "x-mockingbird-volatile",
+  scope: "x-mockingbird-scope",
+  unsupported: "x-mockingbird-unsupported",
+  parityHeader: "x-mockingbird-parity-header"
+};
+
+// ../../openapi/metadata/dist/read.js
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var extensionOf = (holder, key) => holder[key];
+var operationMetadata = (operation) => {
+  const raw = extensionOf(operation, EXTENSION_KEYS.operation);
+  const ext = isRecord2(raw) ? raw : {};
+  const supported = ext.supported ?? true;
+  const parity = ext.parity ?? {};
+  return {
+    supported,
+    reason: typeof ext.reason === "string" ? ext.reason : void 0,
+    parity: {
+      enabled: supported && (parity.enabled ?? true),
+      safe: parity.safe ?? true,
+      reason: typeof parity.reason === "string" ? parity.reason : void 0
+    }
+  };
+};
+
+// ../core/dist/service.js
+import { Hono } from "hono";
+var defineOperations = (handlers) => handlers;
+var OperationRegistryError = class extends Error {
+  problems;
+  constructor(problems) {
+    super(`operation registry is inconsistent:
+${problems.map((p) => `  - ${p}`).join("\n")}`);
+    this.problems = problems;
+    this.name = "OperationRegistryError";
+  }
+};
+var verifyOperations = (document2, handlers) => {
+  const problems = [];
+  const operations = listOperations(document2);
+  const seen = /* @__PURE__ */ new Set();
+  for (const operation of operations) {
+    if (seen.has(operation.operationId))
+      problems.push(`duplicate operationId ${operation.operationId}`);
+    seen.add(operation.operationId);
+    const supported = operationMetadata(operation.operation).supported;
+    const handler = handlers[operation.operationId];
+    if (supported && !handler)
+      problems.push(`supported operation ${operation.operationId} has no handler`);
+    if (!supported && handler)
+      problems.push(`operation ${operation.operationId} is marked unsupported but has a handler`);
+  }
+  for (const id of Object.keys(handlers)) {
+    if (!seen.has(id))
+      problems.push(`handler ${id} has no OpenAPI operation`);
+  }
+  return problems;
+};
+var honoPath = (template) => template.replace(/\{([^}]+)\}/g, ":$1");
+var routeOrder = (a, b) => {
+  const sa = a.path.split("/");
+  const sb = b.path.split("/");
+  for (let i = 0; i < Math.max(sa.length, sb.length); i++) {
+    const x = sa[i] ?? "";
+    const y = sb[i] ?? "";
+    const px = x.startsWith("{");
+    const py = y.startsWith("{");
+    if (px !== py)
+      return px ? 1 : -1;
+    if (x !== y)
+      return x < y ? -1 : 1;
+  }
+  return 0;
+};
+var queryOf = (url) => decodeFormPairs(url.searchParams.entries());
+var bootSqlite = (sqlite) => {
+  const client = resolveSqlite(sqlite);
+  migrateCore(client);
+  return client;
+};
+var createService = (options) => {
+  const problems = verifyOperations(options.document, options.handlers);
+  if (problems.length > 0)
+    throw new OperationRegistryError(problems);
+  migrateCore(options.sqlite);
+  const now = options.now ?? (() => Date.now());
+  const app = new Hono();
+  app.notFound((c) => options.notFound(c.req.raw));
+  app.onError((error, c) => options.onError(error, c.req.raw));
+  const operations = [...listOperations(options.document)].sort(routeOrder);
+  for (const operation of operations) {
+    const metadata = operationMetadata(operation.operation);
+    const handler = options.handlers[operation.operationId];
+    const route = async (c) => {
+      const request = c.req.raw;
+      if (!metadata.supported || !handler) {
+        return options.unsupported ? options.unsupported(request, operation) : options.notFound(request);
+      }
+      const url = new URL(request.url);
+      const context = {
+        request,
+        url,
+        params: c.req.param(),
+        query: queryOf(url),
+        body: await readBody(request),
+        sqlite: options.sqlite,
+        namespace: options.namespace,
+        operation,
+        document: options.document,
+        now
+      };
+      const short = await options.before?.(context);
+      if (short)
+        return short;
+      return handler(context);
+    };
+    app.on(operation.method.toUpperCase(), honoPath(operation.path), route);
+  }
+  return {
+    app,
+    sqlite: options.sqlite,
+    namespace: options.namespace,
+    fetch: async (request) => app.fetch(request),
+    reset: async () => {
+      clearNamespace(options.sqlite, options.namespace);
+    }
+  };
+};
+
+// ../core/dist/snapshot.js
+var snapshotNamespace = (sqlite, namespace) => ({
+  namespace,
+  records: sqlite.prepare("SELECT collection, id, seq, value FROM mockingbird_records WHERE namespace = ? ORDER BY collection, seq").all(namespace),
+  sequences: sqlite.prepare("SELECT name, kind, value FROM mockingbird_sequences WHERE namespace = ? ORDER BY name, kind").all(namespace)
+});
+var restoreNamespace = (sqlite, namespace, snapshot) => {
+  sqlite.transaction(() => {
+    sqlite.prepare("DELETE FROM mockingbird_records WHERE namespace = ?").run(namespace);
+    sqlite.prepare("DELETE FROM mockingbird_sequences WHERE namespace = ?").run(namespace);
+    const record = sqlite.prepare("INSERT INTO mockingbird_records (namespace, collection, id, seq, value) VALUES (?, ?, ?, ?, ?)");
+    for (const row of snapshot.records) {
+      record.run(namespace, row.collection, row.id, row.seq, row.value);
+    }
+    const sequence = sqlite.prepare("INSERT INTO mockingbird_sequences (namespace, name, kind, value) VALUES (?, ?, ?, ?)");
+    for (const row of snapshot.sequences) {
+      sequence.run(namespace, row.name, row.kind, row.value);
+    }
+  });
+};
+
+// ../core/dist/version.js
+var PACKAGE_VERSION = true ? "0.1.0" : UNRELEASED_VERSION;
+
+// ../core/dist/signing.js
+var encoder = new TextEncoder();
+var toBase64 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+};
+var fromBase64 = (value) => Uint8Array.from(atob(value), (char) => char.charCodeAt(0));
+var toHex = (bytes) => [...bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+var keyBytes = (key) => typeof key === "string" ? encoder.encode(key) : key;
+var hmac = async (algorithm, key, message, encoding = "hex") => {
+  const imported = await crypto.subtle.importKey("raw", keyBytes(key), { name: "HMAC", hash: algorithm }, false, ["sign"]);
+  const signed = await crypto.subtle.sign("HMAC", imported, typeof message === "string" ? encoder.encode(message) : message);
+  return encoding === "hex" ? toHex(signed) : toBase64(signed);
+};
+var svixSecretBytes = (secret) => {
+  const raw = secret.replace(/^f?whsec_/, "");
+  try {
+    return fromBase64(raw);
+  } catch {
+    throw new TypeError("webhook secret must be whsec_<base64> (as Svix issues it)");
+  }
+};
+var signSvix = async (secret, messageId, timestampSeconds, body) => `v1,${await hmac("SHA-256", svixSecretBytes(secret), `${messageId}.${timestampSeconds}.${body}`, "base64")}`;
+var signTimestamped = async (secret, timestampSeconds, body) => `t=${timestampSeconds},v1=${await hmac("SHA-256", secret, `${timestampSeconds}.${body}`, "hex")}`;
+var signTwilio = async (authToken, url, params) => {
+  const payload = url + Object.keys(params).sort().map((key) => `${key}${params[key]}`).join("");
+  return hmac("SHA-1", authToken, payload, "base64");
+};
+
+// ../core/dist/webhooks.js
+var signers = {
+  /** No signature. */
+  none: () => () => ({}),
+  /** Svix (`svix-id`, `svix-timestamp`, `svix-signature: v1,<b64>`): Junction, Flex, Resend. */
+  svix: (options = {}) => async ({ messageId, body, timestampSeconds, secret }) => {
+    if (!secret)
+      return {};
+    const prefix = options.prefix ?? "svix";
+    return {
+      [`${prefix}-id`]: messageId,
+      [`${prefix}-timestamp`]: String(timestampSeconds),
+      [`${prefix}-signature`]: await signSvix(secret, messageId, timestampSeconds, body)
+    };
+  },
+  /** `<header>: t=<unix>,v1=<hex HMAC-SHA256(secret, "t.body")>`: Stripe, Persona, Fullscript. */
+  timestamped: (header2 = "Stripe-Signature") => async ({ body, timestampSeconds, secret }) => secret ? { [header2]: await signTimestamped(secret, timestampSeconds, body) } : {},
+  /** `X-Twilio-Signature` over the public URL plus the sorted form parameters. */
+  twilio: () => async ({ signUrl, form, secret }) => secret ? { "X-Twilio-Signature": await signTwilio(secret, signUrl, form ?? {}) } : {},
+  /** The secret itself in a header (optionally templated): RxVortex, Pharmetika, AHA `Token <s>`. */
+  header: (header2, format = (s) => s) => ({ secret }) => secret ? { [header2]: format(secret) } : {},
+  /** Anything else: the service computes the headers itself. */
+  custom: (sign) => sign
+};
+var DEFAULT_DELAYS = [0, 5e3, 3e5, 18e5, 72e5];
+var unref = (timer) => {
+  ;
+  timer.unref?.();
+};
+var randomId = (prefix) => `${prefix}${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+var matchesEndpoint = (endpoint, message) => {
+  const events = endpoint.events ?? ["*"];
+  if (!events.includes("*") && !events.includes(message.type))
+    return false;
+  for (const [key, value] of Object.entries(endpoint.tags ?? {})) {
+    if (message.tags[key] !== value)
+      return false;
+  }
+  return true;
+};
+var createWebhookHub = (options) => {
+  const delays = options.retryDelaysMs ?? DEFAULT_DELAYS;
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const delivered = options.delivered ?? ((status) => status >= 200 && status < 300);
+  const send = options.fetch ?? ((request) => fetch(request));
+  const keep = options.keep ?? 500;
+  const now = options.now ?? Date.now;
+  const id = options.id ?? randomId;
+  const scheduleTimer = options.schedule ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+  const cancel = options.cancel ?? ((handle) => clearTimeout(handle));
+  const global = (options.endpoints ?? []).map((e, i) => ({ ...e, id: e.id ?? `we_global_${i}` }));
+  const own = /* @__PURE__ */ new Map();
+  const messages = [];
+  const deliveries = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const payloads = /* @__PURE__ */ new Map();
+  const faults = /* @__PURE__ */ new Map();
+  const held = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Set();
+  const track = (work) => {
+    inFlight.add(work);
+    void work.finally(() => inFlight.delete(work));
+  };
+  const attempt = async (delivery) => {
+    const entry = payloads.get(delivery.id);
+    if (!entry)
+      return false;
+    const { message, endpoint } = entry;
+    const timestampSeconds = Math.floor(now() / 1e3);
+    const started = now();
+    const record = {
+      attempt: delivery.attempts.length + 1,
+      at: new Date(started).toISOString(),
+      status: null,
+      error: null,
+      durationMs: 0,
+      responseBody: null
+    };
+    const controller = new AbortController();
+    const timer = scheduleTimer(() => controller.abort(), timeoutMs);
+    try {
+      const signed = await options.signer({
+        messageId: message.id,
+        body: message.body,
+        timestampSeconds,
+        url: endpoint.url,
+        secret: endpoint.secret,
+        signUrl: endpoint.signUrl ?? endpoint.url,
+        form: message.contentType.startsWith("application/x-www-form-urlencoded") ? Object.fromEntries(new URLSearchParams(message.body)) : void 0,
+        type: message.type,
+        tags: message.tags
+      });
+      const response = await send(new Request(endpoint.url, {
+        method: "POST",
+        headers: {
+          "content-type": message.contentType,
+          ...endpoint.headers,
+          ...message.headers,
+          ...signed
+        },
+        body: message.body,
+        signal: controller.signal
+      }));
+      record.status = response.status;
+      record.responseBody = await response.text();
+    } catch (error) {
+      record.error = controller.signal.aborted ? `timed out after ${timeoutMs}ms` : error instanceof Error ? error.message : String(error);
+    } finally {
+      cancel(timer);
+      record.durationMs = now() - started;
+      delivery.attempts.push(record);
+    }
+    return record.status !== null && delivered(record.status);
+  };
+  const schedule = (delivery) => {
+    const index = delivery.attempts.length;
+    if (index >= delays.length) {
+      delivery.state = "failed";
+      pending.delete(delivery.id);
+      return;
+    }
+    const run = () => {
+      pending.delete(delivery.id);
+      track(attempt(delivery).then((ok) => {
+        if (ok)
+          delivery.state = "delivered";
+        else
+          schedule(delivery);
+      }));
+    };
+    const delay = delays[index] ?? 0;
+    if (delay <= 0) {
+      pending.set(delivery.id, void 0);
+      run();
+      return;
+    }
+    const timer = scheduleTimer(run, delay);
+    unref(timer);
+    pending.set(delivery.id, timer);
+  };
+  const endpointsFor = (namespace) => [...own.get(namespace) ?? [], ...global];
+  const fanOut = (message, state = "pending") => {
+    for (const endpoint of endpointsFor(message.namespace)) {
+      if (!matchesEndpoint(endpoint, message))
+        continue;
+      const delivery = {
+        id: id("dlv_"),
+        messageId: message.id,
+        namespace: message.namespace,
+        type: message.type,
+        endpointId: endpoint.id ?? "we_unknown",
+        url: endpoint.url,
+        state,
+        attempts: []
+      };
+      deliveries.set(delivery.id, delivery);
+      payloads.set(delivery.id, { message, endpoint });
+      if (state === "pending")
+        schedule(delivery);
+    }
+  };
+  const takeFault = (namespace) => {
+    const queue = faults.get(namespace);
+    const head = queue?.[0];
+    if (!queue || !head)
+      return void 0;
+    head.remaining--;
+    if (head.remaining <= 0)
+      queue.shift();
+    return head.mode;
+  };
+  const releaseHeld = (namespace) => {
+    const waiting = held.get(namespace);
+    if (!waiting)
+      return;
+    held.delete(namespace);
+    for (const message of waiting)
+      fanOut(message);
+  };
+  const hub = {
+    publish(input) {
+      const contentType = input.contentType ?? (input.form ? "application/x-www-form-urlencoded" : "application/json");
+      const body = typeof input.body === "string" ? input.body : input.form ? new URLSearchParams(input.form).toString() : JSON.stringify(input.body);
+      const message = {
+        id: input.id ?? id("msg_"),
+        namespace: input.namespace,
+        type: input.type,
+        body,
+        contentType,
+        tags: input.tags ?? {},
+        headers: input.headers ?? {},
+        publishedAt: new Date(now()).toISOString()
+      };
+      messages.push(message);
+      const ofNamespace = messages.filter((m) => m.namespace === message.namespace);
+      const oldest = ofNamespace[0];
+      if (ofNamespace.length > keep && oldest)
+        messages.splice(messages.indexOf(oldest), 1);
+      options.onMessage?.(message);
+      const fault = takeFault(message.namespace);
+      if (fault === "drop") {
+        fanOut(message, "dropped");
+        return message;
+      }
+      if (fault === "reorder") {
+        held.set(message.namespace, [...held.get(message.namespace) ?? [], message]);
+        return message;
+      }
+      fanOut(message);
+      if (fault === "duplicate")
+        fanOut(message);
+      releaseHeld(message.namespace);
+      return message;
+    },
+    setEndpoints(namespace, endpoints) {
+      const withIds = endpoints.map((e, i) => ({ ...e, id: e.id ?? `we_${namespace}_${i}` }));
+      own.set(namespace, withIds);
+      return withIds;
+    },
+    endpoints: endpointsFor,
+    messages: (namespace) => namespace === void 0 ? [...messages] : messages.filter((m) => m.namespace === namespace),
+    deliveries: (namespace) => [...deliveries.values()].filter((d) => namespace === void 0 || d.namespace === namespace),
+    async replay(id2) {
+      const delivery = deliveries.get(id2);
+      if (!delivery)
+        return void 0;
+      const ok = await attempt(delivery);
+      if (ok)
+        delivery.state = "delivered";
+      return delivery;
+    },
+    async flush() {
+      for (const namespace of [...held.keys()])
+        releaseHeld(namespace);
+      const waiting = [...pending.entries()];
+      for (const [id2, timer] of waiting) {
+        if (timer === void 0)
+          continue;
+        cancel(timer);
+        pending.delete(id2);
+        const delivery = deliveries.get(id2);
+        if (!delivery)
+          continue;
+        track(attempt(delivery).then((ok) => {
+          if (ok)
+            delivery.state = "delivered";
+          else
+            schedule(delivery);
+        }));
+      }
+      await hub.idle();
+    },
+    async idle() {
+      while (inFlight.size > 0)
+        await Promise.allSettled([...inFlight]);
+    },
+    fault(namespace, fault) {
+      const queue = faults.get(namespace) ?? [];
+      queue.push({ mode: fault.mode, remaining: Math.max(1, fault.count ?? 1) });
+      faults.set(namespace, queue);
+    },
+    clear(namespace) {
+      for (const [id2, delivery] of deliveries) {
+        if (namespace !== void 0 && delivery.namespace !== namespace)
+          continue;
+        const timer = pending.get(id2);
+        if (timer !== void 0)
+          cancel(timer);
+        pending.delete(id2);
+        deliveries.delete(id2);
+        payloads.delete(id2);
+      }
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (namespace === void 0 || messages[i]?.namespace === namespace)
+          messages.splice(i, 1);
+      }
+      if (namespace === void 0) {
+        held.clear();
+        faults.clear();
+        own.clear();
+      } else {
+        held.delete(namespace);
+        faults.delete(namespace);
+        own.delete(namespace);
+      }
+    }
+  };
+  return hub;
+};
+var json3 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminError2 = (status, message) => json3(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 }) => json3(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 json3(200, {
+      events: hub.messages(url.searchParams.get("all") === "1" ? void 0 : namespace).filter((m) => type === null || m.type === type).map((m) => ({ ...m, payload: parsePayload(m) }))
+    });
+  },
+  "POST /webhooks/:id/replay": async ({ params }) => {
+    const replayed = await hub.replay(params.id);
+    return replayed ? json3(200, replayed) : adminError2(404, `no delivery ${params.id}`);
+  },
+  "POST /webhooks/flush": async () => {
+    await hub.flush();
+    return json3(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 json3(201, { namespace, ...fault });
+  },
+  "GET /webhook-endpoints": ({ namespace }) => json3(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 json3(200, { endpoints: set.map((e) => ({ ...e, secret: e.secret ? "(set)" : null })) });
+  },
+  "DELETE /webhook-endpoints": ({ namespace }) => {
+    hub.setEndpoints(namespace, []);
+    return json3(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 DroppedConnectionError = class extends TypeError {
+  code = "MOCKINGBIRD_DROP";
+  constructor() {
+    super("fetch failed: connection dropped by Mockingbird fault");
+    this.name = "TypeError";
+  }
+};
+var operationMatcher = (document2) => {
+  const matchers = listOperations(document2).map((operation) => ({
+    operationId: operation.operationId,
+    method: operation.method.toUpperCase(),
+    pattern: new RegExp(`^${operation.path.split("/").map((segment) => segment.startsWith("{") ? "[^/]+" : segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("/")}/?$`),
+    params: (operation.path.match(/\{/g) ?? []).length
+  })).sort((a, b) => a.params - b.params);
+  return (request, path) => matchers.find((m) => m.method === request.method && m.pattern.test(path))?.operationId;
+};
+var createRuntime = (options) => {
+  const sqlite = bootSqlite(options.sqlite);
+  const clock = options.clock ?? createClock();
+  const rng = createRng(options.seed ?? 0);
+  const wallNow = options.io?.wallNow ?? Date.now;
+  const monotonicNow = options.io?.monotonicNow ?? (() => performance.now());
+  const sleep = options.io?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const faults = createFaultRegistry(createRng(options.seed ?? 0), sleep);
+  const metrics = createMetrics();
+  const journal = createJournal(options.journalSize ?? DEFAULT_JOURNAL_SIZE);
+  const version = options.version ?? PACKAGE_VERSION;
+  const instances = /* @__PURE__ */ new Map();
+  const publicNamespaces = /* @__PURE__ */ new Set();
+  const branchRngs = /* @__PURE__ */ new Map();
+  const timelines = /* @__PURE__ */ new Map();
+  const branchStorage = /* @__PURE__ */ new Map();
+  const captured = /* @__PURE__ */ new Map();
+  const credentials = createCredentialRegistry();
+  const operationIdFor = options.document ? operationMatcher(options.document) : () => void 0;
+  const storageNamespace = (name) => name === DEFAULT_NAMESPACE ? options.name : `${options.name}:${name}`;
+  const instanceFor = (key, publicNamespace = key, isolatedRng) => {
+    const existing = instances.get(key);
+    if (existing)
+      return existing;
+    if (!NAMESPACE_PATTERN.test(key) || !NAMESPACE_PATTERN.test(publicNamespace)) {
+      throw new RangeError(`namespace must match ${NAMESPACE_PATTERN}: ${JSON.stringify(publicNamespace)}`);
+    }
+    const created = options.create({
+      namespace: storageNamespace(key),
+      publicNamespace,
+      sqlite,
+      clock,
+      rng: isolatedRng ?? rng
+    });
+    instances.set(key, created);
+    publicNamespaces.add(publicNamespace);
+    if (isolatedRng)
+      branchRngs.set(key, isolatedRng);
+    return created;
+  };
+  const instance = (name = DEFAULT_NAMESPACE) => instanceFor(name);
+  const capture = (storage) => {
+    const fresh = snapshotNamespace(sqlite, storageNamespace(storage));
+    const previous = captured.get(storage);
+    const snapshot2 = {
+      namespace: fresh.namespace,
+      records: reuseSorted(fresh.records, previous?.records, (left, right) => left.collection < right.collection ? -1 : left.collection > right.collection ? 1 : left.seq - right.seq, (left, right) => left.id === right.id && left.value === right.value),
+      sequences: reuseSorted(fresh.sequences, previous?.sequences, (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : left.kind < right.kind ? -1 : left.kind > right.kind ? 1 : 0, (left, right) => left.value === right.value)
+    };
+    Object.freeze(snapshot2.records);
+    Object.freeze(snapshot2.sequences);
+    Object.freeze(snapshot2);
+    captured.set(storage, snapshot2);
+    return Object.freeze({
+      snapshot: snapshot2,
+      clock: Object.freeze(clock.state()),
+      rngState: (branchRngs.get(storage) ?? rng).state()
+    });
+  };
+  const timeline = (name = DEFAULT_NAMESPACE) => {
+    let found = timelines.get(name);
+    if (found)
+      return found;
+    instance(name);
+    found = new Timeline({
+      now: clock.now,
+      ...options.maxCheckpoints !== void 0 ? { maxCheckpoints: options.maxCheckpoints } : {}
+    });
+    found.commit(capture(name));
+    timelines.set(name, found);
+    return found;
+  };
+  const physicalBranch = (namespace, branch2) => {
+    if (branch2 === "main")
+      return namespace;
+    const mapKey = `${namespace}\0${branch2}`;
+    const existing = branchStorage.get(mapKey);
+    if (existing)
+      return existing;
+    const key = `branch_${seedFrom(`${options.name}\0${namespace}\0${branch2}`).toString(36)}`;
+    branchStorage.set(mapKey, key);
+    return key;
+  };
+  const ensureBranch = (namespace, branch2, at) => {
+    if (!BRANCH_PATTERN2.test(branch2))
+      throw new RangeError(`branch must match ${BRANCH_PATTERN2}`);
+    const history = timeline(namespace);
+    if (branch2 === "main") {
+      if (at !== void 0) {
+        const point = history.checkout("main", at);
+        restoreNamespace(sqlite, storageNamespace(namespace), point.value.snapshot);
+        captured.set(namespace, point.value.snapshot);
+        rng.setState(point.value.rngState);
+        clock.set(point.value.clock.now);
+        if (point.value.clock.frozen)
+          clock.freeze();
+        else
+          clock.unfreeze();
+      }
+      return namespace;
+    }
+    const storage = physicalBranch(namespace, branch2);
+    if (!history.hasBranch(branch2)) {
+      if (at === void 0)
+        history.commit(capture(namespace));
+      const point = history.fork(branch2, at === void 0 ? {} : { from: at });
+      const branchRng = createRng(options.seed ?? 0);
+      if (point)
+        branchRng.setState(point.value.rngState);
+      instanceFor(storage, namespace, branchRng);
+      if (point)
+        restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+      if (point)
+        captured.set(storage, point.value.snapshot);
+    } else if (at !== void 0 && history.head(branch2)?.id !== at) {
+      const point = history.checkout(branch2, at);
+      if (!instances.has(storage)) {
+        const branchRng = createRng(options.seed ?? 0);
+        branchRng.setState(point.value.rngState);
+        instanceFor(storage, namespace, branchRng);
+      }
+      branchRngs.get(storage)?.setState(point.value.rngState);
+      restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+      captured.set(storage, point.value.snapshot);
+    } else {
+      if (!instances.has(storage)) {
+        const point = history.head(branch2);
+        const branchRng = createRng(options.seed ?? 0);
+        if (point)
+          branchRng.setState(point.value.rngState);
+        instanceFor(storage, namespace, branchRng);
+      }
+    }
+    return storage;
+  };
+  const checkpoint = (namespace = DEFAULT_NAMESPACE, branch2 = "main") => {
+    const storage = ensureBranch(namespace, branch2);
+    return timeline(namespace).commit(capture(storage), { branch: branch2 });
+  };
+  const branch = (name, branchOptions = {}) => {
+    const namespace = branchOptions.namespace ?? DEFAULT_NAMESPACE;
+    ensureBranch(namespace, name, branchOptions.at);
+    const head = timeline(namespace).head(name);
+    if (!head)
+      throw new RangeError(`branch ${name} has no checkpoint`);
+    return head;
+  };
+  const checkout = (checkpointId, checkoutOptions = {}) => {
+    const namespace = checkoutOptions.namespace ?? DEFAULT_NAMESPACE;
+    const branchName = checkoutOptions.branch ?? "main";
+    const history = timeline(namespace);
+    const point = history.checkout(branchName, checkpointId);
+    const storage = ensureBranch(namespace, branchName);
+    restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+    captured.set(storage, point.value.snapshot);
+    clock.set(point.value.clock.now);
+    if (point.value.clock.frozen)
+      clock.freeze();
+    else
+      clock.unfreeze();
+    (branchRngs.get(storage) ?? rng).setState(point.value.rngState);
+  };
+  const reset = async (name = DEFAULT_NAMESPACE) => {
+    if (name === "*") {
+      options.webhooks?.clear();
+      for (const each of instances.values())
+        await each.reset();
+      timelines.clear();
+      branchStorage.clear();
+      branchRngs.clear();
+      captured.clear();
+      return;
+    }
+    options.webhooks?.clear(name);
+    const target = instances.get(name);
+    if (target)
+      await target.reset();
+    else
+      clearNamespace(sqlite, storageNamespace(name));
+    for (const [mapping, storage] of branchStorage) {
+      if (!mapping.startsWith(`${name}\0`))
+        continue;
+      const branchInstance = instances.get(storage);
+      if (branchInstance)
+        await branchInstance.reset();
+      else
+        clearNamespace(sqlite, storageNamespace(storage));
+      branchStorage.delete(mapping);
+      branchRngs.delete(storage);
+      captured.delete(storage);
+    }
+    timelines.delete(name);
+    captured.delete(name);
+  };
+  const snapshot = (name = DEFAULT_NAMESPACE) => {
+    return checkpoint(name, "main").value.snapshot;
+  };
+  const restore = (from, name = DEFAULT_NAMESPACE) => {
+    instance(name);
+    restoreNamespace(sqlite, storageNamespace(name), from);
+    captured.set(name, from);
+    const history = timelines.get(name);
+    if (history)
+      history.commit(capture(name), { branch: "main" });
+    else
+      timeline(name);
+  };
+  const runtime = {
+    name: options.name,
+    sqlite,
+    clock,
+    faults,
+    metrics,
+    journal,
+    rng,
+    credentials,
+    webhooks: options.webhooks,
+    applyPreset: (name, namespace = DEFAULT_NAMESPACE, overrides = {}) => {
+      const preset = options.presets?.[name];
+      if (!preset)
+        throw new RangeError(`no fault preset ${JSON.stringify(name)}`);
+      const added = (preset.rules ?? []).map((rule, index) => faults.add({
+        namespace,
+        ...rule,
+        ...overrides,
+        preset: name,
+        id: `${overrides.id ?? name}${(preset.rules ?? []).length > 1 ? `_${index + 1}` : ""}`
+      }));
+      if (preset.webhook && options.webhooks) {
+        options.webhooks.fault(namespace, {
+          ...preset.webhook,
+          ...overrides.count !== void 0 ? { count: overrides.count } : {}
+        });
+      }
+      return added;
+    },
+    instance,
+    namespaces: () => [...publicNamespaces].sort(),
+    reset,
+    snapshot,
+    restore,
+    checkpoint,
+    branch,
+    checkout,
+    timeline,
+    fetch: async (incoming) => {
+      let request = incoming;
+      const prefixed = PATH_PREFIX.exec(new URL(request.url).pathname);
+      if (prefixed) {
+        const url2 = new URL(request.url);
+        url2.pathname = prefixed[2] ?? "/";
+        const headers = new Headers(request.headers);
+        if (!headers.has(NAMESPACE_HEADER)) {
+          headers.set(NAMESPACE_HEADER, decodeURIComponent(prefixed[1]));
+        }
+        const hasBody = request.method !== "GET" && request.method !== "HEAD";
+        request = new Request(url2, {
+          method: request.method,
+          headers,
+          ...hasBody ? { body: await request.arrayBuffer() } : {},
+          signal: request.signal
+        });
+      }
+      let namespace = control.namespaceOf(request);
+      if (!request.headers.has(NAMESPACE_HEADER) && options.credential) {
+        const credential = options.credential(request);
+        const mapped = credential !== void 0 ? credentials.get(credential) : void 0;
+        if (mapped !== void 0)
+          namespace = mapped;
+      }
+      const selectedBranch = request.headers.get(BRANCH_HEADER) ?? "main";
+      const at = request.headers.get(AT_HEADER) ?? void 0;
+      const stamp = (response2) => {
+        const value = NAMESPACE_PATTERN.test(namespace) ? `${options.name}@${version}; ns=${namespace}` : `${options.name}@${version}`;
+        try {
+          response2.headers.set(MOCKINGBIRD_HEADER, value);
+          return response2;
+        } catch {
+          const copy = new Response(response2.body, response2);
+          copy.headers.set(MOCKINGBIRD_HEADER, value);
+          return copy;
+        }
+      };
+      const handled = await control.handle(request);
+      if (handled)
+        return stamp(handled);
+      const started = monotonicNow();
+      const url = new URL(request.url);
+      const operationId = operationIdFor(request, url.pathname);
+      const log = (status, faultId, response2) => {
+        const noted = response2 ? responseNotes(response2) : void 0;
+        const entry = {
+          service: options.name,
+          namespace,
+          operationId,
+          method: request.method,
+          path: url.pathname,
+          status,
+          durationMs: Math.round((monotonicNow() - started) * 100) / 100,
+          unmatched: options.document !== void 0 && operationId === void 0,
+          ...faultId !== void 0 ? { faultId } : {},
+          ...noted?.ids && Object.keys(noted.ids).length > 0 ? { ids: noted.ids } : {},
+          ...noted?.adopted ? { adopted: true } : {}
+        };
+        metrics.record(entry);
+        journal.record({ ...entry, at: new Date(clock.now()).toISOString() });
+        options.onLog?.(entry);
+      };
+      if (!NAMESPACE_PATTERN.test(namespace)) {
+        log(400);
+        return stamp(new Response(JSON.stringify({
+          error: {
+            type: "mockingbird_admin",
+            message: `${NAMESPACE_HEADER} must match ${NAMESPACE_PATTERN}`
+          }
+        }), { status: 400, headers: { "content-type": "application/json" } }));
+      }
+      if (!BRANCH_PATTERN2.test(selectedBranch)) {
+        log(400);
+        return stamp(adminFail(400, `${BRANCH_HEADER} must match ${BRANCH_PATTERN2}`));
+      }
+      let storage;
+      try {
+        if (at !== void 0 && selectedBranch === "main" && !MUTATING_METHODS.has(request.method)) {
+          const point = timeline(namespace).get(at);
+          storage = physicalBranch(namespace, `at_${at}`);
+          let viewRng = branchRngs.get(storage);
+          if (!viewRng) {
+            viewRng = createRng(options.seed ?? 0);
+            instanceFor(storage, namespace, viewRng);
+          }
+          viewRng.setState(point.value.rngState);
+          restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+          captured.set(storage, point.value.snapshot);
+        } else {
+          storage = ensureBranch(namespace, selectedBranch, at);
+        }
+      } catch (error) {
+        log(409);
+        return stamp(adminFail(409, error instanceof Error ? error.message : String(error)));
+      }
+      const hits = await faults.take({
+        operationId,
+        method: request.method,
+        path: url.pathname,
+        namespace
+      });
+      const final = hits.find((hit) => hit.drop || hit.response);
+      if (final?.drop) {
+        log(0, final.id);
+        throw new DroppedConnectionError();
+      }
+      if (final?.response) {
+        log(final.response.status, final.id);
+        return stamp(final.response);
+      }
+      const fired = hits.filter((hit) => hit.effect !== void 0);
+      if (fired.length > 0)
+        effects.set(request, fired.map((hit) => hit.effect));
+      let response = await instanceFor(storage, namespace).fetch(request);
+      if (MUTATING_METHODS.has(request.method) && response.status >= 200 && response.status < 400) {
+        const point = timeline(namespace).commit(capture(storage), { branch: selectedBranch });
+        response = mutableResponse(response);
+        response.headers.set(CHECKPOINT_HEADER, point.id);
+      }
+      if (selectedBranch !== "main") {
+        response = mutableResponse(response);
+        response.headers.set(BRANCH_HEADER, selectedBranch);
+      }
+      if (at !== void 0) {
+        response = mutableResponse(response);
+        response.headers.set(AT_HEADER, at);
+      }
+      log(response.status, fired[0]?.id, response);
+      return stamp(response);
+    }
+  };
+  const control = createControlPlane({
+    name: options.name,
+    startedAt: wallNow(),
+    wallNow,
+    clock,
+    faults,
+    metrics,
+    journal,
+    defaultNamespace: DEFAULT_NAMESPACE,
+    namespaces: runtime.namespaces,
+    reset,
+    timeTravel: {
+      checkpoint: (name, branchName) => {
+        const point = checkpoint(name, branchName);
+        return {
+          id: point.id,
+          branch: point.branch,
+          parent: point.parent,
+          at: point.at,
+          records: point.value.snapshot.records.length
+        };
+      },
+      branch: (branchName, branchOptions) => {
+        const point = branch(branchName, branchOptions);
+        return { id: point.id, branch: point.branch, parent: point.parent, at: point.at };
+      },
+      checkout: (checkpointId, checkoutOptions) => checkout(checkpointId, checkoutOptions),
+      retain: (name, checkpointId) => {
+        timeline(name).retain(checkpointId);
+      },
+      release: (name, checkpointId) => timeline(name).release(checkpointId),
+      inspect: (name) => {
+        const history = timeline(name);
+        return {
+          branches: history.branches(),
+          checkpoints: history.checkpoints().map(({ id, branch: branchName, parent, at }) => ({
+            id,
+            branch: branchName,
+            parent,
+            at
+          }))
+        };
+      }
+    },
+    describe: options.describe ?? (() => ({})),
+    ...options.presets ? {
+      applyPreset: (name, namespace, overrides) => runtime.applyPreset(name, namespace, overrides)
+    } : {},
+    routes: {
+      ...credentialRoutes(credentials),
+      ...options.presets ? presetRoutes(options.presets, runtime) : {},
+      ...options.webhooks ? webhookAdminRoutes(options.webhooks) : {},
+      ...options.admin?.(runtime) ?? {}
+    },
+    adminKey: options.adminKey
+  });
+  return runtime;
+};
+var mutableResponse = (response) => {
+  try {
+    response.headers.set("x-mockingbird-mutable-probe", "1");
+    response.headers.delete("x-mockingbird-mutable-probe");
+    return response;
+  } catch {
+    return new Response(response.body, response);
+  }
+};
+var adminJson = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminFail = (status, 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) });
+  }
+});
+
+// src/generated/openapi.ts
+var document = JSON.parse(`{"openapi":"3.1.0","info":{"title":"Twilio Verify, Lookup, Messaging and Recordings (Mockingbird subset)","description":"Stateful mock subset of Twilio, served on one port. Each product keeps its own host upstream\\n(api.twilio.com, verify.twilio.com, lookups.twilio.com); the mock routes by that host carried\\nas a path prefix (\`/api/\u2026\`, \`/verify/\u2026\`, \`/lookups/\u2026\`), which is what a custom twilio-node\\n\`httpClient\` produces when it rewrites \`https://<product>.twilio.com/<path>\` to\\n\`{mock}/<product>/<path>\`. Hand-authored from Twilio's published API reference, trimmed to\\nwhat our consumer calls, and checked against live Lookup v2 responses.\\n","version":"2010-04-01","x-mockingbird-upstream":{"note":"Trimmed from Twilio's public API reference (twilio-oai) to the operations our consumer calls (twilio.service.ts, twilio-conversation-sms.adapter.ts, notification-dispatcher channels/sms.ts, twilio-recording-http.adapter.ts); Lookup v2 shapes verified against the live API."}},"servers":[{"url":"https://api.twilio.com","description":"Every product on one origin, routed by the /api, /verify or /lookups prefix."}],"security":[{"basicAuth":[]}],"paths":{"/lookups/v2/PhoneNumbers/{PhoneNumber}":{"parameters":[{"name":"PhoneNumber","in":"path","required":true,"description":"E.164 (\`+12025550123\`) or national format; formatting characters are ignored.","schema":{"type":"string","minLength":1,"maxLength":24,"pattern":"^[+]?[0-9 ()-]{1,20}$","examples":["+12025550123","+13105550142","2025550199","+15550100","+442079460123"]}},{"name":"CountryCode","in":"query","required":false,"description":"ISO-3166 alpha-2 region used to parse a national-format number.","schema":{"type":"string","enum":["US","CA","GB"]}},{"name":"Fields","in":"query","required":false,"description":"Paid data packages (line_type_intelligence, caller_name, \u2026); the mock answers null for every package.","schema":{"type":"string","x-mockingbird-unsupported":{"reason":"Data packages cost money upstream and our consumer never requests them."}}}],"get":{"operationId":"FetchPhoneNumber","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"responses":{"200":{"description":"Lookup result (also for invalid numbers, with \`valid:false\` and \`validation_errors\`)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/PhoneNumber"}}}},"401":{"description":"Bad credentials (code 20003)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}}}}},"/verify/v2/Services/{ServiceSid}/Verifications":{"parameters":[{"$ref":"#/components/parameters/ServiceSid"}],"post":{"operationId":"CreateVerification","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/x-www-form-urlencoded":{"schema":{"type":"object","required":["To","Channel"],"properties":{"To":{"type":"string","description":"E.164 phone number (or an email address for Channel=email).","pattern":"^[+][1-9][0-9]{7,14}$","examples":["+12025550123","+13105550142","+14155550100"]},"Channel":{"type":"string","enum":["sms","call","email","whatsapp","sna","auto"]},"CustomCode":{"type":"string","pattern":"^[0-9]{4,10}$"},"Locale":{"type":"string","maxLength":10}}}}}},"responses":{"201":{"description":"Verification started (or the pending one re-sent)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Verification"}}}},"400":{"description":"Invalid parameter (code 60200)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"401":{"description":"Bad credentials (code 20003)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"404":{"description":"Unknown Verify service (code 20404)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"429":{"description":"Max send attempts reached (code 60203)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}}}}},"/verify/v2/Services/{ServiceSid}/Verifications/{Sid}":{"parameters":[{"$ref":"#/components/parameters/ServiceSid"},{"name":"Sid","in":"path","required":true,"description":"The verification sid (\`VE\u2026\`).","schema":{"type":"string","x-mockingbird-resource-ref":{"type":"verification","missing":"VE00000000000000000000000000000000"}}}],"get":{"operationId":"FetchVerification","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"responses":{"200":{"description":"The verification","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Verification"}}}},"401":{"description":"Bad credentials (code 20003)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"404":{"description":"Unknown or expired verification (code 20404)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}}}},"post":{"operationId":"UpdateVerification","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/x-www-form-urlencoded":{"schema":{"type":"object","required":["Status"],"properties":{"Status":{"type":"string","enum":["canceled","approved"]}}}}}},"responses":{"200":{"description":"The updated verification","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Verification"}}}},"400":{"description":"Invalid parameter (code 60200)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"401":{"description":"Bad credentials (code 20003)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"404":{"description":"Unknown, expired or no longer pending verification (code 20404)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}}}}},"/verify/v2/Services/{ServiceSid}/VerificationCheck":{"parameters":[{"$ref":"#/components/parameters/ServiceSid"}],"post":{"operationId":"CreateVerificationCheck","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/x-www-form-urlencoded":{"schema":{"type":"object","required":["Code"],"properties":{"Code":{"type":"string","pattern":"^[0-9]{4,10}$","examples":["000000","123456"]},"To":{"type":"string","pattern":"^[+][1-9][0-9]{7,14}$","examples":["+12025550123","+13105550142"]},"VerificationSid":{"type":"string","x-mockingbird-resource-ref":{"type":"verification","missing":"VE00000000000000000000000000000000"}}}}}}},"responses":{"200":{"description":"Check result; \`status\` is \`approved\` only for the right code","content":{"application/json":{"schema":{"$ref":"#/components/schemas/VerificationCheck"}}}},"400":{"description":"Invalid parameter (code 60200)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"401":{"description":"Bad credentials (code 20003)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"404":{"description":"No pending verification (missing, approved, canceled or expired; code 20404)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"429":{"description":"Max check attempts reached (code 60202)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}}}}},"/api/2010-04-01/Accounts/{AccountSid}/Messages.json":{"parameters":[{"$ref":"#/components/parameters/AccountSid"}],"post":{"operationId":"CreateMessage","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"requestBody":{"required":true,"content":{"application/x-www-form-urlencoded":{"schema":{"type":"object","required":["To"],"properties":{"To":{"type":"string","pattern":"^[+][1-9][0-9]{7,14}$","examples":["+12025550123","+13105550142"]},"Body":{"type":"string","maxLength":1600},"From":{"type":"string","pattern":"^[+][1-9][0-9]{7,14}$","examples":["+15005550006"]},"MessagingServiceSid":{"type":"string","pattern":"^MG[0-9a-f]{32}$"},"MediaUrl":{"type":"string","format":"uri"},"StatusCallback":{"type":"string","format":"uri"}}}}}},"responses":{"201":{"description":"Message accepted (\`queued\`, or \`accepted\` through a Messaging Service)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Message"}}}},"400":{"description":"Invalid request (21211 bad To, 21602 no Body, 21603 no From, 21604 no To, 21617 too long)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"401":{"description":"Bad credentials (code 20003)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"404":{"description":"Malformed account sid (code 20404)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}}}}},"/api/2010-04-01/Accounts/{AccountSid}/Messages/{Sid}.json":{"parameters":[{"$ref":"#/components/parameters/AccountSid"},{"name":"Sid","in":"path","required":true,"schema":{"type":"string","x-mockingbird-resource-ref":{"type":"message","missing":"SM00000000000000000000000000000000"}}}],"get":{"operationId":"FetchMessage","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"responses":{"200":{"description":"The message","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Message"}}}},"401":{"description":"Bad credentials (code 20003)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"404":{"description":"Unknown message (code 20404)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}}}}},"/api/2010-04-01/Accounts/{AccountSid}/Recordings/{Sid}.wav":{"parameters":[{"$ref":"#/components/parameters/AccountSid"},{"$ref":"#/components/parameters/RecordingSid"},{"name":"RequestedChannels","in":"query","required":false,"description":"2 returns a dual-channel recording as two channels; otherwise it is mixed down to mono.","schema":{"type":"integer","enum":[1,2]}}],"get":{"operationId":"FetchRecordingMedia","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"responses":{"200":{"description":"RIFF WAV (PCM)","content":{"audio/x-wav":{"schema":{"type":"string","format":"binary"}}}},"401":{"description":"Bad credentials (code 20003)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"404":{"description":"Unknown or deleted recording (code 20404)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}}}}},"/api/2010-04-01/Accounts/{AccountSid}/Recordings/{Sid}.json":{"parameters":[{"$ref":"#/components/parameters/AccountSid"},{"$ref":"#/components/parameters/RecordingSid"}],"get":{"operationId":"FetchRecording","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"responses":{"200":{"description":"Recording metadata","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Recording"}}}},"401":{"description":"Bad credentials (code 20003)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"404":{"description":"Unknown or deleted recording (code 20404)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}}}},"delete":{"operationId":"DeleteRecording","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":false}},"responses":{"204":{"description":"Deleted"},"401":{"description":"Bad credentials (code 20003)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}},"404":{"description":"Unknown or already deleted recording (code 20404; our consumer tolerates it)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/Error"}}}}}}}},"components":{"securitySchemes":{"basicAuth":{"type":"http","scheme":"basic","description":"AccountSid (or an SK API key sid) as the username, AuthToken (or key secret) as the password."}},"parameters":{"ServiceSid":{"name":"ServiceSid","in":"path","required":true,"description":"The Verify service sid (\`VA\u2026\`).","schema":{"type":"string","pattern":"^VA[0-9a-f]{32}$","examples":["VA0123456789abcdef0123456789abcdef"]}},"AccountSid":{"name":"AccountSid","in":"path","required":true,"schema":{"type":"string","pattern":"^AC[0-9a-f]{32}$","examples":["AC33333333333333333333333333333333"]}},"RecordingSid":{"name":"Sid","in":"path","required":true,"description":"The recording sid (\`RE\u2026\`).","schema":{"type":"string","x-mockingbird-resource-ref":{"type":"recording","missing":"RE00000000000000000000000000000000"}}}},"schemas":{"Error":{"type":"object","required":["code","message","more_info","status"],"properties":{"code":{"type":"integer"},"message":{"type":"string"},"more_info":{"type":"string"},"status":{"type":"integer"}}},"PhoneNumber":{"type":"object","required":["calling_country_code","country_code","phone_number","national_format","valid","validation_errors","url"],"properties":{"calling_country_code":{"type":["string","null"]},"country_code":{"type":["string","null"]},"phone_number":{"type":"string"},"national_format":{"type":["string","null"]},"valid":{"type":"boolean"},"validation_errors":{"type":"array","items":{"type":"string","enum":["TOO_SHORT","TOO_LONG","INVALID_BUT_POSSIBLE","INVALID_COUNTRY_CODE","INVALID_LENGTH","NOT_A_NUMBER"]}},"caller_name":{"type":["object","null"]},"sim_swap":{"type":["object","null"]},"call_forwarding":{"type":["object","null"]},"line_status":{"type":["object","null"]},"line_type_intelligence":{"type":["object","null"]},"identity_match":{"type":["object","null"]},"reassigned_number":{"type":["object","null"]},"sms_pumping_risk":{"type":["object","null"]},"phone_number_quality_score":{"type":["object","null"]},"pre_fill":{"type":["object","null"]},"url":{"type":"string"}}},"SendCodeAttempt":{"type":"object","required":["attempt_sid","channel","time"],"properties":{"attempt_sid":{"type":"string","x-mockingbird-volatile":{"kind":"id"}},"channel":{"type":"string"},"time":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}}}},"Verification":{"type":"object","required":["sid","service_sid","account_sid","to","channel","status","valid","date_created","date_updated","send_code_attempts","url"],"properties":{"sid":{"type":"string","x-mockingbird-resource":{"type":"verification","identity":true},"x-mockingbird-volatile":{"kind":"id"}},"service_sid":{"type":"string"},"account_sid":{"type":"string"},"to":{"type":"string"},"channel":{"type":"string"},"status":{"type":"string","enum":["pending","approved","canceled","expired"]},"valid":{"type":"boolean"},"lookup":{"type":["object","null"]},"amount":{"type":["string","null"]},"payee":{"type":["string","null"]},"send_code_attempts":{"type":"array","items":{"$ref":"#/components/schemas/SendCodeAttempt"}},"sna":{"type":["object","null"]},"date_created":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}},"date_updated":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}},"url":{"type":"string","x-mockingbird-volatile":{"kind":"url"}}}},"VerificationCheck":{"type":"object","required":["sid","service_sid","account_sid","to","channel","status","valid","date_created","date_updated"],"properties":{"sid":{"type":"string","x-mockingbird-volatile":{"kind":"id"}},"service_sid":{"type":"string"},"account_sid":{"type":"string"},"to":{"type":"string"},"channel":{"type":"string"},"status":{"type":"string","enum":["pending","approved","canceled","expired"]},"valid":{"type":"boolean"},"amount":{"type":["string","null"]},"payee":{"type":["string","null"]},"sna_attempts_error_codes":{"type":"array","items":{"type":"object"}},"date_created":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}},"date_updated":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}}}},"Message":{"type":"object","required":["sid","account_sid","to","from","body","status","direction","num_segments","num_media","api_version","date_created","date_updated","uri"],"properties":{"sid":{"type":"string","x-mockingbird-resource":{"type":"message","identity":true},"x-mockingbird-volatile":{"kind":"id"}},"account_sid":{"type":"string"},"api_version":{"type":"string"},"body":{"type":"string"},"to":{"type":"string"},"from":{"type":["string","null"]},"messaging_service_sid":{"type":["string","null"]},"status":{"type":"string","enum":["queued","accepted","sending","sent","delivered","undelivered","failed","received"]},"direction":{"type":"string"},"num_segments":{"type":"string"},"num_media":{"type":"string"},"price":{"type":["string","null"]},"price_unit":{"type":["string","null"]},"error_code":{"type":["integer","null"]},"error_message":{"type":["string","null"]},"date_created":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}},"date_updated":{"type":"string","x-mockingbird-volatile":{"kind":"timestamp"}},"date_sent":{"type":["string","null"],"x-mockingbird-volatile":{"kind":"timestamp"}},"uri":{"type":"string","x-mockingbird-volatile":{"kind":"url"}},"subresource_uris":{"type":"object","x-mockingbird-volatile":{"kind":"url"}}}},"Recording":{"type":"object","required":["sid","account_sid","call_sid","status","channels","duration","uri","media_url","date_created"],"properties":{"sid":{"type":"string","x-mockingbird-resource":{"type":"recording","identity":true}},"account_sid":{"type":"string"},"api_version":{"type":"string"},"call_sid":{"type":"string"},"status":{"type":"string"},"channels":{"type":"integer"},"duration":{"type":"string"},"source":{"type":"string"},"price":{"type":["string","null"]},"price_unit":{"type":["string","null"]},"error_code":{"type":["integer","null"]},"start_time":{"type":"string"},"date_created":{"type":"string"},"date_updated":{"type":"string"},"uri":{"type":"string"},"media_url":{"type":"string"}}}}}}`);
+var operationIds = ["FetchPhoneNumber", "CreateVerification", "FetchVerification", "UpdateVerification", "CreateVerificationCheck", "CreateMessage", "FetchMessage", "FetchRecordingMedia", "FetchRecording", "DeleteRecording"];
+var supportedOperationIds = ["FetchPhoneNumber", "CreateVerification", "FetchVerification", "UpdateVerification", "CreateVerificationCheck", "CreateMessage", "FetchMessage", "FetchRecordingMedia", "FetchRecording", "DeleteRecording"];
+
+// src/phone.ts
+import {
+  getCountryCallingCode,
+  parsePhoneNumber,
+  validatePhoneNumberLength
+} from "libphonenumber-js/max";
+var LOOKUP_BASE = "https://lookups.twilio.com/v2/PhoneNumbers/";
+var PACKAGES = {
+  caller_name: null,
+  sim_swap: null,
+  call_forwarding: null,
+  line_status: null,
+  line_type_intelligence: null,
+  identity_match: null,
+  reassigned_number: null,
+  sms_pumping_risk: null,
+  phone_number_quality_score: null,
+  pre_fill: null
+};
+var LOCAL_ONLY_LENGTHS = {
+  "1": [7],
+  "44": [4, 5, 6, 8]
+};
+var PUNCTUATION = "-x\u2010-\u2015\u2212\u30FC\uFF0D-\uFF0F \xA0\xAD\u200B\u2060\u3000()\uFF08\uFF09\uFF3B\uFF3D.\\[\\]/~\u2053\u223C\uFF5E";
+var VIABLE = new RegExp(
+  `^(?:[0-9]{2}|\\+*(?:[${PUNCTUATION}*]*[0-9]){3,}[${PUNCTUATION}*]*[A-Za-z0-9]*)$`
+);
+var KEYPAD = {
+  a: "2",
+  b: "2",
+  c: "2",
+  d: "3",
+  e: "3",
+  f: "3",
+  g: "4",
+  h: "4",
+  i: "4",
+  j: "5",
+  k: "5",
+  l: "5",
+  m: "6",
+  n: "6",
+  o: "6",
+  p: "7",
+  q: "7",
+  r: "7",
+  s: "7",
+  t: "8",
+  u: "8",
+  v: "8",
+  w: "9",
+  x: "9",
+  y: "9",
+  z: "9"
+};
+var digitsOf = (value) => value.toLowerCase().replace(/[a-z]/g, (letter) => KEYPAD[letter] ?? "").replace(/[^0-9]/g, "");
+var invalid = (phone, error, nationalFormat = null) => ({
+  calling_country_code: null,
+  country_code: null,
+  phone_number: phone,
+  national_format: nationalFormat,
+  valid: false,
+  validation_errors: [error]
+});
+var callingCodeOf = (country) => {
+  try {
+    return getCountryCallingCode(country ?? "US");
+  } catch {
+    return "1";
+  }
+};
+var lookup = (raw, countryCode) => {
+  const input = raw.trim();
+  const international = input.startsWith("+");
+  const display = displayOf(input, countryCode);
+  if (!VIABLE.test(input)) return invalid(display, "NOT_A_NUMBER");
+  const digits = digitsOf(input);
+  let parsed;
+  try {
+    parsed = international ? parsePhoneNumber(`+${digits}`) : parsePhoneNumber(digits, { defaultCountry: countryCode ?? "US" });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "";
+    if (reason === "INVALID_COUNTRY") return invalid(display, "INVALID_COUNTRY_CODE");
+    if (reason === "TOO_LONG") return invalid(display, "TOO_LONG");
+    if (reason === "TOO_SHORT") return invalid(display, "TOO_SHORT");
+    return invalid(display, "NOT_A_NUMBER");
+  }
+  if (!parsed) return invalid(display, "NOT_A_NUMBER");
+  if (parsed.isValid()) {
+    return {
+      calling_country_code: parsed.countryCallingCode,
+      country_code: parsed.country ?? null,
+      phone_number: parsed.number,
+      national_format: parsed.formatNational(),
+      valid: true,
+      validation_errors: []
+    };
+  }
+  if (!international && countryCode === void 0) return invalid(display, "INVALID_COUNTRY_CODE");
+  const national = parsed.nationalNumber;
+  const echoed = international ? `+${digits}` : `+${parsed.countryCallingCode}${digits}`;
+  return invalid(echoed, possibility(parsed.countryCallingCode, national), national);
+};
+var possibility = (callingCode, national) => {
+  if ((LOCAL_ONLY_LENGTHS[callingCode] ?? []).includes(national.length)) {
+    return "INVALID_BUT_POSSIBLE";
+  }
+  const reason = validatePhoneNumberLength(`+${callingCode}${national}`);
+  if (reason === "TOO_SHORT" || reason === "TOO_LONG" || reason === "INVALID_LENGTH") return reason;
+  return "INVALID_BUT_POSSIBLE";
+};
+var displayOf = (raw, countryCode) => {
+  const input = raw.trim();
+  return input.startsWith("+") ? input : `+${callingCodeOf(countryCode)}${input}`;
+};
+var lookupBody = (result, raw, countryCode) => ({
+  ...PACKAGES,
+  ...result,
+  // Live: the url names the normalized number when valid, else the input as sent.
+  url: `${LOOKUP_BASE}${result.valid ? result.phone_number : encodeURI(displayOf(raw, countryCode))}`
+});
+var e164Key = (value) => `+${value.replace(/[^0-9]/g, "")}`;
+
+// src/state.ts
+var DEFAULT_VERIFY_SETTINGS = {
+  fixedCode: null,
+  ttlSeconds: 600,
+  maxCheckAttempts: 5,
+  maxSendAttempts: 5,
+  sendWindowSeconds: 600
+};
+var mix2 = (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 hexOf = (input, length = 32) => {
+  let out = "";
+  for (let round = 0; out.length < length; round++) {
+    out += mix2(`${input}:${round}`).toString(16).padStart(8, "0");
+  }
+  return out.slice(0, length);
+};
+var digitsOf2 = (input, length = 6) => {
+  let out = "";
+  for (let round = 0; out.length < length; round++) {
+    out += String(mix2(`${input}:${round}`) % 1e9).padStart(9, "0");
+  }
+  return out.slice(0, length);
+};
+var TwilioState = class {
+  constructor(sqlite, namespace, seed = {}) {
+    this.namespace = namespace;
+    this.seed = seed;
+    this.verifications = new Collection(sqlite, namespace, "verifications");
+    this.messages = new Collection(sqlite, namespace, "messages");
+    this.recordings = new Collection(sqlite, namespace, "recordings");
+    this.lookups = new Collection(sqlite, namespace, "lookups");
+    this.settings = new Collection(sqlite, namespace, "settings");
+    this.outbox = new OutboxStore(sqlite, namespace);
+    this.ids = new IdSequence(sqlite, namespace, "twilio");
+  }
+  namespace;
+  seed;
+  verifications;
+  messages;
+  recordings;
+  lookups;
+  settings;
+  outbox;
+  ids;
+  /** A Twilio sid: two-letter prefix plus 32 hex characters, deterministic per history. */
+  sid(prefix) {
+    return `${prefix}${hexOf(`${this.namespace}:${this.ids.next(prefix)}`)}`;
+  }
+  /** A random-looking but reproducible 6-digit code for a new verification. */
+  code(sid, length = 6) {
+    return digitsOf2(`${this.namespace}:code:${sid}`, length);
+  }
+  verify() {
+    return this.settings.get("verify") ?? { ...DEFAULT_VERIFY_SETTINGS, ...this.seed };
+  }
+  updateVerify(patch) {
+    const next = { ...this.verify(), ...patch };
+    if (this.settings.has("verify")) this.settings.update("verify", next);
+    else this.settings.insert("verify", next);
+    return next;
+  }
+  /** Newest first. */
+  verificationsTo(to, serviceSid) {
+    return this.verifications.list({
+      where: (v) => v.to === to && (serviceSid === void 0 || v.serviceSid === serviceSid)
+    }).map((row) => row.value);
+  }
+};
+
+// src/wav.ts
+var ascii = (bytes, offset, length) => String.fromCharCode(...bytes.subarray(offset, offset + length));
+var readWav = (bytes) => {
+  if (bytes.length < 12 || ascii(bytes, 0, 4) !== "RIFF" || ascii(bytes, 8, 4) !== "WAVE") {
+    return void 0;
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let offset = 12;
+  let format;
+  while (offset + 8 <= bytes.length) {
+    const name = ascii(bytes, offset, 4);
+    const size = view.getUint32(offset + 4, true);
+    const start = offset + 8;
+    if (name === "fmt " && size >= 16 && start + 16 <= bytes.length) {
+      format = {
+        audioFormat: view.getUint16(start, true),
+        channels: view.getUint16(start + 2, true),
+        sampleRate: view.getUint32(start + 4, true),
+        bitsPerSample: view.getUint16(start + 14, true)
+      };
+    }
+    if (name === "data" && format) {
+      return { ...format, dataOffset: start, dataLength: Math.min(size, bytes.length - start) };
+    }
+    offset = start + size + size % 2;
+  }
+  return void 0;
+};
+var header = (channels, sampleRate, bits, dataLength) => {
+  const out = new Uint8Array(44);
+  const view = new DataView(out.buffer);
+  const write = (offset, text) => {
+    for (let i = 0; i < text.length; i++) out[offset + i] = text.charCodeAt(i);
+  };
+  const blockAlign = channels * bits / 8;
+  write(0, "RIFF");
+  view.setUint32(4, 36 + dataLength, true);
+  write(8, "WAVE");
+  write(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, channels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * blockAlign, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bits, true);
+  write(36, "data");
+  view.setUint32(40, dataLength, true);
+  return out;
+};
+var synthesizeWav = (options = {}) => {
+  const channels = options.channels ?? 2;
+  const sampleRate = 8e3;
+  const frames = Math.max(1, Math.round(sampleRate * (options.seconds ?? 0.25)));
+  const data = new Uint8Array(frames * channels * 2);
+  const view = new DataView(data.buffer);
+  for (let frame = 0; frame < frames; frame++) {
+    for (let channel = 0; channel < channels; channel++) {
+      const pitch = 440 * (channel + 1);
+      const sample = Math.round(2e3 * Math.sin(2 * Math.PI * pitch * frame / sampleRate));
+      view.setInt16((frame * channels + channel) * 2, sample, true);
+    }
+  }
+  const out = new Uint8Array(44 + data.length);
+  out.set(header(channels, sampleRate, 16, data.length), 0);
+  out.set(data, 44);
+  return out;
+};
+var mixDownToMono = (bytes) => {
+  const format = readWav(bytes);
+  if (!format || format.channels < 2 || format.audioFormat !== 1 || format.bitsPerSample !== 16) {
+    return bytes;
+  }
+  const source = new DataView(bytes.buffer, bytes.byteOffset + format.dataOffset, format.dataLength);
+  const frames = Math.floor(format.dataLength / (2 * format.channels));
+  const data = new Uint8Array(frames * 2);
+  const target = new DataView(data.buffer);
+  for (let frame = 0; frame < frames; frame++) {
+    let sum = 0;
+    for (let channel = 0; channel < format.channels; channel++) {
+      sum += source.getInt16((frame * format.channels + channel) * 2, true);
+    }
+    target.setInt16(frame * 2, Math.round(sum / format.channels), true);
+  }
+  const out = new Uint8Array(44 + data.length);
+  out.set(header(1, format.sampleRate, 16, data.length), 0);
+  out.set(data, 44);
+  return out;
+};
+var durationSeconds = (bytes) => {
+  const format = readWav(bytes);
+  if (!format || format.sampleRate === 0 || format.bitsPerSample === 0) return 0;
+  const bytesPerSecond = format.sampleRate * format.channels * format.bitsPerSample / 8;
+  return Math.round(format.dataLength / bytesPerSecond);
+};
+
+// src/rewrite.ts
+var TWILIO_PRODUCTS = ["api", "verify", "lookups"];
+var TWILIO_HOST = /^(api|verify|lookups)(?:\.[a-z0-9-]+)*\.twilio\.com$/i;
+var twilioMockUrl = (uri, mockBaseUrl) => {
+  const upstream = new URL(uri);
+  const product = TWILIO_HOST.exec(upstream.hostname)?.[1]?.toLowerCase();
+  if (!product) return uri;
+  const base = new URL(mockBaseUrl);
+  const prefix = base.pathname.replace(/\/+$/, "");
+  return `${base.origin}${prefix}/${product}${upstream.pathname}${upstream.search}`;
+};
+var routeByHost = async (request) => {
+  const url = new URL(request.url);
+  const product = TWILIO_HOST.exec(url.hostname)?.[1]?.toLowerCase();
+  if (!product) return request;
+  const ns = /^(\/ns\/[^/]+)(\/.*)?$/.exec(url.pathname);
+  const prefix = ns?.[1] ?? "";
+  const rest = ns ? ns[2] ?? "/" : url.pathname;
+  if (rest === "/health" || rest === "/__admin" || rest.startsWith("/__admin/") || TWILIO_PRODUCTS.some((p) => rest === `/${p}` || rest.startsWith(`/${p}/`))) {
+    return request;
+  }
+  url.pathname = `${prefix}/${product}${rest}`;
+  const hasBody = request.method !== "GET" && request.method !== "HEAD";
+  return new Request(url, {
+    method: request.method,
+    headers: request.headers,
+    ...hasBody ? { body: await request.arrayBuffer() } : {},
+    signal: request.signal
+  });
+};
+
+// src/runtime.ts
+var errorBody = (status, code, message) => ({
+  code,
+  message,
+  more_info: `https://www.twilio.com/docs/errors/${code}`,
+  status
+});
+var TWILIO_PRESETS = {
+  verify_5xx: {
+    description: "Verify start and check answer 500 (20500); the backend surfaces a 400",
+    rules: [
+      {
+        operationId: "CreateVerification",
+        status: 500,
+        body: errorBody(500, 20500, "An internal server error has occurred"),
+        headers: { "x-twilio-error-code": "20500" }
+      },
+      {
+        operationId: "CreateVerificationCheck",
+        status: 500,
+        body: errorBody(500, 20500, "An internal server error has occurred"),
+        headers: { "x-twilio-error-code": "20500" }
+      }
+    ]
+  },
+  sms_socket_drop: {
+    description: "Messages.json drops the connection: an unknown outcome the notification dispatcher must not retry",
+    rules: [{ operationId: "CreateMessage", drop: true }]
+  },
+  sms_4xx: {
+    description: "Messages.json answers 400 21211 (invalid To): a definite failure",
+    rules: [
+      {
+        operationId: "CreateMessage",
+        status: 400,
+        body: errorBody(400, 21211, "Invalid 'To' Phone Number"),
+        headers: { "x-twilio-error-code": "21211" }
+      }
+    ]
+  },
+  lookup_5xx: {
+    description: "Lookup answers 503 (20503); the EMR phone validation fails open",
+    rules: [
+      {
+        operationId: "FetchPhoneNumber",
+        status: 503,
+        body: errorBody(503, 20503, "Service is unavailable. Please try again"),
+        headers: { "x-twilio-error-code": "20503" }
+      }
+    ]
+  },
+  webhook_duplicate: {
+    description: "The next inbound webhook is delivered twice (the app dedupes on MessageSid)",
+    webhook: { mode: "duplicate" }
+  },
+  webhook_drop: {
+    description: "The next inbound webhook is never delivered",
+    webhook: { mode: "drop" }
+  }
+};
+var TWILIO_WEBHOOK_EVENTS = {
+  "sms.inbound": "/messaging/inbound/sms",
+  "voice.twiml": "/admin/messaging/voice/twiml",
+  "voice.disclosure": "/admin/messaging/voice/disclosure",
+  "voice.status": "/admin/messaging/voice/status",
+  "voice.recording": "/admin/messaging/voice/recording"
+};
+var json4 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminError3 = (status, message) => json4(status, { error: { type: "mockingbird_admin", message } });
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var stringsOf = (value) => isRecord4(value) ? Object.fromEntries(
+  Object.entries(value).filter(([, v]) => typeof v === "string" || typeof v === "number").map(([k, v]) => [k, String(v)])
+) : {};
+var RECORDING_SID = /^RE[0-9a-f]{32}$/i;
+var VALIDATION_ERRORS = [
+  "TOO_SHORT",
+  "TOO_LONG",
+  "INVALID_BUT_POSSIBLE",
+  "INVALID_COUNTRY_CODE",
+  "INVALID_LENGTH",
+  "NOT_A_NUMBER"
+];
+var clientIdentity = (seed) => {
+  const hex = hexOf(seed, 32);
+  return `client:${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+};
+var createRuntime2 = (options = {}) => {
+  const app = options.app;
+  const publicBase = (app?.publicBaseUrl ?? app?.url ?? "").replace(/\/+$/, "");
+  const appBase = (app?.url ?? "").replace(/\/+$/, "");
+  const send = options.fetch ?? ((request) => fetch(request));
+  const endpoints = app ? Object.entries(TWILIO_WEBHOOK_EVENTS).map(([event, path]) => ({
+    id: `twilio_${event}`,
+    url: `${appBase}${path}`,
+    signUrl: `${publicBase}${path}`,
+    secret: app.authToken,
+    events: [event]
+  })) : [];
+  const hub = createWebhookHub({
+    signer: signers.twilio(),
+    retryDelaysMs: options.retryDelaysMs ?? [0],
+    endpoints,
+    fetch: send
+  });
+  const runtime = createRuntime({
+    name: TWILIO_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: (request) => basicAuth(request)?.username,
+    presets: TWILIO_PRESETS,
+    webhooks: hub,
+    create: ({ sqlite, namespace, clock }) => new TwilioAPI({
+      sqlite,
+      namespace,
+      now: clock.now,
+      ...options.verify ? { verify: options.verify } : {},
+      ...options.accounts ? { accounts: options.accounts } : {}
+    }),
+    describe: () => ({ webhooks: app ? "on" : "off" }),
+    admin: adminRoutes
+  });
+  const publish = async (namespace, type, params, id) => {
+    const message = hub.publish({
+      namespace,
+      type,
+      body: new URLSearchParams(params).toString(),
+      form: params,
+      id
+    });
+    await hub.idle();
+    const deliveries = hub.deliveries(namespace).filter((d) => d.messageId === message.id).map((d) => {
+      const last = d.attempts.at(-1);
+      return {
+        url: d.url,
+        state: d.state,
+        status: last?.status ?? null,
+        error: last?.error ?? null,
+        response: last?.responseBody ?? null
+      };
+    });
+    return { params, deliveries };
+  };
+  const accountSid = (override) => override ?? app?.accountSid ?? DEFAULT_ACCOUNT_SID;
+  const inboundSms = (input, namespace = "default") => {
+    const instance = runtime.instance(namespace);
+    const media = (input.media ?? []).map((m) => typeof m === "string" ? { url: m } : m);
+    const sid = input.messageSid ?? instance.state.sid(media.length > 0 ? "MM" : "SM");
+    const account = accountSid(input.accountSid);
+    const params = {
+      AccountSid: account,
+      ApiVersion: "2010-04-01",
+      Body: input.body,
+      From: input.from,
+      FromCountry: "US",
+      MessageSid: sid,
+      NumMedia: String(media.length),
+      NumSegments: "1",
+      SmsMessageSid: sid,
+      SmsSid: sid,
+      SmsStatus: "received",
+      To: input.to ?? app?.callerId ?? "",
+      ToCountry: "US",
+      ...app?.messagingServiceSid ? { MessagingServiceSid: app.messagingServiceSid } : {}
+    };
+    media.forEach((item, index) => {
+      params[`MediaUrl${index}`] = item.url;
+      params[`MediaContentType${index}`] = item.contentType ?? "image/jpeg";
+    });
+    Object.assign(params, input.params ?? {});
+    return publish(namespace, "sms.inbound", params, sid);
+  };
+  const voiceWebhook = (kind, overrides = {}, namespace = "default") => {
+    const instance = runtime.instance(namespace);
+    const account = accountSid(overrides.AccountSid);
+    const callSid = overrides.CallSid ?? instance.state.sid("CA");
+    const base = {
+      AccountSid: account,
+      ApiVersion: "2010-04-01",
+      CallSid: callSid
+    };
+    let params;
+    switch (kind) {
+      case "twiml":
+        params = {
+          ...base,
+          CallStatus: "ringing",
+          Direction: "inbound",
+          From: clientIdentity(callSid),
+          To: app?.callerId ?? "",
+          ...overrides
+        };
+        break;
+      case "disclosure":
+        params = { ...base, CallStatus: "in-progress", ...overrides };
+        break;
+      case "status":
+        params = { ...base, CallStatus: "completed", CallDuration: "42", ...overrides };
+        break;
+      case "recording": {
+        const recordingSid = overrides.RecordingSid ?? instance.state.sid("RE");
+        if (!instance.state.recordings.get(recordingSid)) {
+          instance.putRecording(recordingSid, { accountSid: account, callSid });
+        }
+        const recording = instance.state.recordings.get(recordingSid);
+        params = {
+          ...base,
+          RecordingSid: recordingSid,
+          // The canonical form our recording adapter insists on.
+          RecordingUrl: `https://api.twilio.com/2010-04-01/Accounts/${account}/Recordings/${recordingSid}`,
+          RecordingStatus: "completed",
+          RecordingDuration: String(recording?.duration ?? 1),
+          RecordingChannels: String(recording?.channels ?? 2),
+          RecordingSource: "DialVerb",
+          RecordingStartTime: new Date(runtime.clock.now()).toUTCString().replace("GMT", "+0000"),
+          ...overrides
+        };
+        break;
+      }
+    }
+    return publish(namespace, `voice.${kind}`, params, `${callSid}:${kind}:${runtime.clock.now()}`);
+  };
+  const inner = runtime.fetch;
+  return Object.assign(runtime, {
+    webhooks: hub,
+    inboundSms,
+    voiceWebhook,
+    fetch: async (request) => inner(await acceptRawRecording(await routeByHost(request)))
+  });
+};
+var acceptRawRecording = async (request) => {
+  if (request.method !== "PUT") return request;
+  const url = new URL(request.url);
+  if (!/(?:^|\/)__admin\/recordings\/[^/]+$/.test(url.pathname)) return request;
+  const type = request.headers.get("content-type") ?? "";
+  if (type.includes("json")) return request;
+  const bytes = new Uint8Array(await request.arrayBuffer());
+  const headers = new Headers(request.headers);
+  headers.set("content-type", "application/json");
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return new Request(url, {
+    method: "PUT",
+    headers,
+    body: JSON.stringify(bytes.length > 0 ? { wavBase64: btoa(binary) } : {})
+  });
+};
+var adminRoutes = (runtime) => {
+  const twilio = runtime;
+  return {
+    ...outboxAdminRoutes(
+      runtime,
+      (api) => api.state.outbox,
+      (params) => {
+        const kind = params.get("kind");
+        return kind === null ? void 0 : (item) => item.kind === kind;
+      }
+    ),
+    "GET /verify/:e164/latest": ({ params, namespace }) => {
+      const latest = runtime.instance(namespace).latestVerification(params.e164);
+      return latest ? json4(200, latest) : adminError3(404, `no verification to ${params.e164}`);
+    },
+    "GET /verify": ({ namespace }) => json4(200, runtime.instance(namespace).state.verify()),
+    "PUT /verify": ({ body, namespace }) => {
+      if (!isRecord4(body)) return adminError3(400, "expected a JSON object");
+      const patch = {};
+      if (body.fixedCode !== void 0) {
+        if (body.fixedCode !== null && !(typeof body.fixedCode === "string" && /^\d{4,10}$/.test(body.fixedCode))) {
+          return adminError3(400, "fixedCode: 4\u201310 digits, or null for random codes");
+        }
+        patch.fixedCode = body.fixedCode;
+      }
+      for (const key of [
+        "ttlSeconds",
+        "maxCheckAttempts",
+        "maxSendAttempts",
+        "sendWindowSeconds"
+      ]) {
+        if (body[key] === void 0) continue;
+        if (typeof body[key] !== "number" || body[key] < 0) {
+          return adminError3(400, `${key}: a non-negative number`);
+        }
+        patch[key] = body[key];
+      }
+      return json4(200, runtime.instance(namespace).state.updateVerify(patch));
+    },
+    "PUT /lookups/:e164": ({ params, body, namespace }) => {
+      if (!isRecord4(body) || typeof body.valid !== "boolean") {
+        return adminError3(400, 'expected {"valid": boolean, "validationErrors"?: [...]}');
+      }
+      const errors = Array.isArray(body.validationErrors) ? body.validationErrors : [];
+      const bad = errors.find((e) => !VALIDATION_ERRORS.includes(e));
+      if (bad !== void 0) {
+        return adminError3(400, `validationErrors: one of ${VALIDATION_ERRORS.join(", ")}`);
+      }
+      runtime.instance(namespace).setLookup(params.e164, {
+        valid: body.valid,
+        validationErrors: errors
+      });
+      return json4(200, { phoneNumber: params.e164, valid: body.valid, validationErrors: errors });
+    },
+    "DELETE /lookups/:e164": ({ params, namespace }) => {
+      const instance = runtime.instance(namespace);
+      const key = `+${params.e164.replace(/[^0-9]/g, "")}`;
+      return json4(200, { deleted: instance.state.lookups.delete(key) });
+    },
+    "PUT /recordings/:sid": ({ params, body, namespace }) => {
+      const sid = params.sid;
+      if (!RECORDING_SID.test(sid)) return adminError3(400, "sid must look like RE + 32 hex");
+      const input = isRecord4(body) ? body : {};
+      let wav;
+      if (typeof input.wavBase64 === "string") {
+        try {
+          wav = fromBase64(input.wavBase64);
+        } catch {
+          return adminError3(400, "wavBase64 is not base64");
+        }
+        if (!readWav(wav)) return adminError3(400, "the upload is not a RIFF/WAVE file");
+      }
+      const recording = runtime.instance(namespace).putRecording(sid, {
+        ...wav ? { wav } : {},
+        ...typeof input.channels === "number" ? { channels: input.channels } : {},
+        ...typeof input.seconds === "number" ? { seconds: input.seconds } : {},
+        ...typeof input.accountSid === "string" ? { accountSid: input.accountSid } : {},
+        ...typeof input.callSid === "string" ? { callSid: input.callSid } : {}
+      });
+      const { wavBase64: _bytes, ...metadata } = recording;
+      return json4(200, metadata);
+    },
+    "GET /messages": ({ namespace }) => json4(200, { messages: runtime.instance(namespace).messages() }),
+    "POST /inbound/sms": async ({ body, namespace }) => {
+      if (!isRecord4(body) || typeof body.from !== "string" || typeof body.body !== "string") {
+        return adminError3(400, 'expected {"from": "+1\u2026", "body": "\u2026", "to"?, "media"?}');
+      }
+      const media = Array.isArray(body.media) ? body.media.map(
+        (m) => typeof m === "string" ? m : isRecord4(m) && typeof m.url === "string" ? {
+          url: m.url,
+          ...typeof m.contentType === "string" ? { contentType: m.contentType } : {}
+        } : void 0
+      ).filter((m) => m !== void 0) : [];
+      const sent = await twilio.inboundSms(
+        {
+          from: body.from,
+          body: body.body,
+          media,
+          ...typeof body.to === "string" ? { to: body.to } : {},
+          ...typeof body.messageSid === "string" ? { messageSid: body.messageSid } : {},
+          ...typeof body.accountSid === "string" ? { accountSid: body.accountSid } : {},
+          params: stringsOf(body.params)
+        },
+        namespace
+      );
+      return json4(200, sent);
+    },
+    "POST /voice/:kind": async ({ params, body, namespace }) => {
+      const kind = params.kind;
+      if (!["twiml", "disclosure", "status", "recording"].includes(kind)) {
+        return adminError3(404, "kind: twiml, disclosure, status or recording");
+      }
+      return json4(200, await twilio.voiceWebhook(kind, stringsOf(body), namespace));
+    }
+  };
+};
+
+// src/index.ts
+var TWILIO_NAMESPACE = "twilio";
+var DEFAULT_ACCOUNT_SID = "AC00000000000000000000000000000000";
+var twilioError = (status, code, message) => jsonRes(
+  status,
+  { code, message, more_info: `https://www.twilio.com/docs/errors/${code}`, status },
+  { "x-twilio-error-code": String(code) }
+);
+var fail = (status, code, message) => new HttpError(
+  status,
+  { code, message, more_info: `https://www.twilio.com/docs/errors/${code}`, status },
+  { "x-twilio-error-code": String(code) }
+);
+var SID = (prefix) => new RegExp(`^${prefix}[0-9a-f]{32}$`, "i");
+var ACCOUNT_SID = SID("AC");
+var SERVICE_SID = SID("VA");
+var MESSAGING_SERVICE_SID = SID("MG");
+var SUFFIXED = /\/(Messages|Recordings)\/([^/]+?)\.(json|wav)$/;
+var routingDocument = (source) => ({
+  ...source,
+  paths: Object.fromEntries(
+    Object.entries(source.paths ?? {}).map(([path, item]) => [
+      path.replace(/\{Sid\}\.(json|wav)$/, "{Sid}/.$1"),
+      item
+    ])
+  )
+});
+var ROUTING = routingDocument(document);
+var upstreamPath = (pathname) => pathname.replace(/^\/(api|verify|lookups)(?=\/)/, "").replace(/\/\.(json|wav)$/, ".$1");
+var isoSeconds = (ms) => new Date(ms).toISOString().replace(/\.\d{3}Z$/, "Z");
+var rfc2822 = (ms) => new Date(ms).toUTCString().replace("GMT", "+0000");
+var GSM = /^[\n\r\x20-\x7E£¥èéùìòÇØøÅåΔ_ΦΓΛΩΠΨΣΘΞÆæßɤ¡ÄÖÑܧ¿äöñüà€]*$/;
+var segments = (body) => {
+  const length = [...body].length;
+  if (length === 0) return 1;
+  const [single, part] = GSM.test(body) ? [160, 153] : [70, 67];
+  return length <= single ? 1 : Math.ceil(length / part);
+};
+var formOf = (context) => {
+  const value = context.body.kind === "form" || context.body.kind === "json" ? context.body.value : void 0;
+  if (typeof value !== "object" || value === null) return {};
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (typeof item === "string") out[key] = item;
+    else if (Array.isArray(item)) out[key] = item.map(String);
+    else if (item !== void 0 && item !== null) out[key] = String(item);
+  }
+  return out;
+};
+var one = (value) => Array.isArray(value) ? value.at(-1) : value;
+var many = (value) => value === void 0 ? [] : Array.isArray(value) ? value : [value];
+var TwilioAPI = class {
+  app;
+  sqlite;
+  state;
+  service;
+  now;
+  accounts;
+  constructor(options = {}) {
+    const sqlite = bootSqlite(options.sqlite);
+    const namespace = options.namespace ?? TWILIO_NAMESPACE;
+    this.now = options.now ?? (() => Date.now());
+    this.accounts = options.accounts;
+    this.state = new TwilioState(sqlite, namespace, options.verify ?? {});
+    const handlers = defineOperations({
+      FetchPhoneNumber: (context) => this.fetchPhoneNumber(context),
+      CreateVerification: (context) => this.createVerification(context),
+      FetchVerification: (context) => this.fetchVerification(context),
+      UpdateVerification: (context) => this.updateVerification(context),
+      CreateVerificationCheck: (context) => this.createVerificationCheck(context),
+      CreateMessage: (context) => this.createMessage(context),
+      FetchMessage: (context) => this.fetchMessage(context),
+      FetchRecordingMedia: (context) => this.fetchRecordingMedia(context),
+      FetchRecording: (context) => this.fetchRecording(context),
+      DeleteRecording: (context) => this.deleteRecording(context)
+    });
+    this.service = createService({
+      document: ROUTING,
+      handlers,
+      sqlite,
+      namespace,
+      now: this.now,
+      notFound: (request) => twilioError(
+        404,
+        20404,
+        `The requested resource ${upstreamPath(new URL(request.url).pathname)} was 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) {
+    const url = new URL(request.url);
+    const suffixed = SUFFIXED.exec(url.pathname);
+    if (!suffixed) return this.service.fetch(request);
+    url.pathname = url.pathname.replace(SUFFIXED, "/$1/$2/.$3");
+    return this.service.fetch(new Request(url, request));
+  }
+  async reset() {
+    await this.service.reset();
+  }
+  authenticate(context) {
+    const credentials = basicAuth(context.request);
+    if (!credentials?.username || !credentials.password || !/^(AC|SK)/.test(credentials.username)) {
+      return twilioError(401, 20003, "Authenticate");
+    }
+    if (this.accounts !== void 0) {
+      const expected = this.accounts[credentials.username];
+      if (expected === void 0) return twilioError(401, 20003, "Authenticate");
+      if (expected !== credentials.password) {
+        return twilioError(
+          401,
+          20003,
+          `authentication failed, auth token is not valid for account ${credentials.username}`
+        );
+      }
+    }
+    return void 0;
+  }
+  /** The account a request acts for: the path's, else the Basic username when it is one. */
+  accountOf(context) {
+    const fromPath = context.params.AccountSid;
+    if (fromPath) return fromPath;
+    const username = basicAuth(context.request)?.username ?? "";
+    return username.startsWith("AC") ? username : DEFAULT_ACCOUNT_SID;
+  }
+  requireAccount(context) {
+    const account = context.params.AccountSid ?? "";
+    if (!ACCOUNT_SID.test(account)) {
+      throw fail(
+        404,
+        20404,
+        `The requested resource ${upstreamPath(context.url.pathname)} was not found`
+      );
+    }
+    return account;
+  }
+  // ---- Lookup v2 -----------------------------------------------------------------------------
+  /** Lookup validity, with any `PUT /__admin/lookups/:e164` override applied. */
+  resolveLookup(raw, countryCode) {
+    const computed = lookup(raw, countryCode);
+    const override = this.state.lookups.get(computed.phone_number) ?? this.state.lookups.get(e164Key(raw));
+    if (!override) return computed;
+    if (override.valid) return { ...computed, valid: true, validation_errors: [] };
+    return {
+      ...computed,
+      calling_country_code: null,
+      country_code: null,
+      valid: false,
+      validation_errors: override.validationErrors.length > 0 ? override.validationErrors : ["INVALID_BUT_POSSIBLE"]
+    };
+  }
+  fetchPhoneNumber(context) {
+    const raw = context.params.PhoneNumber ?? "";
+    const country = typeof context.query.CountryCode === "string" ? context.query.CountryCode : void 0;
+    const result = this.resolveLookup(raw, country);
+    return jsonRes(200, lookupBody(result, raw, country));
+  }
+  // ---- Verify v2 -----------------------------------------------------------------------------
+  requireService(context) {
+    const sid = context.params.ServiceSid ?? "";
+    if (!SERVICE_SID.test(sid)) {
+      throw fail(
+        404,
+        20404,
+        `The requested resource ${upstreamPath(context.url.pathname)} was not found`
+      );
+    }
+    return sid;
+  }
+  /** The verification as of now: a pending one past its expiry becomes `expired`. */
+  current(verification) {
+    const ttl = this.state.verify().ttlSeconds * 1e3;
+    if (verification.status !== "pending" || this.now() < verification.createdAtMs + ttl) {
+      return verification;
+    }
+    const expired = { ...verification, status: "expired" };
+    this.state.verifications.update(verification.sid, expired);
+    return expired;
+  }
+  verificationBody(v) {
+    return {
+      sid: v.sid,
+      service_sid: v.serviceSid,
+      account_sid: v.accountSid,
+      to: v.to,
+      channel: v.channel,
+      status: v.status,
+      valid: v.status === "approved",
+      lookup: { carrier: null },
+      amount: null,
+      payee: null,
+      send_code_attempts: v.sendAttempts.map((a) => ({
+        attempt_sid: a.attemptSid,
+        channel: a.channel,
+        time: a.time
+      })),
+      sna: null,
+      date_created: v.dateCreated,
+      date_updated: v.dateUpdated,
+      url: `https://verify.twilio.com/v2/Services/${v.serviceSid}/Verifications/${v.sid}`
+    };
+  }
+  /** `To` as Verify accepts it: an email for the email channel, else a valid E.164 number. */
+  verifyRecipient(to, channel) {
+    if (to === void 0 || to.trim() === "") throw fail(400, 60200, "Invalid parameter `To`: ");
+    if (channel === "email") {
+      if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(to)) {
+        throw fail(400, 60200, `Invalid parameter \`To\`: ${to}`);
+      }
+      return to.trim().toLowerCase();
+    }
+    const result = to.trim().startsWith("+") ? this.resolveLookup(to) : void 0;
+    if (!result?.valid) throw fail(400, 60200, `Invalid parameter \`To\`: ${to}`);
+    return result.phone_number;
+  }
+  createVerification(context) {
+    const serviceSid = this.requireService(context);
+    const form = formOf(context);
+    const channel = one(form.Channel);
+    if (!channel || !["sms", "call", "email", "whatsapp", "sna", "auto"].includes(channel)) {
+      throw fail(400, 60200, `Invalid parameter \`Channel\`: ${channel ?? ""}`);
+    }
+    const to = this.verifyRecipient(one(form.To), channel);
+    const customCode = one(form.CustomCode);
+    if (customCode !== void 0 && !/^[0-9]{4,10}$/.test(customCode)) {
+      throw fail(400, 60200, `Invalid parameter \`CustomCode\`: ${customCode}`);
+    }
+    const settings = this.state.verify();
+    const now = this.now();
+    const history = this.state.verificationsTo(to, serviceSid).map((v) => this.current(v));
+    const windowStart = now - settings.sendWindowSeconds * 1e3;
+    const recentSends = history.flatMap((v) => v.sendAttempts).filter((attempt2) => attempt2.timeMs > windowStart).length;
+    if (recentSends >= settings.maxSendAttempts) {
+      throw fail(429, 60203, "Max send attempts reached");
+    }
+    const attempt = {
+      attemptSid: this.state.sid("VL"),
+      channel,
+      time: isoSeconds(now),
+      timeMs: now
+    };
+    const pending = history.find((v) => v.status === "pending");
+    const verification = pending ? {
+      ...pending,
+      channel,
+      sendAttempts: [...pending.sendAttempts, attempt],
+      dateUpdated: isoSeconds(now)
+    } : (() => {
+      const sid = this.state.sid("VE");
+      return {
+        sid,
+        serviceSid,
+        accountSid: this.accountOf(context),
+        to,
+        channel,
+        code: customCode ?? settings.fixedCode ?? this.state.code(sid),
+        status: "pending",
+        attempts: 0,
+        sendAttempts: [attempt],
+        createdAtMs: now,
+        dateCreated: isoSeconds(now),
+        dateUpdated: isoSeconds(now)
+      };
+    })();
+    if (pending) this.state.verifications.update(verification.sid, verification);
+    else this.state.verifications.insert(verification.sid, verification);
+    this.state.outbox.record({
+      id: attempt.attemptSid,
+      kind: "verify",
+      sid: verification.sid,
+      to,
+      from: null,
+      messagingServiceSid: null,
+      body: `Your verification code is: ${verification.code}`,
+      channel,
+      code: verification.code,
+      createdAt: new Date(now).toISOString()
+    });
+    return annotateResponse(jsonRes(201, this.verificationBody(verification)), {
+      ids: { verificationSid: verification.sid }
+    });
+  }
+  findVerification(context, sid) {
+    const serviceSid = this.requireService(context);
+    const found = this.state.verifications.get(sid);
+    const verification = found && found.serviceSid === serviceSid ? this.current(found) : void 0;
+    if (!verification || verification.status === "expired") {
+      throw fail(
+        404,
+        20404,
+        `The requested resource ${upstreamPath(context.url.pathname)} was not found`
+      );
+    }
+    return verification;
+  }
+  fetchVerification(context) {
+    const verification = this.findVerification(context, context.params.Sid ?? "");
+    return annotateResponse(jsonRes(200, this.verificationBody(verification)), {
+      ids: { verificationSid: verification.sid }
+    });
+  }
+  updateVerification(context) {
+    const verification = this.findVerification(context, context.params.Sid ?? "");
+    const status = one(formOf(context).Status);
+    if (status !== "canceled" && status !== "approved") {
+      throw fail(400, 60200, `Invalid parameter \`Status\`: ${status ?? ""}`);
+    }
+    if (verification.status !== "pending") {
+      throw fail(
+        404,
+        20404,
+        `The requested resource ${upstreamPath(context.url.pathname)} was not found`
+      );
+    }
+    const updated = {
+      ...verification,
+      status,
+      dateUpdated: isoSeconds(this.now())
+    };
+    this.state.verifications.update(verification.sid, updated);
+    return annotateResponse(jsonRes(200, this.verificationBody(updated)), {
+      ids: { verificationSid: updated.sid }
+    });
+  }
+  createVerificationCheck(context) {
+    const serviceSid = this.requireService(context);
+    const form = formOf(context);
+    const code = one(form.Code);
+    if (code === void 0 || code === "") throw fail(400, 60200, "Invalid parameter `Code`: ");
+    const verificationSid = one(form.VerificationSid);
+    const to = one(form.To);
+    if (verificationSid === void 0 && to === void 0) {
+      throw fail(400, 60200, "Either a 'To' number or 'VerificationSid' must be specified");
+    }
+    const notFound = () => fail(404, 20404, `The requested resource ${upstreamPath(context.url.pathname)} was not found`);
+    let found;
+    if (verificationSid !== void 0) {
+      const byId = this.state.verifications.get(verificationSid);
+      found = byId && byId.serviceSid === serviceSid ? byId : void 0;
+    } else {
+      const normalized = to?.includes("@") ? to.toLowerCase() : e164Key(to ?? "");
+      found = this.state.verificationsTo(normalized, serviceSid).map((v) => this.current(v)).find((v) => v.status === "pending");
+    }
+    const verification = found ? this.current(found) : void 0;
+    if (verification?.status !== "pending") throw notFound();
+    if (verification.attempts >= this.state.verify().maxCheckAttempts) {
+      throw fail(429, 60202, "Max check attempts reached");
+    }
+    const now = this.now();
+    const approved = code === verification.code;
+    const updated = {
+      ...verification,
+      attempts: verification.attempts + 1,
+      status: approved ? "approved" : "pending",
+      dateUpdated: isoSeconds(now)
+    };
+    this.state.verifications.update(verification.sid, updated);
+    return annotateResponse(
+      jsonRes(200, {
+        sid: updated.sid,
+        service_sid: updated.serviceSid,
+        account_sid: updated.accountSid,
+        to: updated.to,
+        channel: updated.channel,
+        status: updated.status,
+        valid: approved,
+        amount: null,
+        payee: null,
+        sna_attempts_error_codes: [],
+        date_created: updated.dateCreated,
+        date_updated: updated.dateUpdated
+      }),
+      { ids: { verificationSid: updated.sid } }
+    );
+  }
+  // ---- Messaging -----------------------------------------------------------------------------
+  createMessage(context) {
+    const accountSid = this.requireAccount(context);
+    const form = formOf(context);
+    const to = one(form.To);
+    const body = one(form.Body) ?? "";
+    const from = one(form.From);
+    const messagingServiceSid = one(form.MessagingServiceSid);
+    const media = many(form.MediaUrl);
+    if (to === void 0 || to.trim() === "")
+      throw fail(400, 21604, "A 'To' phone number is required.");
+    if (body === "" && media.length === 0) throw fail(400, 21602, "Message body is required.");
+    if (!from && !messagingServiceSid) throw fail(400, 21603, "A 'From' phone number is required.");
+    if (messagingServiceSid !== void 0 && !MESSAGING_SERVICE_SID.test(messagingServiceSid)) {
+      throw fail(400, 21701, `The Messaging Service Sid ${messagingServiceSid} is invalid.`);
+    }
+    if ([...body].length > 1600) {
+      throw fail(400, 21617, "The concatenated message body exceeds the 1600 character limit.");
+    }
+    const recipient = this.resolveLookup(to);
+    if (!recipient.valid) throw fail(400, 21211, `Invalid 'To' Phone Number: ${to}`);
+    const now = this.now();
+    const sid = this.state.sid(media.length > 0 ? "MM" : "SM");
+    const base = `/2010-04-01/Accounts/${accountSid}/Messages/${sid}`;
+    const message = {
+      sid,
+      account_sid: accountSid,
+      api_version: "2010-04-01",
+      body,
+      to: recipient.phone_number,
+      from: from ?? null,
+      messaging_service_sid: messagingServiceSid ?? null,
+      status: messagingServiceSid ? "accepted" : "queued",
+      direction: "outbound-api",
+      num_segments: String(segments(body)),
+      num_media: String(media.length),
+      price: null,
+      price_unit: "USD",
+      error_code: null,
+      error_message: null,
+      date_created: rfc2822(now),
+      date_updated: rfc2822(now),
+      date_sent: null,
+      uri: `${base}.json`,
+      subresource_uris: { media: `${base}/Media.json`, feedback: `${base}/Feedback.json` }
+    };
+    this.state.messages.insert(sid, message);
+    this.state.outbox.record({
+      id: sid,
+      kind: "sms",
+      sid,
+      to: recipient.phone_number,
+      from: from ?? null,
+      messagingServiceSid: messagingServiceSid ?? null,
+      body,
+      channel: "sms",
+      ...media.length > 0 ? { mediaUrls: media } : {},
+      createdAt: new Date(now).toISOString()
+    });
+    return annotateResponse(jsonRes(201, message), { ids: { messageSid: sid } });
+  }
+  fetchMessage(context) {
+    const accountSid = this.requireAccount(context);
+    const message = this.state.messages.get(context.params.Sid ?? "");
+    if (!message || message.account_sid !== accountSid) {
+      throw fail(
+        404,
+        20404,
+        `The requested resource ${upstreamPath(context.url.pathname)} was not found`
+      );
+    }
+    return annotateResponse(jsonRes(200, message), { ids: { messageSid: message.sid } });
+  }
+  // ---- Recordings ----------------------------------------------------------------------------
+  findRecording(context) {
+    this.requireAccount(context);
+    const recording = this.state.recordings.get(context.params.Sid ?? "");
+    if (!recording || recording.deleted) {
+      throw fail(
+        404,
+        20404,
+        `The requested resource ${upstreamPath(context.url.pathname)} was not found`
+      );
+    }
+    return recording;
+  }
+  fetchRecordingMedia(context) {
+    const recording = this.findRecording(context);
+    const bytes = fromBase64(recording.wavBase64);
+    const served = String(context.query.RequestedChannels ?? "") === "2" ? bytes : mixDownToMono(bytes);
+    return annotateResponse(
+      new Response(served, {
+        status: 200,
+        headers: { "content-type": "audio/x-wav", "content-length": String(served.byteLength) }
+      }),
+      { ids: { recordingSid: recording.sid } }
+    );
+  }
+  recordingBody(recording) {
+    const uri = `/2010-04-01/Accounts/${recording.accountSid}/Recordings/${recording.sid}`;
+    return {
+      sid: recording.sid,
+      account_sid: recording.accountSid,
+      api_version: "2010-04-01",
+      call_sid: recording.callSid,
+      conference_sid: null,
+      status: "completed",
+      channels: recording.channels,
+      duration: String(recording.duration),
+      source: "RecordVerb",
+      price: null,
+      price_unit: "USD",
+      error_code: null,
+      encryption_details: null,
+      start_time: recording.createdAt,
+      date_created: recording.createdAt,
+      date_updated: recording.createdAt,
+      uri: `${uri}.json`,
+      media_url: `https://api.twilio.com${uri}`
+    };
+  }
+  fetchRecording(context) {
+    const recording = this.findRecording(context);
+    return annotateResponse(jsonRes(200, this.recordingBody(recording)), {
+      ids: { recordingSid: recording.sid }
+    });
+  }
+  deleteRecording(context) {
+    const recording = this.findRecording(context);
+    this.state.recordings.update(recording.sid, { ...recording, deleted: true, wavBase64: "" });
+    return annotateResponse(new Response(null, { status: 204 }), {
+      ids: { recordingSid: recording.sid }
+    });
+  }
+  // ---- Admin-plane helpers -------------------------------------------------------------------
+  /** The newest verification to a number (what `GET /__admin/verify/:e164/latest` answers). */
+  latestVerification(to) {
+    const key = to.includes("@") ? to.toLowerCase() : e164Key(to);
+    const newest = this.state.verificationsTo(key).at(0);
+    if (!newest) return void 0;
+    const v = this.current(newest);
+    return {
+      sid: v.sid,
+      code: v.code,
+      status: v.status,
+      to: v.to,
+      channel: v.channel,
+      serviceSid: v.serviceSid,
+      attempts: v.attempts,
+      sendAttempts: v.sendAttempts.length,
+      createdAt: v.dateCreated,
+      expiresAt: isoSeconds(v.createdAtMs + this.state.verify().ttlSeconds * 1e3)
+    };
+  }
+  setLookup(e164, override) {
+    this.state.lookups.insert(e164Key(e164), override);
+  }
+  /** Store (or synthesise) a recording so `GET …/Recordings/{sid}.wav` serves it. */
+  putRecording(sid, input = {}) {
+    const wav = input.wav ?? synthesizeWav({ channels: input.channels ?? 2, seconds: input.seconds ?? 1 });
+    const format = readWav(wav);
+    const recording = {
+      sid,
+      accountSid: input.accountSid ?? DEFAULT_ACCOUNT_SID,
+      callSid: input.callSid ?? this.state.sid("CA"),
+      wavBase64: toBase64(wav),
+      channels: format?.channels ?? 0,
+      duration: durationSeconds(wav),
+      createdAt: rfc2822(this.now()),
+      deleted: false
+    };
+    this.state.recordings.insert(sid, recording);
+    return recording;
+  }
+  outbox() {
+    return this.state.outbox.list();
+  }
+  messages() {
+    return this.state.messages.list({ order: "oldest" }).map((row) => row.value);
+  }
+};
+
+export {
+  document,
+  operationIds,
+  supportedOperationIds,
+  lookup,
+  e164Key,
+  DEFAULT_VERIFY_SETTINGS,
+  readWav,
+  synthesizeWav,
+  mixDownToMono,
+  TWILIO_PRODUCTS,
+  twilioMockUrl,
+  TWILIO_PRESETS,
+  TWILIO_WEBHOOK_EVENTS,
+  createRuntime2 as createRuntime,
+  TWILIO_NAMESPACE,
+  DEFAULT_ACCOUNT_SID,
+  twilioError,
+  TwilioAPI
+};
+//# sourceMappingURL=chunk-VOBVFMYN.js.map