@crvouga/mockingbird-service-google-maps 0.1.0

package/dist/chunk-5HEE5U7V.js

@@ -0,0 +1,3393 @@
+// ../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 row2 = this.sqlite.prepare("SELECT value FROM mockingbird_sequences WHERE namespace = ? AND name = ? AND kind = 'collection'").get(this.namespace, this.name);
+    const next = (row2?.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 row2 = this.sqlite.prepare("SELECT value FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").get(this.namespace, this.name, id);
+    if (!row2)
+      return void 0;
+    return JSON.parse(row2.value).value;
+  }
+  has(id) {
+    const row2 = this.sqlite.prepare("SELECT 1 AS ok FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").get(this.namespace, this.name, id);
+    return row2 !== 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 row2 = this.sqlite.prepare("SELECT seq, value FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").get(this.namespace, this.name, id);
+      if (!row2)
+        return void 0;
+      const stored = { seq: row2.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 row2 = this.sqlite.prepare("SELECT COUNT(*) AS n FROM mockingbird_records WHERE namespace = ? AND collection = ?").get(this.namespace, this.name);
+    return Number(row2?.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 row2 of rows) {
+      const stored = JSON.parse(row2.value);
+      if (options.where && !options.where(stored.value, stored.seq))
+        continue;
+      out.push({ id: row2.id, seq: stored.seq, value: stored.value });
+    }
+    out.sort((a, b) => options.order === "oldest" ? a.seq - b.seq : b.seq - a.seq);
+    return out;
+  }
+};
+
+// ../core/dist/control.js
+var HEALTH_PATH = "/health";
+var ADMIN_PREFIX = "/__admin";
+var ADMIN_KEY_HEADER = "x-mockingbird-admin-key";
+var NAMESPACE_HEADER = "x-mockingbird-namespace";
+var json = (status, body) => new Response(JSON.stringify(body), {
+  status,
+  headers: { "content-type": "application/json" }
+});
+var adminError = (status, message) => json(status, { error: { type: "mockingbird_admin", message } });
+var UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+var parseDuration = (value) => {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value !== "string")
+    return void 0;
+  const match = /^(-?\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/.exec(value.trim());
+  if (!match)
+    return void 0;
+  return Number(match[1]) * UNITS[match[2]];
+};
+var parseInstant = (value) => {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value !== "string")
+    return void 0;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+};
+var matchRoute = (pattern, path) => {
+  const want = pattern.split("/").filter(Boolean);
+  const have = path.split("/").filter(Boolean);
+  if (want.length !== have.length)
+    return void 0;
+  const params = {};
+  for (let i = 0; i < want.length; i++) {
+    const segment = want[i];
+    const actual = have[i];
+    if (segment.startsWith(":"))
+      params[segment.slice(1)] = decodeURIComponent(actual);
+    else if (segment !== actual)
+      return void 0;
+  }
+  return params;
+};
+var readJson = async (request) => {
+  const text2 = await request.text();
+  if (text2.trim() === "")
+    return void 0;
+  return JSON.parse(text2);
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var createControlPlane = (context) => {
+  const snapshots = /* @__PURE__ */ new Map();
+  let snapshotCounter = 0;
+  const headerNamespace = (request) => request.headers.get(NAMESPACE_HEADER) ?? context.defaultNamespace;
+  const adminNamespace = (request, url) => url.searchParams.get("namespace") ?? headerNamespace(request);
+  const builtin = {
+    "GET /": () => json(200, {
+      service: context.name,
+      routes: [...Object.keys(builtin), ...Object.keys(context.routes)].sort()
+    }),
+    "POST /reset": async ({ url, namespace }) => {
+      const target = url.searchParams.get("all") === "1" ? "*" : namespace;
+      await context.reset(target);
+      return json(200, { status: "ok", reset: target === "*" ? context.namespaces() : [target] });
+    },
+    "GET /namespaces": () => json(200, { default: context.defaultNamespace, namespaces: context.namespaces() }),
+    "GET /clock": () => json(200, context.clock.state()),
+    "POST /clock": ({ body }) => {
+      if (!isRecord(body))
+        return adminError(400, "expected a JSON object");
+      if (body.reset === true)
+        context.clock.reset();
+      if (body.set !== void 0) {
+        const instant = parseInstant(body.set);
+        if (instant === void 0)
+          return adminError(400, "set: expected epoch ms or ISO-8601");
+        context.clock.set(instant);
+      }
+      if (body.advance !== void 0) {
+        const delta = parseDuration(body.advance);
+        if (delta === void 0)
+          return adminError(400, 'advance: expected ms or "15m"-style');
+        context.clock.advance(delta);
+      }
+      if (body.freeze === true)
+        context.clock.freeze();
+      if (body.freeze === false)
+        context.clock.unfreeze();
+      return json(200, context.clock.state());
+    },
+    "GET /faults": () => json(200, { faults: context.faults.list() }),
+    "POST /faults": ({ body, namespace }) => {
+      if (isRecord(body) && typeof body.preset === "string") {
+        if (!context.applyPreset)
+          return adminError(400, `${context.name} has no fault presets`);
+        const { preset, ...overrides } = body;
+        try {
+          return json(201, {
+            preset,
+            rules: context.applyPreset(preset, namespace, overrides)
+          });
+        } catch (error) {
+          return adminError(404, error instanceof Error ? error.message : String(error));
+        }
+      }
+      if (!isRecord(body) || typeof body.status !== "number" && typeof body.delayMs !== "number" && typeof body.latencyMs !== "number" && body.drop !== true && typeof body.effect !== "string") {
+        return adminError(400, "a fault needs a numeric status, a delayMs/latencyMs, drop: true, an effect, or a preset");
+      }
+      const rule = {
+        // Scoped to the caller's namespace unless it asks for every one, so one worker's
+        // injected failure never lands on another's request.
+        namespace,
+        ...body,
+        id: typeof body.id === "string" ? body.id : `fault_${context.faults.list().length + 1}`
+      };
+      return json(201, context.faults.add(rule));
+    },
+    "DELETE /faults": ({ url }) => {
+      const id = url.searchParams.get("id");
+      if (id === null) {
+        context.faults.clear();
+        return json(200, { status: "ok" });
+      }
+      return context.faults.remove(id) ? json(200, { status: "ok" }) : adminError(404, `no fault ${id}`);
+    },
+    "POST /snapshots": ({ namespace }) => {
+      const point = context.timeTravel.checkpoint(namespace, "main");
+      context.timeTravel.retain(namespace, point.id);
+      snapshotCounter++;
+      const id = `snap_${snapshotCounter}`;
+      snapshots.set(id, { namespace, checkpoint: point.id });
+      return json(201, { id, namespace, records: point.records ?? 0 });
+    },
+    "POST /snapshots/:id/restore": ({ params, namespace }) => {
+      const alias = snapshots.get(params.id);
+      if (!alias)
+        return adminError(404, `no snapshot ${params.id}`);
+      if (alias.namespace !== namespace) {
+        return adminError(409, `snapshot ${params.id} belongs to namespace ${alias.namespace}`);
+      }
+      context.timeTravel.checkout(alias.checkpoint, { namespace, branch: "main" });
+      return json(200, { status: "ok", id: params.id, namespace });
+    },
+    "DELETE /snapshots/:id": ({ params }) => {
+      const id = params.id;
+      const alias = snapshots.get(id);
+      if (!alias)
+        return adminError(404, `no snapshot ${id}`);
+      snapshots.delete(id);
+      context.timeTravel.release(alias.namespace, alias.checkpoint);
+      return json(200, { status: "ok" });
+    },
+    "GET /timeline": ({ namespace }) => json(200, context.timeTravel.inspect(namespace)),
+    "POST /checkpoints": ({ body, namespace }) => {
+      const branch = isRecord(body) && typeof body.branch === "string" ? body.branch : "main";
+      try {
+        return json(201, context.timeTravel.checkpoint(namespace, branch));
+      } catch (error) {
+        return adminError(409, error instanceof Error ? error.message : String(error));
+      }
+    },
+    "POST /branches/:name": ({ params, body, namespace }) => {
+      const at = isRecord(body) && typeof body.at === "string" ? body.at : void 0;
+      try {
+        return json(201, context.timeTravel.branch(params.name, {
+          namespace,
+          ...at !== void 0 ? { at } : {}
+        }));
+      } catch (error) {
+        return adminError(409, error instanceof Error ? error.message : String(error));
+      }
+    },
+    "POST /branches/:name/checkout": ({ params, body, namespace }) => {
+      if (!isRecord(body) || typeof body.checkpoint !== "string") {
+        return adminError(400, 'expected {"checkpoint":"cp_..."}');
+      }
+      try {
+        context.timeTravel.checkout(body.checkpoint, {
+          namespace,
+          branch: params.name
+        });
+        return json(200, { status: "ok", branch: params.name, checkpoint: body.checkpoint });
+      } catch (error) {
+        return adminError(409, error instanceof Error ? error.message : String(error));
+      }
+    },
+    "GET /requests": ({ url, namespace }) => {
+      const status = url.searchParams.get("status");
+      const since = url.searchParams.get("since");
+      const limit = url.searchParams.get("limit");
+      const sinceMs = since === null ? void 0 : parseInstant(/^\d+$/.test(since) ? Number(since) : since);
+      if (since !== null && sinceMs === void 0) {
+        return adminError(400, "since: expected epoch ms or ISO-8601");
+      }
+      if (status !== null && !/^\d{3}$/.test(status))
+        return adminError(400, "status: expected an HTTP status");
+      if (limit !== null && !/^\d+$/.test(limit))
+        return adminError(400, "limit: expected a count");
+      const operationId = url.searchParams.get("operationId");
+      const everyNamespace = url.searchParams.get("all") === "1";
+      return json(200, {
+        size: context.journal.size,
+        requests: context.journal.list({
+          ...everyNamespace ? {} : { namespace },
+          ...operationId !== null ? { operationId } : {},
+          ...status !== null ? { status: Number(status) } : {},
+          ...sinceMs !== void 0 ? { since: sinceMs } : {},
+          ...limit !== null ? { limit: Number(limit) } : {}
+        })
+      });
+    },
+    "DELETE /requests": ({ url, namespace }) => {
+      context.journal.clear(url.searchParams.get("all") === "1" ? void 0 : namespace);
+      return json(200, { status: "ok" });
+    },
+    "GET /metrics": () => json(200, context.metrics.report()),
+    "DELETE /metrics": () => {
+      context.metrics.reset();
+      return json(200, { status: "ok" });
+    }
+  };
+  const routes = [...Object.entries(context.routes), ...Object.entries(builtin)].map(([key, handler]) => {
+    const space = key.indexOf(" ");
+    return { method: key.slice(0, space), pattern: key.slice(space + 1), handler };
+  });
+  return {
+    namespaceOf: headerNamespace,
+    async handle(request) {
+      const url = new URL(request.url);
+      if (url.pathname === HEALTH_PATH && request.method === "GET") {
+        return json(200, {
+          status: "ok",
+          service: context.name,
+          uptimeMs: context.wallNow() - context.startedAt,
+          clock: context.clock.state(),
+          namespaces: context.namespaces().length,
+          ...context.describe()
+        });
+      }
+      if (url.pathname !== ADMIN_PREFIX && !url.pathname.startsWith(`${ADMIN_PREFIX}/`)) {
+        return void 0;
+      }
+      if (context.adminKey !== void 0 && request.headers.get(ADMIN_KEY_HEADER) !== context.adminKey) {
+        return adminError(401, `missing or wrong ${ADMIN_KEY_HEADER}`);
+      }
+      const path = url.pathname.slice(ADMIN_PREFIX.length) || "/";
+      for (const route of routes) {
+        if (route.method !== request.method)
+          continue;
+        const params = matchRoute(route.pattern, path);
+        if (!params)
+          continue;
+        let body;
+        try {
+          body = await readJson(request);
+        } catch {
+          return adminError(400, "request body is not valid JSON");
+        }
+        return route.handler({
+          request,
+          url,
+          params,
+          namespace: adminNamespace(request, url),
+          body
+        });
+      }
+      return adminError(404, `no admin route ${request.method} ${path}; GET ${ADMIN_PREFIX} lists them`);
+    }
+  };
+};
+
+// ../core/dist/credentials.js
+var createCredentialRegistry = () => {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    set: (credential, namespace) => {
+      map.set(credential, namespace);
+    },
+    get: (credential) => map.get(credential),
+    remove: (credential) => map.delete(credential),
+    clear: () => map.clear(),
+    entries: () => [...map].map(([credential, namespace]) => ({ credential, namespace })).sort((a, b) => a.credential.localeCompare(b.credential))
+  };
+};
+var maskCredential = (credential) => credential.length <= 8 ? `${credential.slice(0, 2)}\u2026` : `${credential.slice(0, 6)}\u2026${credential.slice(-2)}`;
+
+// ../core/dist/rng.js
+var seedFrom = (value) => {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var createRng = (seed = 0) => {
+  const numeric = typeof seed === "string" ? seedFrom(seed) : seed >>> 0;
+  let state = numeric;
+  const next = () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+  return {
+    next,
+    int: (min, max) => min + Math.floor(next() * (max - min + 1)),
+    reset: () => {
+      state = numeric;
+    },
+    state: () => state,
+    setState: (next2) => {
+      if (!Number.isSafeInteger(next2) || next2 < 0 || next2 > 4294967295) {
+        throw new RangeError("rng state must be an unsigned 32-bit integer");
+      }
+      state = next2 >>> 0;
+    },
+    seed: numeric
+  };
+};
+
+// ../core/dist/faults.js
+var matches = (rule, candidate) => {
+  if (rule.namespace !== void 0 && rule.namespace !== "*" && rule.namespace !== candidate.namespace) {
+    return false;
+  }
+  if (rule.operationId !== void 0 && rule.operationId !== candidate.operationId)
+    return false;
+  if (rule.method !== void 0 && rule.method.toUpperCase() !== candidate.method.toUpperCase()) {
+    return false;
+  }
+  if (rule.pathPrefix !== void 0 && !candidate.path.startsWith(rule.pathPrefix))
+    return false;
+  return true;
+};
+var faultResponse = (rule) => {
+  const status = rule.status ?? 500;
+  const headers = { "content-type": "application/json", ...rule.headers };
+  if (typeof rule.body === "string")
+    return new Response(rule.body, { status, headers });
+  if (rule.body === null)
+    return new Response(null, { status, headers: rule.headers ?? {} });
+  const body = rule.body === void 0 ? { detail: "Injected by Mockingbird" } : rule.body;
+  return new Response(JSON.stringify(body), { status, headers });
+};
+var createFaultRegistry = (rng = createRng(0), sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) => {
+  const entries = [];
+  return {
+    add(rule) {
+      const existing = entries.findIndex((e) => e.rule.id === rule.id);
+      const entry = { rule, remaining: rule.count ?? null, hits: 0 };
+      if (existing >= 0)
+        entries[existing] = entry;
+      else
+        entries.push(entry);
+      return rule;
+    },
+    list: () => entries.map((e) => ({ ...e.rule, remaining: e.remaining, hits: e.hits })),
+    remove(id) {
+      const index = entries.findIndex((e) => e.rule.id === id);
+      if (index < 0)
+        return false;
+      entries.splice(index, 1);
+      return true;
+    },
+    clear() {
+      entries.length = 0;
+    },
+    async take(candidate) {
+      const hits = [];
+      for (const entry of entries) {
+        if (entry.remaining === 0)
+          continue;
+        if (!matches(entry.rule, candidate))
+          continue;
+        const rate = entry.rule.rate ?? 1;
+        if (rng.next() >= rate)
+          continue;
+        entry.hits++;
+        if (entry.remaining !== null)
+          entry.remaining--;
+        const delay = entry.rule.delayMs ?? entry.rule.latencyMs;
+        if (delay !== void 0 && delay > 0) {
+          await sleep(delay);
+        }
+        const hit = { id: entry.rule.id };
+        if (entry.rule.effect !== void 0) {
+          hit.effect = { name: entry.rule.effect, params: entry.rule.params ?? {} };
+        }
+        if (entry.rule.drop === true)
+          hit.drop = true;
+        else if (entry.rule.status !== void 0)
+          hit.response = faultResponse(entry.rule);
+        hits.push(hit);
+        if (hit.drop || hit.response)
+          break;
+      }
+      return hits;
+    }
+  };
+};
+
+// ../../openapi/core/dist/refs.js
+var OpenAPIReferenceError = class extends Error {
+  ref;
+  constructor(ref) {
+    super(`unresolvable $ref: ${ref}`);
+    this.ref = ref;
+    this.name = "OpenAPIReferenceError";
+  }
+};
+var unescapePointer = (segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~");
+var isReference = (value) => typeof value === "object" && value !== null && typeof value.$ref === "string";
+var resolveRef = (document2, ref) => {
+  if (!ref.startsWith("#/"))
+    throw new OpenAPIReferenceError(ref);
+  let cursor = document2;
+  for (const raw of ref.slice(2).split("/")) {
+    const segment = unescapePointer(raw);
+    if (typeof cursor !== "object" || cursor === null || !(segment in cursor)) {
+      throw new OpenAPIReferenceError(ref);
+    }
+    cursor = cursor[segment];
+  }
+  if (cursor === void 0)
+    throw new OpenAPIReferenceError(ref);
+  return cursor;
+};
+var deref = (document2, value) => {
+  let current = value;
+  const seen = /* @__PURE__ */ new Set();
+  while (isReference(current)) {
+    if (seen.has(current.$ref))
+      throw new OpenAPIReferenceError(`${current.$ref} (cycle)`);
+    seen.add(current.$ref);
+    current = resolveRef(document2, current.$ref);
+  }
+  return current;
+};
+
+// ../../openapi/core/dist/types.js
+var HTTP_METHODS = [
+  "get",
+  "put",
+  "post",
+  "delete",
+  "options",
+  "head",
+  "patch",
+  "trace"
+];
+
+// ../../openapi/core/dist/document.js
+var mergeParameters = (document2, item, own) => {
+  const merged = /* @__PURE__ */ new Map();
+  for (const raw of item.parameters ?? []) {
+    const parameter = deref(document2, raw);
+    merged.set(`${parameter.in}:${parameter.name}`, parameter);
+  }
+  for (const raw of own ?? []) {
+    const parameter = deref(document2, raw);
+    merged.set(`${parameter.in}:${parameter.name}`, parameter);
+  }
+  return [...merged.values()];
+};
+var listOperations = (document2) => {
+  const operations = [];
+  for (const [path, item] of Object.entries(document2.paths)) {
+    for (const method of HTTP_METHODS) {
+      const operation = item[method];
+      if (operation?.operationId === void 0)
+        continue;
+      const responses = {};
+      for (const [status, response] of Object.entries(operation.responses)) {
+        responses[status] = deref(document2, response);
+      }
+      operations.push({
+        operationId: operation.operationId,
+        method,
+        path,
+        operation,
+        parameters: mergeParameters(document2, item, operation.parameters),
+        requestBody: operation.requestBody === void 0 ? void 0 : deref(document2, operation.requestBody),
+        responses
+      });
+    }
+  }
+  return operations;
+};
+
+// ../../http/codec/dist/form.js
+var parsePath = (rawKey) => {
+  const open = rawKey.indexOf("[");
+  if (open === -1)
+    return [rawKey];
+  const path = [rawKey.slice(0, open)];
+  const rest = rawKey.slice(open);
+  const pattern = /\[([^\]]*)\]/g;
+  let match = pattern.exec(rest);
+  let consumed = 0;
+  while (match !== null) {
+    if (match.index !== consumed)
+      return [rawKey];
+    path.push(match[1] ?? "");
+    consumed = match.index + match[0].length;
+    match = pattern.exec(rest);
+  }
+  if (consumed !== rest.length)
+    return [rawKey];
+  return path;
+};
+var isIndex = (segment) => /^(0|[1-9][0-9]*)$/.test(segment);
+var put = (target, key, value) => {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+    return;
+  }
+  ;
+  target[key] = value;
+};
+var assign = (target, path, value) => {
+  let cursor = target;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    const last = i === path.length - 1;
+    if (Array.isArray(cursor)) {
+      const index = segment === "" ? cursor.length : isIndex(segment) ? Number(segment) : void 0;
+      if (index === void 0)
+        return;
+      if (last) {
+        put(cursor, index, value);
+        return;
+      }
+      const next = Object.hasOwn(cursor, index) ? cursor[index] : void 0;
+      if (next === void 0 || typeof next === "string") {
+        const created = path[i + 1] === "" || isIndex(path[i + 1]) ? [] : {};
+        put(cursor, index, created);
+        cursor = created;
+      } else {
+        cursor = next;
+      }
+      continue;
+    }
+    if (typeof cursor === "string")
+      return;
+    if (last) {
+      put(cursor, segment, value);
+      return;
+    }
+    const nextSegment = path[i + 1];
+    const existing = Object.hasOwn(cursor, segment) ? cursor[segment] : void 0;
+    if (existing === void 0 || typeof existing === "string") {
+      const created = nextSegment === "" || isIndex(nextSegment) ? [] : {};
+      put(cursor, segment, created);
+      cursor = created;
+    } else {
+      cursor = existing;
+    }
+  }
+};
+var decodeFormPairs = (pairs) => {
+  const out = {};
+  for (const [rawKey, value] of pairs)
+    assign(out, parsePath(rawKey), value);
+  return densify(out);
+};
+var densify = (value) => {
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value))
+    return value.filter((item) => item !== void 0).map(densify);
+  const out = {};
+  for (const [key, item] of Object.entries(value))
+    put(out, key, densify(item));
+  return out;
+};
+var decodeForm = (text2) => {
+  const source = text2.startsWith("?") ? text2.slice(1) : text2;
+  return decodeFormPairs(new URLSearchParams(source).entries());
+};
+
+// ../../http/codec/dist/content.js
+var JSON_MEDIA_TYPE = "application/json";
+var FORM_MEDIA_TYPE = "application/x-www-form-urlencoded";
+var mediaTypeOf = (contentType) => {
+  if (!contentType)
+    return void 0;
+  const essence = contentType.split(";")[0]?.trim().toLowerCase();
+  return essence ? essence : void 0;
+};
+var isJsonMediaType = (mediaType) => mediaType === JSON_MEDIA_TYPE || mediaType.endsWith("+json") || mediaType === "text/json";
+var utf8 = new TextDecoder("utf-8", { fatal: false });
+var decodeBody = (contentType, bytes) => {
+  if (bytes.byteLength === 0)
+    return { kind: "empty" };
+  const mediaType = mediaTypeOf(contentType);
+  if (mediaType === void 0)
+    return { kind: "bytes", value: bytes };
+  if (isJsonMediaType(mediaType)) {
+    const text2 = utf8.decode(bytes);
+    try {
+      return { kind: "json", value: JSON.parse(text2) };
+    } catch (error) {
+      return {
+        kind: "invalid",
+        mediaType,
+        text: text2,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  if (mediaType === FORM_MEDIA_TYPE) {
+    return { kind: "form", value: decodeForm(utf8.decode(bytes)) };
+  }
+  if (mediaType.startsWith("text/"))
+    return { kind: "text", value: utf8.decode(bytes) };
+  return { kind: "bytes", value: bytes };
+};
+var readBody = async (message) => {
+  const bytes = new Uint8Array(await message.arrayBuffer());
+  return decodeBody(message.headers.get("content-type"), bytes);
+};
+
+// ../core/dist/http.js
+var jsonRes = (status, body, headers = {}) => new Response(JSON.stringify(body), {
+  status,
+  headers: { "content-type": JSON_MEDIA_TYPE, ...headers }
+});
+var HttpError = class extends Error {
+  status;
+  body;
+  headers;
+  constructor(status, body, headers = {}) {
+    super(`HTTP ${status}`);
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+    this.name = "HttpError";
+  }
+  toResponse() {
+    const contentType = this.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+    if (contentType === "text/plain") {
+      return new Response(String(this.body), {
+        status: this.status,
+        headers: this.headers
+      });
+    }
+    return jsonRes(this.status, this.body, this.headers);
+  }
+};
+
+// ../core/dist/ids.js
+var ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+var mix = (input) => {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  hash ^= hash >>> 16;
+  hash = Math.imul(hash, 2246822507) >>> 0;
+  hash ^= hash >>> 13;
+  return hash >>> 0;
+};
+var opaqueToken = (input, length) => {
+  let out = "";
+  let round2 = 0;
+  while (out.length < length) {
+    let hash = mix(`${input}:${round2++}`);
+    for (let i = 0; i < 5 && out.length < length; i++) {
+      out += ALPHABET.charAt(hash % ALPHABET.length);
+      hash = Math.floor(hash / ALPHABET.length);
+    }
+  }
+  return out;
+};
+
+// ../core/dist/journal.js
+var DEFAULT_JOURNAL_SIZE = 1e3;
+var createJournal = (size = DEFAULT_JOURNAL_SIZE) => {
+  const capacity = Math.max(0, Math.floor(size));
+  const rings = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const order = /* @__PURE__ */ new WeakMap();
+  const inOrder = (ring) => ring.entries.length < capacity ? ring.entries : [...ring.entries.slice(ring.next), ...ring.entries.slice(0, ring.next)];
+  return {
+    size: capacity,
+    record(entry) {
+      if (capacity === 0)
+        return;
+      order.set(entry, sequence++);
+      let ring = rings.get(entry.namespace);
+      if (!ring) {
+        ring = { entries: [], next: 0 };
+        rings.set(entry.namespace, ring);
+      }
+      if (ring.entries.length < capacity)
+        ring.entries.push(entry);
+      else {
+        ring.entries[ring.next] = entry;
+        ring.next = (ring.next + 1) % capacity;
+      }
+    },
+    list(query = {}) {
+      const source = query.namespace !== void 0 ? inOrder(rings.get(query.namespace) ?? { entries: [], next: 0 }) : [...rings.values()].flatMap(inOrder).sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+      const matched = source.filter((entry) => (query.operationId === void 0 || entry.operationId === query.operationId) && (query.status === void 0 || entry.status === query.status) && (query.since === void 0 || Date.parse(entry.at) >= query.since));
+      return query.limit !== void 0 ? matched.slice(-Math.max(0, query.limit)) : matched;
+    },
+    clear(namespace) {
+      if (namespace === void 0)
+        rings.clear();
+      else
+        rings.delete(namespace);
+    }
+  };
+};
+var notes = /* @__PURE__ */ new WeakMap();
+var annotateResponse = (response, extra) => {
+  const existing = notes.get(response);
+  notes.set(response, {
+    ...existing,
+    ...extra,
+    ...existing?.ids || extra.ids ? { ids: { ...existing?.ids, ...extra.ids } } : {}
+  });
+  return response;
+};
+var responseNotes = (response) => notes.get(response);
+
+// ../core/dist/metrics.js
+var createMetrics = () => {
+  let requests = 0;
+  let faults = 0;
+  let totalDurationMs = 0;
+  const byOperation = /* @__PURE__ */ new Map();
+  const unmatched = /* @__PURE__ */ new Map();
+  return {
+    record(entry) {
+      requests++;
+      totalDurationMs += entry.durationMs;
+      if (entry.faultId !== void 0)
+        faults++;
+      const key = `${entry.operationId ?? "(unmatched)"} ${entry.status}`;
+      byOperation.set(key, (byOperation.get(key) ?? 0) + 1);
+      if (entry.unmatched) {
+        const route = `${entry.method} ${entry.path}`;
+        unmatched.set(route, (unmatched.get(route) ?? 0) + 1);
+      }
+    },
+    report: () => ({
+      requests,
+      byOperation: Object.fromEntries([...byOperation].sort(([a], [b]) => a.localeCompare(b))),
+      unmatched: [...unmatched].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([route, count]) => {
+        const space = route.indexOf(" ");
+        return { method: route.slice(0, space), path: route.slice(space + 1), count };
+      }),
+      faults,
+      totalDurationMs
+    }),
+    reset() {
+      requests = 0;
+      faults = 0;
+      totalDurationMs = 0;
+      byOperation.clear();
+      unmatched.clear();
+    }
+  };
+};
+
+// ../../core/dist/timeline.js
+var BRANCH_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
+var Timeline = class {
+  maxCheckpoints;
+  now;
+  makeId;
+  nodes = /* @__PURE__ */ new Map();
+  heads = /* @__PURE__ */ new Map();
+  /** Unreferenced nodes in the exact order they became collectible. */
+  evictable = /* @__PURE__ */ new Set();
+  /** Branch heads plus explicit retainers. Absent means zero. */
+  references = /* @__PURE__ */ new Map();
+  explicitPins = /* @__PURE__ */ new Map();
+  sequence = 0;
+  constructor(options = {}) {
+    const max = options.maxCheckpoints ?? 1e3;
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("maxCheckpoints must be a positive integer");
+    this.maxCheckpoints = max;
+    this.now = options.now ?? (() => this.sequence);
+    this.makeId = options.id ?? ((sequence) => `cp_${sequence.toString(36).padStart(8, "0")}`);
+  }
+  /** Capture a new immutable value and move `branch` to it. */
+  commit(value, options = {}) {
+    const branch = options.branch ?? "main";
+    this.assertBranch(branch);
+    const parent = options.parent === void 0 ? this.heads.get(branch) ?? null : options.parent;
+    if (parent !== null && !this.nodes.has(parent))
+      throw new RangeError(`no checkpoint ${parent}`);
+    const id = this.makeId(++this.sequence);
+    if (this.nodes.has(id))
+      throw new RangeError(`duplicate checkpoint id ${id}`);
+    const checkpoint = Object.freeze({ id, branch, parent, at: this.now(), value });
+    this.nodes.set(id, checkpoint);
+    this.moveHead(branch, id);
+    this.collect(this.maxCheckpoints);
+    return checkpoint;
+  }
+  /** Create a branch pointer without copying its checkpoint value. */
+  fork(branch, options = {}) {
+    this.assertBranch(branch);
+    if (this.heads.has(branch))
+      throw new RangeError(`branch already exists: ${branch}`);
+    const from = options.from ?? this.heads.get("main");
+    if (from === void 0)
+      return void 0;
+    const checkpoint = this.get(from);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  /** Move a branch pointer to an existing checkpoint. */
+  checkout(branch, id) {
+    this.assertBranch(branch);
+    const checkpoint = this.get(id);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  get(id) {
+    const checkpoint = this.nodes.get(id);
+    if (!checkpoint)
+      throw new RangeError(`no checkpoint ${id}`);
+    return checkpoint;
+  }
+  head(branch = "main") {
+    const id = this.heads.get(branch);
+    return id === void 0 ? void 0 : this.get(id);
+  }
+  hasBranch(branch) {
+    return this.heads.has(branch);
+  }
+  branches() {
+    return Object.freeze(Object.fromEntries([...this.heads].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)));
+  }
+  checkpoints() {
+    return [...this.nodes.values()];
+  }
+  /** Number of retained checkpoints without allocating an array. */
+  get size() {
+    return this.nodes.size;
+  }
+  /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
+  retain(id) {
+    const checkpoint = this.get(id);
+    this.explicitPins.set(id, (this.explicitPins.get(id) ?? 0) + 1);
+    this.addReference(id);
+    return checkpoint;
+  }
+  /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
+  release(id) {
+    if (!this.nodes.has(id))
+      return false;
+    const pins = this.explicitPins.get(id) ?? 0;
+    if (pins === 0)
+      return false;
+    if (pins === 1)
+      this.explicitPins.delete(id);
+    else
+      this.explicitPins.set(id, pins - 1);
+    this.removeReference(id);
+    this.collect(this.maxCheckpoints);
+    return true;
+  }
+  deleteBranch(branch) {
+    if (branch === "main")
+      throw new RangeError("cannot delete main branch");
+    const previous = this.heads.get(branch);
+    const deleted = this.heads.delete(branch);
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.collect(this.maxCheckpoints);
+    return deleted;
+  }
+  /**
+   * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
+   * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
+   * storage dependency, so a retained node remains usable after pruning.
+   */
+  gc(max = this.maxCheckpoints) {
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("max must be a positive integer");
+    const removed = [];
+    this.collect(max, removed);
+    return removed;
+  }
+  collect(max, removed) {
+    while (this.nodes.size > max && this.evictable.size > 0) {
+      const id = this.evictable.values().next().value;
+      this.evictable.delete(id);
+      this.nodes.delete(id);
+      removed?.push(id);
+    }
+  }
+  moveHead(branch, id) {
+    const previous = this.heads.get(branch);
+    if (previous === id)
+      return;
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.heads.set(branch, id);
+    this.addReference(id);
+  }
+  addReference(id) {
+    this.references.set(id, (this.references.get(id) ?? 0) + 1);
+    this.evictable.delete(id);
+  }
+  removeReference(id) {
+    const next = (this.references.get(id) ?? 0) - 1;
+    if (next > 0)
+      this.references.set(id, next);
+    else {
+      this.references.delete(id);
+      if (this.nodes.has(id))
+        this.evictable.add(id);
+    }
+  }
+  assertBranch(branch) {
+    if (!BRANCH_PATTERN.test(branch))
+      throw new RangeError(`branch must match ${BRANCH_PATTERN}`);
+  }
+};
+
+// ../../sqlite/dist/default.js
+import { Database } from "@crvouga/mockingbird-service-sqlite";
+var createDefaultSqlite = () => new Database();
+var resolveSqlite = (sqlite) => sqlite ?? createDefaultSqlite();
+
+// ../../sqlite/dist/migrate.js
+var ensureMigrationsTable = (sqlite) => {
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      id TEXT PRIMARY KEY NOT NULL,
+      applied_at INTEGER NOT NULL
+    )
+  `);
+};
+var migrate = (sqlite, migrations) => {
+  ensureMigrationsTable(sqlite);
+  const applied = new Set(sqlite.prepare("SELECT id FROM schema_migrations").all().map((row2) => row2.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 row2 of snapshot.records) {
+      record.run(namespace, row2.collection, row2.id, row2.seq, row2.value);
+    }
+    const sequence = sqlite.prepare("INSERT INTO mockingbird_sequences (namespace, name, kind, value) VALUES (?, ?, ?, ?)");
+    for (const row2 of snapshot.sequences) {
+      sequence.run(namespace, row2.name, row2.kind, row2.value);
+    }
+  });
+};
+
+// ../core/dist/version.js
+var PACKAGE_VERSION = true ? "0.1.0" : UNRELEASED_VERSION;
+
+// ../core/dist/signing.js
+var encoder = new TextEncoder();
+var toBase64 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+};
+var fromBase64 = (value) => Uint8Array.from(atob(value), (char) => char.charCodeAt(0));
+
+// ../core/dist/webhooks.js
+var json2 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminError2 = (status, message) => json2(status, { error: { type: "mockingbird_admin", message } });
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseEndpoint = (value) => {
+  if (!isRecord3(value) || typeof value.url !== "string")
+    return "each endpoint needs a url";
+  try {
+    new URL(value.url);
+  } catch {
+    return `not a URL: ${value.url}`;
+  }
+  const endpoint = { url: value.url };
+  if (typeof value.id === "string")
+    endpoint.id = value.id;
+  if (typeof value.secret === "string")
+    endpoint.secret = value.secret;
+  if (typeof value.signUrl === "string")
+    endpoint.signUrl = value.signUrl;
+  const events = value.events ?? value.enabledEvents;
+  if (Array.isArray(events))
+    endpoint.events = events.map(String);
+  if (isRecord3(value.tags)) {
+    endpoint.tags = Object.fromEntries(Object.entries(value.tags).map(([k, v]) => [k, String(v)]));
+  }
+  if (typeof value.account === "string")
+    endpoint.tags = { ...endpoint.tags, account: value.account };
+  if (isRecord3(value.headers)) {
+    endpoint.headers = Object.fromEntries(Object.entries(value.headers).map(([k, v]) => [k, String(v)]));
+  }
+  return endpoint;
+};
+var webhookAdminRoutes = (hub) => ({
+  "GET /webhooks": ({ url, namespace }) => json2(200, {
+    deliveries: hub.deliveries(url.searchParams.get("all") === "1" ? void 0 : namespace).filter((d) => {
+      const type = url.searchParams.get("type");
+      return type === null || d.type === type;
+    })
+  }),
+  "GET /webhooks/events": ({ url, namespace }) => {
+    const type = url.searchParams.get("type");
+    return json2(200, {
+      events: hub.messages(url.searchParams.get("all") === "1" ? void 0 : namespace).filter((m) => type === null || m.type === type).map((m) => ({ ...m, payload: parsePayload(m) }))
+    });
+  },
+  "POST /webhooks/:id/replay": async ({ params }) => {
+    const replayed = await hub.replay(params.id);
+    return replayed ? json2(200, replayed) : adminError2(404, `no delivery ${params.id}`);
+  },
+  "POST /webhooks/flush": async () => {
+    await hub.flush();
+    return json2(200, { status: "ok" });
+  },
+  "POST /webhooks/faults": ({ body, namespace }) => {
+    if (!isRecord3(body) || !["duplicate", "reorder", "drop"].includes(String(body.mode))) {
+      return adminError2(400, "mode must be duplicate, reorder or drop");
+    }
+    const fault = { mode: body.mode };
+    if (typeof body.count === "number")
+      fault.count = body.count;
+    hub.fault(namespace, fault);
+    return json2(201, { namespace, ...fault });
+  },
+  "GET /webhook-endpoints": ({ namespace }) => json2(200, {
+    endpoints: hub.endpoints(namespace).map(({ secret, ...rest }) => ({
+      ...rest,
+      secret: secret ? "(set)" : null
+    }))
+  }),
+  "PUT /webhook-endpoints": ({ body, namespace }) => {
+    const list = Array.isArray(body) ? body : isRecord3(body) ? body.endpoints : void 0;
+    if (!Array.isArray(list))
+      return adminError2(400, "expected [{url, secret?, events?}]");
+    const parsed = [];
+    for (const each of list) {
+      const endpoint = parseEndpoint(each);
+      if (typeof endpoint === "string")
+        return adminError2(400, endpoint);
+      parsed.push(endpoint);
+    }
+    const set = hub.setEndpoints(namespace, parsed);
+    return json2(200, { endpoints: set.map((e) => ({ ...e, secret: e.secret ? "(set)" : null })) });
+  },
+  "DELETE /webhook-endpoints": ({ namespace }) => {
+    hub.setEndpoints(namespace, []);
+    return json2(200, { status: "ok" });
+  }
+});
+var parsePayload = (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((row2) => Object.freeze(row2));
+  const result = new Array(fresh.length);
+  let unchanged = fresh.length === previous.length;
+  let oldIndex = 0;
+  for (let index = 0; index < fresh.length; index++) {
+    const row2 = fresh[index];
+    while (oldIndex < previous.length && compare(previous[oldIndex], row2) < 0) {
+      oldIndex++;
+    }
+    const old = previous[oldIndex];
+    result[index] = old !== void 0 && compare(old, row2) === 0 && equal(old, row2) ? old : Object.freeze(row2);
+    if (result[index] !== previous[index])
+      unchanged = false;
+  }
+  return unchanged ? previous : result;
+};
+var faultEffects = (request) => (effects.get(request) ?? []).filter((e) => e !== void 0);
+var faultEffect = (request, name) => faultEffects(request).find((e) => e.name === name)?.params;
+var DroppedConnectionError = class extends TypeError {
+  code = "MOCKINGBIRD_DROP";
+  constructor() {
+    super("fetch failed: connection dropped by Mockingbird fault");
+    this.name = "TypeError";
+  }
+};
+var operationMatcher = (document2) => {
+  const matchers = listOperations(document2).map((operation) => ({
+    operationId: operation.operationId,
+    method: operation.method.toUpperCase(),
+    pattern: new RegExp(`^${operation.path.split("/").map((segment) => segment.startsWith("{") ? "[^/]+" : segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("/")}/?$`),
+    params: (operation.path.match(/\{/g) ?? []).length
+  })).sort((a, b) => a.params - b.params);
+  return (request, path) => matchers.find((m) => m.method === request.method && m.pattern.test(path))?.operationId;
+};
+var createRuntime = (options) => {
+  const sqlite = bootSqlite(options.sqlite);
+  const clock = options.clock ?? createClock();
+  const rng = createRng(options.seed ?? 0);
+  const wallNow = options.io?.wallNow ?? Date.now;
+  const monotonicNow = options.io?.monotonicNow ?? (() => performance.now());
+  const sleep = options.io?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const faults = createFaultRegistry(createRng(options.seed ?? 0), sleep);
+  const metrics = createMetrics();
+  const journal = createJournal(options.journalSize ?? DEFAULT_JOURNAL_SIZE);
+  const version = options.version ?? PACKAGE_VERSION;
+  const instances = /* @__PURE__ */ new Map();
+  const publicNamespaces = /* @__PURE__ */ new Set();
+  const branchRngs = /* @__PURE__ */ new Map();
+  const timelines = /* @__PURE__ */ new Map();
+  const branchStorage = /* @__PURE__ */ new Map();
+  const captured = /* @__PURE__ */ new Map();
+  const credentials = createCredentialRegistry();
+  const operationIdFor = options.document ? operationMatcher(options.document) : () => void 0;
+  const storageNamespace = (name) => name === DEFAULT_NAMESPACE ? options.name : `${options.name}:${name}`;
+  const instanceFor = (key, publicNamespace = key, isolatedRng) => {
+    const existing = instances.get(key);
+    if (existing)
+      return existing;
+    if (!NAMESPACE_PATTERN.test(key) || !NAMESPACE_PATTERN.test(publicNamespace)) {
+      throw new RangeError(`namespace must match ${NAMESPACE_PATTERN}: ${JSON.stringify(publicNamespace)}`);
+    }
+    const created = options.create({
+      namespace: storageNamespace(key),
+      publicNamespace,
+      sqlite,
+      clock,
+      rng: isolatedRng ?? rng
+    });
+    instances.set(key, created);
+    publicNamespaces.add(publicNamespace);
+    if (isolatedRng)
+      branchRngs.set(key, isolatedRng);
+    return created;
+  };
+  const instance = (name = DEFAULT_NAMESPACE) => instanceFor(name);
+  const capture = (storage) => {
+    const fresh = snapshotNamespace(sqlite, storageNamespace(storage));
+    const previous = captured.get(storage);
+    const snapshot2 = {
+      namespace: fresh.namespace,
+      records: reuseSorted(fresh.records, previous?.records, (left, right) => left.collection < right.collection ? -1 : left.collection > right.collection ? 1 : left.seq - right.seq, (left, right) => left.id === right.id && left.value === right.value),
+      sequences: reuseSorted(fresh.sequences, previous?.sequences, (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : left.kind < right.kind ? -1 : left.kind > right.kind ? 1 : 0, (left, right) => left.value === right.value)
+    };
+    Object.freeze(snapshot2.records);
+    Object.freeze(snapshot2.sequences);
+    Object.freeze(snapshot2);
+    captured.set(storage, snapshot2);
+    return Object.freeze({
+      snapshot: snapshot2,
+      clock: Object.freeze(clock.state()),
+      rngState: (branchRngs.get(storage) ?? rng).state()
+    });
+  };
+  const timeline = (name = DEFAULT_NAMESPACE) => {
+    let found = timelines.get(name);
+    if (found)
+      return found;
+    instance(name);
+    found = new Timeline({
+      now: clock.now,
+      ...options.maxCheckpoints !== void 0 ? { maxCheckpoints: options.maxCheckpoints } : {}
+    });
+    found.commit(capture(name));
+    timelines.set(name, found);
+    return found;
+  };
+  const physicalBranch = (namespace, branch2) => {
+    if (branch2 === "main")
+      return namespace;
+    const mapKey = `${namespace}\0${branch2}`;
+    const existing = branchStorage.get(mapKey);
+    if (existing)
+      return existing;
+    const key = `branch_${seedFrom(`${options.name}\0${namespace}\0${branch2}`).toString(36)}`;
+    branchStorage.set(mapKey, key);
+    return key;
+  };
+  const ensureBranch = (namespace, branch2, at) => {
+    if (!BRANCH_PATTERN2.test(branch2))
+      throw new RangeError(`branch must match ${BRANCH_PATTERN2}`);
+    const history = timeline(namespace);
+    if (branch2 === "main") {
+      if (at !== void 0) {
+        const point = history.checkout("main", at);
+        restoreNamespace(sqlite, storageNamespace(namespace), point.value.snapshot);
+        captured.set(namespace, point.value.snapshot);
+        rng.setState(point.value.rngState);
+        clock.set(point.value.clock.now);
+        if (point.value.clock.frozen)
+          clock.freeze();
+        else
+          clock.unfreeze();
+      }
+      return namespace;
+    }
+    const storage = physicalBranch(namespace, branch2);
+    if (!history.hasBranch(branch2)) {
+      if (at === void 0)
+        history.commit(capture(namespace));
+      const point = history.fork(branch2, at === void 0 ? {} : { from: at });
+      const branchRng = createRng(options.seed ?? 0);
+      if (point)
+        branchRng.setState(point.value.rngState);
+      instanceFor(storage, namespace, branchRng);
+      if (point)
+        restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+      if (point)
+        captured.set(storage, point.value.snapshot);
+    } else if (at !== void 0 && history.head(branch2)?.id !== at) {
+      const point = history.checkout(branch2, at);
+      if (!instances.has(storage)) {
+        const branchRng = createRng(options.seed ?? 0);
+        branchRng.setState(point.value.rngState);
+        instanceFor(storage, namespace, branchRng);
+      }
+      branchRngs.get(storage)?.setState(point.value.rngState);
+      restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+      captured.set(storage, point.value.snapshot);
+    } else {
+      if (!instances.has(storage)) {
+        const point = history.head(branch2);
+        const branchRng = createRng(options.seed ?? 0);
+        if (point)
+          branchRng.setState(point.value.rngState);
+        instanceFor(storage, namespace, branchRng);
+      }
+    }
+    return storage;
+  };
+  const checkpoint = (namespace = DEFAULT_NAMESPACE, branch2 = "main") => {
+    const storage = ensureBranch(namespace, branch2);
+    return timeline(namespace).commit(capture(storage), { branch: branch2 });
+  };
+  const branch = (name, branchOptions = {}) => {
+    const namespace = branchOptions.namespace ?? DEFAULT_NAMESPACE;
+    ensureBranch(namespace, name, branchOptions.at);
+    const head = timeline(namespace).head(name);
+    if (!head)
+      throw new RangeError(`branch ${name} has no checkpoint`);
+    return head;
+  };
+  const checkout = (checkpointId, checkoutOptions = {}) => {
+    const namespace = checkoutOptions.namespace ?? DEFAULT_NAMESPACE;
+    const branchName = checkoutOptions.branch ?? "main";
+    const history = timeline(namespace);
+    const point = history.checkout(branchName, checkpointId);
+    const storage = ensureBranch(namespace, branchName);
+    restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+    captured.set(storage, point.value.snapshot);
+    clock.set(point.value.clock.now);
+    if (point.value.clock.frozen)
+      clock.freeze();
+    else
+      clock.unfreeze();
+    (branchRngs.get(storage) ?? rng).setState(point.value.rngState);
+  };
+  const reset = async (name = DEFAULT_NAMESPACE) => {
+    if (name === "*") {
+      options.webhooks?.clear();
+      for (const each of instances.values())
+        await each.reset();
+      timelines.clear();
+      branchStorage.clear();
+      branchRngs.clear();
+      captured.clear();
+      return;
+    }
+    options.webhooks?.clear(name);
+    const target = instances.get(name);
+    if (target)
+      await target.reset();
+    else
+      clearNamespace(sqlite, storageNamespace(name));
+    for (const [mapping, storage] of branchStorage) {
+      if (!mapping.startsWith(`${name}\0`))
+        continue;
+      const branchInstance = instances.get(storage);
+      if (branchInstance)
+        await branchInstance.reset();
+      else
+        clearNamespace(sqlite, storageNamespace(storage));
+      branchStorage.delete(mapping);
+      branchRngs.delete(storage);
+      captured.delete(storage);
+    }
+    timelines.delete(name);
+    captured.delete(name);
+  };
+  const snapshot = (name = DEFAULT_NAMESPACE) => {
+    return checkpoint(name, "main").value.snapshot;
+  };
+  const restore = (from, name = DEFAULT_NAMESPACE) => {
+    instance(name);
+    restoreNamespace(sqlite, storageNamespace(name), from);
+    captured.set(name, from);
+    const history = timelines.get(name);
+    if (history)
+      history.commit(capture(name), { branch: "main" });
+    else
+      timeline(name);
+  };
+  const runtime = {
+    name: options.name,
+    sqlite,
+    clock,
+    faults,
+    metrics,
+    journal,
+    rng,
+    credentials,
+    webhooks: options.webhooks,
+    applyPreset: (name, namespace = DEFAULT_NAMESPACE, overrides = {}) => {
+      const preset = options.presets?.[name];
+      if (!preset)
+        throw new RangeError(`no fault preset ${JSON.stringify(name)}`);
+      const added = (preset.rules ?? []).map((rule, index) => faults.add({
+        namespace,
+        ...rule,
+        ...overrides,
+        preset: name,
+        id: `${overrides.id ?? name}${(preset.rules ?? []).length > 1 ? `_${index + 1}` : ""}`
+      }));
+      if (preset.webhook && options.webhooks) {
+        options.webhooks.fault(namespace, {
+          ...preset.webhook,
+          ...overrides.count !== void 0 ? { count: overrides.count } : {}
+        });
+      }
+      return added;
+    },
+    instance,
+    namespaces: () => [...publicNamespaces].sort(),
+    reset,
+    snapshot,
+    restore,
+    checkpoint,
+    branch,
+    checkout,
+    timeline,
+    fetch: async (incoming) => {
+      let request = incoming;
+      const prefixed = PATH_PREFIX.exec(new URL(request.url).pathname);
+      if (prefixed) {
+        const url2 = new URL(request.url);
+        url2.pathname = prefixed[2] ?? "/";
+        const headers = new Headers(request.headers);
+        if (!headers.has(NAMESPACE_HEADER)) {
+          headers.set(NAMESPACE_HEADER, decodeURIComponent(prefixed[1]));
+        }
+        const hasBody = request.method !== "GET" && request.method !== "HEAD";
+        request = new Request(url2, {
+          method: request.method,
+          headers,
+          ...hasBody ? { body: await request.arrayBuffer() } : {},
+          signal: request.signal
+        });
+      }
+      let namespace = control.namespaceOf(request);
+      if (!request.headers.has(NAMESPACE_HEADER) && options.credential) {
+        const credential = options.credential(request);
+        const mapped = credential !== void 0 ? credentials.get(credential) : void 0;
+        if (mapped !== void 0)
+          namespace = mapped;
+      }
+      const selectedBranch = request.headers.get(BRANCH_HEADER) ?? "main";
+      const at = request.headers.get(AT_HEADER) ?? void 0;
+      const stamp = (response2) => {
+        const value = NAMESPACE_PATTERN.test(namespace) ? `${options.name}@${version}; ns=${namespace}` : `${options.name}@${version}`;
+        try {
+          response2.headers.set(MOCKINGBIRD_HEADER, value);
+          return response2;
+        } catch {
+          const copy = new Response(response2.body, response2);
+          copy.headers.set(MOCKINGBIRD_HEADER, value);
+          return copy;
+        }
+      };
+      const handled = await control.handle(request);
+      if (handled)
+        return stamp(handled);
+      const started = monotonicNow();
+      const url = new URL(request.url);
+      const operationId = operationIdFor(request, url.pathname);
+      const log = (status, faultId, response2) => {
+        const noted = response2 ? responseNotes(response2) : void 0;
+        const entry = {
+          service: options.name,
+          namespace,
+          operationId,
+          method: request.method,
+          path: url.pathname,
+          status,
+          durationMs: Math.round((monotonicNow() - started) * 100) / 100,
+          unmatched: options.document !== void 0 && operationId === void 0,
+          ...faultId !== void 0 ? { faultId } : {},
+          ...noted?.ids && Object.keys(noted.ids).length > 0 ? { ids: noted.ids } : {},
+          ...noted?.adopted ? { adopted: true } : {}
+        };
+        metrics.record(entry);
+        journal.record({ ...entry, at: new Date(clock.now()).toISOString() });
+        options.onLog?.(entry);
+      };
+      if (!NAMESPACE_PATTERN.test(namespace)) {
+        log(400);
+        return stamp(new Response(JSON.stringify({
+          error: {
+            type: "mockingbird_admin",
+            message: `${NAMESPACE_HEADER} must match ${NAMESPACE_PATTERN}`
+          }
+        }), { status: 400, headers: { "content-type": "application/json" } }));
+      }
+      if (!BRANCH_PATTERN2.test(selectedBranch)) {
+        log(400);
+        return stamp(adminFail(400, `${BRANCH_HEADER} must match ${BRANCH_PATTERN2}`));
+      }
+      let storage;
+      try {
+        if (at !== void 0 && selectedBranch === "main" && !MUTATING_METHODS.has(request.method)) {
+          const point = timeline(namespace).get(at);
+          storage = physicalBranch(namespace, `at_${at}`);
+          let viewRng = branchRngs.get(storage);
+          if (!viewRng) {
+            viewRng = createRng(options.seed ?? 0);
+            instanceFor(storage, namespace, viewRng);
+          }
+          viewRng.setState(point.value.rngState);
+          restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+          captured.set(storage, point.value.snapshot);
+        } else {
+          storage = ensureBranch(namespace, selectedBranch, at);
+        }
+      } catch (error) {
+        log(409);
+        return stamp(adminFail(409, error instanceof Error ? error.message : String(error)));
+      }
+      const hits = await faults.take({
+        operationId,
+        method: request.method,
+        path: url.pathname,
+        namespace
+      });
+      const final = hits.find((hit) => hit.drop || hit.response);
+      if (final?.drop) {
+        log(0, final.id);
+        throw new DroppedConnectionError();
+      }
+      if (final?.response) {
+        log(final.response.status, final.id);
+        return stamp(final.response);
+      }
+      const fired = hits.filter((hit) => hit.effect !== void 0);
+      if (fired.length > 0)
+        effects.set(request, fired.map((hit) => hit.effect));
+      let response = await instanceFor(storage, namespace).fetch(request);
+      if (MUTATING_METHODS.has(request.method) && response.status >= 200 && response.status < 400) {
+        const point = timeline(namespace).commit(capture(storage), { branch: selectedBranch });
+        response = mutableResponse(response);
+        response.headers.set(CHECKPOINT_HEADER, point.id);
+      }
+      if (selectedBranch !== "main") {
+        response = mutableResponse(response);
+        response.headers.set(BRANCH_HEADER, selectedBranch);
+      }
+      if (at !== void 0) {
+        response = mutableResponse(response);
+        response.headers.set(AT_HEADER, at);
+      }
+      log(response.status, fired[0]?.id, response);
+      return stamp(response);
+    }
+  };
+  const control = createControlPlane({
+    name: options.name,
+    startedAt: wallNow(),
+    wallNow,
+    clock,
+    faults,
+    metrics,
+    journal,
+    defaultNamespace: DEFAULT_NAMESPACE,
+    namespaces: runtime.namespaces,
+    reset,
+    timeTravel: {
+      checkpoint: (name, branchName) => {
+        const point = checkpoint(name, branchName);
+        return {
+          id: point.id,
+          branch: point.branch,
+          parent: point.parent,
+          at: point.at,
+          records: point.value.snapshot.records.length
+        };
+      },
+      branch: (branchName, branchOptions) => {
+        const point = branch(branchName, branchOptions);
+        return { id: point.id, branch: point.branch, parent: point.parent, at: point.at };
+      },
+      checkout: (checkpointId, checkoutOptions) => checkout(checkpointId, checkoutOptions),
+      retain: (name, checkpointId) => {
+        timeline(name).retain(checkpointId);
+      },
+      release: (name, checkpointId) => timeline(name).release(checkpointId),
+      inspect: (name) => {
+        const history = timeline(name);
+        return {
+          branches: history.branches(),
+          checkpoints: history.checkpoints().map(({ id, branch: branchName, parent, at }) => ({
+            id,
+            branch: branchName,
+            parent,
+            at
+          }))
+        };
+      }
+    },
+    describe: options.describe ?? (() => ({})),
+    ...options.presets ? {
+      applyPreset: (name, namespace, overrides) => runtime.applyPreset(name, namespace, overrides)
+    } : {},
+    routes: {
+      ...credentialRoutes(credentials),
+      ...options.presets ? presetRoutes(options.presets, runtime) : {},
+      ...options.webhooks ? webhookAdminRoutes(options.webhooks) : {},
+      ...options.admin?.(runtime) ?? {}
+    },
+    adminKey: options.adminKey
+  });
+  return runtime;
+};
+var mutableResponse = (response) => {
+  try {
+    response.headers.set("x-mockingbird-mutable-probe", "1");
+    response.headers.delete("x-mockingbird-mutable-probe");
+    return response;
+  } catch {
+    return new Response(response.body, response);
+  }
+};
+var adminJson = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminFail = (status, 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":"Google Places, Geocoding and Maps JavaScript API (Mockingbird subset)","description":"The Google Maps Platform surface our member app calls: Places Autocomplete, Place Details\\nand Find Place From Text (the legacy JSON web services), the Geocoding API, and the Maps\\nJavaScript API loader (\`/maps/api/js?libraries=places\`). Every web-service answer is HTTP 200\\nwith Google's \`status\` field; the mock resolves addresses from a QA corpus.\\n","version":"1","x-mockingbird-upstream":{"note":"Hand-authored from Google's documented response shapes and the fields our consumer reads (address-autocomplete-native-rest.tsx, address-autocomplete-web.tsx, use-geocoded-address.ts). Google publishes no OpenAPI document for these endpoints."}},"servers":[{"url":"https://maps.googleapis.com"}],"paths":{"/maps/api/place/autocomplete/json":{"get":{"operationId":"PlaceAutocomplete","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/Key"},{"name":"input","in":"query","required":true,"schema":{"type":"string","minLength":1,"maxLength":60,"examples":["1625 N Central","Phoenix","85004","4821 Maple Street Denver","200 N Spring St, Los Angeles","136 Murray"]}},{"name":"types","in":"query","schema":{"type":"string","enum":["address","geocode"]}},{"name":"components","in":"query","schema":{"type":"string","enum":["country:us","country:ca","country:us|country:ca"]}},{"$ref":"#/components/parameters/SessionToken"}],"responses":{"200":{"description":"Predictions, or a non-OK status (HTTP 200 either way)","content":{"application/json":{"schema":{"$ref":"#/components/schemas/AutocompleteResponse"}}}},"500":{"description":"Google front-end failure (server_error preset)","content":{"application/json":{"schema":{"type":"object"}}}}}}},"/maps/api/place/details/json":{"get":{"operationId":"PlaceDetails","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/Key"},{"name":"place_id","in":"query","required":true,"schema":{"type":"string","minLength":1,"maxLength":200,"examples":["ChIJ5BKAwJuCB5951g03ZzrkHx9","ChIJE1ellR5XyWiy2lHIlJ5cls3","ChIJaWYsCINV1XBQQ97jO3pznpg","EieyJsIjoiNDgyMSBNYXBsZSBTdHJlZXQiLCJjIjoiRGVudmVyIiwicyI6IkNPIiwieiI6IjgwMjAyIiwibiI6IkRlbnZlciBDb3VudHkiLCJhIjozOS43NDc4OCwibyI6LTEwNC45OTQyNX0","ChIJdoesNotExist000000000"]}},{"name":"fields","in":"query","schema":{"type":"string","enum":["address_component","address_components","geometry","formatted_address,geometry","place_id,name,types","address_component,geometry,formatted_address"]}},{"$ref":"#/components/parameters/SessionToken"}],"responses":{"200":{"description":"The place, or a non-OK status","content":{"application/json":{"schema":{"$ref":"#/components/schemas/DetailsResponse"}}}},"500":{"description":"Google front-end failure (server_error preset)","content":{"application/json":{"schema":{"type":"object"}}}}}}},"/maps/api/geocode/json":{"get":{"operationId":"Geocode","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/Key"},{"name":"address","in":"query","schema":{"type":"string","minLength":1,"maxLength":80,"examples":["1625 N Central Ave, Phoenix, AZ 85004","88 Greenwich St, New York, NY 10006","4821 Maple Street, Denver, CO 80202","85004","Phoenix, AZ","1625 N Central Ave"]}},{"name":"place_id","in":"query","schema":{"type":"string","examples":["ChIJ5BKAwJuCB5951g03ZzrkHx9"]}},{"name":"components","in":"query","schema":{"type":"string","enum":["postal_code:85004","postal_code:10006","postal_code:00000"]}}],"responses":{"200":{"description":"Geocoding results, or a non-OK status","content":{"application/json":{"schema":{"$ref":"#/components/schemas/GeocodeResponse"}}}},"500":{"description":"Google front-end failure (server_error preset)","content":{"application/json":{"schema":{"type":"object"}}}}}}},"/maps/api/place/findplacefromtext/json":{"get":{"operationId":"FindPlaceFromText","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"$ref":"#/components/parameters/Key"},{"name":"input","in":"query","required":true,"schema":{"type":"string","minLength":1,"maxLength":80,"examples":["1625 N Central Ave, Phoenix, AZ 85004","1625 N Central","Gilbert"]}},{"name":"inputtype","in":"query","required":true,"schema":{"type":"string","enum":["textquery","phonenumber"]}},{"name":"fields","in":"query","schema":{"type":"string","enum":["geometry","formatted_address,geometry","place_id,name","place_id"]}}],"responses":{"200":{"description":"Candidates, or a non-OK status","content":{"application/json":{"schema":{"$ref":"#/components/schemas/FindPlaceResponse"}}}},"500":{"description":"Google front-end failure (server_error preset)","content":{"application/json":{"schema":{"type":"object"}}}}}}},"/maps/api/js":{"get":{"operationId":"MapsJavaScriptApi","description":"The Maps JavaScript API loader. The mock serves a shim defining google.maps.places (AutocompleteService, PlacesService, AutocompleteSessionToken, PlacesServiceStatus) and google.maps.Geocoder, backed by the REST operations above.","x-mockingbird":{"supported":true,"parity":{"enabled":false,"reason":"A JavaScript program, not data: it is exercised by evaluating it in a fake window and driving our web client through it (google-maps.acceptance.test.ts)."}},"parameters":[{"name":"key","in":"query","schema":{"type":"string"}},{"name":"libraries","in":"query","schema":{"type":"string"}},{"name":"callback","in":"query","schema":{"type":"string"}},{"name":"v","in":"query","schema":{"type":"string"}}],"responses":{"200":{"description":"The Maps JavaScript shim","content":{"text/javascript":{"schema":{"type":"string"}}}},"503":{"description":"Script unavailable (script_unavailable preset)","content":{"text/plain":{"schema":{"type":"string"}}}}}}}},"components":{"parameters":{"Key":{"name":"key","in":"query","required":true,"description":"The Google Maps Platform API key (\`PLACES_KEY\`); also the namespace credential.","schema":{"type":"string","minLength":1,"maxLength":40,"examples":["parity-key"]}},"SessionToken":{"name":"sessiontoken","in":"query","description":"Autocomplete session token (billing grouping); accepted and journaled as metadata.","schema":{"type":"string","format":"uuid"}}},"schemas":{"Status":{"type":"string","enum":["OK","ZERO_RESULTS","INVALID_REQUEST","OVER_QUERY_LIMIT","REQUEST_DENIED","UNKNOWN_ERROR","NOT_FOUND"]},"LatLng":{"type":"object","required":["lat","lng"],"properties":{"lat":{"type":"number"},"lng":{"type":"number"}}},"Viewport":{"type":"object","required":["northeast","southwest"],"properties":{"northeast":{"$ref":"#/components/schemas/LatLng"},"southwest":{"$ref":"#/components/schemas/LatLng"}}},"Geometry":{"type":"object","required":["location","viewport"],"properties":{"location":{"$ref":"#/components/schemas/LatLng"},"location_type":{"type":"string","enum":["ROOFTOP","RANGE_INTERPOLATED","GEOMETRIC_CENTER","APPROXIMATE"]},"viewport":{"$ref":"#/components/schemas/Viewport"}}},"AddressComponent":{"type":"object","required":["long_name","short_name","types"],"properties":{"long_name":{"type":"string"},"short_name":{"type":"string"},"types":{"type":"array","items":{"type":"string"}}}},"MatchedSubstring":{"type":"object","required":["length","offset"],"properties":{"length":{"type":"integer"},"offset":{"type":"integer"}}},"Prediction":{"type":"object","required":["description","place_id","reference","structured_formatting","terms","types","matched_substrings"],"properties":{"description":{"type":"string"},"matched_substrings":{"type":"array","items":{"$ref":"#/components/schemas/MatchedSubstring"}},"place_id":{"type":"string","x-mockingbird-resource":{"type":"place","identity":true}},"reference":{"type":"string"},"structured_formatting":{"type":"object","required":["main_text","secondary_text"],"properties":{"main_text":{"type":"string"},"main_text_matched_substrings":{"type":"array","items":{"$ref":"#/components/schemas/MatchedSubstring"}},"secondary_text":{"type":"string"}}},"terms":{"type":"array","items":{"type":"object","required":["offset","value"],"properties":{"offset":{"type":"integer"},"value":{"type":"string"}}}},"types":{"type":"array","items":{"type":"string"}}}},"PlaceResult":{"type":"object","description":"Only the fields requested with \`fields=\` are present.","properties":{"address_components":{"type":"array","items":{"$ref":"#/components/schemas/AddressComponent"}},"adr_address":{"type":"string"},"formatted_address":{"type":"string"},"geometry":{"$ref":"#/components/schemas/Geometry"},"name":{"type":"string"},"place_id":{"type":"string"},"reference":{"type":"string"},"types":{"type":"array","items":{"type":"string"}},"url":{"type":"string"},"utc_offset":{"type":"integer"},"vicinity":{"type":"string"}}},"AutocompleteResponse":{"type":"object","required":["predictions","status"],"properties":{"predictions":{"type":"array","items":{"$ref":"#/components/schemas/Prediction"}},"status":{"$ref":"#/components/schemas/Status"},"error_message":{"type":"string"}}},"DetailsResponse":{"type":"object","required":["html_attributions","status"],"properties":{"html_attributions":{"type":"array","items":{"type":"string"}},"result":{"$ref":"#/components/schemas/PlaceResult"},"status":{"$ref":"#/components/schemas/Status"},"error_message":{"type":"string"}}},"GeocodeResult":{"type":"object","required":["address_components","formatted_address","geometry","place_id","types"],"properties":{"address_components":{"type":"array","items":{"$ref":"#/components/schemas/AddressComponent"}},"formatted_address":{"type":"string"},"geometry":{"$ref":"#/components/schemas/Geometry"},"place_id":{"type":"string"},"types":{"type":"array","items":{"type":"string"}}}},"GeocodeResponse":{"type":"object","required":["results","status"],"properties":{"results":{"type":"array","items":{"$ref":"#/components/schemas/GeocodeResult"}},"status":{"$ref":"#/components/schemas/Status"},"error_message":{"type":"string"}}},"FindPlaceResponse":{"type":"object","required":["candidates","status"],"properties":{"candidates":{"type":"array","items":{"$ref":"#/components/schemas/PlaceResult"}},"status":{"$ref":"#/components/schemas/Status"},"error_message":{"type":"string"}}}}}}`);
+var operationIds = ["PlaceAutocomplete", "PlaceDetails", "Geocode", "FindPlaceFromText", "MapsJavaScriptApi"];
+var supportedOperationIds = ["PlaceAutocomplete", "PlaceDetails", "Geocode", "FindPlaceFromText", "MapsJavaScriptApi"];
+
+// src/corpus.ts
+var row = (id, line1, city, state, zip, county, lat, lng) => ({ id, line1, city, state, zip, county, lat, lng });
+var DEFAULT_CORPUS = [
+  row(
+    "al-birmingham",
+    "2100 1st Ave N",
+    "Birmingham",
+    "AL",
+    "35203",
+    "Jefferson County",
+    33.5167,
+    -86.807
+  ),
+  row("ak-anchorage", "320 W 5th Ave", "Anchorage", "AK", "99501", "Anchorage", 61.218, -149.894),
+  row(
+    "az-phoenix",
+    "1625 N Central Ave",
+    "Phoenix",
+    "AZ",
+    "85004",
+    "Maricopa County",
+    33.4665,
+    -112.0738
+  ),
+  row(
+    "az-phoenix-2",
+    "501 N 5th St",
+    "Phoenix",
+    "AZ",
+    "85004",
+    "Maricopa County",
+    33.454,
+    -112.066
+  ),
+  row(
+    "az-gilbert",
+    "420 E Stonebridge Dr",
+    "Gilbert",
+    "AZ",
+    "85234",
+    "Maricopa County",
+    33.37,
+    -111.783
+  ),
+  row(
+    "ar-little-rock",
+    "500 President Clinton Ave",
+    "Little Rock",
+    "AR",
+    "72201",
+    "Pulaski County",
+    34.747,
+    -92.265
+  ),
+  row(
+    "ca-alturas",
+    "712 Western Street",
+    "Alturas",
+    "CA",
+    "96101",
+    "Modoc County",
+    41.487,
+    -120.542
+  ),
+  row(
+    "ca-los-angeles",
+    "200 N Spring St",
+    "Los Angeles",
+    "CA",
+    "90012",
+    "Los Angeles County",
+    34.0537,
+    -118.2427
+  ),
+  row("co-denver", "1437 Bannock St", "Denver", "CO", "80202", "Denver County", 39.7392, -104.9903),
+  row(
+    "ct-hartford",
+    "550 Main St",
+    "Hartford",
+    "CT",
+    "06103",
+    "Hartford County",
+    41.7637,
+    -72.6851
+  ),
+  row(
+    "dc-washington",
+    "1350 Pennsylvania Ave NW",
+    "Washington",
+    "DC",
+    "20001",
+    "District of Columbia",
+    38.8951,
+    -77.031
+  ),
+  row(
+    "de-wilmington",
+    "800 N French St",
+    "Wilmington",
+    "DE",
+    "19801",
+    "New Castle County",
+    39.7447,
+    -75.5484
+  ),
+  row(
+    "fl-miami",
+    "3500 Pan American Dr",
+    "Miami",
+    "FL",
+    "33130",
+    "Miami-Dade County",
+    25.728,
+    -80.233
+  ),
+  row("ga-atlanta", "55 Trinity Ave SW", "Atlanta", "GA", "30303", "Fulton County", 33.749, -84.39),
+  row(
+    "hi-honolulu",
+    "530 S King St",
+    "Honolulu",
+    "HI",
+    "96813",
+    "Honolulu County",
+    21.3069,
+    -157.8583
+  ),
+  row("id-boise", "150 N Capitol Blvd", "Boise", "ID", "83702", "Ada County", 43.615, -116.2023),
+  row("il-chicago", "121 N LaSalle St", "Chicago", "IL", "60601", "Cook County", 41.8837, -87.6323),
+  row(
+    "in-newburgh",
+    "5366 E Sherwood Dr",
+    "Newburgh",
+    "IN",
+    "47630",
+    "Warrick County",
+    37.9445,
+    -87.4053
+  ),
+  row(
+    "in-indianapolis",
+    "200 E Washington St",
+    "Indianapolis",
+    "IN",
+    "46204",
+    "Marion County",
+    39.767,
+    -86.155
+  ),
+  row(
+    "ia-des-moines",
+    "400 Robert D Ray Dr",
+    "Des Moines",
+    "IA",
+    "50309",
+    "Polk County",
+    41.5868,
+    -93.625
+  ),
+  row("ks-wichita", "455 N Main St", "Wichita", "KS", "67202", "Sedgwick County", 37.6872, -97.339),
+  row(
+    "ky-louisville",
+    "527 W Jefferson St",
+    "Louisville",
+    "KY",
+    "40202",
+    "Jefferson County",
+    38.2542,
+    -85.7594
+  ),
+  row(
+    "la-new-orleans",
+    "1300 Perdido St",
+    "New Orleans",
+    "LA",
+    "70112",
+    "Orleans Parish",
+    29.9511,
+    -90.0715
+  ),
+  row(
+    "me-portland",
+    "389 Congress St",
+    "Portland",
+    "ME",
+    "04101",
+    "Cumberland County",
+    43.6591,
+    -70.2568
+  ),
+  row(
+    "md-baltimore",
+    "100 Holliday St",
+    "Baltimore",
+    "MD",
+    "21201",
+    "Baltimore City",
+    39.2904,
+    -76.6122
+  ),
+  row(
+    "ma-boston",
+    "1 City Hall Square",
+    "Boston",
+    "MA",
+    "02108",
+    "Suffolk County",
+    42.3601,
+    -71.0589
+  ),
+  row("mi-detroit", "2 Woodward Ave", "Detroit", "MI", "48226", "Wayne County", 42.3292, -83.044),
+  row(
+    "mn-minneapolis",
+    "350 S 5th St",
+    "Minneapolis",
+    "MN",
+    "55415",
+    "Hennepin County",
+    44.9778,
+    -93.265
+  ),
+  row(
+    "ms-jackson",
+    "219 S President St",
+    "Jackson",
+    "MS",
+    "39201",
+    "Hinds County",
+    32.2988,
+    -90.1848
+  ),
+  row(
+    "mo-kansas-city",
+    "414 E 12th St",
+    "Kansas City",
+    "MO",
+    "64106",
+    "Jackson County",
+    39.0997,
+    -94.5786
+  ),
+  row(
+    "mt-billings",
+    "210 N 27th St",
+    "Billings",
+    "MT",
+    "59101",
+    "Yellowstone County",
+    45.7833,
+    -108.5007
+  ),
+  row("ne-omaha", "1819 Farnam St", "Omaha", "NE", "68102", "Douglas County", 41.2587, -95.9378),
+  row(
+    "nv-las-vegas",
+    "495 S Main St",
+    "Las Vegas",
+    "NV",
+    "89101",
+    "Clark County",
+    36.1672,
+    -115.1485
+  ),
+  row(
+    "nh-manchester",
+    "1 City Hall Plaza",
+    "Manchester",
+    "NH",
+    "03101",
+    "Hillsborough County",
+    42.9956,
+    -71.4548
+  ),
+  row("nj-hoboken", "1 Hudson Pl", "Hoboken", "NJ", "07030", "Hudson County", 40.7359, -74.0275),
+  row(
+    "nm-albuquerque",
+    "1 Civic Plaza NW",
+    "Albuquerque",
+    "NM",
+    "87102",
+    "Bernalillo County",
+    35.0853,
+    -106.651
+  ),
+  row(
+    "ny-port-washington",
+    "136 Murray Avenue",
+    "Port Washington",
+    "NY",
+    "11050",
+    "Nassau County",
+    40.8257,
+    -73.6982
+  ),
+  row(
+    "ny-manhattan",
+    "88 Greenwich St",
+    "New York",
+    "NY",
+    "10006",
+    "New York County",
+    40.7077,
+    -74.0137
+  ),
+  row(
+    "nc-charlotte",
+    "600 E 4th St",
+    "Charlotte",
+    "NC",
+    "28202",
+    "Mecklenburg County",
+    35.221,
+    -80.839
+  ),
+  row("nd-fargo", "225 4th St N", "Fargo", "ND", "58102", "Cass County", 46.8772, -96.7898),
+  row(
+    "oh-columbus",
+    "90 W Broad St",
+    "Columbus",
+    "OH",
+    "43215",
+    "Franklin County",
+    39.9612,
+    -83.0007
+  ),
+  row(
+    "ok-oklahoma-city",
+    "200 N Walker Ave",
+    "Oklahoma City",
+    "OK",
+    "73102",
+    "Oklahoma County",
+    35.4689,
+    -97.5195
+  ),
+  row(
+    "or-portland",
+    "1221 SW 4th Ave",
+    "Portland",
+    "OR",
+    "97204",
+    "Multnomah County",
+    45.5152,
+    -122.6784
+  ),
+  row(
+    "pa-east-berlin",
+    "100 W King St",
+    "East Berlin",
+    "PA",
+    "17316",
+    "Adams County",
+    39.9376,
+    -76.9786
+  ),
+  row(
+    "pa-philadelphia",
+    "1401 John F Kennedy Blvd",
+    "Philadelphia",
+    "PA",
+    "19107",
+    "Philadelphia County",
+    39.9535,
+    -75.1636
+  ),
+  row(
+    "ri-providence",
+    "1 Park Row",
+    "Providence",
+    "RI",
+    "02903",
+    "Providence County",
+    41.824,
+    -71.4128
+  ),
+  row(
+    "sc-columbia",
+    "1737 Main St",
+    "Columbia",
+    "SC",
+    "29201",
+    "Richland County",
+    34.0007,
+    -81.0348
+  ),
+  row(
+    "sd-sioux-falls",
+    "224 W 9th St",
+    "Sioux Falls",
+    "SD",
+    "57104",
+    "Minnehaha County",
+    43.5446,
+    -96.7311
+  ),
+  row(
+    "tn-nashville",
+    "1 Public Square",
+    "Nashville",
+    "TN",
+    "37219",
+    "Davidson County",
+    36.1667,
+    -86.7784
+  ),
+  row("tx-plano", "2601 Preston Rd", "Frisco", "TX", "75034", "Collin County", 33.1507, -96.8236),
+  row("tx-houston", "901 Bagby St", "Houston", "TX", "77002", "Harris County", 29.7604, -95.3698),
+  row(
+    "ut-salt-lake",
+    "451 S State St",
+    "Salt Lake City",
+    "UT",
+    "84111",
+    "Salt Lake County",
+    40.7608,
+    -111.891
+  ),
+  row(
+    "vt-burlington",
+    "149 Church St",
+    "Burlington",
+    "VT",
+    "05401",
+    "Chittenden County",
+    44.4759,
+    -73.2121
+  ),
+  row(
+    "va-richmond",
+    "900 E Broad St",
+    "Richmond",
+    "VA",
+    "23219",
+    "Richmond City",
+    37.5407,
+    -77.436
+  ),
+  row("wa-seattle", "600 4th Ave", "Seattle", "WA", "98104", "King County", 47.6036, -122.3294),
+  row(
+    "wv-charleston",
+    "501 Virginia St E",
+    "Charleston",
+    "WV",
+    "25301",
+    "Kanawha County",
+    38.3498,
+    -81.6326
+  ),
+  row(
+    "wi-scandinavia",
+    "N7145 Rosholt Road",
+    "Scandinavia",
+    "WI",
+    "54977",
+    "Waupaca County",
+    44.46,
+    -89.146
+  ),
+  row(
+    "wi-milwaukee",
+    "200 E Wells St",
+    "Milwaukee",
+    "WI",
+    "53202",
+    "Milwaukee County",
+    43.0418,
+    -87.9097
+  ),
+  row(
+    "wy-cheyenne",
+    "2101 O Neil Ave",
+    "Cheyenne",
+    "WY",
+    "82001",
+    "Laramie County",
+    41.14,
+    -104.8202
+  )
+];
+var PHOENIX_DEMO_ADDRESS = DEFAULT_CORPUS.find(
+  (a) => a.id === "az-phoenix"
+);
+var STATE_NAMES = {
+  AL: "Alabama",
+  AK: "Alaska",
+  AZ: "Arizona",
+  AR: "Arkansas",
+  CA: "California",
+  CO: "Colorado",
+  CT: "Connecticut",
+  DC: "District of Columbia",
+  DE: "Delaware",
+  FL: "Florida",
+  GA: "Georgia",
+  HI: "Hawaii",
+  ID: "Idaho",
+  IL: "Illinois",
+  IN: "Indiana",
+  IA: "Iowa",
+  KS: "Kansas",
+  KY: "Kentucky",
+  LA: "Louisiana",
+  ME: "Maine",
+  MD: "Maryland",
+  MA: "Massachusetts",
+  MI: "Michigan",
+  MN: "Minnesota",
+  MS: "Mississippi",
+  MO: "Missouri",
+  MT: "Montana",
+  NE: "Nebraska",
+  NV: "Nevada",
+  NH: "New Hampshire",
+  NJ: "New Jersey",
+  NM: "New Mexico",
+  NY: "New York",
+  NC: "North Carolina",
+  ND: "North Dakota",
+  OH: "Ohio",
+  OK: "Oklahoma",
+  OR: "Oregon",
+  PA: "Pennsylvania",
+  RI: "Rhode Island",
+  SC: "South Carolina",
+  SD: "South Dakota",
+  TN: "Tennessee",
+  TX: "Texas",
+  UT: "Utah",
+  VT: "Vermont",
+  VA: "Virginia",
+  WA: "Washington",
+  WV: "West Virginia",
+  WI: "Wisconsin",
+  WY: "Wyoming"
+};
+
+// src/places.ts
+var MAX_PREDICTIONS = 5;
+var normalize = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+var base64url = (value) => toBase64(new TextEncoder().encode(value)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+var fromBase64url = (value) => {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(
+      fromBase64(value.replace(/-/g, "+").replace(/_/g, "/"))
+    );
+  } catch {
+    return void 0;
+  }
+};
+var corpusPlaceId = (row2) => `ChIJ${opaqueToken(`gmaps:${row2.id}`, 23)}`;
+var postalPlaceId = (zip) => `ChIJ${opaqueToken(`gmaps:zip:${zip}`, 23)}`;
+var fromRow = (row2) => ({
+  placeId: corpusPlaceId(row2),
+  kind: "street_address",
+  line1: row2.line1,
+  city: row2.city,
+  state: row2.state,
+  zip: row2.zip,
+  county: row2.county,
+  lat: row2.lat,
+  lng: row2.lng
+});
+var jitter = (seed, axis) => {
+  const token = opaqueToken(`gmaps:jitter:${axis}:${seed}`, 4);
+  let n = 0;
+  for (const char of token) n = (n * 31 + char.charCodeAt(0)) % 1800;
+  return (n - 900) / 1e5;
+};
+var round = (value) => Math.round(value * 1e7) / 1e7;
+var synthesize = (line1, row2) => {
+  const payload = {
+    l: line1,
+    c: row2.city,
+    s: row2.state,
+    z: row2.zip,
+    n: row2.county,
+    a: round(row2.lat + jitter(line1, "lat")),
+    o: round(row2.lng + jitter(line1, "lng"))
+  };
+  return {
+    placeId: `Ei${base64url(JSON.stringify(payload))}`,
+    kind: "street_address",
+    line1,
+    city: row2.city,
+    state: row2.state,
+    zip: row2.zip,
+    county: row2.county,
+    lat: payload.a,
+    lng: payload.o
+  };
+};
+var postalPlace = (row2) => ({
+  placeId: postalPlaceId(row2.zip),
+  kind: "postal_code",
+  line1: "",
+  city: row2.city,
+  state: row2.state,
+  zip: row2.zip,
+  county: row2.county,
+  lat: row2.lat,
+  lng: row2.lng
+});
+var placeById = (placeId, rows) => {
+  if (placeId.startsWith("Ei")) {
+    const decoded = fromBase64url(placeId.slice(2));
+    if (decoded === void 0) return void 0;
+    try {
+      const p = JSON.parse(decoded);
+      if (typeof p.l !== "string" || typeof p.c !== "string" || typeof p.s !== "string" || typeof p.z !== "string" || typeof p.a !== "number" || typeof p.o !== "number") {
+        return void 0;
+      }
+      return {
+        placeId,
+        kind: "street_address",
+        line1: p.l,
+        city: p.c,
+        state: p.s,
+        zip: p.z,
+        county: typeof p.n === "string" ? p.n : "",
+        lat: p.a,
+        lng: p.o
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  for (const row2 of rows) {
+    if (corpusPlaceId(row2) === placeId) return fromRow(row2);
+    if (postalPlaceId(row2.zip) === placeId) return postalPlace(row2);
+  }
+  return void 0;
+};
+var STREET_NUMBER = /^([A-Za-z]?\d+[A-Za-z]?(?:-\d+)?)\s+(.+)$/;
+var splitStreet = (line1) => {
+  const match = STREET_NUMBER.exec(line1.trim());
+  return match ? { number: match[1], route: match[2].trim() } : { number: void 0, route: line1.trim() };
+};
+var addressComponents = (place) => {
+  const out = [];
+  if (place.kind === "street_address") {
+    const { number, route } = splitStreet(place.line1);
+    if (number) out.push({ long_name: number, short_name: number, types: ["street_number"] });
+    out.push({ long_name: route, short_name: route, types: ["route"] });
+  } else {
+    out.push({ long_name: place.zip, short_name: place.zip, types: ["postal_code"] });
+  }
+  out.push({ long_name: place.city, short_name: place.city, types: ["locality", "political"] });
+  if (place.county) {
+    out.push({
+      long_name: place.county,
+      short_name: place.county,
+      types: ["administrative_area_level_2", "political"]
+    });
+  }
+  out.push({
+    long_name: STATE_NAMES[place.state] ?? place.state,
+    short_name: place.state,
+    types: ["administrative_area_level_1", "political"]
+  });
+  out.push({ long_name: "United States", short_name: "US", types: ["country", "political"] });
+  if (place.kind === "street_address") {
+    out.push({ long_name: place.zip, short_name: place.zip, types: ["postal_code"] });
+  }
+  return out;
+};
+var formattedAddress = (place) => place.kind === "street_address" ? `${place.line1}, ${place.city}, ${place.state} ${place.zip}, USA` : `${place.city}, ${place.state} ${place.zip}, USA`;
+var geometry = (place, withType = false) => {
+  const span = place.kind === "street_address" ? 135e-5 : 0.02;
+  return {
+    location: { lat: place.lat, lng: place.lng },
+    ...withType ? { location_type: place.kind === "street_address" ? "ROOFTOP" : "APPROXIMATE" } : {},
+    viewport: {
+      northeast: { lat: round(place.lat + span), lng: round(place.lng + span) },
+      southwest: { lat: round(place.lat - span), lng: round(place.lng - span) }
+    }
+  };
+};
+var placeTypes = (place) => place.kind === "street_address" ? ["street_address"] : ["postal_code"];
+var placeResult = (place) => ({
+  address_components: addressComponents(place),
+  adr_address: place.kind === "street_address" ? `<span class="street-address">${place.line1}</span>, <span class="locality">${place.city}</span>, <span class="region">${place.state}</span> <span class="postal-code">${place.zip}</span>, <span class="country-name">USA</span>` : `<span class="locality">${place.city}</span>, <span class="region">${place.state}</span> <span class="postal-code">${place.zip}</span>, <span class="country-name">USA</span>`,
+  formatted_address: formattedAddress(place),
+  geometry: geometry(place),
+  name: place.kind === "street_address" ? place.line1 : place.zip,
+  place_id: place.placeId,
+  reference: place.placeId,
+  types: placeTypes(place),
+  url: `https://maps.google.com/?q=${encodeURIComponent(formattedAddress(place))}`,
+  utc_offset: 0,
+  vicinity: place.city
+});
+var FIELD_ALIASES = {
+  address_component: "address_components",
+  address_components: "address_components",
+  adr_address: "adr_address",
+  formatted_address: "formatted_address",
+  geometry: "geometry",
+  "geometry/location": "geometry",
+  "geometry/viewport": "geometry",
+  name: "name",
+  place_id: "place_id",
+  reference: "reference",
+  type: "types",
+  types: "types",
+  url: "url",
+  utc_offset: "utc_offset",
+  vicinity: "vicinity"
+};
+var pickFields = (result, fields, fallback) => {
+  const requested = (fields ?? "").split(",").map((f) => f.trim()).filter(Boolean);
+  if (requested.length === 0) {
+    if (fallback === "all") return result;
+    return Object.fromEntries(fallback.map((key) => [key, result[key]]));
+  }
+  if (requested.includes("*")) return result;
+  const keys = new Set(requested.map((f) => FIELD_ALIASES[f]).filter((k) => !!k));
+  return Object.fromEntries(Object.entries(result).filter(([key]) => keys.has(key)));
+};
+var unknownFields = (fields) => (fields ?? "").split(",").map((f) => f.trim()).filter((f) => f && f !== "*" && !(f in FIELD_ALIASES));
+var secondary = (place) => `${place.city}, ${place.state}, USA`;
+var prediction = (place, input) => {
+  const main = place.kind === "street_address" ? place.line1 : place.zip;
+  const second = secondary(place);
+  const description = `${main}, ${second}`;
+  const matched = Math.min(input.trim().length, main.length);
+  const terms = [];
+  let offset = 0;
+  for (const value of [main, place.city, place.state, "USA"]) {
+    terms.push({ offset, value });
+    offset += value.length + 2;
+  }
+  return {
+    description,
+    matched_substrings: [{ length: matched, offset: 0 }],
+    place_id: place.placeId,
+    reference: place.placeId,
+    structured_formatting: {
+      main_text: main,
+      main_text_matched_substrings: [{ length: matched, offset: 0 }],
+      secondary_text: second
+    },
+    terms,
+    types: place.kind === "street_address" ? ["premise", "geocode"] : ["postal_code", "geocode"]
+  };
+};
+var tokens = (value) => normalize(value).split(" ").filter(Boolean);
+var IGNORED = /* @__PURE__ */ new Set(["usa", "us", "united", "states"]);
+var tokensMatch = (input, haystack) => {
+  const used = /* @__PURE__ */ new Set();
+  for (const token of input) {
+    const at = haystack.findIndex((h, i) => !used.has(i) && h.startsWith(token));
+    if (at < 0) return false;
+    used.add(at);
+  }
+  return true;
+};
+var rowHaystack = (row2) => tokens(`${row2.line1} ${row2.city} ${row2.state} ${STATE_NAMES[row2.state] ?? ""} ${row2.zip}`);
+var parseStreetInCity = (input, rows) => {
+  const trimmed = input.trim().replace(/[,\s]+(USA|US|United States)$/i, "");
+  const match = STREET_NUMBER.exec(trimmed);
+  if (!match) return void 0;
+  const number = match[1];
+  const rest = match[2].replace(/,/g, " ").replace(/\s+/g, " ").trim();
+  const restNorm = normalize(rest);
+  const candidates = [...rows].sort((a, b) => b.city.length - a.city.length);
+  for (const row2 of candidates) {
+    const city = normalize(row2.city);
+    const suffixes = [
+      `${city} ${row2.state.toLowerCase()} ${row2.zip}`,
+      `${city} ${row2.state.toLowerCase()}`,
+      `${city} ${row2.zip}`,
+      city
+    ];
+    for (const suffix of suffixes) {
+      if (!restNorm.endsWith(` ${suffix}`)) continue;
+      const streetNorm = restNorm.slice(0, restNorm.length - suffix.length).trim();
+      if (!streetNorm) continue;
+      const words = rest.split(" ");
+      const streetWords = words.slice(0, streetNorm.split(" ").length);
+      const street = streetWords.join(" ").replace(/[,\s]+$/, "");
+      return { line1: `${number} ${street}`, row: row2 };
+    }
+  }
+  return void 0;
+};
+var autocomplete = (input, rows) => {
+  const wanted = tokens(input).filter((t) => !IGNORED.has(t));
+  if (wanted.length === 0) return [];
+  const out = [];
+  const synth = parseStreetInCity(input, rows);
+  if (synth) {
+    const exact = rows.find(
+      (row2) => normalize(row2.line1) === normalize(synth.line1) && normalize(row2.city) === normalize(synth.row.city)
+    );
+    out.push(exact ? fromRow(exact) : synthesize(synth.line1, synth.row));
+  }
+  for (const row2 of rows) {
+    if (out.length >= MAX_PREDICTIONS) break;
+    if (out.some((p) => p.placeId === corpusPlaceId(row2))) continue;
+    if (tokensMatch(wanted, rowHaystack(row2))) out.push(fromRow(row2));
+  }
+  return out;
+};
+var geocode = (address, rows) => {
+  const n = normalize(address);
+  if (!n) return void 0;
+  const synth = parseStreetInCity(address, rows);
+  if (synth) {
+    const exact = rows.find(
+      (row2) => normalize(row2.line1) === normalize(synth.line1) && normalize(row2.city) === normalize(synth.row.city)
+    );
+    return exact ? fromRow(exact) : synthesize(synth.line1, synth.row);
+  }
+  const wanted = tokens(address).filter((t) => !IGNORED.has(t));
+  if (wanted.length === 1 && /^\d{5}$/.test(wanted[0])) {
+    const row2 = rows.find((r) => r.zip === wanted[0]);
+    return row2 ? postalPlace(row2) : void 0;
+  }
+  if (!/\d/.test(n)) {
+    const row2 = rows.find((r) => {
+      const city = tokens(r.city);
+      return wanted.length >= city.length && city.every((t, i) => wanted[i] === t) && wanted.slice(city.length).every((t) => t === r.state.toLowerCase());
+    });
+    return row2 ? postalPlace(row2) : void 0;
+  }
+  return void 0;
+};
+var findPlace = (input, rows) => geocode(input, rows) ?? autocomplete(input, rows)[0];
+
+// src/shim.ts
+var embed = (value) => JSON.stringify(value).replace(/</g, "\\u003c");
+var mapsJavaScript = (options) => `/* Mockingbird Google Maps JavaScript API shim (places, geocoder) */
+(function () {
+  var BASE = ${embed(options.base)};
+  var KEY = ${embed(options.key)};
+  var AUTH_FAILED = ${options.authFailed ? "true" : "false"};
+  var CALLBACK = ${embed(options.callback)};
+  var w = typeof window !== "undefined" ? window : globalThis;
+  var doFetch = (w.fetch && w.fetch.bind(w)) || fetch;
+
+  function request(path, params) {
+    var parts = [];
+    for (var name in params) {
+      var value = params[name];
+      if (value === undefined || value === null || value === "") continue;
+      parts.push(encodeURIComponent(name) + "=" + encodeURIComponent(String(value)));
+    }
+    parts.push("key=" + encodeURIComponent(KEY));
+    return doFetch(BASE + path + "?" + parts.join("&")).then(
+      function (response) {
+        if (!response.ok) return { status: "UNKNOWN_ERROR" };
+        return response.json().then(null, function () { return { status: "UNKNOWN_ERROR" }; });
+      },
+      function () { return { status: "UNKNOWN_ERROR" }; }
+    );
+  }
+
+  function LatLng(lat, lng) { this._lat = Number(lat); this._lng = Number(lng); }
+  LatLng.prototype.lat = function () { return this._lat; };
+  LatLng.prototype.lng = function () { return this._lng; };
+  LatLng.prototype.toJSON = function () { return { lat: this._lat, lng: this._lng }; };
+  LatLng.prototype.toString = function () { return "(" + this._lat + ", " + this._lng + ")"; };
+  LatLng.prototype.equals = function (other) { return !!other && other.lat() === this._lat && other.lng() === this._lng; };
+
+  function LatLngBounds(sw, ne) { this._sw = sw; this._ne = ne; }
+  LatLngBounds.prototype.getSouthWest = function () { return this._sw; };
+  LatLngBounds.prototype.getNorthEast = function () { return this._ne; };
+  LatLngBounds.prototype.toJSON = function () {
+    return { south: this._sw.lat(), west: this._sw.lng(), north: this._ne.lat(), east: this._ne.lng() };
+  };
+
+  function wrapGeometry(g) {
+    if (!g || !g.location) return g;
+    var out = { location: new LatLng(g.location.lat, g.location.lng) };
+    if (g.location_type) out.location_type = g.location_type;
+    if (g.viewport) {
+      out.viewport = new LatLngBounds(
+        new LatLng(g.viewport.southwest.lat, g.viewport.southwest.lng),
+        new LatLng(g.viewport.northeast.lat, g.viewport.northeast.lng)
+      );
+    }
+    return out;
+  }
+
+  function wrapPlace(p) {
+    if (!p) return p;
+    var out = {};
+    for (var k in p) out[k] = p[k];
+    if (p.geometry) out.geometry = wrapGeometry(p.geometry);
+    return out;
+  }
+
+  var PlacesServiceStatus = {
+    OK: "OK", ZERO_RESULTS: "ZERO_RESULTS", INVALID_REQUEST: "INVALID_REQUEST",
+    OVER_QUERY_LIMIT: "OVER_QUERY_LIMIT", REQUEST_DENIED: "REQUEST_DENIED",
+    UNKNOWN_ERROR: "UNKNOWN_ERROR", NOT_FOUND: "NOT_FOUND"
+  };
+  var GeocoderStatus = {
+    OK: "OK", ZERO_RESULTS: "ZERO_RESULTS", INVALID_REQUEST: "INVALID_REQUEST",
+    OVER_QUERY_LIMIT: "OVER_QUERY_LIMIT", REQUEST_DENIED: "REQUEST_DENIED",
+    UNKNOWN_ERROR: "UNKNOWN_ERROR", ERROR: "ERROR"
+  };
+
+  function MapsRequestError(status, endpoint) {
+    var error = new Error(endpoint + ": " + status);
+    error.name = "MapsRequestError";
+    error.code = status;
+    error.endpoint = endpoint;
+    return error;
+  }
+
+  /** Call back, or settle the returned promise (rejecting on errors) when there is no callback. */
+  function settle(callback, results, status, value, endpoint, okStatuses) {
+    if (typeof callback === "function") {
+      callback(results, status);
+      return value;
+    }
+    if (okStatuses.indexOf(status) < 0) throw MapsRequestError(status, endpoint);
+    return value;
+  }
+
+  var tokenSeq = 0;
+  function AutocompleteSessionToken() {
+    tokenSeq += 1;
+    this._id = "mbst-" + tokenSeq + "-" + tokenSeq.toString(36).padStart(8, "0");
+  }
+  AutocompleteSessionToken.prototype.toString = function () { return this._id; };
+
+  function countries(restrictions) {
+    if (!restrictions || !restrictions.country) return undefined;
+    var list = [].concat(restrictions.country);
+    return list.map(function (c) { return "country:" + String(c).toLowerCase(); }).join("|");
+  }
+
+  function fieldList(fields) {
+    if (!fields) return undefined;
+    return [].concat(fields).join(",");
+  }
+
+  function AutocompleteService() {}
+  AutocompleteService.prototype.getPlacePredictions = function (req, callback) {
+    req = req || {};
+    return request("/maps/api/place/autocomplete/json", {
+      input: req.input,
+      sessiontoken: req.sessionToken ? String(req.sessionToken) : undefined,
+      types: req.types ? [].concat(req.types).join("|") : undefined,
+      components: countries(req.componentRestrictions)
+    }).then(function (data) {
+      var status = data.status || "UNKNOWN_ERROR";
+      var predictions = status === "OK" ? data.predictions : null;
+      return settle(callback, predictions, status, { predictions: predictions || [] },
+        "PLACES_AUTOCOMPLETE", ["OK", "ZERO_RESULTS"]);
+    });
+  };
+
+  function PlacesService(attributions) { this._attributions = attributions || null; }
+  PlacesService.prototype.getDetails = function (req, callback) {
+    req = req || {};
+    return request("/maps/api/place/details/json", {
+      place_id: req.placeId,
+      fields: fieldList(req.fields),
+      sessiontoken: req.sessionToken ? String(req.sessionToken) : undefined
+    }).then(function (data) {
+      var status = data.status || "UNKNOWN_ERROR";
+      var place = status === "OK" ? wrapPlace(data.result) : null;
+      return settle(callback, place, status, place, "PLACES_GET_PLACE", ["OK"]);
+    });
+  };
+  PlacesService.prototype.findPlaceFromQuery = function (req, callback) {
+    req = req || {};
+    return request("/maps/api/place/findplacefromtext/json", {
+      input: req.query,
+      inputtype: "textquery",
+      fields: fieldList(req.fields)
+    }).then(function (data) {
+      var status = data.status || "UNKNOWN_ERROR";
+      var results = status === "OK" ? (data.candidates || []).map(wrapPlace) : null;
+      return settle(callback, results, status, { results: results || [] },
+        "PLACES_FIND_PLACE_FROM_QUERY", ["OK", "ZERO_RESULTS"]);
+    });
+  };
+
+  function Geocoder() {}
+  Geocoder.prototype.geocode = function (req, callback) {
+    req = req || {};
+    return request("/maps/api/geocode/json", {
+      address: req.address,
+      place_id: req.placeId,
+      components: req.componentRestrictions && req.componentRestrictions.postalCode
+        ? "postal_code:" + req.componentRestrictions.postalCode : undefined
+    }).then(function (data) {
+      var status = data.status || "ERROR";
+      var results = status === "OK" ? (data.results || []).map(wrapPlace) : null;
+      return settle(callback, results, status, { results: results || [] }, "GEOCODER_GEOCODE", ["OK"]);
+    });
+  };
+
+  w.google = w.google || {};
+  w.google.maps = {
+    version: "mockingbird",
+    LatLng: LatLng,
+    LatLngBounds: LatLngBounds,
+    Geocoder: Geocoder,
+    GeocoderStatus: GeocoderStatus,
+    places: {
+      AutocompleteService: AutocompleteService,
+      AutocompleteSessionToken: AutocompleteSessionToken,
+      PlacesService: PlacesService,
+      PlacesServiceStatus: PlacesServiceStatus
+    },
+    importLibrary: function (name) {
+      if (name === "places") return Promise.resolve(w.google.maps.places);
+      if (name === "geocoding") return Promise.resolve({ Geocoder: Geocoder, GeocoderStatus: GeocoderStatus });
+      return Promise.resolve({ LatLng: LatLng, LatLngBounds: LatLngBounds });
+    }
+  };
+
+  if (AUTH_FAILED) {
+    setTimeout(function () { if (typeof w.gm_authFailure === "function") w.gm_authFailure(); }, 0);
+  }
+  if (CALLBACK && typeof w[CALLBACK] === "function") w[CALLBACK]();
+})();
+`;
+
+// src/state.ts
+var DEFAULT_SETTINGS = { keys: [], publicUrl: null };
+var GoogleMapsState = class {
+  constructor(sqlite, namespace, seed) {
+    this.seed = seed;
+    this.custom = new Collection(sqlite, namespace, "addresses");
+    this.settings = new Collection(sqlite, namespace, "settings");
+    this.ensureSeeded();
+  }
+  seed;
+  /** Addresses a suite added to this namespace, on top of the built-in corpus. */
+  custom;
+  settings;
+  ensureSeeded() {
+    if (!this.settings.has("settings")) {
+      this.settings.insert("settings", { ...DEFAULT_SETTINGS, ...this.seed.settings });
+    }
+  }
+  current() {
+    return this.settings.get("settings") ?? DEFAULT_SETTINGS;
+  }
+  update(patch) {
+    const next = { ...this.current(), ...patch };
+    this.settings.insert("settings", next);
+    return next;
+  }
+  /** Custom rows first (a suite's own addresses win ties), then the built-in corpus. */
+  corpus() {
+    const custom = this.custom.list({ order: "oldest" }).map((row2) => row2.value);
+    const ids = new Set(custom.map((row2) => row2.id));
+    const base = this.seed.corpus.length > 0 ? this.seed.corpus : DEFAULT_CORPUS;
+    return [...custom, ...base.filter((row2) => !ids.has(row2.id))];
+  }
+  replaceCustom(rows) {
+    for (const { id } of this.custom.list()) this.custom.delete(id);
+    for (const row2 of rows) this.custom.insert(row2.id, row2);
+  }
+};
+
+// src/runtime.ts
+var WEB_SERVICES = ["PlaceAutocomplete", "PlaceDetails", "Geocode", "FindPlaceFromText"];
+var everyWebService = (rule) => WEB_SERVICES.map((operationId) => ({ operationId, ...rule }));
+var GOOGLE_MAPS_PRESETS = {
+  over_query_limit: {
+    description: "Every web-service call answers status OVER_QUERY_LIMIT (HTTP 200)",
+    rules: everyWebService({ effect: "google_status", params: { status: "OVER_QUERY_LIMIT" } })
+  },
+  request_denied: {
+    description: "Every web-service call answers status REQUEST_DENIED, as for a revoked key",
+    rules: everyWebService({ effect: "google_status", params: { status: "REQUEST_DENIED" } })
+  },
+  unknown_error: {
+    description: "Every web-service call answers status UNKNOWN_ERROR (Google's transient failure)",
+    rules: everyWebService({ effect: "google_status", params: { status: "UNKNOWN_ERROR" } })
+  },
+  zero_results: {
+    description: "Every web-service call answers status ZERO_RESULTS",
+    rules: everyWebService({ effect: "google_status", params: { status: "ZERO_RESULTS" } })
+  },
+  geocode_zero_results: {
+    description: "Geocoding answers ZERO_RESULTS, so our client falls back to Find Place",
+    rules: [
+      { operationId: "Geocode", effect: "google_status", params: { status: "ZERO_RESULTS" } }
+    ]
+  },
+  autocomplete_over_query_limit: {
+    description: "Only Place Autocomplete answers OVER_QUERY_LIMIT (the manual-entry fallback path)",
+    rules: [
+      {
+        operationId: "PlaceAutocomplete",
+        effect: "google_status",
+        params: { status: "OVER_QUERY_LIMIT" }
+      }
+    ]
+  },
+  server_error: {
+    description: "Every web-service call answers HTTP 500 (our client counts !res.ok as a failure)",
+    rules: everyWebService({ status: 500, body: { error: "Internal Server Error" } })
+  },
+  slow: {
+    description: "Every web-service call is held 6 s: past QA's 5 s wait for predictions",
+    rules: everyWebService({ latencyMs: 6e3 })
+  },
+  script_unavailable: {
+    description: "The Maps JavaScript API answers 503, so the script's onerror fires",
+    rules: [{ operationId: "MapsJavaScriptApi", status: 503, body: "Service Unavailable" }]
+  }
+};
+var json3 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminError3 = (status, message) => json3(status, { error: { type: "mockingbird_admin", message } });
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseAddress = (value, index) => {
+  if (!isRecord4(value)) return `addresses[${index}] must be an object`;
+  for (const key of ["line1", "city", "state", "zip"]) {
+    if (typeof value[key] !== "string" || !value[key].trim()) {
+      return `addresses[${index}].${key} must be a non-empty string`;
+    }
+  }
+  const state = String(value.state).toUpperCase();
+  if (!/^[A-Z]{2}$/.test(state)) return `addresses[${index}].state must be a two-letter code`;
+  const lat = value.lat === void 0 ? 0 : Number(value.lat);
+  const lng = value.lng === void 0 ? 0 : Number(value.lng);
+  if (!Number.isFinite(lat) || !Number.isFinite(lng)) {
+    return `addresses[${index}].lat/lng must be numbers`;
+  }
+  return {
+    id: typeof value.id === "string" && value.id ? value.id : `custom-${String(value.zip)}-${String(value.line1).toLowerCase().replace(/[^a-z0-9]+/g, "-")}`,
+    line1: String(value.line1).trim(),
+    city: String(value.city).trim(),
+    state,
+    zip: String(value.zip).trim(),
+    county: typeof value.county === "string" ? value.county : "",
+    lat,
+    lng
+  };
+};
+var adminRoutes = (runtime) => ({
+  "GET /corpus": ({ namespace }) => {
+    const api = runtime.instance(namespace);
+    return json3(200, {
+      addresses: api.corpus(),
+      custom: api.state.custom.count()
+    });
+  },
+  "PUT /corpus": ({ body, namespace }) => {
+    const list = Array.isArray(body) ? body : isRecord4(body) ? body.addresses : void 0;
+    if (!Array.isArray(list)) {
+      return adminError3(400, 'expected {"addresses": [{line1, city, state, zip, lat?, lng?}]}');
+    }
+    const rows = [];
+    for (const [index, each] of list.entries()) {
+      const parsed = parseAddress(each, index);
+      if (typeof parsed === "string") return adminError3(400, parsed);
+      rows.push(parsed);
+    }
+    const api = runtime.instance(namespace);
+    api.state.replaceCustom(rows);
+    return json3(200, { custom: rows });
+  },
+  "DELETE /corpus": ({ namespace }) => {
+    runtime.instance(namespace).state.replaceCustom([]);
+    return json3(200, { status: "ok" });
+  },
+  "GET /settings": ({ namespace }) => json3(200, runtime.instance(namespace).state.current()),
+  "PUT /settings": ({ body, namespace }) => {
+    if (!isRecord4(body)) return adminError3(400, "expected a JSON object");
+    const patch = {};
+    if (body.keys !== void 0) {
+      if (!Array.isArray(body.keys)) return adminError3(400, "keys: string[]");
+      patch.keys = body.keys.map(String);
+    }
+    if (body.publicUrl !== void 0) {
+      if (body.publicUrl !== null && typeof body.publicUrl !== "string") {
+        return adminError3(400, "publicUrl: string | null");
+      }
+      patch.publicUrl = body.publicUrl;
+    }
+    return json3(200, runtime.instance(namespace).state.update(patch));
+  }
+});
+var createRuntime2 = (options = {}) => createRuntime({
+  name: GOOGLE_MAPS_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: keyCredential,
+  presets: GOOGLE_MAPS_PRESETS,
+  create: ({ sqlite, namespace, publicNamespace, clock }) => new GoogleMapsAPI({
+    sqlite,
+    namespace,
+    publicNamespace,
+    now: clock.now,
+    ...options.corpus ? { corpus: options.corpus } : {},
+    ...options.settings ? { settings: options.settings } : {}
+  }),
+  describe: () => ({
+    corpus: options.corpus ? `custom (${options.corpus.length})` : `qa-routing-zip-corpus (${DEFAULT_CORPUS.length})`
+  }),
+  admin: adminRoutes
+});
+
+// src/index.ts
+var GOOGLE_MAPS_NAMESPACE = "google-maps";
+var MISSING_KEY_MESSAGE = "You must use an API key to authenticate each request to Google Maps Platform APIs. For additional information, please refer to http://g.co/dev/maps-no-account";
+var INVALID_KEY_MESSAGE = "The provided API key is invalid. ";
+var keyCredential = (request) => new URL(request.url).searchParams.get("key") ?? void 0;
+var CORS = { "access-control-allow-origin": "*" };
+var json4 = (body, status = 200) => new Response(JSON.stringify(body, null, 3), {
+  status,
+  headers: { "content-type": "application/json; charset=UTF-8", ...CORS }
+});
+var EMPTY = {
+  PlaceAutocomplete: { predictions: [] },
+  PlaceDetails: { html_attributions: [] },
+  Geocode: { results: [] },
+  FindPlaceFromText: { candidates: [] }
+};
+var DEFAULT_MESSAGES = {
+  OVER_QUERY_LIMIT: "You have exceeded your rate-limit for this API. For more information on Google Maps Platform rate limits, please see https://developers.google.com/maps/documentation/places/web-service/usage-and-billing",
+  UNKNOWN_ERROR: "An unknown error occurred. Please try again.",
+  REQUEST_DENIED: INVALID_KEY_MESSAGE
+};
+var text = (value) => typeof value === "string" ? value : Array.isArray(value) ? String(value[0]) : void 0;
+var GoogleMapsAPI = class {
+  app;
+  sqlite;
+  state;
+  service;
+  publicNamespace;
+  constructor(options = {}) {
+    const sqlite = bootSqlite(options.sqlite);
+    const namespace = options.namespace ?? GOOGLE_MAPS_NAMESPACE;
+    this.publicNamespace = options.publicNamespace ?? "default";
+    this.state = new GoogleMapsState(sqlite, namespace, {
+      corpus: options.corpus ?? [],
+      settings: options.settings ?? {}
+    });
+    const handlers = defineOperations({
+      PlaceAutocomplete: (context) => this.autocomplete(context),
+      PlaceDetails: (context) => this.details(context),
+      Geocode: (context) => this.geocode(context),
+      FindPlaceFromText: (context) => this.findPlace(context),
+      MapsJavaScriptApi: (context) => this.script(context)
+    });
+    this.service = createService({
+      document,
+      handlers,
+      sqlite,
+      namespace,
+      ...options.now ? { now: options.now } : {},
+      notFound: () => new Response("<html><body><h1>Not Found</h1></body></html>", {
+        status: 404,
+        headers: { "content-type": "text/html; charset=UTF-8", ...CORS }
+      }),
+      onError: (error) => {
+        if (error instanceof HttpError) return error.toResponse();
+        throw error;
+      },
+      before: (context) => this.gate(context)
+    });
+    this.app = this.service.app;
+    this.sqlite = this.service.sqlite;
+  }
+  fetch(request) {
+    return this.service.fetch(request);
+  }
+  async reset() {
+    await this.service.reset();
+    this.state.ensureSeeded();
+  }
+  /** The addresses this namespace resolves (custom rows first). */
+  corpus() {
+    return this.state.corpus();
+  }
+  status(operationId, status, message) {
+    return json4({
+      ...EMPTY[operationId],
+      ...message ? { error_message: message } : {},
+      status
+    });
+  }
+  /** Key check and status-effect faults, before every web-service call. */
+  gate(context) {
+    const operationId = context.operation.operationId;
+    if (operationId === "MapsJavaScriptApi") return void 0;
+    const key = text(context.query.key);
+    if (!key) return this.status(operationId, "REQUEST_DENIED", MISSING_KEY_MESSAGE);
+    const keys = this.state.current().keys;
+    if (keys.length > 0 && !keys.includes(key)) {
+      return this.status(operationId, "REQUEST_DENIED", INVALID_KEY_MESSAGE);
+    }
+    const forced = faultEffect(context.request, "google_status");
+    if (forced !== void 0) {
+      const status = typeof forced.status === "string" ? forced.status : "UNKNOWN_ERROR";
+      const message = typeof forced.error_message === "string" ? forced.error_message : DEFAULT_MESSAGES[status];
+      return this.status(operationId, status, message);
+    }
+    return void 0;
+  }
+  noted(response, context, place) {
+    const session = text(context.query.sessiontoken);
+    const ids = {};
+    if (place) ids.placeId = place.placeId;
+    if (session) ids.sessionToken = session;
+    return Object.keys(ids).length > 0 ? annotateResponse(response, { ids }) : response;
+  }
+  autocomplete(context) {
+    const input = text(context.query.input);
+    if (!input) return this.status("PlaceAutocomplete", "INVALID_REQUEST");
+    const components = text(context.query.components);
+    if (components !== void 0) {
+      const countries = components.split("|").map((c) => c.trim().toLowerCase()).filter((c) => c.startsWith("country:")).map((c) => c.slice("country:".length));
+      if (countries.length > 0 && !countries.includes("us")) {
+        return this.noted(json4({ predictions: [], status: "ZERO_RESULTS" }), context);
+      }
+    }
+    const types = text(context.query.types);
+    let places = autocomplete(input, this.state.corpus());
+    if (types === "address") places = places.filter((p) => p.kind === "street_address");
+    if (places.length === 0) {
+      return this.noted(json4({ predictions: [], status: "ZERO_RESULTS" }), context);
+    }
+    return this.noted(
+      json4({ predictions: places.map((p) => prediction(p, input)), status: "OK" }),
+      context,
+      places[0]
+    );
+  }
+  details(context) {
+    const placeId = text(context.query.place_id);
+    if (!placeId) return this.status("PlaceDetails", "INVALID_REQUEST");
+    const fields = text(context.query.fields);
+    if (unknownFields(fields).length > 0) {
+      return this.status(
+        "PlaceDetails",
+        "INVALID_REQUEST",
+        `Error while parsing 'fields' parameter: Unsupported field name '${unknownFields(fields)[0]}'. `
+      );
+    }
+    const place = placeById(placeId, this.state.corpus());
+    if (!place) return this.noted(this.status("PlaceDetails", "NOT_FOUND"), context);
+    return this.noted(
+      json4({
+        html_attributions: [],
+        result: pickFields(placeResult(place), fields, "all"),
+        status: "OK"
+      }),
+      context,
+      place
+    );
+  }
+  geocode(context) {
+    const address = text(context.query.address);
+    const placeId = text(context.query.place_id);
+    const components = text(context.query.components);
+    const zip = components?.split("|").find((c) => c.startsWith("postal_code:"))?.slice("postal_code:".length);
+    if (!address && !placeId && !zip) return this.status("Geocode", "INVALID_REQUEST");
+    const rows = this.state.corpus();
+    const place = placeId ? placeById(placeId, rows) : address ? geocode(address, rows) : geocode(zip, rows);
+    if (!place) return this.noted(json4({ results: [], status: "ZERO_RESULTS" }), context);
+    const full = placeResult(place);
+    return this.noted(
+      json4({
+        results: [
+          {
+            address_components: full.address_components,
+            formatted_address: full.formatted_address,
+            geometry: geometry(place, true),
+            place_id: place.placeId,
+            types: full.types
+          }
+        ],
+        status: "OK"
+      }),
+      context,
+      place
+    );
+  }
+  findPlace(context) {
+    const input = text(context.query.input);
+    const inputtype = text(context.query.inputtype);
+    if (!input || inputtype !== "textquery" && inputtype !== "phonenumber") {
+      return this.status("FindPlaceFromText", "INVALID_REQUEST");
+    }
+    const fields = text(context.query.fields);
+    if (unknownFields(fields).length > 0) {
+      return this.status(
+        "FindPlaceFromText",
+        "INVALID_REQUEST",
+        `Error while parsing 'fields' parameter: Unsupported field name '${unknownFields(fields)[0]}'. `
+      );
+    }
+    const place = inputtype === "textquery" ? findPlace(input, this.state.corpus()) : void 0;
+    if (!place) return this.noted(json4({ candidates: [], status: "ZERO_RESULTS" }), context);
+    return this.noted(
+      json4({ candidates: [pickFields(placeResult(place), fields, ["place_id"])], status: "OK" }),
+      context,
+      place
+    );
+  }
+  script(context) {
+    const key = text(context.query.key) ?? "";
+    const settings = this.state.current();
+    const origin = (settings.publicUrl ?? context.url.origin).replace(/\/$/, "");
+    const prefix = this.publicNamespace === "default" ? "" : `/ns/${encodeURIComponent(this.publicNamespace)}`;
+    const callback = text(context.query.callback) ?? null;
+    const safeCallback = callback && /^[A-Za-z_$][\w$.]*$/.test(callback) ? callback : null;
+    const authFailed = !key || settings.keys.length > 0 && !settings.keys.includes(key);
+    return new Response(
+      mapsJavaScript({ base: `${origin}${prefix}`, key, authFailed, callback: safeCallback }),
+      {
+        status: 200,
+        headers: { "content-type": "text/javascript; charset=UTF-8", ...CORS }
+      }
+    );
+  }
+};
+
+export {
+  document,
+  operationIds,
+  supportedOperationIds,
+  DEFAULT_CORPUS,
+  PHOENIX_DEMO_ADDRESS,
+  STATE_NAMES,
+  normalize,
+  corpusPlaceId,
+  mapsJavaScript,
+  GOOGLE_MAPS_PRESETS,
+  createRuntime2 as createRuntime,
+  GOOGLE_MAPS_NAMESPACE,
+  MISSING_KEY_MESSAGE,
+  INVALID_KEY_MESSAGE,
+  keyCredential,
+  GoogleMapsAPI
+};
+//# sourceMappingURL=chunk-5HEE5U7V.js.map