@crvouga/mockingbird-service-bedrock 0.1.0

package/dist/chunk-O5ZO5KMR.js

@@ -0,0 +1,4641 @@
+// ../core/dist/clock.js
+var createClock = (source = Date.now) => {
+  let offsetMs = 0;
+  let frozenAt;
+  const now = () => frozenAt ?? source() + offsetMs;
+  return {
+    now,
+    set: (epochMs) => {
+      if (frozenAt !== void 0)
+        frozenAt = epochMs;
+      else
+        offsetMs = epochMs - source();
+    },
+    advance: (deltaMs) => {
+      if (frozenAt !== void 0)
+        frozenAt += deltaMs;
+      else
+        offsetMs += deltaMs;
+    },
+    freeze: () => {
+      frozenAt = now();
+    },
+    unfreeze: () => {
+      if (frozenAt === void 0)
+        return;
+      offsetMs = frozenAt - source();
+      frozenAt = void 0;
+    },
+    reset: () => {
+      offsetMs = 0;
+      frozenAt = void 0;
+    },
+    state: () => ({ now: now(), frozen: frozenAt !== void 0, offsetMs })
+  };
+};
+
+// ../core/dist/collection.js
+var Collection = class {
+  sqlite;
+  namespace;
+  name;
+  constructor(sqlite, namespace, name) {
+    this.sqlite = sqlite;
+    this.namespace = namespace;
+    this.name = name;
+  }
+  bumpCollectionSeq() {
+    const row = this.sqlite.prepare("SELECT value FROM mockingbird_sequences WHERE namespace = ? AND name = ? AND kind = 'collection'").get(this.namespace, this.name);
+    const next = (row?.value ?? 0) + 1;
+    this.sqlite.prepare(`INSERT INTO mockingbird_sequences (namespace, name, kind, value) VALUES (?, ?, 'collection', ?)
+         ON CONFLICT(namespace, name, kind) DO UPDATE SET value = excluded.value`).run(this.namespace, this.name, next);
+    return next;
+  }
+  nextSequence() {
+    return this.sqlite.transaction(() => this.bumpCollectionSeq());
+  }
+  get(id) {
+    const row = this.sqlite.prepare("SELECT value FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").get(this.namespace, this.name, id);
+    if (!row)
+      return void 0;
+    return JSON.parse(row.value).value;
+  }
+  has(id) {
+    const row = this.sqlite.prepare("SELECT 1 AS ok FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").get(this.namespace, this.name, id);
+    return row !== void 0;
+  }
+  /** Insert a new record, assigning it the next sequence number. */
+  insert(id, value) {
+    return this.sqlite.transaction(() => {
+      const seq = this.bumpCollectionSeq();
+      const stored = { seq, value };
+      this.sqlite.prepare(`INSERT INTO mockingbird_records (namespace, collection, id, seq, value)
+           VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT(namespace, collection, id) DO UPDATE SET seq = excluded.seq, value = excluded.value`).run(this.namespace, this.name, id, seq, JSON.stringify(stored));
+      return stored;
+    });
+  }
+  /** Replace an existing record's value, keeping its position. */
+  update(id, value) {
+    return this.sqlite.transaction(() => {
+      const row = this.sqlite.prepare("SELECT seq, value FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").get(this.namespace, this.name, id);
+      if (!row)
+        return void 0;
+      const stored = { seq: row.seq, value };
+      this.sqlite.prepare("UPDATE mockingbird_records SET value = ? WHERE namespace = ? AND collection = ? AND id = ?").run(JSON.stringify(stored), this.namespace, this.name, id);
+      return stored;
+    });
+  }
+  delete(id) {
+    const result = this.sqlite.prepare("DELETE FROM mockingbird_records WHERE namespace = ? AND collection = ? AND id = ?").run(this.namespace, this.name, id);
+    return result.changes > 0;
+  }
+  /** How many records the collection holds, without reading them. */
+  count() {
+    const row = this.sqlite.prepare("SELECT COUNT(*) AS n FROM mockingbird_records WHERE namespace = ? AND collection = ?").get(this.namespace, this.name);
+    return Number(row?.n ?? 0);
+  }
+  list(options = {}) {
+    const rows = this.sqlite.prepare("SELECT id, seq, value FROM mockingbird_records WHERE namespace = ? AND collection = ?").all(this.namespace, this.name);
+    const out = [];
+    for (const row of rows) {
+      const stored = JSON.parse(row.value);
+      if (options.where && !options.where(stored.value, stored.seq))
+        continue;
+      out.push({ id: row.id, seq: stored.seq, value: stored.value });
+    }
+    out.sort((a, b) => options.order === "oldest" ? a.seq - b.seq : b.seq - a.seq);
+    return out;
+  }
+};
+
+// ../core/dist/control.js
+var HEALTH_PATH = "/health";
+var ADMIN_PREFIX = "/__admin";
+var ADMIN_KEY_HEADER = "x-mockingbird-admin-key";
+var NAMESPACE_HEADER = "x-mockingbird-namespace";
+var json = (status, body) => new Response(JSON.stringify(body), {
+  status,
+  headers: { "content-type": "application/json" }
+});
+var adminError = (status, message) => json(status, { error: { type: "mockingbird_admin", message } });
+var UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+var parseDuration = (value) => {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value !== "string")
+    return void 0;
+  const match = /^(-?\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/.exec(value.trim());
+  if (!match)
+    return void 0;
+  return Number(match[1]) * UNITS[match[2]];
+};
+var parseInstant = (value) => {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value !== "string")
+    return void 0;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+};
+var matchRoute = (pattern, path) => {
+  const want = pattern.split("/").filter(Boolean);
+  const have = path.split("/").filter(Boolean);
+  if (want.length !== have.length)
+    return void 0;
+  const params = {};
+  for (let i = 0; i < want.length; i++) {
+    const segment = want[i];
+    const actual = have[i];
+    if (segment.startsWith(":"))
+      params[segment.slice(1)] = decodeURIComponent(actual);
+    else if (segment !== actual)
+      return void 0;
+  }
+  return params;
+};
+var readJson = async (request) => {
+  const 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 sigV4AccessKeyId = (request) => {
+  const header = request.headers.get("authorization");
+  const fromHeader = header ? /Credential=([^/,\s]+)\//.exec(header)?.[1] : void 0;
+  if (fromHeader)
+    return fromHeader;
+  const query = new URL(request.url).searchParams.get("X-Amz-Credential");
+  return query ? query.split("/")[0] ?? void 0 : void 0;
+};
+var createCredentialRegistry = () => {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    set: (credential, namespace) => {
+      map.set(credential, namespace);
+    },
+    get: (credential) => map.get(credential),
+    remove: (credential) => map.delete(credential),
+    clear: () => map.clear(),
+    entries: () => [...map].map(([credential, namespace]) => ({ credential, namespace })).sort((a, b) => a.credential.localeCompare(b.credential))
+  };
+};
+var maskCredential = (credential) => credential.length <= 8 ? `${credential.slice(0, 2)}\u2026` : `${credential.slice(0, 6)}\u2026${credential.slice(-2)}`;
+
+// ../core/dist/rng.js
+var seedFrom = (value) => {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var createRng = (seed = 0) => {
+  const numeric = typeof seed === "string" ? seedFrom(seed) : seed >>> 0;
+  let state = numeric;
+  const next = () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+  return {
+    next,
+    int: (min, max) => min + Math.floor(next() * (max - min + 1)),
+    reset: () => {
+      state = numeric;
+    },
+    state: () => state,
+    setState: (next2) => {
+      if (!Number.isSafeInteger(next2) || next2 < 0 || next2 > 4294967295) {
+        throw new RangeError("rng state must be an unsigned 32-bit integer");
+      }
+      state = next2 >>> 0;
+    },
+    seed: numeric
+  };
+};
+
+// ../core/dist/faults.js
+var matches = (rule, candidate) => {
+  if (rule.namespace !== void 0 && rule.namespace !== "*" && rule.namespace !== candidate.namespace) {
+    return false;
+  }
+  if (rule.operationId !== void 0 && rule.operationId !== candidate.operationId)
+    return false;
+  if (rule.method !== void 0 && rule.method.toUpperCase() !== candidate.method.toUpperCase()) {
+    return false;
+  }
+  if (rule.pathPrefix !== void 0 && !candidate.path.startsWith(rule.pathPrefix))
+    return false;
+  return true;
+};
+var faultResponse = (rule) => {
+  const status = rule.status ?? 500;
+  const headers = { "content-type": "application/json", ...rule.headers };
+  if (typeof rule.body === "string")
+    return new Response(rule.body, { status, headers });
+  if (rule.body === null)
+    return new Response(null, { status, headers: rule.headers ?? {} });
+  const body = rule.body === void 0 ? { detail: "Injected by Mockingbird" } : rule.body;
+  return new Response(JSON.stringify(body), { status, headers });
+};
+var createFaultRegistry = (rng = createRng(0), sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) => {
+  const entries = [];
+  return {
+    add(rule) {
+      const existing = entries.findIndex((e) => e.rule.id === rule.id);
+      const entry = { rule, remaining: rule.count ?? null, hits: 0 };
+      if (existing >= 0)
+        entries[existing] = entry;
+      else
+        entries.push(entry);
+      return rule;
+    },
+    list: () => entries.map((e) => ({ ...e.rule, remaining: e.remaining, hits: e.hits })),
+    remove(id) {
+      const index = entries.findIndex((e) => e.rule.id === id);
+      if (index < 0)
+        return false;
+      entries.splice(index, 1);
+      return true;
+    },
+    clear() {
+      entries.length = 0;
+    },
+    async take(candidate) {
+      const hits = [];
+      for (const entry of entries) {
+        if (entry.remaining === 0)
+          continue;
+        if (!matches(entry.rule, candidate))
+          continue;
+        const rate = entry.rule.rate ?? 1;
+        if (rng.next() >= rate)
+          continue;
+        entry.hits++;
+        if (entry.remaining !== null)
+          entry.remaining--;
+        const delay = entry.rule.delayMs ?? entry.rule.latencyMs;
+        if (delay !== void 0 && delay > 0) {
+          await sleep(delay);
+        }
+        const hit = { id: entry.rule.id };
+        if (entry.rule.effect !== void 0) {
+          hit.effect = { name: entry.rule.effect, params: entry.rule.params ?? {} };
+        }
+        if (entry.rule.drop === true)
+          hit.drop = true;
+        else if (entry.rule.status !== void 0)
+          hit.response = faultResponse(entry.rule);
+        hits.push(hit);
+        if (hit.drop || hit.response)
+          break;
+      }
+      return hits;
+    }
+  };
+};
+
+// ../../openapi/core/dist/refs.js
+var OpenAPIReferenceError = class extends Error {
+  ref;
+  constructor(ref) {
+    super(`unresolvable $ref: ${ref}`);
+    this.ref = ref;
+    this.name = "OpenAPIReferenceError";
+  }
+};
+var unescapePointer = (segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~");
+var isReference = (value) => typeof value === "object" && value !== null && typeof value.$ref === "string";
+var resolveRef = (document2, ref) => {
+  if (!ref.startsWith("#/"))
+    throw new OpenAPIReferenceError(ref);
+  let cursor = document2;
+  for (const raw of ref.slice(2).split("/")) {
+    const segment = unescapePointer(raw);
+    if (typeof cursor !== "object" || cursor === null || !(segment in cursor)) {
+      throw new OpenAPIReferenceError(ref);
+    }
+    cursor = cursor[segment];
+  }
+  if (cursor === void 0)
+    throw new OpenAPIReferenceError(ref);
+  return cursor;
+};
+var deref = (document2, value) => {
+  let current = value;
+  const seen = /* @__PURE__ */ new Set();
+  while (isReference(current)) {
+    if (seen.has(current.$ref))
+      throw new OpenAPIReferenceError(`${current.$ref} (cycle)`);
+    seen.add(current.$ref);
+    current = resolveRef(document2, current.$ref);
+  }
+  return current;
+};
+
+// ../../openapi/core/dist/types.js
+var HTTP_METHODS = [
+  "get",
+  "put",
+  "post",
+  "delete",
+  "options",
+  "head",
+  "patch",
+  "trace"
+];
+
+// ../../openapi/core/dist/document.js
+var mergeParameters = (document2, item, own) => {
+  const merged = /* @__PURE__ */ new Map();
+  for (const raw of item.parameters ?? []) {
+    const parameter = deref(document2, raw);
+    merged.set(`${parameter.in}:${parameter.name}`, parameter);
+  }
+  for (const raw of own ?? []) {
+    const parameter = deref(document2, raw);
+    merged.set(`${parameter.in}:${parameter.name}`, parameter);
+  }
+  return [...merged.values()];
+};
+var listOperations = (document2) => {
+  const operations = [];
+  for (const [path, item] of Object.entries(document2.paths)) {
+    for (const method of HTTP_METHODS) {
+      const operation = item[method];
+      if (operation?.operationId === void 0)
+        continue;
+      const responses = {};
+      for (const [status, response] of Object.entries(operation.responses)) {
+        responses[status] = deref(document2, response);
+      }
+      operations.push({
+        operationId: operation.operationId,
+        method,
+        path,
+        operation,
+        parameters: mergeParameters(document2, item, operation.parameters),
+        requestBody: operation.requestBody === void 0 ? void 0 : deref(document2, operation.requestBody),
+        responses
+      });
+    }
+  }
+  return operations;
+};
+
+// ../../openapi/core/dist/schema.js
+var resolveSchema = (document2, schema) => {
+  let current = schema;
+  const seen = /* @__PURE__ */ new Set();
+  while (typeof current.$ref === "string") {
+    const ref = current.$ref;
+    if (seen.has(ref))
+      break;
+    seen.add(ref);
+    const { $ref: _ignored, ...siblings } = current;
+    const target = resolveRef(document2, ref);
+    current = { ...target, ...siblings };
+  }
+  if (current.nullable === true) {
+    const { nullable: _nullable, ...rest } = current;
+    const types = schemaTypes(rest);
+    if (types.length > 0 && !types.includes("null"))
+      current = { ...rest, type: [...types, "null"] };
+    else
+      current = rest;
+  }
+  return current;
+};
+var schemaTypes = (schema) => {
+  if (Array.isArray(schema.type))
+    return schema.type;
+  if (schema.type !== void 0)
+    return [schema.type];
+  const inferred = [];
+  if (schema.properties || schema.required || schema.additionalProperties !== void 0)
+    inferred.push("object");
+  if (schema.items || schema.prefixItems || schema.minItems !== void 0 || schema.maxItems !== void 0)
+    inferred.push("array");
+  if (schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern !== void 0)
+    inferred.push("string");
+  if (schema.minimum !== void 0 || schema.maximum !== void 0 || schema.multipleOf !== void 0)
+    inferred.push("number");
+  return inferred;
+};
+var jsonTypeOf = (value) => {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "number":
+      return Number.isInteger(value) ? "integer" : "number";
+    case "object":
+      return "object";
+    default:
+      return "undefined";
+  }
+};
+var deepEqual = (a, b) => {
+  if (a === b)
+    return true;
+  if (typeof a !== typeof b || a === null || b === null)
+    return false;
+  if (Array.isArray(a)) {
+    return Array.isArray(b) && a.length === b.length && a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object" && !Array.isArray(b)) {
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    return ka.length === kb.length && ka.every((k) => deepEqual(a[k], b[k]));
+  }
+  return false;
+};
+var FORMAT_PATTERNS = {
+  uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  date: /^\d{4}-\d{2}-\d{2}$/,
+  "date-time": /^\d{4}-\d{2}-\d{2}[Tt ]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/,
+  email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  uri: /^[a-zA-Z][a-zA-Z0-9+.-]*:[^\s]*$/,
+  ipv4: /^(25[0-5]|2[0-4]\d|1?\d?\d)(\.(25[0-5]|2[0-4]\d|1?\d?\d)){3}$/
+};
+var graphemeLength = (value) => [...value].length;
+var validateValue = (document2, schema, value, path = []) => {
+  const errors = [];
+  const s = resolveSchema(document2, schema);
+  const fail2 = (message) => errors.push({ path, message });
+  const actual = jsonTypeOf(value);
+  if (actual === "undefined") {
+    fail2("value is undefined");
+    return errors;
+  }
+  const types = schemaTypes(s);
+  if (types.length > 0) {
+    const ok = types.some((t) => t === actual || t === "number" && actual === "integer");
+    if (!ok) {
+      fail2(`expected type ${types.join("|")}, got ${actual}`);
+      return errors;
+    }
+  }
+  if (s.enum && !(value === null && types.includes("null")) && !s.enum.some((candidate) => deepEqual(candidate, value))) {
+    fail2("value not in enum");
+  }
+  if (s.const !== void 0 && !deepEqual(s.const, value))
+    fail2("value does not equal const");
+  if (typeof value === "string") {
+    const length = graphemeLength(value);
+    if (s.minLength !== void 0 && length < s.minLength)
+      fail2(`length ${length} < minLength ${s.minLength}`);
+    if (s.maxLength !== void 0 && length > s.maxLength)
+      fail2(`length ${length} > maxLength ${s.maxLength}`);
+    if (s.pattern !== void 0) {
+      try {
+        if (!new RegExp(s.pattern, "u").test(value))
+          fail2(`does not match pattern ${s.pattern}`);
+      } catch {
+      }
+    }
+    if (s.format !== void 0) {
+      const pattern = FORMAT_PATTERNS[s.format];
+      if (pattern && !pattern.test(value))
+        fail2(`does not match format ${s.format}`);
+    }
+  }
+  if (typeof value === "number") {
+    if (s.minimum !== void 0 && value < s.minimum)
+      fail2(`${value} < minimum ${s.minimum}`);
+    if (s.maximum !== void 0 && value > s.maximum)
+      fail2(`${value} > maximum ${s.maximum}`);
+    if (s.exclusiveMinimum !== void 0 && value <= s.exclusiveMinimum)
+      fail2(`${value} <= exclusiveMinimum ${s.exclusiveMinimum}`);
+    if (s.exclusiveMaximum !== void 0 && value >= s.exclusiveMaximum)
+      fail2(`${value} >= exclusiveMaximum ${s.exclusiveMaximum}`);
+    if (s.multipleOf !== void 0 && Math.abs(value / s.multipleOf - Math.round(value / s.multipleOf)) > 1e-9) {
+      fail2(`${value} is not a multiple of ${s.multipleOf}`);
+    }
+  }
+  if (Array.isArray(value)) {
+    if (s.minItems !== void 0 && value.length < s.minItems)
+      fail2(`${value.length} items < minItems ${s.minItems}`);
+    if (s.maxItems !== void 0 && value.length > s.maxItems)
+      fail2(`${value.length} items > maxItems ${s.maxItems}`);
+    if (s.uniqueItems && value.some((item, i) => value.slice(0, i).some((prev) => deepEqual(prev, item))))
+      fail2("items are not unique");
+    value.forEach((item, i) => {
+      const itemSchema = s.prefixItems?.[i] ?? s.items;
+      if (itemSchema)
+        errors.push(...validateValue(document2, itemSchema, item, [...path, i]));
+    });
+  }
+  if (actual === "object") {
+    const record = value;
+    const keys = Object.keys(record);
+    for (const name of s.required ?? [])
+      if (!(name in record))
+        fail2(`missing required property ${name}`);
+    if (s.minProperties !== void 0 && keys.length < s.minProperties)
+      fail2(`${keys.length} properties < minProperties ${s.minProperties}`);
+    if (s.maxProperties !== void 0 && keys.length > s.maxProperties)
+      fail2(`${keys.length} properties > maxProperties ${s.maxProperties}`);
+    for (const key of keys) {
+      const property = s.properties?.[key];
+      if (property) {
+        errors.push(...validateValue(document2, property, record[key], [...path, key]));
+        continue;
+      }
+      if (s.additionalProperties === false)
+        fail2(`unexpected property ${key}`);
+      else if (typeof s.additionalProperties === "object") {
+        errors.push(...validateValue(document2, s.additionalProperties, record[key], [...path, key]));
+      }
+      if (s.propertyNames) {
+        const nameErrors = validateValue(document2, s.propertyNames, key, [...path, key]);
+        if (nameErrors.length > 0)
+          fail2(`property name ${key} is invalid: ${nameErrors[0]?.message}`);
+      }
+    }
+  }
+  if (s.allOf)
+    for (const branch of s.allOf)
+      errors.push(...validateValue(document2, branch, value, path));
+  if (s.anyOf && !s.anyOf.some((branch) => validateValue(document2, branch, value).length === 0))
+    fail2("matches no anyOf branch");
+  if (s.oneOf) {
+    const matches3 = s.oneOf.filter((branch) => validateValue(document2, branch, value).length === 0).length;
+    if (matches3 !== 1)
+      fail2(`matches ${matches3} oneOf branches, expected exactly 1`);
+  }
+  if (s.not && validateValue(document2, s.not, value).length === 0)
+    fail2("matches forbidden `not` schema");
+  return errors;
+};
+
+// ../../http/codec/dist/form.js
+var parsePath = (rawKey) => {
+  const open = rawKey.indexOf("[");
+  if (open === -1)
+    return [rawKey];
+  const path = [rawKey.slice(0, open)];
+  const rest = rawKey.slice(open);
+  const pattern = /\[([^\]]*)\]/g;
+  let match = pattern.exec(rest);
+  let consumed = 0;
+  while (match !== null) {
+    if (match.index !== consumed)
+      return [rawKey];
+    path.push(match[1] ?? "");
+    consumed = match.index + match[0].length;
+    match = pattern.exec(rest);
+  }
+  if (consumed !== rest.length)
+    return [rawKey];
+  return path;
+};
+var isIndex = (segment) => /^(0|[1-9][0-9]*)$/.test(segment);
+var put = (target, key, value) => {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+    return;
+  }
+  ;
+  target[key] = value;
+};
+var assign = (target, path, value) => {
+  let cursor = target;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    const last = i === path.length - 1;
+    if (Array.isArray(cursor)) {
+      const index = segment === "" ? cursor.length : isIndex(segment) ? Number(segment) : void 0;
+      if (index === void 0)
+        return;
+      if (last) {
+        put(cursor, index, value);
+        return;
+      }
+      const next = Object.hasOwn(cursor, index) ? cursor[index] : void 0;
+      if (next === void 0 || typeof next === "string") {
+        const created = path[i + 1] === "" || isIndex(path[i + 1]) ? [] : {};
+        put(cursor, index, created);
+        cursor = created;
+      } else {
+        cursor = next;
+      }
+      continue;
+    }
+    if (typeof cursor === "string")
+      return;
+    if (last) {
+      put(cursor, segment, value);
+      return;
+    }
+    const nextSegment = path[i + 1];
+    const existing = Object.hasOwn(cursor, segment) ? cursor[segment] : void 0;
+    if (existing === void 0 || typeof existing === "string") {
+      const created = nextSegment === "" || isIndex(nextSegment) ? [] : {};
+      put(cursor, segment, created);
+      cursor = created;
+    } else {
+      cursor = existing;
+    }
+  }
+};
+var decodeFormPairs = (pairs) => {
+  const out = {};
+  for (const [rawKey, value] of pairs)
+    assign(out, parsePath(rawKey), value);
+  return densify(out);
+};
+var densify = (value) => {
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value))
+    return value.filter((item) => item !== void 0).map(densify);
+  const out = {};
+  for (const [key, item] of Object.entries(value))
+    put(out, key, densify(item));
+  return out;
+};
+var decodeForm = (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 round = 0;
+  while (out.length < length) {
+    let hash = mix(`${input}:${round++}`);
+    for (let i = 0; i < 5 && out.length < length; i++) {
+      out += ALPHABET.charAt(hash % ALPHABET.length);
+      hash = Math.floor(hash / ALPHABET.length);
+    }
+  }
+  return out;
+};
+var IdSequence = class {
+  sqlite;
+  namespace;
+  salt;
+  constructor(sqlite, namespace, salt = "mockingbird") {
+    this.sqlite = sqlite;
+    this.namespace = namespace;
+    this.salt = salt;
+  }
+  next(prefix, length = 14) {
+    return this.sqlite.transaction(() => {
+      const row = this.sqlite.prepare("SELECT value FROM mockingbird_sequences WHERE namespace = ? AND name = ? AND kind = 'id'").get(this.namespace, prefix);
+      const value = (row?.value ?? 0) + 1;
+      this.sqlite.prepare(`INSERT INTO mockingbird_sequences (namespace, name, kind, value) VALUES (?, ?, 'id', ?)
+           ON CONFLICT(namespace, name, kind) DO UPDATE SET value = excluded.value`).run(this.namespace, prefix, value);
+      return `${prefix}${opaqueToken(`${this.salt}:${prefix}:${value}`, length)}`;
+    });
+  }
+};
+
+// ../core/dist/journal.js
+var DEFAULT_JOURNAL_SIZE = 1e3;
+var createJournal = (size = DEFAULT_JOURNAL_SIZE) => {
+  const capacity = Math.max(0, Math.floor(size));
+  const rings = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const order = /* @__PURE__ */ new WeakMap();
+  const inOrder = (ring) => ring.entries.length < capacity ? ring.entries : [...ring.entries.slice(ring.next), ...ring.entries.slice(0, ring.next)];
+  return {
+    size: capacity,
+    record(entry) {
+      if (capacity === 0)
+        return;
+      order.set(entry, sequence++);
+      let ring = rings.get(entry.namespace);
+      if (!ring) {
+        ring = { entries: [], next: 0 };
+        rings.set(entry.namespace, ring);
+      }
+      if (ring.entries.length < capacity)
+        ring.entries.push(entry);
+      else {
+        ring.entries[ring.next] = entry;
+        ring.next = (ring.next + 1) % capacity;
+      }
+    },
+    list(query = {}) {
+      const source = query.namespace !== void 0 ? inOrder(rings.get(query.namespace) ?? { entries: [], next: 0 }) : [...rings.values()].flatMap(inOrder).sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+      const matched = source.filter((entry) => (query.operationId === void 0 || entry.operationId === query.operationId) && (query.status === void 0 || entry.status === query.status) && (query.since === void 0 || Date.parse(entry.at) >= query.since));
+      return query.limit !== void 0 ? matched.slice(-Math.max(0, query.limit)) : matched;
+    },
+    clear(namespace) {
+      if (namespace === void 0)
+        rings.clear();
+      else
+        rings.delete(namespace);
+    }
+  };
+};
+var notes = /* @__PURE__ */ new WeakMap();
+var annotateResponse = (response, extra) => {
+  const existing = notes.get(response);
+  notes.set(response, {
+    ...existing,
+    ...extra,
+    ...existing?.ids || extra.ids ? { ids: { ...existing?.ids, ...extra.ids } } : {}
+  });
+  return response;
+};
+var responseNotes = (response) => notes.get(response);
+
+// ../core/dist/metrics.js
+var createMetrics = () => {
+  let requests = 0;
+  let faults = 0;
+  let totalDurationMs = 0;
+  const byOperation = /* @__PURE__ */ new Map();
+  const unmatched = /* @__PURE__ */ new Map();
+  return {
+    record(entry) {
+      requests++;
+      totalDurationMs += entry.durationMs;
+      if (entry.faultId !== void 0)
+        faults++;
+      const key = `${entry.operationId ?? "(unmatched)"} ${entry.status}`;
+      byOperation.set(key, (byOperation.get(key) ?? 0) + 1);
+      if (entry.unmatched) {
+        const route = `${entry.method} ${entry.path}`;
+        unmatched.set(route, (unmatched.get(route) ?? 0) + 1);
+      }
+    },
+    report: () => ({
+      requests,
+      byOperation: Object.fromEntries([...byOperation].sort(([a], [b]) => a.localeCompare(b))),
+      unmatched: [...unmatched].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([route, count]) => {
+        const space = route.indexOf(" ");
+        return { method: route.slice(0, space), path: route.slice(space + 1), count };
+      }),
+      faults,
+      totalDurationMs
+    }),
+    reset() {
+      requests = 0;
+      faults = 0;
+      totalDurationMs = 0;
+      byOperation.clear();
+      unmatched.clear();
+    }
+  };
+};
+
+// ../../core/dist/timeline.js
+var BRANCH_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
+var Timeline = class {
+  maxCheckpoints;
+  now;
+  makeId;
+  nodes = /* @__PURE__ */ new Map();
+  heads = /* @__PURE__ */ new Map();
+  /** Unreferenced nodes in the exact order they became collectible. */
+  evictable = /* @__PURE__ */ new Set();
+  /** Branch heads plus explicit retainers. Absent means zero. */
+  references = /* @__PURE__ */ new Map();
+  explicitPins = /* @__PURE__ */ new Map();
+  sequence = 0;
+  constructor(options = {}) {
+    const max = options.maxCheckpoints ?? 1e3;
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("maxCheckpoints must be a positive integer");
+    this.maxCheckpoints = max;
+    this.now = options.now ?? (() => this.sequence);
+    this.makeId = options.id ?? ((sequence) => `cp_${sequence.toString(36).padStart(8, "0")}`);
+  }
+  /** Capture a new immutable value and move `branch` to it. */
+  commit(value, options = {}) {
+    const branch = options.branch ?? "main";
+    this.assertBranch(branch);
+    const parent = options.parent === void 0 ? this.heads.get(branch) ?? null : options.parent;
+    if (parent !== null && !this.nodes.has(parent))
+      throw new RangeError(`no checkpoint ${parent}`);
+    const id = this.makeId(++this.sequence);
+    if (this.nodes.has(id))
+      throw new RangeError(`duplicate checkpoint id ${id}`);
+    const checkpoint = Object.freeze({ id, branch, parent, at: this.now(), value });
+    this.nodes.set(id, checkpoint);
+    this.moveHead(branch, id);
+    this.collect(this.maxCheckpoints);
+    return checkpoint;
+  }
+  /** Create a branch pointer without copying its checkpoint value. */
+  fork(branch, options = {}) {
+    this.assertBranch(branch);
+    if (this.heads.has(branch))
+      throw new RangeError(`branch already exists: ${branch}`);
+    const from = options.from ?? this.heads.get("main");
+    if (from === void 0)
+      return void 0;
+    const checkpoint = this.get(from);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  /** Move a branch pointer to an existing checkpoint. */
+  checkout(branch, id) {
+    this.assertBranch(branch);
+    const checkpoint = this.get(id);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  get(id) {
+    const checkpoint = this.nodes.get(id);
+    if (!checkpoint)
+      throw new RangeError(`no checkpoint ${id}`);
+    return checkpoint;
+  }
+  head(branch = "main") {
+    const id = this.heads.get(branch);
+    return id === void 0 ? void 0 : this.get(id);
+  }
+  hasBranch(branch) {
+    return this.heads.has(branch);
+  }
+  branches() {
+    return Object.freeze(Object.fromEntries([...this.heads].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)));
+  }
+  checkpoints() {
+    return [...this.nodes.values()];
+  }
+  /** Number of retained checkpoints without allocating an array. */
+  get size() {
+    return this.nodes.size;
+  }
+  /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
+  retain(id) {
+    const checkpoint = this.get(id);
+    this.explicitPins.set(id, (this.explicitPins.get(id) ?? 0) + 1);
+    this.addReference(id);
+    return checkpoint;
+  }
+  /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
+  release(id) {
+    if (!this.nodes.has(id))
+      return false;
+    const pins = this.explicitPins.get(id) ?? 0;
+    if (pins === 0)
+      return false;
+    if (pins === 1)
+      this.explicitPins.delete(id);
+    else
+      this.explicitPins.set(id, pins - 1);
+    this.removeReference(id);
+    this.collect(this.maxCheckpoints);
+    return true;
+  }
+  deleteBranch(branch) {
+    if (branch === "main")
+      throw new RangeError("cannot delete main branch");
+    const previous = this.heads.get(branch);
+    const deleted = this.heads.delete(branch);
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.collect(this.maxCheckpoints);
+    return deleted;
+  }
+  /**
+   * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
+   * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
+   * storage dependency, so a retained node remains usable after pruning.
+   */
+  gc(max = this.maxCheckpoints) {
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("max must be a positive integer");
+    const removed = [];
+    this.collect(max, removed);
+    return removed;
+  }
+  collect(max, removed) {
+    while (this.nodes.size > max && this.evictable.size > 0) {
+      const id = this.evictable.values().next().value;
+      this.evictable.delete(id);
+      this.nodes.delete(id);
+      removed?.push(id);
+    }
+  }
+  moveHead(branch, id) {
+    const previous = this.heads.get(branch);
+    if (previous === id)
+      return;
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.heads.set(branch, id);
+    this.addReference(id);
+  }
+  addReference(id) {
+    this.references.set(id, (this.references.get(id) ?? 0) + 1);
+    this.evictable.delete(id);
+  }
+  removeReference(id) {
+    const next = (this.references.get(id) ?? 0) - 1;
+    if (next > 0)
+      this.references.set(id, next);
+    else {
+      this.references.delete(id);
+      if (this.nodes.has(id))
+        this.evictable.add(id);
+    }
+  }
+  assertBranch(branch) {
+    if (!BRANCH_PATTERN.test(branch))
+      throw new RangeError(`branch must match ${BRANCH_PATTERN}`);
+  }
+};
+
+// ../../sqlite/dist/default.js
+import { Database } from "@crvouga/mockingbird-service-sqlite";
+var createDefaultSqlite = () => new Database();
+var resolveSqlite = (sqlite) => sqlite ?? createDefaultSqlite();
+
+// ../../sqlite/dist/migrate.js
+var ensureMigrationsTable = (sqlite) => {
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      id TEXT PRIMARY KEY NOT NULL,
+      applied_at INTEGER NOT NULL
+    )
+  `);
+};
+var migrate = (sqlite, migrations) => {
+  ensureMigrationsTable(sqlite);
+  const applied = new Set(sqlite.prepare("SELECT id FROM schema_migrations").all().map((row) => row.id));
+  const pending = migrations.filter((migration) => !applied.has(migration.id));
+  if (pending.length === 0)
+    return;
+  const insert = sqlite.prepare("INSERT INTO schema_migrations (id, applied_at) VALUES (?, ?)");
+  const now = Math.floor(Date.now() / 1e3);
+  sqlite.transaction(() => {
+    for (const migration of pending) {
+      sqlite.exec(migration.sql);
+      insert.run(migration.id, now);
+    }
+  });
+};
+
+// ../../sqlite/dist/schema.js
+var CORE_MIGRATIONS = [
+  {
+    id: "20260322_core_records_sequences",
+    sql: `
+      CREATE TABLE IF NOT EXISTS mockingbird_records (
+        namespace TEXT NOT NULL,
+        collection TEXT NOT NULL,
+        id TEXT NOT NULL,
+        seq INTEGER NOT NULL,
+        value TEXT NOT NULL,
+        PRIMARY KEY (namespace, collection, id)
+      );
+      CREATE INDEX IF NOT EXISTS mockingbird_records_seq
+        ON mockingbird_records (namespace, collection, seq);
+      CREATE TABLE IF NOT EXISTS mockingbird_sequences (
+        namespace TEXT NOT NULL,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        value INTEGER NOT NULL,
+        PRIMARY KEY (namespace, name, kind)
+      );
+    `
+  }
+];
+var migrateCore = (sqlite) => {
+  migrate(sqlite, CORE_MIGRATIONS);
+};
+var clearNamespace = (sqlite, namespace) => {
+  sqlite.transaction(() => {
+    sqlite.prepare("DELETE FROM mockingbird_records WHERE namespace = ?").run(namespace);
+    sqlite.prepare("DELETE FROM mockingbird_sequences WHERE namespace = ?").run(namespace);
+  });
+};
+
+// ../../openapi/metadata/dist/types.js
+var EXTENSION_KEYS = {
+  operation: "x-mockingbird",
+  resource: "x-mockingbird-resource",
+  resourceRef: "x-mockingbird-resource-ref",
+  volatile: "x-mockingbird-volatile",
+  scope: "x-mockingbird-scope",
+  unsupported: "x-mockingbird-unsupported",
+  parityHeader: "x-mockingbird-parity-header"
+};
+
+// ../../openapi/metadata/dist/read.js
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var extensionOf = (holder, key) => holder[key];
+var operationMetadata = (operation) => {
+  const raw = extensionOf(operation, EXTENSION_KEYS.operation);
+  const ext = isRecord2(raw) ? raw : {};
+  const supported = ext.supported ?? true;
+  const parity = ext.parity ?? {};
+  return {
+    supported,
+    reason: typeof ext.reason === "string" ? ext.reason : void 0,
+    parity: {
+      enabled: supported && (parity.enabled ?? true),
+      safe: parity.safe ?? true,
+      reason: typeof parity.reason === "string" ? parity.reason : void 0
+    }
+  };
+};
+
+// ../core/dist/service.js
+import { Hono } from "hono";
+var defineOperations = (handlers) => handlers;
+var OperationRegistryError = class extends Error {
+  problems;
+  constructor(problems) {
+    super(`operation registry is inconsistent:
+${problems.map((p) => `  - ${p}`).join("\n")}`);
+    this.problems = problems;
+    this.name = "OperationRegistryError";
+  }
+};
+var verifyOperations = (document2, handlers) => {
+  const problems = [];
+  const operations = listOperations(document2);
+  const seen = /* @__PURE__ */ new Set();
+  for (const operation of operations) {
+    if (seen.has(operation.operationId))
+      problems.push(`duplicate operationId ${operation.operationId}`);
+    seen.add(operation.operationId);
+    const supported = operationMetadata(operation.operation).supported;
+    const handler = handlers[operation.operationId];
+    if (supported && !handler)
+      problems.push(`supported operation ${operation.operationId} has no handler`);
+    if (!supported && handler)
+      problems.push(`operation ${operation.operationId} is marked unsupported but has a handler`);
+  }
+  for (const id of Object.keys(handlers)) {
+    if (!seen.has(id))
+      problems.push(`handler ${id} has no OpenAPI operation`);
+  }
+  return problems;
+};
+var honoPath = (template) => template.replace(/\{([^}]+)\}/g, ":$1");
+var routeOrder = (a, b) => {
+  const sa = a.path.split("/");
+  const sb = b.path.split("/");
+  for (let i = 0; i < Math.max(sa.length, sb.length); i++) {
+    const x = sa[i] ?? "";
+    const y = sb[i] ?? "";
+    const px = x.startsWith("{");
+    const py = y.startsWith("{");
+    if (px !== py)
+      return px ? 1 : -1;
+    if (x !== y)
+      return x < y ? -1 : 1;
+  }
+  return 0;
+};
+var queryOf = (url) => decodeFormPairs(url.searchParams.entries());
+var bootSqlite = (sqlite) => {
+  const client = resolveSqlite(sqlite);
+  migrateCore(client);
+  return client;
+};
+var createService = (options) => {
+  const problems = verifyOperations(options.document, options.handlers);
+  if (problems.length > 0)
+    throw new OperationRegistryError(problems);
+  migrateCore(options.sqlite);
+  const now = options.now ?? (() => Date.now());
+  const app = new Hono();
+  app.notFound((c) => options.notFound(c.req.raw));
+  app.onError((error, c) => options.onError(error, c.req.raw));
+  const operations = [...listOperations(options.document)].sort(routeOrder);
+  for (const operation of operations) {
+    const metadata = operationMetadata(operation.operation);
+    const handler = options.handlers[operation.operationId];
+    const route = async (c) => {
+      const request = c.req.raw;
+      if (!metadata.supported || !handler) {
+        return options.unsupported ? options.unsupported(request, operation) : options.notFound(request);
+      }
+      const url = new URL(request.url);
+      const context = {
+        request,
+        url,
+        params: c.req.param(),
+        query: queryOf(url),
+        body: await readBody(request),
+        sqlite: options.sqlite,
+        namespace: options.namespace,
+        operation,
+        document: options.document,
+        now
+      };
+      const short = await options.before?.(context);
+      if (short)
+        return short;
+      return handler(context);
+    };
+    app.on(operation.method.toUpperCase(), honoPath(operation.path), route);
+  }
+  return {
+    app,
+    sqlite: options.sqlite,
+    namespace: options.namespace,
+    fetch: async (request) => app.fetch(request),
+    reset: async () => {
+      clearNamespace(options.sqlite, options.namespace);
+    }
+  };
+};
+
+// ../core/dist/snapshot.js
+var snapshotNamespace = (sqlite, namespace) => ({
+  namespace,
+  records: sqlite.prepare("SELECT collection, id, seq, value FROM mockingbird_records WHERE namespace = ? ORDER BY collection, seq").all(namespace),
+  sequences: sqlite.prepare("SELECT name, kind, value FROM mockingbird_sequences WHERE namespace = ? ORDER BY name, kind").all(namespace)
+});
+var restoreNamespace = (sqlite, namespace, snapshot) => {
+  sqlite.transaction(() => {
+    sqlite.prepare("DELETE FROM mockingbird_records WHERE namespace = ?").run(namespace);
+    sqlite.prepare("DELETE FROM mockingbird_sequences WHERE namespace = ?").run(namespace);
+    const record = sqlite.prepare("INSERT INTO mockingbird_records (namespace, collection, id, seq, value) VALUES (?, ?, ?, ?, ?)");
+    for (const row of snapshot.records) {
+      record.run(namespace, row.collection, row.id, row.seq, row.value);
+    }
+    const sequence = sqlite.prepare("INSERT INTO mockingbird_sequences (namespace, name, kind, value) VALUES (?, ?, ?, ?)");
+    for (const row of snapshot.sequences) {
+      sequence.run(namespace, row.name, row.kind, row.value);
+    }
+  });
+};
+
+// ../core/dist/version.js
+var PACKAGE_VERSION = true ? "0.1.0" : UNRELEASED_VERSION;
+
+// ../core/dist/signing.js
+var encoder = new TextEncoder();
+var toHex = (bytes) => [...bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+var sha = async (algorithm, input) => toHex(await crypto.subtle.digest(algorithm, typeof input === "string" ? encoder.encode(input) : input));
+
+// ../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((row) => Object.freeze(row));
+  const result = new Array(fresh.length);
+  let unchanged = fresh.length === previous.length;
+  let oldIndex = 0;
+  for (let index = 0; index < fresh.length; index++) {
+    const row = fresh[index];
+    while (oldIndex < previous.length && compare(previous[oldIndex], row) < 0) {
+      oldIndex++;
+    }
+    const old = previous[oldIndex];
+    result[index] = old !== void 0 && compare(old, row) === 0 && equal(old, row) ? old : Object.freeze(row);
+    if (result[index] !== previous[index])
+      unchanged = false;
+  }
+  return unchanged ? previous : result;
+};
+var faultEffects = (request) => (effects.get(request) ?? []).filter((e) => e !== void 0);
+var faultEffect = (request, name) => faultEffects(request).find((e) => e.name === name)?.params;
+var DroppedConnectionError = class extends TypeError {
+  code = "MOCKINGBIRD_DROP";
+  constructor() {
+    super("fetch failed: connection dropped by Mockingbird fault");
+    this.name = "TypeError";
+  }
+};
+var operationMatcher = (document2) => {
+  const matchers = listOperations(document2).map((operation) => ({
+    operationId: operation.operationId,
+    method: operation.method.toUpperCase(),
+    pattern: new RegExp(`^${operation.path.split("/").map((segment) => segment.startsWith("{") ? "[^/]+" : segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("/")}/?$`),
+    params: (operation.path.match(/\{/g) ?? []).length
+  })).sort((a, b) => a.params - b.params);
+  return (request, path) => matchers.find((m) => m.method === request.method && m.pattern.test(path))?.operationId;
+};
+var createRuntime = (options) => {
+  const sqlite = bootSqlite(options.sqlite);
+  const clock = options.clock ?? createClock();
+  const rng = createRng(options.seed ?? 0);
+  const wallNow = options.io?.wallNow ?? Date.now;
+  const monotonicNow = options.io?.monotonicNow ?? (() => performance.now());
+  const sleep = options.io?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const faults = createFaultRegistry(createRng(options.seed ?? 0), sleep);
+  const metrics = createMetrics();
+  const journal = createJournal(options.journalSize ?? DEFAULT_JOURNAL_SIZE);
+  const version = options.version ?? PACKAGE_VERSION;
+  const instances = /* @__PURE__ */ new Map();
+  const publicNamespaces = /* @__PURE__ */ new Set();
+  const branchRngs = /* @__PURE__ */ new Map();
+  const timelines = /* @__PURE__ */ new Map();
+  const branchStorage = /* @__PURE__ */ new Map();
+  const captured = /* @__PURE__ */ new Map();
+  const credentials = createCredentialRegistry();
+  const operationIdFor = options.document ? operationMatcher(options.document) : () => void 0;
+  const storageNamespace = (name) => name === DEFAULT_NAMESPACE ? options.name : `${options.name}:${name}`;
+  const instanceFor = (key, publicNamespace = key, isolatedRng) => {
+    const existing = instances.get(key);
+    if (existing)
+      return existing;
+    if (!NAMESPACE_PATTERN.test(key) || !NAMESPACE_PATTERN.test(publicNamespace)) {
+      throw new RangeError(`namespace must match ${NAMESPACE_PATTERN}: ${JSON.stringify(publicNamespace)}`);
+    }
+    const created = options.create({
+      namespace: storageNamespace(key),
+      publicNamespace,
+      sqlite,
+      clock,
+      rng: isolatedRng ?? rng
+    });
+    instances.set(key, created);
+    publicNamespaces.add(publicNamespace);
+    if (isolatedRng)
+      branchRngs.set(key, isolatedRng);
+    return created;
+  };
+  const instance = (name = DEFAULT_NAMESPACE) => instanceFor(name);
+  const capture = (storage) => {
+    const fresh = snapshotNamespace(sqlite, storageNamespace(storage));
+    const previous = captured.get(storage);
+    const snapshot2 = {
+      namespace: fresh.namespace,
+      records: reuseSorted(fresh.records, previous?.records, (left, right) => left.collection < right.collection ? -1 : left.collection > right.collection ? 1 : left.seq - right.seq, (left, right) => left.id === right.id && left.value === right.value),
+      sequences: reuseSorted(fresh.sequences, previous?.sequences, (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : left.kind < right.kind ? -1 : left.kind > right.kind ? 1 : 0, (left, right) => left.value === right.value)
+    };
+    Object.freeze(snapshot2.records);
+    Object.freeze(snapshot2.sequences);
+    Object.freeze(snapshot2);
+    captured.set(storage, snapshot2);
+    return Object.freeze({
+      snapshot: snapshot2,
+      clock: Object.freeze(clock.state()),
+      rngState: (branchRngs.get(storage) ?? rng).state()
+    });
+  };
+  const timeline = (name = DEFAULT_NAMESPACE) => {
+    let found = timelines.get(name);
+    if (found)
+      return found;
+    instance(name);
+    found = new Timeline({
+      now: clock.now,
+      ...options.maxCheckpoints !== void 0 ? { maxCheckpoints: options.maxCheckpoints } : {}
+    });
+    found.commit(capture(name));
+    timelines.set(name, found);
+    return found;
+  };
+  const physicalBranch = (namespace, branch2) => {
+    if (branch2 === "main")
+      return namespace;
+    const mapKey = `${namespace}\0${branch2}`;
+    const existing = branchStorage.get(mapKey);
+    if (existing)
+      return existing;
+    const key = `branch_${seedFrom(`${options.name}\0${namespace}\0${branch2}`).toString(36)}`;
+    branchStorage.set(mapKey, key);
+    return key;
+  };
+  const ensureBranch = (namespace, branch2, at) => {
+    if (!BRANCH_PATTERN2.test(branch2))
+      throw new RangeError(`branch must match ${BRANCH_PATTERN2}`);
+    const history = timeline(namespace);
+    if (branch2 === "main") {
+      if (at !== void 0) {
+        const point = history.checkout("main", at);
+        restoreNamespace(sqlite, storageNamespace(namespace), point.value.snapshot);
+        captured.set(namespace, point.value.snapshot);
+        rng.setState(point.value.rngState);
+        clock.set(point.value.clock.now);
+        if (point.value.clock.frozen)
+          clock.freeze();
+        else
+          clock.unfreeze();
+      }
+      return namespace;
+    }
+    const storage = physicalBranch(namespace, branch2);
+    if (!history.hasBranch(branch2)) {
+      if (at === void 0)
+        history.commit(capture(namespace));
+      const point = history.fork(branch2, at === void 0 ? {} : { from: at });
+      const branchRng = createRng(options.seed ?? 0);
+      if (point)
+        branchRng.setState(point.value.rngState);
+      instanceFor(storage, namespace, branchRng);
+      if (point)
+        restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+      if (point)
+        captured.set(storage, point.value.snapshot);
+    } else if (at !== void 0 && history.head(branch2)?.id !== at) {
+      const point = history.checkout(branch2, at);
+      if (!instances.has(storage)) {
+        const branchRng = createRng(options.seed ?? 0);
+        branchRng.setState(point.value.rngState);
+        instanceFor(storage, namespace, branchRng);
+      }
+      branchRngs.get(storage)?.setState(point.value.rngState);
+      restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+      captured.set(storage, point.value.snapshot);
+    } else {
+      if (!instances.has(storage)) {
+        const point = history.head(branch2);
+        const branchRng = createRng(options.seed ?? 0);
+        if (point)
+          branchRng.setState(point.value.rngState);
+        instanceFor(storage, namespace, branchRng);
+      }
+    }
+    return storage;
+  };
+  const checkpoint = (namespace = DEFAULT_NAMESPACE, branch2 = "main") => {
+    const storage = ensureBranch(namespace, branch2);
+    return timeline(namespace).commit(capture(storage), { branch: branch2 });
+  };
+  const branch = (name, branchOptions = {}) => {
+    const namespace = branchOptions.namespace ?? DEFAULT_NAMESPACE;
+    ensureBranch(namespace, name, branchOptions.at);
+    const head = timeline(namespace).head(name);
+    if (!head)
+      throw new RangeError(`branch ${name} has no checkpoint`);
+    return head;
+  };
+  const checkout = (checkpointId, checkoutOptions = {}) => {
+    const namespace = checkoutOptions.namespace ?? DEFAULT_NAMESPACE;
+    const branchName = checkoutOptions.branch ?? "main";
+    const history = timeline(namespace);
+    const point = history.checkout(branchName, checkpointId);
+    const storage = ensureBranch(namespace, branchName);
+    restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+    captured.set(storage, point.value.snapshot);
+    clock.set(point.value.clock.now);
+    if (point.value.clock.frozen)
+      clock.freeze();
+    else
+      clock.unfreeze();
+    (branchRngs.get(storage) ?? rng).setState(point.value.rngState);
+  };
+  const reset = async (name = DEFAULT_NAMESPACE) => {
+    if (name === "*") {
+      options.webhooks?.clear();
+      for (const each of instances.values())
+        await each.reset();
+      timelines.clear();
+      branchStorage.clear();
+      branchRngs.clear();
+      captured.clear();
+      return;
+    }
+    options.webhooks?.clear(name);
+    const target = instances.get(name);
+    if (target)
+      await target.reset();
+    else
+      clearNamespace(sqlite, storageNamespace(name));
+    for (const [mapping, storage] of branchStorage) {
+      if (!mapping.startsWith(`${name}\0`))
+        continue;
+      const branchInstance = instances.get(storage);
+      if (branchInstance)
+        await branchInstance.reset();
+      else
+        clearNamespace(sqlite, storageNamespace(storage));
+      branchStorage.delete(mapping);
+      branchRngs.delete(storage);
+      captured.delete(storage);
+    }
+    timelines.delete(name);
+    captured.delete(name);
+  };
+  const snapshot = (name = DEFAULT_NAMESPACE) => {
+    return checkpoint(name, "main").value.snapshot;
+  };
+  const restore = (from, name = DEFAULT_NAMESPACE) => {
+    instance(name);
+    restoreNamespace(sqlite, storageNamespace(name), from);
+    captured.set(name, from);
+    const history = timelines.get(name);
+    if (history)
+      history.commit(capture(name), { branch: "main" });
+    else
+      timeline(name);
+  };
+  const runtime = {
+    name: options.name,
+    sqlite,
+    clock,
+    faults,
+    metrics,
+    journal,
+    rng,
+    credentials,
+    webhooks: options.webhooks,
+    applyPreset: (name, namespace = DEFAULT_NAMESPACE, overrides = {}) => {
+      const preset = options.presets?.[name];
+      if (!preset)
+        throw new RangeError(`no fault preset ${JSON.stringify(name)}`);
+      const added = (preset.rules ?? []).map((rule, index) => faults.add({
+        namespace,
+        ...rule,
+        ...overrides,
+        preset: name,
+        id: `${overrides.id ?? name}${(preset.rules ?? []).length > 1 ? `_${index + 1}` : ""}`
+      }));
+      if (preset.webhook && options.webhooks) {
+        options.webhooks.fault(namespace, {
+          ...preset.webhook,
+          ...overrides.count !== void 0 ? { count: overrides.count } : {}
+        });
+      }
+      return added;
+    },
+    instance,
+    namespaces: () => [...publicNamespaces].sort(),
+    reset,
+    snapshot,
+    restore,
+    checkpoint,
+    branch,
+    checkout,
+    timeline,
+    fetch: async (incoming) => {
+      let request = incoming;
+      const prefixed = PATH_PREFIX.exec(new URL(request.url).pathname);
+      if (prefixed) {
+        const url2 = new URL(request.url);
+        url2.pathname = prefixed[2] ?? "/";
+        const headers = new Headers(request.headers);
+        if (!headers.has(NAMESPACE_HEADER)) {
+          headers.set(NAMESPACE_HEADER, decodeURIComponent(prefixed[1]));
+        }
+        const hasBody = request.method !== "GET" && request.method !== "HEAD";
+        request = new Request(url2, {
+          method: request.method,
+          headers,
+          ...hasBody ? { body: await request.arrayBuffer() } : {},
+          signal: request.signal
+        });
+      }
+      let namespace = control.namespaceOf(request);
+      if (!request.headers.has(NAMESPACE_HEADER) && options.credential) {
+        const credential = options.credential(request);
+        const mapped = credential !== void 0 ? credentials.get(credential) : void 0;
+        if (mapped !== void 0)
+          namespace = mapped;
+      }
+      const selectedBranch = request.headers.get(BRANCH_HEADER) ?? "main";
+      const at = request.headers.get(AT_HEADER) ?? void 0;
+      const stamp = (response2) => {
+        const value = NAMESPACE_PATTERN.test(namespace) ? `${options.name}@${version}; ns=${namespace}` : `${options.name}@${version}`;
+        try {
+          response2.headers.set(MOCKINGBIRD_HEADER, value);
+          return response2;
+        } catch {
+          const copy = new Response(response2.body, response2);
+          copy.headers.set(MOCKINGBIRD_HEADER, value);
+          return copy;
+        }
+      };
+      const handled = await control.handle(request);
+      if (handled)
+        return stamp(handled);
+      const started = monotonicNow();
+      const url = new URL(request.url);
+      const operationId = operationIdFor(request, url.pathname);
+      const log = (status, faultId, response2) => {
+        const noted = response2 ? responseNotes(response2) : void 0;
+        const entry = {
+          service: options.name,
+          namespace,
+          operationId,
+          method: request.method,
+          path: url.pathname,
+          status,
+          durationMs: Math.round((monotonicNow() - started) * 100) / 100,
+          unmatched: options.document !== void 0 && operationId === void 0,
+          ...faultId !== void 0 ? { faultId } : {},
+          ...noted?.ids && Object.keys(noted.ids).length > 0 ? { ids: noted.ids } : {},
+          ...noted?.adopted ? { adopted: true } : {}
+        };
+        metrics.record(entry);
+        journal.record({ ...entry, at: new Date(clock.now()).toISOString() });
+        options.onLog?.(entry);
+      };
+      if (!NAMESPACE_PATTERN.test(namespace)) {
+        log(400);
+        return stamp(new Response(JSON.stringify({
+          error: {
+            type: "mockingbird_admin",
+            message: `${NAMESPACE_HEADER} must match ${NAMESPACE_PATTERN}`
+          }
+        }), { status: 400, headers: { "content-type": "application/json" } }));
+      }
+      if (!BRANCH_PATTERN2.test(selectedBranch)) {
+        log(400);
+        return stamp(adminFail(400, `${BRANCH_HEADER} must match ${BRANCH_PATTERN2}`));
+      }
+      let storage;
+      try {
+        if (at !== void 0 && selectedBranch === "main" && !MUTATING_METHODS.has(request.method)) {
+          const point = timeline(namespace).get(at);
+          storage = physicalBranch(namespace, `at_${at}`);
+          let viewRng = branchRngs.get(storage);
+          if (!viewRng) {
+            viewRng = createRng(options.seed ?? 0);
+            instanceFor(storage, namespace, viewRng);
+          }
+          viewRng.setState(point.value.rngState);
+          restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+          captured.set(storage, point.value.snapshot);
+        } else {
+          storage = ensureBranch(namespace, selectedBranch, at);
+        }
+      } catch (error) {
+        log(409);
+        return stamp(adminFail(409, error instanceof Error ? error.message : String(error)));
+      }
+      const hits = await faults.take({
+        operationId,
+        method: request.method,
+        path: url.pathname,
+        namespace
+      });
+      const final = hits.find((hit) => hit.drop || hit.response);
+      if (final?.drop) {
+        log(0, final.id);
+        throw new DroppedConnectionError();
+      }
+      if (final?.response) {
+        log(final.response.status, final.id);
+        return stamp(final.response);
+      }
+      const fired = hits.filter((hit) => hit.effect !== void 0);
+      if (fired.length > 0)
+        effects.set(request, fired.map((hit) => hit.effect));
+      let response = await instanceFor(storage, namespace).fetch(request);
+      if (MUTATING_METHODS.has(request.method) && response.status >= 200 && response.status < 400) {
+        const point = timeline(namespace).commit(capture(storage), { branch: selectedBranch });
+        response = mutableResponse(response);
+        response.headers.set(CHECKPOINT_HEADER, point.id);
+      }
+      if (selectedBranch !== "main") {
+        response = mutableResponse(response);
+        response.headers.set(BRANCH_HEADER, selectedBranch);
+      }
+      if (at !== void 0) {
+        response = mutableResponse(response);
+        response.headers.set(AT_HEADER, at);
+      }
+      log(response.status, fired[0]?.id, response);
+      return stamp(response);
+    }
+  };
+  const control = createControlPlane({
+    name: options.name,
+    startedAt: wallNow(),
+    wallNow,
+    clock,
+    faults,
+    metrics,
+    journal,
+    defaultNamespace: DEFAULT_NAMESPACE,
+    namespaces: runtime.namespaces,
+    reset,
+    timeTravel: {
+      checkpoint: (name, branchName) => {
+        const point = checkpoint(name, branchName);
+        return {
+          id: point.id,
+          branch: point.branch,
+          parent: point.parent,
+          at: point.at,
+          records: point.value.snapshot.records.length
+        };
+      },
+      branch: (branchName, branchOptions) => {
+        const point = branch(branchName, branchOptions);
+        return { id: point.id, branch: point.branch, parent: point.parent, at: point.at };
+      },
+      checkout: (checkpointId, checkoutOptions) => checkout(checkpointId, checkoutOptions),
+      retain: (name, checkpointId) => {
+        timeline(name).retain(checkpointId);
+      },
+      release: (name, checkpointId) => timeline(name).release(checkpointId),
+      inspect: (name) => {
+        const history = timeline(name);
+        return {
+          branches: history.branches(),
+          checkpoints: history.checkpoints().map(({ id, branch: branchName, parent, at }) => ({
+            id,
+            branch: branchName,
+            parent,
+            at
+          }))
+        };
+      }
+    },
+    describe: options.describe ?? (() => ({})),
+    ...options.presets ? {
+      applyPreset: (name, namespace, overrides) => runtime.applyPreset(name, namespace, overrides)
+    } : {},
+    routes: {
+      ...credentialRoutes(credentials),
+      ...options.presets ? presetRoutes(options.presets, runtime) : {},
+      ...options.webhooks ? webhookAdminRoutes(options.webhooks) : {},
+      ...options.admin?.(runtime) ?? {}
+    },
+    adminKey: options.adminKey
+  });
+  return runtime;
+};
+var mutableResponse = (response) => {
+  try {
+    response.headers.set("x-mockingbird-mutable-probe", "1");
+    response.headers.delete("x-mockingbird-mutable-probe");
+    return response;
+  } catch {
+    return new Response(response.body, response);
+  }
+};
+var adminJson = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminFail = (status, message) => adminJson(status, { error: { type: "mockingbird_admin", message } });
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var credentialRoutes = (registry) => ({
+  "GET /credentials": () => adminJson(200, {
+    credentials: registry.entries().map(({ credential, namespace }) => ({
+      credential: maskCredential(credential),
+      namespace
+    }))
+  }),
+  "PUT /credentials": ({ body, namespace }) => {
+    const pairs = [];
+    const list = Array.isArray(body) ? body : isObject(body) ? body.credentials : void 0;
+    if (Array.isArray(list)) {
+      for (const each of list) {
+        if (typeof each === "string")
+          pairs.push([each, namespace]);
+        else if (isObject(each) && typeof each.credential === "string") {
+          pairs.push([
+            each.credential,
+            typeof each.namespace === "string" ? each.namespace : namespace
+          ]);
+        } else
+          return adminFail(400, "each entry is a credential string or {credential, namespace}");
+      }
+    } else if (isObject(list)) {
+      for (const [credential, target] of Object.entries(list)) {
+        if (typeof target !== "string")
+          return adminFail(400, `namespace for ${credential} must be a string`);
+        pairs.push([credential, target]);
+      }
+    } else if (isObject(body) && typeof body.credential === "string") {
+      pairs.push([body.credential, typeof body.namespace === "string" ? body.namespace : namespace]);
+    } else {
+      return adminFail(400, 'expected {"credentials": {"<credential>": "<namespace>"}}');
+    }
+    for (const [credential, target] of pairs) {
+      if (!NAMESPACE_PATTERN.test(target))
+        return adminFail(400, `bad namespace ${JSON.stringify(target)}`);
+      registry.set(credential, target);
+    }
+    return adminJson(200, { mapped: pairs.length });
+  },
+  "DELETE /credentials": ({ url }) => {
+    const credential = url.searchParams.get("credential");
+    if (credential === null)
+      registry.clear();
+    else
+      registry.remove(credential);
+    return adminJson(200, { status: "ok" });
+  }
+});
+var presetRoutes = (presets, runtime) => ({
+  "GET /faults/presets": () => adminJson(200, {
+    presets: Object.entries(presets).map(([name, preset]) => ({ name, ...preset }))
+  }),
+  "POST /faults/presets/:name": ({ params, body, namespace }) => {
+    const name = params.name;
+    if (!presets[name])
+      return adminFail(404, `no fault preset ${name}; GET /__admin/faults/presets`);
+    const overrides = isObject(body) ? body : {};
+    return adminJson(201, { preset: name, rules: runtime.applyPreset(name, namespace, overrides) });
+  }
+});
+
+// ../core/dist/validation.js
+var bodyIssues = (context, contentType = "application/json") => {
+  const requestBody = context.operation.operation.requestBody;
+  if (!requestBody)
+    return [];
+  const resolved = deref(context.document, requestBody);
+  const schema = resolved.content?.[contentType]?.schema;
+  if (!schema)
+    return [];
+  const value = context.body.kind === "json" || context.body.kind === "form" ? context.body.value : void 0;
+  if (context.body.kind === "invalid") {
+    return [{ path: "", message: `request body is not valid ${context.body.mediaType}` }];
+  }
+  if (value === void 0) {
+    return resolved.required ? [{ path: "", message: "request body is required" }] : [];
+  }
+  return validateValue(context.document, resolveSchema(context.document, schema), value).map((issue) => ({ path: issue.path.join("."), message: issue.message }));
+};
+
+// src/analyze.ts
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var array = (value) => Array.isArray(value) ? value : [];
+var ValidationProblem = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationProblem";
+  }
+};
+var NO_PREFILL = /claude-(?:sonnet|opus)-4-[5-9]|claude-opus-4-1|claude-(?:sonnet|opus|haiku)-[5-9]/i;
+var ONE_SAMPLING_PARAM = /claude-(?:sonnet|opus|haiku)-4-[5-9]|claude-opus-4-1|claude-(?:sonnet|opus|haiku)-[5-9]/i;
+var parseSchema = (value) => {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+};
+var textOf = (blocks) => blocks.map((block) => isRecord4(block) && typeof block.text === "string" ? block.text : "").filter((text2) => text2.length > 0).join("\n");
+var conversationFacts = (messages) => {
+  let lastSaid = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "user" && message.hasContent) {
+      lastSaid = i;
+      break;
+    }
+  }
+  const turnIndex = messages.slice(lastSaid + 1).filter((m) => m.role === "assistant").length;
+  const toolNames = /* @__PURE__ */ new Map();
+  for (const message of messages)
+    for (const use of message.toolUses) toolNames.set(use.id, use.name);
+  const last = messages.at(-1);
+  const toolResults = last?.role === "user" ? last.toolResultIds.map((id) => toolNames.get(id)).filter((n) => !!n) : [];
+  return {
+    turnIndex,
+    toolResults,
+    lastUserText: lastSaid >= 0 ? messages[lastSaid].text : ""
+  };
+};
+var checkConversation = (messages, modelId, hasToolConfig) => {
+  if (messages.length === 0 || messages[0]?.role !== "user") {
+    throw new ValidationProblem(
+      "A conversation must start with a user message. Try again with a conversation that starts with a user message."
+    );
+  }
+  for (let i = 1; i < messages.length; i++) {
+    if (messages[i]?.role === messages[i - 1]?.role) {
+      throw new ValidationProblem(
+        "A conversation must alternate between user and assistant roles. Make sure the conversation alternates between user and assistant roles and try again."
+      );
+    }
+  }
+  const usesTools = messages.some((m) => m.toolUses.length > 0 || m.toolResultIds.length > 0);
+  if (usesTools && !hasToolConfig) {
+    throw new ValidationProblem(
+      "The toolConfig field must be defined when using toolUse and toolResult content blocks."
+    );
+  }
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (message.role === "user" && message.hasDocument && message.text.length === 0) {
+      throw new ValidationProblem(
+        `The model returned the following errors: messages.${i}: A text block must be included alongside a document block.`
+      );
+    }
+    if (message.role !== "assistant" || message.toolUses.length === 0) continue;
+    const next = messages[i + 1];
+    if (!next) continue;
+    const missing = message.toolUses.filter((use) => !next.toolResultIds.includes(use.id));
+    if (missing.length > 0) {
+      throw new ValidationProblem(
+        `Expected toolResult blocks at messages.${i + 1}.content for the following Ids: ${missing.map((m) => m.id).join(", ")}`
+      );
+    }
+  }
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (message.toolResultIds.length === 0) continue;
+    const previous = messages[i - 1];
+    const known = new Set(previous?.toolUses.map((use) => use.id) ?? []);
+    const orphan = message.toolResultIds.find((id) => !known.has(id));
+    if (orphan !== void 0) {
+      throw new ValidationProblem(
+        `messages.${i}.content: unexpected tool_use_id found in tool_result blocks: ${orphan}. Each tool_result block must have a corresponding tool_use block in the previous message.`
+      );
+    }
+  }
+  if (messages.at(-1)?.role === "assistant" && NO_PREFILL.test(modelId)) {
+    throw new ValidationProblem(
+      "This model does not support assistant message prefill. The conversation must end with a user message."
+    );
+  }
+};
+var converseMessage = (value, index) => {
+  if (!isRecord4(value) || value.role !== "user" && value.role !== "assistant") {
+    throw new ValidationProblem(`messages.${index}.role: must be one of [user, assistant]`);
+  }
+  const content = array(value.content);
+  if (content.length === 0) {
+    throw new ValidationProblem(
+      `messages.${index}.content: The content field in the Message object at messages.${index} is empty. Add a ContentBlock object to the content field and try again.`
+    );
+  }
+  const out = {
+    role: value.role,
+    text: textOf(content),
+    toolUses: [],
+    toolResultIds: [],
+    hasContent: false,
+    hasDocument: false,
+    hasImage: false,
+    hasCachePoint: false,
+    chars: 0
+  };
+  for (const block of content) {
+    if (!isRecord4(block)) continue;
+    out.chars += JSON.stringify(block).length;
+    if (typeof block.text === "string") out.hasContent = true;
+    if (isRecord4(block.document)) {
+      out.hasDocument = true;
+      out.hasContent = true;
+    }
+    if (isRecord4(block.image)) {
+      out.hasImage = true;
+      out.hasContent = true;
+    }
+    if (isRecord4(block.video)) out.hasContent = true;
+    if (isRecord4(block.cachePoint)) out.hasCachePoint = true;
+    if (isRecord4(block.toolUse)) {
+      out.toolUses.push({
+        id: String(block.toolUse.toolUseId ?? ""),
+        name: String(block.toolUse.name ?? "")
+      });
+    }
+    if (isRecord4(block.toolResult)) out.toolResultIds.push(String(block.toolResult.toolUseId ?? ""));
+  }
+  return out;
+};
+var analyzeConverse = (operation, modelId, body) => {
+  if (!isRecord4(body))
+    throw new ValidationProblem(
+      "Malformed input request, please reformat your input and try again."
+    );
+  const messages = array(body.messages).map(converseMessage);
+  const system = array(body.system);
+  const toolConfig = isRecord4(body.toolConfig) ? body.toolConfig : void 0;
+  const toolSchemas = {};
+  for (const tool of array(toolConfig?.tools)) {
+    if (!isRecord4(tool) || !isRecord4(tool.toolSpec)) continue;
+    const spec = tool.toolSpec;
+    const schema = isRecord4(spec.inputSchema) ? spec.inputSchema.json : void 0;
+    toolSchemas[String(spec.name)] = parseSchema(schema) ?? {};
+  }
+  const tools = Object.keys(toolSchemas);
+  const choice = isRecord4(toolConfig?.toolChoice) ? toolConfig.toolChoice : void 0;
+  let toolChoice;
+  if (choice) {
+    if (isRecord4(choice.tool)) toolChoice = `tool:${String(choice.tool.name)}`;
+    else if (choice.any !== void 0) toolChoice = "any";
+    else if (choice.auto !== void 0) toolChoice = "auto";
+  }
+  if (toolConfig && tools.length === 0) {
+    throw new ValidationProblem(
+      "The value at toolConfig.tools failed to satisfy constraint: Member must have length greater than or equal to 1"
+    );
+  }
+  if (toolChoice?.startsWith("tool:") && !tools.includes(toolChoice.slice(5))) {
+    throw new ValidationProblem(
+      `The provided toolChoice ${toolChoice.slice(5)} is not a tool in toolConfig.tools.`
+    );
+  }
+  const inference = isRecord4(body.inferenceConfig) ? body.inferenceConfig : {};
+  const additional = isRecord4(body.additionalModelRequestFields) ? body.additionalModelRequestFields : {};
+  const hasTemperature = inference.temperature !== void 0 || additional.temperature !== void 0;
+  const hasTopP = inference.topP !== void 0 || additional.top_p !== void 0;
+  if (hasTemperature && hasTopP && ONE_SAMPLING_PARAM.test(modelId)) {
+    throw new ValidationProblem(
+      "The model returned the following errors: `temperature` and `top_p` cannot both be specified for this model. Please use only one."
+    );
+  }
+  checkConversation(messages, modelId, toolConfig !== void 0);
+  let structured;
+  const outputConfig = isRecord4(body.outputConfig) ? body.outputConfig : void 0;
+  const textFormat = isRecord4(outputConfig?.textFormat) ? outputConfig.textFormat : void 0;
+  const jsonSchema = textFormat && isRecord4(textFormat.structure) && isRecord4(textFormat.structure.jsonSchema) ? textFormat.structure.jsonSchema : void 0;
+  const nativeFormat = isRecord4(additional.output_config) && isRecord4(additional.output_config.format) ? additional.output_config.format : void 0;
+  if (jsonSchema) {
+    structured = {
+      form: "outputConfig",
+      schema: parseSchema(jsonSchema.schema),
+      ...typeof jsonSchema.name === "string" ? { name: jsonSchema.name } : {}
+    };
+  } else if (nativeFormat && nativeFormat.type === "json_schema") {
+    structured = { form: "outputFormat", schema: parseSchema(nativeFormat.schema) };
+  } else if (toolChoice?.startsWith("tool:")) {
+    const tool = toolChoice.slice(5);
+    structured = { form: "tool", tool, schema: toolSchemas[tool] };
+  } else if (toolChoice === "any" && tools.length > 0) {
+    const tool = tools.includes("json") ? "json" : tools[0];
+    structured = { form: "tool", tool, schema: toolSchemas[tool] };
+  }
+  const facts = conversationFacts(messages);
+  const systemText = textOf(system);
+  return {
+    operation,
+    modelId,
+    lastUserText: facts.lastUserText,
+    systemText,
+    tools,
+    toolSchemas,
+    toolChoice,
+    hasDocument: messages.some((m) => m.hasDocument),
+    hasImage: messages.some((m) => m.hasImage),
+    hasCachePoint: messages.some((m) => m.hasCachePoint) || system.some((b) => isRecord4(b) && isRecord4(b.cachePoint)) || array(toolConfig?.tools).some((t) => isRecord4(t) && isRecord4(t.cachePoint)),
+    hasGuardrail: isRecord4(body.guardrailConfig),
+    toolResults: facts.toolResults,
+    turnIndex: facts.turnIndex,
+    structured,
+    inputChars: messages.reduce((sum, m) => sum + m.chars, 0) + systemText.length + JSON.stringify(toolSchemas).length
+  };
+};
+var anthropicMessage = (value, index) => {
+  if (!isRecord4(value) || value.role !== "user" && value.role !== "assistant") {
+    throw new ValidationProblem(`messages.${index}.role: Input should be 'user' or 'assistant'`);
+  }
+  const blocks = typeof value.content === "string" ? [{ type: "text", text: value.content }] : array(value.content);
+  if (blocks.length === 0)
+    throw new ValidationProblem(`messages.${index}: all messages must have non-empty content`);
+  const out = {
+    role: value.role,
+    text: textOf(blocks.filter((b) => isRecord4(b) && b.type === "text")),
+    toolUses: [],
+    toolResultIds: [],
+    hasContent: false,
+    hasDocument: false,
+    hasImage: false,
+    hasCachePoint: false,
+    chars: 0
+  };
+  for (const block of blocks) {
+    if (!isRecord4(block)) continue;
+    out.chars += JSON.stringify(block).length;
+    if (isRecord4(block.cache_control)) out.hasCachePoint = true;
+    switch (block.type) {
+      case "text":
+        out.hasContent = true;
+        break;
+      case "document":
+        out.hasDocument = true;
+        out.hasContent = true;
+        break;
+      case "image":
+        out.hasImage = true;
+        out.hasContent = true;
+        break;
+      case "tool_use":
+        out.toolUses.push({ id: String(block.id ?? ""), name: String(block.name ?? "") });
+        break;
+      case "tool_result":
+        out.toolResultIds.push(String(block.tool_use_id ?? ""));
+        break;
+    }
+  }
+  return out;
+};
+var analyzeAnthropic = (modelId, body) => {
+  if (!isRecord4(body))
+    throw new ValidationProblem(
+      "Malformed input request, please reformat your input and try again."
+    );
+  if (typeof body.anthropic_version !== "string") {
+    throw new ValidationProblem(
+      "Malformed input request: #: required key [anthropic_version] not found, please reformat your input and try again."
+    );
+  }
+  if (typeof body.max_tokens !== "number") {
+    throw new ValidationProblem(
+      "Malformed input request: #: required key [max_tokens] not found, please reformat your input and try again."
+    );
+  }
+  if (body.temperature !== void 0 && body.top_p !== void 0 && ONE_SAMPLING_PARAM.test(modelId)) {
+    throw new ValidationProblem(
+      "`temperature` and `top_p` cannot both be specified for this model. Please use only one."
+    );
+  }
+  const messages = array(body.messages).map(anthropicMessage);
+  const toolSchemas = {};
+  for (const tool of array(body.tools)) {
+    if (isRecord4(tool) && typeof tool.name === "string")
+      toolSchemas[tool.name] = tool.input_schema ?? {};
+  }
+  checkConversation(messages, modelId, true);
+  const system = typeof body.system === "string" ? body.system : textOf(array(body.system));
+  const choice = isRecord4(body.tool_choice) ? body.tool_choice : void 0;
+  const toolChoice = choice?.type === "tool" ? `tool:${String(choice.name)}` : typeof choice?.type === "string" ? choice.type : void 0;
+  const tools = Object.keys(toolSchemas);
+  let structured;
+  const format = isRecord4(body.output_config) && isRecord4(body.output_config.format) ? body.output_config.format : void 0;
+  if (format?.type === "json_schema") structured = { form: "outputFormat", schema: format.schema };
+  else if (toolChoice?.startsWith("tool:")) {
+    const tool = toolChoice.slice(5);
+    structured = { form: "tool", tool, schema: toolSchemas[tool] };
+  }
+  const facts = conversationFacts(messages);
+  return {
+    operation: "InvokeModel",
+    modelId,
+    lastUserText: facts.lastUserText,
+    systemText: system,
+    tools,
+    toolSchemas,
+    toolChoice,
+    hasDocument: messages.some((m) => m.hasDocument),
+    hasImage: messages.some((m) => m.hasImage),
+    hasCachePoint: messages.some((m) => m.hasCachePoint),
+    hasGuardrail: false,
+    toolResults: facts.toolResults,
+    turnIndex: facts.turnIndex,
+    structured,
+    inputChars: messages.reduce((sum, m) => sum + m.chars, 0) + system.length
+  };
+};
+var analyzeHarness = (harnessArn, body) => {
+  if (!isRecord4(body) || !Array.isArray(body.messages) || body.messages.length === 0) {
+    throw new ValidationProblem(
+      "1 validation error detected: Value null at 'messages' failed to satisfy constraint: Member must not be null"
+    );
+  }
+  const messages = array(body.messages).map(converseMessage);
+  const facts = conversationFacts(messages);
+  const system = typeof body.systemPrompt === "string" ? body.systemPrompt : textOf(array(body.systemPrompt));
+  return {
+    operation: "InvokeHarness",
+    modelId: harnessArn,
+    lastUserText: facts.lastUserText,
+    systemText: system,
+    tools: array(body.tools).map((tool) => isRecord4(tool) && typeof tool.name === "string" ? tool.name : void 0).filter((name) => name !== void 0),
+    toolSchemas: {},
+    toolChoice: void 0,
+    hasDocument: false,
+    hasImage: false,
+    hasCachePoint: false,
+    hasGuardrail: false,
+    toolResults: facts.toolResults,
+    turnIndex: facts.turnIndex,
+    structured: void 0,
+    inputChars: messages.reduce((sum, m) => sum + m.chars, 0) + system.length
+  };
+};
+
+// src/generated/openapi.ts
+var document = JSON.parse(`{"openapi":"3.1.0","info":{"title":"Amazon Bedrock Runtime + AgentCore harness (Mockingbird subset)","description":"The Bedrock Runtime data plane our consumer calls: Converse, ConverseStream (event\\nstream), InvokeModel (Anthropic Messages bodies and Titan text embeddings), and\\nInvokeModelWithBidirectionalStream (Nova Sonic, HTTP/2 duplex), plus the AgentCore\\n\`InvokeHarness\` event stream. Hand-trimmed from the Smithy models behind\\n\`@aws-sdk/client-bedrock-runtime@3.1132.0\` and \`@aws-sdk/client-bedrock-agentcore@3.1074.0\`\\nto the fields our consumer sends and reads.\\n","version":"2023-09-30","x-mockingbird-upstream":{"note":"Shapes follow the AWS SDK v3 Smithy schemas (restJson1). Errors carry \`x-amzn-ErrorType: <Name>:http://internal.amazon.com/coral/com.amazon.bedrock/\` and a \`{\\"message\\"}\` body, as Bedrock sends them."}},"servers":[{"url":"https://bedrock-runtime.us-east-1.amazonaws.com"}],"security":[{"sigv4":[]}],"paths":{"/model/{modelId}/converse":{"parameters":[{"$ref":"#/components/parameters/ModelId"}],"post":{"operationId":"Converse","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/ConverseRequest"}}}},"responses":{"200":{"description":"The assistant message, stop reason, usage and (with trace enabled) the guardrail trace.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/ConverseResponse"}}}},"400":{"$ref":"#/components/responses/Error"},"403":{"$ref":"#/components/responses/Error"},"408":{"$ref":"#/components/responses/Error"},"429":{"$ref":"#/components/responses/Error"},"500":{"$ref":"#/components/responses/Error"},"503":{"$ref":"#/components/responses/Error"}}}},"/model/{modelId}/converse-stream":{"parameters":[{"$ref":"#/components/parameters/ModelId"}],"post":{"operationId":"ConverseStream","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/ConverseRequest"}}}},"responses":{"200":{"description":"An \`application/vnd.amazon.eventstream\` body: messageStart, contentBlockStart (tool use), contentBlockDelta (text, toolUse.input, reasoningContent), contentBlockStop, messageStop, metadata; or an exception frame mid-stream.","content":{"application/vnd.amazon.eventstream":{"schema":{"type":"string","format":"binary"}}}},"400":{"$ref":"#/components/responses/Error"},"403":{"$ref":"#/components/responses/Error"},"408":{"$ref":"#/components/responses/Error"},"429":{"$ref":"#/components/responses/Error"},"500":{"$ref":"#/components/responses/Error"},"503":{"$ref":"#/components/responses/Error"}}}},"/model/{modelId}/invoke":{"parameters":[{"$ref":"#/components/parameters/ModelId"}],"post":{"operationId":"InvokeModel","description":"Titan text embeddings (\`amazon.titan-embed-text-*\`: \`{inputText, dimensions, normalize}\` \u2192 \`{embedding, inputTextTokenCount}\`) or an Anthropic Messages body for a Claude model (\`{anthropic_version, max_tokens, system, messages}\` \u2192 a Messages response).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"requestBody":{"required":true,"content":{"application/json":{"schema":{"oneOf":[{"$ref":"#/components/schemas/TitanEmbedRequest"},{"$ref":"#/components/schemas/AnthropicRequest"}]}}}},"responses":{"200":{"description":"The model's native response body.","content":{"application/json":{"schema":{"oneOf":[{"$ref":"#/components/schemas/TitanEmbedResponse"},{"$ref":"#/components/schemas/AnthropicResponse"}]}}}},"400":{"$ref":"#/components/responses/Error"},"403":{"$ref":"#/components/responses/Error"},"408":{"$ref":"#/components/responses/Error"},"429":{"$ref":"#/components/responses/Error"},"500":{"$ref":"#/components/responses/Error"},"503":{"$ref":"#/components/responses/Error"}}}},"/model/{modelId}/invoke-with-response-stream":{"parameters":[{"$ref":"#/components/parameters/ModelId"}],"post":{"operationId":"InvokeModelWithResponseStream","x-mockingbird":{"supported":false,"reason":"No consumer calls it; chat streaming goes through ConverseStream."},"responses":{"200":{"description":"Event stream of model chunks.","content":{"application/vnd.amazon.eventstream":{"schema":{"type":"string","format":"binary"}}}}}}},"/model/{modelId}/invoke-with-bidirectional-stream":{"parameters":[{"$ref":"#/components/parameters/ModelId"}],"post":{"operationId":"InvokeModelWithBidirectionalStream","description":"Nova Sonic. HTTP/2 duplex: the request body is an event stream of \`chunk\` events (\`{bytes: base64(JSON {event})}\`, SigV4-wrapped) that stays open for the session; the response streams \`chunk\` events back while it does.","x-mockingbird":{"supported":true,"parity":{"enabled":false,"reason":"A duplex HTTP/2 session; random request bodies cannot drive it."}},"requestBody":{"required":true,"content":{"application/vnd.amazon.eventstream":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"Event stream of \`chunk\` events (completionStart, contentStart, textOutput, audioOutput, toolUse, contentEnd, usageEvent, completionEnd).","content":{"application/vnd.amazon.eventstream":{"schema":{"type":"string","format":"binary"}}}},"400":{"$ref":"#/components/responses/Error"},"403":{"$ref":"#/components/responses/Error"},"429":{"$ref":"#/components/responses/Error"},"500":{"$ref":"#/components/responses/Error"},"503":{"$ref":"#/components/responses/Error"}}}},"/harnesses/invoke":{"post":{"operationId":"InvokeHarness","description":"AgentCore data plane (\`bedrock-agentcore.<region>.amazonaws.com\`).","x-mockingbird":{"supported":true,"parity":{"enabled":true,"safe":true}},"parameters":[{"name":"harnessArn","in":"query","required":true,"schema":{"type":"string","enum":["arn:aws:bedrock-agentcore:us-east-1:123456789012:harness/erx-prescreen"]}},{"name":"X-Amzn-Bedrock-AgentCore-Runtime-Session-Id","in":"header","required":false,"schema":{"type":"string","pattern":"^[a-zA-Z0-9-]{33,100}$"}},{"name":"X-Amzn-Bedrock-AgentCore-Runtime-User-Id","in":"header","required":false,"schema":{"type":"string","pattern":"^[a-zA-Z0-9_.@-]{1,128}$"}}],"requestBody":{"required":true,"content":{"application/json":{"schema":{"$ref":"#/components/schemas/HarnessRequest"}}}},"responses":{"200":{"description":"Event stream (messageStart, contentBlockDelta text/toolResult, contentBlockStop, messageStop, metadata), or validationException / internalServerException / runtimeClientError frames.","content":{"application/vnd.amazon.eventstream":{"schema":{"type":"string","format":"binary"}}}},"400":{"$ref":"#/components/responses/Error"},"403":{"$ref":"#/components/responses/Error"},"429":{"$ref":"#/components/responses/Error"},"500":{"$ref":"#/components/responses/Error"},"503":{"$ref":"#/components/responses/Error"}}}}},"components":{"securitySchemes":{"sigv4":{"type":"apiKey","in":"header","name":"Authorization","description":"AWS SigV4 (service \`bedrock\` / \`bedrock-agentcore\`). Accepted without verification; the access key id selects a namespace."}},"parameters":{"ModelId":{"name":"modelId","in":"path","required":true,"description":"A model id, inference-profile id (\`global.\` / \`us.\` prefixes) or a URL-encoded inference-profile / foundation-model ARN. Any value is accepted; the enum only steers generated requests.","schema":{"type":"string","enum":["global.anthropic.claude-sonnet-4-6","us.anthropic.claude-haiku-4-5-20251001-v1:0","us.anthropic.claude-sonnet-4-20250514-v1:0","amazon.titan-embed-text-v2:0","arn:aws:bedrock:us-east-1:123456789012:inference-profile/us.amazon.nova-pro-v1:0"]}}},"responses":{"Error":{"description":"A Bedrock error (type in \`x-amzn-ErrorType\`).","headers":{"x-amzn-ErrorType":{"schema":{"type":"string"}}},"content":{"application/json":{"schema":{"$ref":"#/components/schemas/ErrorBody"}}}}},"schemas":{"ErrorBody":{"type":"object","required":["message"],"properties":{"message":{"type":"string","x-mockingbird-volatile":{"kind":"opaque"}}}},"TextBlock":{"type":"object","required":["text"],"properties":{"text":{"type":"string","minLength":1}}},"CachePointBlock":{"type":"object","required":["cachePoint"],"properties":{"cachePoint":{"type":"object","required":["type"],"properties":{"type":{"type":"string","enum":["default"]},"ttl":{"type":"string","enum":["5m","1h"]}}}}},"ToolUseBlock":{"type":"object","required":["toolUse"],"properties":{"toolUse":{"type":"object","required":["toolUseId","name","input"],"properties":{"toolUseId":{"type":"string","minLength":1},"name":{"type":"string","minLength":1},"input":{}}}}},"ToolResultBlock":{"type":"object","required":["toolResult"],"properties":{"toolResult":{"type":"object","required":["toolUseId","content"],"properties":{"toolUseId":{"type":"string","minLength":1},"content":{"type":"array","minItems":1,"items":{"type":"object","properties":{"text":{"type":"string"},"json":{}}}},"status":{"type":"string","enum":["success","error"]}}}}},"DocumentBlock":{"type":"object","required":["document"],"properties":{"document":{"type":"object","required":["format","name","source"],"properties":{"format":{"type":"string","enum":["pdf","csv","doc","docx","xls","xlsx","html","txt","md"]},"name":{"type":"string","minLength":1},"source":{"type":"object","properties":{"bytes":{"type":"string","contentEncoding":"base64"}}}}}}},"ImageBlock":{"type":"object","required":["image"],"properties":{"image":{"type":"object","required":["format","source"],"properties":{"format":{"type":"string","enum":["png","jpeg","gif","webp"]},"source":{"type":"object","properties":{"bytes":{"type":"string","contentEncoding":"base64"}}}}}}},"GuardContentBlock":{"type":"object","required":["guardContent"],"properties":{"guardContent":{"type":"object"}}},"ContentBlock":{"anyOf":[{"$ref":"#/components/schemas/TextBlock"},{"$ref":"#/components/schemas/ToolUseBlock"},{"$ref":"#/components/schemas/ToolResultBlock"},{"$ref":"#/components/schemas/DocumentBlock"},{"$ref":"#/components/schemas/ImageBlock"},{"$ref":"#/components/schemas/CachePointBlock"},{"$ref":"#/components/schemas/GuardContentBlock"},{"type":"object","required":["reasoningContent"],"properties":{"reasoningContent":{"type":"object"}}},{"type":"object","required":["video"],"properties":{"video":{"type":"object"}}}]},"Message":{"type":"object","required":["role","content"],"properties":{"role":{"type":"string","enum":["user","assistant"]},"content":{"type":"array","minItems":1,"items":{"$ref":"#/components/schemas/ContentBlock"}}}},"ToolSpec":{"type":"object","required":["toolSpec"],"properties":{"toolSpec":{"type":"object","required":["name","inputSchema"],"properties":{"name":{"type":"string","pattern":"^[a-zA-Z0-9_-]{1,64}$"},"description":{"type":"string"},"inputSchema":{"type":"object","required":["json"],"properties":{"json":{}}}}}}},"ConverseRequest":{"type":"object","required":["messages"],"properties":{"messages":{"type":"array","minItems":1,"items":{"$ref":"#/components/schemas/Message"}},"system":{"type":"array","items":{"anyOf":[{"$ref":"#/components/schemas/TextBlock"},{"$ref":"#/components/schemas/CachePointBlock"},{"$ref":"#/components/schemas/GuardContentBlock"}]}},"inferenceConfig":{"type":"object","properties":{"maxTokens":{"type":"integer","minimum":1},"temperature":{"type":"number","minimum":0,"maximum":1},"topP":{"type":"number","minimum":0,"maximum":1},"stopSequences":{"type":"array","maxItems":4,"items":{"type":"string"}}}},"toolConfig":{"type":"object","required":["tools"],"properties":{"tools":{"type":"array","minItems":1,"items":{"anyOf":[{"$ref":"#/components/schemas/ToolSpec"},{"$ref":"#/components/schemas/CachePointBlock"}]}},"toolChoice":{"oneOf":[{"type":"object","required":["auto"],"properties":{"auto":{"type":"object"}}},{"type":"object","required":["any"],"properties":{"any":{"type":"object"}}},{"type":"object","required":["tool"],"properties":{"tool":{"type":"object","required":["name"],"properties":{"name":{"type":"string"}}}}}]}}},"guardrailConfig":{"type":"object","required":["guardrailIdentifier","guardrailVersion"],"properties":{"guardrailIdentifier":{"type":"string","minLength":1},"guardrailVersion":{"type":"string","minLength":1},"trace":{"type":"string","enum":["enabled","disabled","enabled_full"]},"streamProcessingMode":{"type":"string","enum":["sync","async"]}}},"additionalModelRequestFields":{"type":"object"},"outputConfig":{"type":"object","properties":{"textFormat":{"type":"object","required":["type","structure"],"properties":{"type":{"type":"string","enum":["json_schema"]},"structure":{"type":"object","required":["jsonSchema"],"properties":{"jsonSchema":{"type":"object","required":["schema"],"properties":{"schema":{"type":"string"},"name":{"type":"string"},"description":{"type":"string"}}}}}}}}},"requestMetadata":{"type":"object","additionalProperties":{"type":"string"}},"performanceConfig":{"type":"object","properties":{"latency":{"type":"string","enum":["standard","optimized"]}}}}},"Usage":{"type":"object","required":["inputTokens","outputTokens","totalTokens"],"properties":{"inputTokens":{"type":"integer","x-mockingbird-volatile":{"kind":"opaque"}},"outputTokens":{"type":"integer","x-mockingbird-volatile":{"kind":"opaque"}},"totalTokens":{"type":"integer","x-mockingbird-volatile":{"kind":"opaque"}},"cacheReadInputTokens":{"type":"integer","x-mockingbird-volatile":{"kind":"opaque"}},"cacheWriteInputTokens":{"type":"integer","x-mockingbird-volatile":{"kind":"opaque"}}}},"ConverseResponse":{"type":"object","required":["output","stopReason","usage","metrics"],"properties":{"output":{"type":"object","required":["message"],"properties":{"message":{"type":"object","required":["role","content"],"properties":{"role":{"type":"string","enum":["assistant"]},"content":{"type":"array","items":{"type":"object","properties":{"text":{"type":"string","x-mockingbird-volatile":{"kind":"opaque"}},"toolUse":{"type":"object","required":["toolUseId","name","input"],"properties":{"toolUseId":{"type":"string","x-mockingbird-volatile":{"kind":"id"}},"name":{"type":"string"},"input":{"x-mockingbird-volatile":{"kind":"opaque"}}}},"reasoningContent":{"type":"object"}}}}}}}},"stopReason":{"type":"string","enum":["end_turn","tool_use","max_tokens","stop_sequence","guardrail_intervened","content_filtered"]},"usage":{"$ref":"#/components/schemas/Usage"},"metrics":{"type":"object","required":["latencyMs"],"properties":{"latencyMs":{"type":"integer","x-mockingbird-volatile":{"kind":"opaque"}}}},"trace":{"type":"object","properties":{"guardrail":{"type":"object"}}}}},"TitanEmbedRequest":{"type":"object","required":["inputText"],"properties":{"inputText":{"type":"string","minLength":1,"maxLength":50000},"dimensions":{"type":"integer","enum":[256,512,1024]},"normalize":{"type":"boolean"},"embeddingTypes":{"type":"array","items":{"type":"string","enum":["float","binary"]}}}},"TitanEmbedResponse":{"type":"object","required":["embedding","inputTextTokenCount"],"properties":{"embedding":{"type":"array","items":{"type":"number","x-mockingbird-volatile":{"kind":"opaque"}}},"inputTextTokenCount":{"type":"integer","x-mockingbird-volatile":{"kind":"opaque"}},"embeddingsByType":{"type":"object"}}},"AnthropicRequest":{"type":"object","required":["anthropic_version","max_tokens","messages"],"properties":{"anthropic_version":{"type":"string","enum":["bedrock-2023-05-31"]},"max_tokens":{"type":"integer","minimum":1},"temperature":{"type":"number","minimum":0,"maximum":1},"system":{"anyOf":[{"type":"string"},{"type":"array","items":{"type":"object"}}]},"messages":{"type":"array","minItems":1,"items":{"type":"object","required":["role","content"],"properties":{"role":{"type":"string","enum":["user","assistant"]},"content":{"anyOf":[{"type":"string","minLength":1},{"type":"array","minItems":1,"items":{"type":"object","required":["type"]}}]}}}}}},"AnthropicResponse":{"type":"object","required":["id","type","role","model","content","stop_reason","usage"],"properties":{"id":{"type":"string","x-mockingbird-volatile":{"kind":"id"}},"type":{"type":"string","enum":["message"]},"role":{"type":"string","enum":["assistant"]},"model":{"type":"string"},"content":{"type":"array","items":{"type":"object","required":["type"],"properties":{"type":{"type":"string"},"text":{"type":"string","x-mockingbird-volatile":{"kind":"opaque"}}}}},"stop_reason":{"type":"string"},"stop_sequence":{"type":["string","null"]},"usage":{"type":"object","required":["input_tokens","output_tokens"],"properties":{"input_tokens":{"type":"integer","x-mockingbird-volatile":{"kind":"opaque"}},"output_tokens":{"type":"integer","x-mockingbird-volatile":{"kind":"opaque"}}}}}},"HarnessRequest":{"type":"object","required":["messages"],"properties":{"messages":{"type":"array","minItems":1,"items":{"type":"object","required":["role","content"],"properties":{"role":{"type":"string","enum":["user","assistant"]},"content":{"type":"array","minItems":1,"items":{"$ref":"#/components/schemas/ContentBlock"}}}}},"systemPrompt":{"type":"array","items":{"$ref":"#/components/schemas/TextBlock"}},"maxIterations":{"type":"integer","minimum":1,"maximum":50}}}}}}`);
+var operationIds = ["Converse", "ConverseStream", "InvokeModel", "InvokeModelWithResponseStream", "InvokeModelWithBidirectionalStream", "InvokeHarness"];
+var supportedOperationIds = ["Converse", "ConverseStream", "InvokeModel", "InvokeModelWithBidirectionalStream", "InvokeHarness"];
+
+// src/schema-sample.ts
+var isSchema = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var FORMATS = {
+  "date-time": "2026-01-01T00:00:00.000Z",
+  date: "2026-01-01",
+  time: "00:00:00",
+  email: "user@example.com",
+  uri: "https://example.com/",
+  url: "https://example.com/",
+  uuid: "00000000-0000-4000-8000-000000000000",
+  ipv4: "127.0.0.1"
+};
+var resolveRef2 = (root, ref) => {
+  if (!ref.startsWith("#")) return void 0;
+  let node = root;
+  for (const part of ref.slice(1).split("/").filter(Boolean)) {
+    if (!isSchema(node)) return void 0;
+    node = node[decodeURIComponent(part.replace(/~1/g, "/").replace(/~0/g, "~"))];
+  }
+  return isSchema(node) ? node : void 0;
+};
+var typesOf = (schema) => {
+  if (Array.isArray(schema.type))
+    return schema.type.filter((t) => typeof t === "string");
+  if (typeof schema.type === "string") return [schema.type];
+  if (isSchema(schema.properties) || Array.isArray(schema.required)) return ["object"];
+  if (schema.items !== void 0) return ["array"];
+  return [];
+};
+var sampleNumber = (schema, integer) => {
+  const min = typeof schema.minimum === "number" ? schema.minimum : void 0;
+  const exclusiveMin = typeof schema.exclusiveMinimum === "number" ? schema.exclusiveMinimum : schema.exclusiveMinimum === true && min !== void 0 ? min : void 0;
+  const max = typeof schema.maximum === "number" ? schema.maximum : void 0;
+  const exclusiveMax = typeof schema.exclusiveMaximum === "number" ? schema.exclusiveMaximum : void 0;
+  let value = 0;
+  if (exclusiveMin !== void 0)
+    value = integer ? Math.floor(exclusiveMin) + 1 : exclusiveMin + (max !== void 0 ? Math.min(1, (max - exclusiveMin) / 2) : 1);
+  else if (min !== void 0) value = integer ? Math.ceil(min) : min;
+  else if (max !== void 0 && max < 0) value = integer ? Math.floor(max) : max;
+  else if (exclusiveMax !== void 0 && exclusiveMax <= 0)
+    value = integer ? Math.ceil(exclusiveMax) - 1 : exclusiveMax - 1;
+  if (typeof schema.multipleOf === "number" && schema.multipleOf > 0) {
+    value = Math.ceil(value / schema.multipleOf) * schema.multipleOf;
+  }
+  return value;
+};
+var sampleString = (schema) => {
+  const format = typeof schema.format === "string" ? FORMATS[schema.format] : void 0;
+  let value = format ?? "";
+  const min = typeof schema.minLength === "number" ? schema.minLength : 0;
+  if (!format && typeof schema.pattern === "string") {
+    const pattern = new RegExp(schema.pattern);
+    value = ["x", "a", "A", "0", "a1", "x".repeat(Math.max(1, min))].find((c) => pattern.test(c)) ?? "x";
+  }
+  while (value.length < min) value += "x";
+  if (typeof schema.maxLength === "number" && value.length > schema.maxLength) {
+    value = value.slice(0, schema.maxLength);
+  }
+  return value;
+};
+var sampleSchema = (schema, root = schema, depth = 0) => {
+  if (!isSchema(schema) || depth > 32) return null;
+  const rootSchema = isSchema(root) ? root : {};
+  if (typeof schema.$ref === "string") {
+    return sampleSchema(resolveRef2(rootSchema, schema.$ref), rootSchema, depth + 1);
+  }
+  if ("const" in schema) return schema.const;
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) return schema.enum[0];
+  if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+    const merged = { ...schema };
+    delete merged.allOf;
+    for (const part of schema.allOf) {
+      const resolved = isSchema(part) && typeof part.$ref === "string" ? resolveRef2(rootSchema, part.$ref) : part;
+      if (!isSchema(resolved)) continue;
+      for (const [key, value] of Object.entries(resolved)) {
+        if (key === "properties" && isSchema(merged.properties) && isSchema(value)) {
+          merged.properties = { ...merged.properties, ...value };
+        } else if (key === "required" && Array.isArray(merged.required) && Array.isArray(value)) {
+          merged.required = [.../* @__PURE__ */ new Set([...merged.required, ...value])];
+        } else merged[key] = value;
+      }
+    }
+    return sampleSchema(merged, rootSchema, depth + 1);
+  }
+  const union = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : void 0;
+  if (union && union.length > 0) {
+    const concrete = union.find((branch) => !(isSchema(branch) && branch.type === "null"));
+    return sampleSchema(concrete ?? union[0], rootSchema, depth + 1);
+  }
+  const types = typesOf(schema);
+  const type = types.find((t) => t !== "null") ?? types[0];
+  switch (type) {
+    case "object": {
+      const properties = isSchema(schema.properties) ? schema.properties : {};
+      const required = Array.isArray(schema.required) ? schema.required.filter((key) => typeof key === "string") : [];
+      const out = {};
+      for (const key of required)
+        out[key] = sampleSchema(properties[key] ?? {}, rootSchema, depth + 1);
+      const minProperties = typeof schema.minProperties === "number" ? schema.minProperties : 0;
+      for (const key of Object.keys(properties)) {
+        if (Object.keys(out).length >= minProperties) break;
+        if (!(key in out)) out[key] = sampleSchema(properties[key], rootSchema, depth + 1);
+      }
+      return out;
+    }
+    case "array": {
+      const min = typeof schema.minItems === "number" ? schema.minItems : 0;
+      const items = Array.isArray(schema.prefixItems) ? schema.prefixItems : void 0;
+      const out = [];
+      for (let i = 0; i < min; i++) {
+        const itemSchema = items?.[i] ?? (Array.isArray(schema.items) ? schema.items[i] : schema.items);
+        let value = sampleSchema(itemSchema ?? {}, rootSchema, depth + 1);
+        if (schema.uniqueItems === true && isSchema(itemSchema)) {
+          const choices = Array.isArray(itemSchema.enum) ? itemSchema.enum : void 0;
+          if (choices && choices.length > i) value = choices[i];
+          else if (typeof value === "string") value = `${value}${i}`;
+          else if (typeof value === "number") value = value + i;
+        }
+        out.push(value);
+      }
+      return out;
+    }
+    case "string":
+      return sampleString(schema);
+    case "integer":
+      return sampleNumber(schema, true);
+    case "number":
+      return sampleNumber(schema, false);
+    case "boolean":
+      return false;
+    case "null":
+      return null;
+    default:
+      return {};
+  }
+};
+
+// src/scripts.ts
+var MODEL_OPERATIONS = [
+  "Converse",
+  "ConverseStream",
+  "InvokeModel",
+  "InvokeModelWithBidirectionalStream",
+  "InvokeHarness"
+];
+var STOP_REASONS = [
+  "end_turn",
+  "tool_use",
+  "max_tokens",
+  "stop_sequence",
+  "guardrail_intervened",
+  "content_filtered"
+];
+var TURN_FAULTS = [
+  "throttling",
+  "validation",
+  "access_denied",
+  "model_timeout",
+  "service_unavailable",
+  "internal_server",
+  "mid_stream_exception",
+  "max_tokens",
+  "truncated_frame",
+  "latency"
+];
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var escapeGlob = (value) => new RegExp(
+  `^${value.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`,
+  "i"
+);
+var globMatch = (pattern, modelId) => escapeGlob(pattern).test(modelId);
+var textMatches = (rule, value) => {
+  if (typeof rule === "string") return value.toLowerCase().includes(rule.toLowerCase());
+  if (rule.contains !== void 0 && !value.toLowerCase().includes(rule.contains.toLowerCase())) {
+    return false;
+  }
+  if (rule.regex !== void 0 && !new RegExp(rule.regex, rule.flags ?? "i").test(value))
+    return false;
+  return true;
+};
+var matches2 = (match, call, context) => {
+  if (!match) return true;
+  if (match.modelId !== void 0 && !globMatch(match.modelId, call.modelId)) return false;
+  if (match.operation !== void 0) {
+    const ops = Array.isArray(match.operation) ? match.operation : [match.operation];
+    if (!ops.includes(call.operation)) return false;
+  }
+  if (match.lastUserText !== void 0 && !textMatches(match.lastUserText, call.lastUserText)) {
+    return false;
+  }
+  if (match.systemHash !== void 0 && match.systemHash.toLowerCase() !== context.systemHash) {
+    return false;
+  }
+  if (match.toolsInclude?.some((name) => !call.tools.includes(name))) return false;
+  if (match.toolChoice !== void 0) {
+    const want = ["auto", "any", "none"].includes(match.toolChoice) ? match.toolChoice : `tool:${match.toolChoice}`;
+    if ((call.toolChoice ?? "auto") !== want) return false;
+  }
+  if (match.hasDocument !== void 0 && match.hasDocument !== call.hasDocument) return false;
+  if (match.hasImage !== void 0 && match.hasImage !== call.hasImage) return false;
+  if (match.callIndex !== void 0 && match.callIndex !== context.callIndex) return false;
+  return true;
+};
+var selectTurn = (script, call) => {
+  const turn = script.turns[call.turnIndex];
+  if (!turn) return void 0;
+  if (turn.expectToolResult && !call.toolResults.includes(turn.expectToolResult.name)) {
+    return void 0;
+  }
+  return turn;
+};
+var fail = (path, message) => `${path}: ${message}`;
+var checkTurn = (turn, path) => {
+  if (!isRecord5(turn)) return fail(path, "a turn is an object");
+  const known = /* @__PURE__ */ new Set([
+    "text",
+    "chunkSize",
+    "delayMsPerChunk",
+    "reasoning",
+    "toolUse",
+    "json",
+    "stopReason",
+    "guardrail",
+    "usage",
+    "expectToolResult",
+    "fault",
+    "userTranscript",
+    "toolResult"
+  ]);
+  for (const key of Object.keys(turn)) {
+    if (!known.has(key)) return fail(`${path}.${key}`, "unknown turn field");
+  }
+  if (turn.text !== void 0 && typeof turn.text !== "string")
+    return fail(`${path}.text`, "string");
+  for (const key of ["chunkSize", "delayMsPerChunk"]) {
+    const value = turn[key];
+    if (value !== void 0 && (typeof value !== "number" || value < (key === "chunkSize" ? 1 : 0))) {
+      return fail(`${path}.${key}`, key === "chunkSize" ? "a positive number" : "ms \u2265 0");
+    }
+  }
+  if (turn.toolUse !== void 0) {
+    const uses = Array.isArray(turn.toolUse) ? turn.toolUse : [turn.toolUse];
+    for (const [i, use] of uses.entries()) {
+      if (!isRecord5(use) || typeof use.name !== "string" || use.name === "") {
+        return fail(`${path}.toolUse[${i}]`, "needs a name");
+      }
+    }
+  }
+  if (turn.stopReason !== void 0 && !STOP_REASONS.includes(turn.stopReason)) {
+    return fail(`${path}.stopReason`, `one of ${STOP_REASONS.join(", ")}`);
+  }
+  if (turn.fault !== void 0) {
+    const type = isRecord5(turn.fault) ? turn.fault.type : turn.fault;
+    if (!TURN_FAULTS.includes(type)) {
+      return fail(`${path}.fault`, `one of ${TURN_FAULTS.join(", ")}`);
+    }
+  }
+  if (turn.toolResult !== void 0 && !Array.isArray(turn.toolResult)) {
+    return fail(`${path}.toolResult`, "an array of {text} | {json}");
+  }
+  if (turn.expectToolResult !== void 0 && !(isRecord5(turn.expectToolResult) && typeof turn.expectToolResult.name === "string")) {
+    return fail(`${path}.expectToolResult`, "{name}");
+  }
+  return void 0;
+};
+var parseScript = (value, index) => {
+  const path = `scripts[${index}]`;
+  if (!isRecord5(value)) return fail(path, "a script is an object");
+  if (typeof value.id !== "string" || value.id === "")
+    return fail(`${path}.id`, "a non-empty string");
+  if (!Array.isArray(value.turns) || value.turns.length === 0) {
+    return fail(`${path}.turns`, "a non-empty array");
+  }
+  for (const [i, turn] of value.turns.entries()) {
+    const problem = checkTurn(turn, `${path}.turns[${i}]`);
+    if (problem) return problem;
+  }
+  if (value.match !== void 0) {
+    if (!isRecord5(value.match)) return fail(`${path}.match`, "an object");
+    const match = value.match;
+    if (match.operation !== void 0) {
+      const ops = Array.isArray(match.operation) ? match.operation : [match.operation];
+      for (const op of ops) {
+        if (!MODEL_OPERATIONS.includes(op)) {
+          return fail(`${path}.match.operation`, `one of ${MODEL_OPERATIONS.join(", ")}`);
+        }
+      }
+    }
+    if (isRecord5(match.lastUserText) && typeof match.lastUserText.regex === "string") {
+      try {
+        new RegExp(match.lastUserText.regex);
+      } catch {
+        return fail(`${path}.match.lastUserText.regex`, "not a valid regular expression");
+      }
+    }
+    if (match.toolsInclude !== void 0 && !Array.isArray(match.toolsInclude)) {
+      return fail(`${path}.match.toolsInclude`, "string[]");
+    }
+  }
+  if (value.times !== void 0 && (typeof value.times !== "number" || value.times < 1)) {
+    return fail(`${path}.times`, "a positive count");
+  }
+  return value;
+};
+var turnFault = (turn) => {
+  if (!turn?.fault) return void 0;
+  return typeof turn.fault === "string" ? { type: turn.fault } : turn.fault;
+};
+
+// src/plan.ts
+var GUARDRAIL_BLOCKED_TEXT = "Sorry, the model cannot answer this question.";
+var DEFAULT_CHAT_TEXT = "OK.";
+var DEFAULT_CLASSIFIER = { category: "general", confidence: 0.9 };
+var DEFAULT_SOAP_NOTE = {
+  sections: [
+    {
+      title: "Subjective",
+      content: "Patient reports no new concerns. [UNCERTAIN] Mock transcript."
+    },
+    { title: "Objective", content: "No examination findings discussed." },
+    {
+      title: "Assessment",
+      content: "Stable. [UNCERTAIN] Generated by the Mockingbird Bedrock mock."
+    },
+    { title: "Plan", content: "Continue current plan; follow up as scheduled." }
+  ],
+  summary: "Routine follow-up visit with no new concerns (mock note)."
+};
+var tokens = (chars) => Math.max(1, Math.ceil(chars / 4));
+var defaultTrace = (guardrailId) => ({
+  guardrail: {
+    actionReason: "Guardrail blocked.",
+    inputAssessment: {
+      [guardrailId ?? "mock-guardrail"]: {
+        topicPolicy: {
+          topics: [{ name: "Medical Advice", type: "DENY", action: "BLOCKED", detected: true }]
+        },
+        invocationMetrics: {
+          guardrailProcessingLatency: 120,
+          usage: {
+            topicPolicyUnits: 1,
+            contentPolicyUnits: 0,
+            wordPolicyUnits: 0,
+            sensitiveInformationPolicyUnits: 0,
+            sensitiveInformationPolicyFreeUnits: 0,
+            contextualGroundingPolicyUnits: 0
+          },
+          guardrailCoverage: { textCharacters: { guarded: 1, total: 1 } }
+        }
+      }
+    }
+  }
+});
+var withUsage = (call, blocks, scripted) => {
+  const outputChars = blocks.reduce(
+    (sum, block) => sum + (block.kind === "toolUse" ? JSON.stringify(block.input ?? {}).length : block.kind === "toolResult" ? JSON.stringify(block.content).length : block.text.length),
+    0
+  );
+  const inputTokens = scripted?.inputTokens ?? tokens(call.inputChars);
+  const outputTokens = scripted?.outputTokens ?? tokens(outputChars);
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: scripted?.totalTokens ?? inputTokens + outputTokens,
+    ...scripted?.cacheReadInputTokens !== void 0 || call.hasCachePoint ? { cacheReadInputTokens: scripted?.cacheReadInputTokens ?? 0 } : {},
+    ...scripted?.cacheWriteInputTokens !== void 0 || call.hasCachePoint ? { cacheWriteInputTokens: scripted?.cacheWriteInputTokens ?? 0 } : {}
+  };
+};
+var renderJson = (call, value, context) => {
+  const structured = call.structured;
+  if (structured?.form === "tool") {
+    return {
+      blocks: [
+        {
+          kind: "toolUse",
+          toolUseId: context.nextToolUseId(),
+          name: structured.tool,
+          input: value
+        }
+      ],
+      stopReason: "tool_use"
+    };
+  }
+  return { blocks: [{ kind: "text", text: JSON.stringify(value) }], stopReason: "end_turn" };
+};
+var capOutput = (blocks, stopReason, maxTokens, force) => {
+  const budget = force ? void 0 : maxTokens !== void 0 ? maxTokens * 4 : void 0;
+  const texts = blocks.filter((b) => b.kind === "text");
+  const length = texts.reduce((sum, b) => sum + b.text.length, 0);
+  if (!force && (budget === void 0 || length <= budget)) return { blocks, stopReason };
+  let remaining = force ? Math.max(1, Math.floor(length / 2)) : budget;
+  const out = [];
+  for (const block of blocks) {
+    if (block.kind === "toolUse" || block.kind === "toolResult") continue;
+    if (block.kind === "reasoning") {
+      out.push(block);
+      continue;
+    }
+    if (remaining <= 0) break;
+    out.push({ kind: "text", text: block.text.slice(0, remaining) });
+    remaining -= block.text.length;
+  }
+  return { blocks: out, stopReason: "max_tokens" };
+};
+var planTurn = (scriptId, turn, call, context) => {
+  let blocks = [];
+  let stopReason;
+  let trace;
+  if (turn.reasoning) blocks.push({ kind: "reasoning", text: turn.reasoning });
+  if (turn.guardrail) {
+    const detail = typeof turn.guardrail === "object" ? turn.guardrail : {};
+    blocks.push({ kind: "text", text: detail.text ?? GUARDRAIL_BLOCKED_TEXT });
+    stopReason = "guardrail_intervened";
+    if (context.traceEnabled || detail.trace !== void 0) {
+      trace = detail.trace ?? defaultTrace(context.guardrailId);
+    }
+  } else {
+    if (turn.text !== void 0) blocks.push({ kind: "text", text: turn.text });
+    if (turn.json !== void 0) {
+      const rendered = renderJson(call, turn.json, context);
+      blocks.push(...rendered.blocks);
+      stopReason = rendered.stopReason;
+    }
+    if (turn.toolResult !== void 0) {
+      blocks.push({
+        kind: "toolResult",
+        toolUseId: context.nextToolUseId(),
+        content: turn.toolResult
+      });
+    }
+    const uses = turn.toolUse === void 0 ? [] : Array.isArray(turn.toolUse) ? turn.toolUse : [turn.toolUse];
+    for (const use of uses) {
+      blocks.push({
+        kind: "toolUse",
+        toolUseId: use.toolUseId ?? context.nextToolUseId(),
+        name: use.name,
+        input: use.input ?? {}
+      });
+      stopReason = "tool_use";
+    }
+  }
+  const fault = turnFault(turn);
+  const capped = capOutput(
+    blocks,
+    turn.stopReason ?? stopReason ?? "end_turn",
+    context.maxTokens,
+    fault?.type === "max_tokens"
+  );
+  blocks = capped.blocks;
+  return {
+    scriptId,
+    blocks,
+    stopReason: turn.stopReason ?? capped.stopReason,
+    usage: withUsage(call, blocks, turn.usage),
+    ...trace ? { trace } : {},
+    ...fault && fault.type !== "max_tokens" ? { fault } : {},
+    chunkSize: turn.chunkSize ?? context.chunkSize,
+    delayMsPerChunk: turn.delayMsPerChunk ?? context.delayMsPerChunk,
+    ...turn.userTranscript !== void 0 ? { userTranscript: turn.userTranscript } : {}
+  };
+};
+var isClassifier = (call) => call.systemText.includes('"category"') && call.systemText.includes('"confidence"');
+var planDefault = (call, context, defaultText) => {
+  let blocks;
+  let stopReason = "end_turn";
+  let fallback = "chat";
+  if (call.structured) {
+    const value = sampleSchema(call.structured.schema ?? {});
+    const rendered = renderJson(call, value, context);
+    blocks = rendered.blocks;
+    stopReason = rendered.stopReason;
+    fallback = "structured";
+  } else if (call.operation === "InvokeModel") {
+    blocks = [{ kind: "text", text: JSON.stringify(DEFAULT_SOAP_NOTE) }];
+    fallback = "scribe";
+  } else if (isClassifier(call)) {
+    blocks = [{ kind: "text", text: JSON.stringify(DEFAULT_CLASSIFIER) }];
+    fallback = "classifier";
+  } else {
+    blocks = [{ kind: "text", text: defaultText }];
+  }
+  const capped = capOutput(blocks, stopReason, context.maxTokens, false);
+  return {
+    scriptId: void 0,
+    fallback,
+    blocks: capped.blocks,
+    stopReason: capped.stopReason,
+    usage: withUsage(call, capped.blocks, void 0),
+    chunkSize: context.chunkSize,
+    delayMsPerChunk: context.delayMsPerChunk
+  };
+};
+var truncatePlan = (plan) => {
+  const capped = capOutput(plan.blocks, plan.stopReason, void 0, true);
+  return { ...plan, blocks: capped.blocks, stopReason: capped.stopReason };
+};
+var chunk = (text2, size) => {
+  if (text2.length === 0) return [""];
+  const out = [];
+  for (let i = 0; i < text2.length; i += Math.max(1, size))
+    out.push(text2.slice(i, i + Math.max(1, size)));
+  return out;
+};
+
+// src/eventstream.ts
+var EventStreamError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EventStreamError";
+  }
+};
+var PRELUDE = 12;
+var TRAILER = 4;
+var utf82 = new TextEncoder();
+var text = new TextDecoder();
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+var crc32 = (bytes) => {
+  let crc = 4294967295;
+  for (let i = 0; i < bytes.length; i++) {
+    crc = CRC_TABLE[(crc ^ bytes[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+};
+var toBytes = (body) => body === void 0 ? new Uint8Array(0) : typeof body === "string" ? utf82.encode(body) : body;
+var encodeHeaders = (headers) => {
+  const parts = [];
+  for (const [name, raw] of Object.entries(headers)) {
+    const header = typeof raw === "string" ? { type: "string", value: raw } : raw;
+    const nameBytes = utf82.encode(name);
+    if (nameBytes.length > 255) throw new EventStreamError(`header name too long: ${name}`);
+    let value;
+    switch (header.type) {
+      case "boolean":
+        value = Uint8Array.of(header.value ? 0 : 1);
+        break;
+      case "byte":
+        value = Uint8Array.of(2, header.value & 255);
+        break;
+      case "short": {
+        value = new Uint8Array(3);
+        value[0] = 3;
+        new DataView(value.buffer).setInt16(1, header.value, false);
+        break;
+      }
+      case "integer": {
+        value = new Uint8Array(5);
+        value[0] = 4;
+        new DataView(value.buffer).setInt32(1, header.value, false);
+        break;
+      }
+      case "long": {
+        value = new Uint8Array(9);
+        value[0] = 5;
+        new DataView(value.buffer).setBigInt64(1, header.value, false);
+        break;
+      }
+      case "binary":
+      case "string": {
+        const bytes = header.type === "binary" ? header.value : utf82.encode(header.value);
+        if (bytes.length > 65535) throw new EventStreamError(`header ${name} value too long`);
+        value = new Uint8Array(3 + bytes.length);
+        value[0] = header.type === "binary" ? 6 : 7;
+        new DataView(value.buffer).setUint16(1, bytes.length, false);
+        value.set(bytes, 3);
+        break;
+      }
+      case "timestamp": {
+        value = new Uint8Array(9);
+        value[0] = 8;
+        new DataView(value.buffer).setBigInt64(1, BigInt(header.value.getTime()), false);
+        break;
+      }
+      case "uuid": {
+        const hex = header.value.replace(/-/g, "");
+        if (!/^[0-9a-f]{32}$/i.test(hex)) throw new EventStreamError(`bad uuid header ${name}`);
+        value = new Uint8Array(17);
+        value[0] = 9;
+        for (let i = 0; i < 16; i++) value[i + 1] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+        break;
+      }
+    }
+    const entry = new Uint8Array(1 + nameBytes.length + value.length);
+    entry[0] = nameBytes.length;
+    entry.set(nameBytes, 1);
+    entry.set(value, 1 + nameBytes.length);
+    parts.push(entry);
+  }
+  return concat(parts);
+};
+var concat = (parts) => {
+  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+};
+var encodeMessage = (message) => {
+  const headers = encodeHeaders(message.headers);
+  const body = toBytes(message.body);
+  const total = PRELUDE + headers.length + body.length + TRAILER;
+  const frame = new Uint8Array(total);
+  const view = new DataView(frame.buffer);
+  view.setUint32(0, total, false);
+  view.setUint32(4, headers.length, false);
+  view.setUint32(8, crc32(frame.subarray(0, 8)), false);
+  frame.set(headers, PRELUDE);
+  frame.set(body, PRELUDE + headers.length);
+  view.setUint32(total - TRAILER, crc32(frame.subarray(0, total - TRAILER)), false);
+  return frame;
+};
+var decodeHeaders = (bytes) => {
+  const headers = {};
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let at = 0;
+  while (at < bytes.length) {
+    const nameLength = bytes[at];
+    const name = text.decode(bytes.subarray(at + 1, at + 1 + nameLength));
+    at += 1 + nameLength;
+    const type = bytes[at];
+    at += 1;
+    switch (type) {
+      case 0:
+      case 1:
+        headers[name] = { type: "boolean", value: type === 0 };
+        break;
+      case 2:
+        headers[name] = { type: "byte", value: view.getInt8(at) };
+        at += 1;
+        break;
+      case 3:
+        headers[name] = { type: "short", value: view.getInt16(at, false) };
+        at += 2;
+        break;
+      case 4:
+        headers[name] = { type: "integer", value: view.getInt32(at, false) };
+        at += 4;
+        break;
+      case 5:
+        headers[name] = { type: "long", value: view.getBigInt64(at, false) };
+        at += 8;
+        break;
+      case 6:
+      case 7: {
+        const length = view.getUint16(at, false);
+        const value = bytes.slice(at + 2, at + 2 + length);
+        headers[name] = type === 6 ? { type: "binary", value } : { type: "string", value: text.decode(value) };
+        at += 2 + length;
+        break;
+      }
+      case 8:
+        headers[name] = { type: "timestamp", value: new Date(Number(view.getBigInt64(at, false))) };
+        at += 8;
+        break;
+      case 9: {
+        const hex = [...bytes.subarray(at, at + 16)].map((b) => b.toString(16).padStart(2, "0")).join("");
+        headers[name] = {
+          type: "uuid",
+          value: `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
+        };
+        at += 16;
+        break;
+      }
+      default:
+        throw new EventStreamError(`unknown header type ${type} for ${name}`);
+    }
+  }
+  return headers;
+};
+var decodeMessage = (frame) => {
+  if (frame.length < PRELUDE + TRAILER) throw new EventStreamError("frame shorter than a prelude");
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const total = view.getUint32(0, false);
+  const headersLength = view.getUint32(4, false);
+  if (total !== frame.length) throw new EventStreamError(`frame length ${frame.length} \u2260 ${total}`);
+  if (view.getUint32(8, false) !== crc32(frame.subarray(0, 8))) {
+    throw new EventStreamError("prelude checksum mismatch");
+  }
+  if (view.getUint32(total - TRAILER, false) !== crc32(frame.subarray(0, total - TRAILER))) {
+    throw new EventStreamError("message checksum mismatch");
+  }
+  return {
+    headers: decodeHeaders(frame.subarray(PRELUDE, PRELUDE + headersLength)),
+    body: frame.slice(PRELUDE + headersLength, total - TRAILER)
+  };
+};
+var FrameReader = class {
+  buffer = new Uint8Array(0);
+  /** Add bytes; returns every frame they complete. */
+  push(chunk2) {
+    this.buffer = this.buffer.length === 0 ? chunk2.slice() : concat([this.buffer, chunk2]);
+    const out = [];
+    while (this.buffer.length >= 4) {
+      const total = new DataView(
+        this.buffer.buffer,
+        this.buffer.byteOffset,
+        this.buffer.byteLength
+      ).getUint32(0, false);
+      if (total < PRELUDE + TRAILER) throw new EventStreamError(`impossible frame length ${total}`);
+      if (this.buffer.length < total) break;
+      out.push(decodeMessage(this.buffer.subarray(0, total)));
+      this.buffer = this.buffer.slice(total);
+    }
+    return out;
+  }
+  /** Bytes of an incomplete frame still waiting for the rest. */
+  get pending() {
+    return this.buffer.length;
+  }
+};
+var headerString = (message, name) => {
+  const header = message.headers[name];
+  return header?.type === "string" ? header.value : void 0;
+};
+var unwrapSigned = (message) => {
+  if (message.headers[":chunk-signature"] === void 0) return message;
+  if (message.body.length === 0) return null;
+  return decodeMessage(message.body);
+};
+var eventFrame = (eventType, payload, contentType = payload instanceof Uint8Array ? "application/octet-stream" : "application/json") => encodeMessage({
+  headers: {
+    ":event-type": eventType,
+    ":content-type": contentType,
+    ":message-type": "event"
+  },
+  body: payload instanceof Uint8Array ? payload : JSON.stringify(payload)
+});
+var exceptionFrame = (exceptionType, body) => encodeMessage({
+  headers: {
+    ":exception-type": exceptionType,
+    ":content-type": "application/json",
+    ":message-type": "exception"
+  },
+  body: JSON.stringify(body)
+});
+var payloadJson = (message) => {
+  try {
+    return JSON.parse(text.decode(message.body));
+  } catch {
+    return void 0;
+  }
+};
+async function* readFrames(body) {
+  if (!body) return;
+  const reader = new FrameReader();
+  const stream = body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await stream.read();
+      if (done) break;
+      for (const frame of reader.push(value)) yield frame;
+    }
+  } finally {
+    stream.releaseLock();
+  }
+  if (reader.pending > 0) throw new EventStreamError("stream ended inside a frame");
+}
+
+// src/render.ts
+var REASONING_SIGNATURE = "mock-reasoning-signature";
+var converseBlock = (block) => {
+  switch (block.kind) {
+    case "text":
+      return { text: block.text };
+    case "reasoning":
+      return {
+        reasoningContent: { reasoningText: { text: block.text, signature: REASONING_SIGNATURE } }
+      };
+    case "toolUse":
+      return { toolUse: { toolUseId: block.toolUseId, name: block.name, input: block.input } };
+    case "toolResult":
+      return void 0;
+  }
+};
+var converseBody = (plan, latencyMs) => ({
+  output: {
+    message: {
+      role: "assistant",
+      content: plan.blocks.map(converseBlock).filter((b) => b !== void 0)
+    }
+  },
+  stopReason: plan.stopReason,
+  usage: plan.usage,
+  metrics: { latencyMs },
+  ...plan.trace ? { trace: plan.trace } : {}
+});
+var anthropicBody = (plan, modelId, id) => ({
+  id,
+  type: "message",
+  role: "assistant",
+  model: modelId,
+  content: plan.blocks.map((block) => {
+    switch (block.kind) {
+      case "text":
+        return { type: "text", text: block.text };
+      case "reasoning":
+        return { type: "thinking", thinking: block.text, signature: REASONING_SIGNATURE };
+      case "toolUse":
+        return { type: "tool_use", id: block.toolUseId, name: block.name, input: block.input };
+      default:
+        return void 0;
+    }
+  }).filter((b) => b !== void 0),
+  stop_reason: plan.stopReason === "guardrail_intervened" ? "refusal" : plan.stopReason,
+  stop_sequence: null,
+  usage: {
+    input_tokens: plan.usage.inputTokens,
+    output_tokens: plan.usage.outputTokens,
+    ...plan.usage.cacheReadInputTokens !== void 0 ? { cache_read_input_tokens: plan.usage.cacheReadInputTokens } : {},
+    ...plan.usage.cacheWriteInputTokens !== void 0 ? { cache_creation_input_tokens: plan.usage.cacheWriteInputTokens } : {}
+  }
+});
+var MESSAGES = {
+  modelStreamErrorException: "The model stream encountered an error. Try your request again.",
+  internalServerException: "The system encountered an unexpected error during processing. Try your request again.",
+  throttlingException: "Too many requests, please wait before trying again.",
+  validationException: "The input fails to satisfy the constraints specified by the service.",
+  serviceUnavailableException: "Bedrock is unable to process your request.",
+  runtimeClientError: "The harness runtime failed while processing the request."
+};
+var paced = (steps, options) => {
+  const fault = options.fault?.type === "mid_stream_exception" || options.fault?.type === "truncated_frame" ? options.fault : void 0;
+  const after = fault?.afterChunks ?? 1;
+  let index = 0;
+  let sent = 0;
+  let done = false;
+  return new ReadableStream({
+    async pull(controller) {
+      if (done) return;
+      const step = steps[index];
+      if (fault && sent >= after && (step === void 0 || step.content)) {
+        done = true;
+        if (fault.type === "mid_stream_exception") {
+          const type = fault.exceptionType ?? options.defaultException;
+          controller.enqueue(
+            exceptionFrame(type, { message: fault.message ?? MESSAGES[type] ?? "Stream failure." })
+          );
+        } else {
+          const next = step?.frame ?? steps.at(-1)?.frame ?? new Uint8Array(16);
+          controller.enqueue(next.subarray(0, Math.max(1, Math.floor(next.length / 2))));
+        }
+        controller.close();
+        return;
+      }
+      if (step === void 0) {
+        done = true;
+        controller.close();
+        return;
+      }
+      if (step.content && options.delayMsPerChunk > 0) {
+        await options.sleep(options.delayMsPerChunk, options.signal);
+      }
+      if (options.signal?.aborted) {
+        done = true;
+        controller.close();
+        return;
+      }
+      controller.enqueue(step.frame);
+      if (step.content) sent++;
+      index++;
+    }
+  });
+};
+var converseStreamSteps = (plan, latencyMs) => {
+  const steps = [
+    { frame: eventFrame("messageStart", { role: "assistant" }), content: false }
+  ];
+  plan.blocks.filter((block) => block.kind !== "toolResult").forEach((block, contentBlockIndex) => {
+    if (block.kind === "toolUse") {
+      steps.push({
+        frame: eventFrame("contentBlockStart", {
+          contentBlockIndex,
+          start: { toolUse: { toolUseId: block.toolUseId, name: block.name } }
+        }),
+        content: false
+      });
+      for (const part of chunk(JSON.stringify(block.input ?? {}), Math.max(plan.chunkSize, 8))) {
+        steps.push({
+          frame: eventFrame("contentBlockDelta", {
+            contentBlockIndex,
+            delta: { toolUse: { input: part } }
+          }),
+          content: true
+        });
+      }
+    } else if (block.kind === "reasoning") {
+      for (const part of chunk(block.text, plan.chunkSize)) {
+        steps.push({
+          frame: eventFrame("contentBlockDelta", {
+            contentBlockIndex,
+            delta: { reasoningContent: { text: part } }
+          }),
+          content: true
+        });
+      }
+      steps.push({
+        frame: eventFrame("contentBlockDelta", {
+          contentBlockIndex,
+          delta: { reasoningContent: { signature: REASONING_SIGNATURE } }
+        }),
+        content: false
+      });
+    } else if (block.kind === "text") {
+      for (const part of chunk(block.text, plan.chunkSize)) {
+        steps.push({
+          frame: eventFrame("contentBlockDelta", { contentBlockIndex, delta: { text: part } }),
+          content: true
+        });
+      }
+    }
+    steps.push({ frame: eventFrame("contentBlockStop", { contentBlockIndex }), content: false });
+  });
+  steps.push({ frame: eventFrame("messageStop", { stopReason: plan.stopReason }), content: false });
+  steps.push({
+    frame: eventFrame("metadata", {
+      usage: plan.usage,
+      metrics: { latencyMs },
+      ...plan.trace ? { trace: plan.trace } : {}
+    }),
+    content: false
+  });
+  return steps;
+};
+var harnessSteps = (plan, latencyMs) => {
+  const steps = [
+    { frame: eventFrame("messageStart", { role: "assistant" }), content: false }
+  ];
+  plan.blocks.forEach((block, contentBlockIndex) => {
+    if (block.kind === "toolUse") {
+      steps.push({
+        frame: eventFrame("contentBlockStart", {
+          contentBlockIndex,
+          start: { toolUse: { toolUseId: block.toolUseId, name: block.name } }
+        }),
+        content: false
+      });
+      steps.push({
+        frame: eventFrame("contentBlockDelta", {
+          contentBlockIndex,
+          delta: { toolUse: { input: JSON.stringify(block.input ?? {}) } }
+        }),
+        content: true
+      });
+    } else if (block.kind === "toolResult") {
+      steps.push({
+        frame: eventFrame("contentBlockStart", {
+          contentBlockIndex,
+          start: { toolResult: { toolUseId: block.toolUseId, status: "success" } }
+        }),
+        content: false
+      });
+      steps.push({
+        frame: eventFrame("contentBlockDelta", {
+          contentBlockIndex,
+          delta: { toolResult: block.content }
+        }),
+        content: true
+      });
+    } else {
+      for (const part of chunk(block.text, plan.chunkSize)) {
+        steps.push({
+          frame: eventFrame("contentBlockDelta", {
+            contentBlockIndex,
+            delta: block.kind === "reasoning" ? { reasoningContent: { text: part } } : { text: part }
+          }),
+          content: true
+        });
+      }
+    }
+    steps.push({ frame: eventFrame("contentBlockStop", { contentBlockIndex }), content: false });
+  });
+  steps.push({ frame: eventFrame("messageStop", { stopReason: plan.stopReason }), content: false });
+  steps.push({
+    frame: eventFrame("metadata", {
+      usage: {
+        inputTokens: plan.usage.inputTokens,
+        outputTokens: plan.usage.outputTokens,
+        totalTokens: plan.usage.totalTokens
+      },
+      metrics: { latencyMs }
+    }),
+    content: false
+  });
+  return steps;
+};
+
+// src/audio.ts
+var MS_PER_CHARACTER = 60;
+var pcmTone = (durationMs, sampleRate) => {
+  const samples = Math.max(1, Math.round(sampleRate * durationMs / 1e3));
+  const out = new Uint8Array(samples * 2);
+  const view = new DataView(out.buffer);
+  for (let i = 0; i < samples; i++) {
+    const value = Math.round(Math.sin(2 * Math.PI * 440 * i / sampleRate) * 0.25 * 32767);
+    view.setInt16(i * 2, value, true);
+  }
+  return out;
+};
+var speechFor = (text2, sampleRate) => pcmTone(Math.max(1, text2.length) * MS_PER_CHARACTER, sampleRate);
+var base64 = (bytes) => {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  }
+  return btoa(binary);
+};
+
+// src/sonic.ts
+var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var utf83 = new TextDecoder();
+var AUDIO_CHUNK_BYTES = 4800;
+var sonicSession = (request, modelId, host) => {
+  let controller;
+  let closed = false;
+  const output = new ReadableStream({
+    start(c) {
+      controller = c;
+    },
+    cancel() {
+      closed = true;
+    }
+  });
+  const sessionId = host.nextId("session");
+  const contents = /* @__PURE__ */ new Map();
+  const tools = [];
+  const toolNames = /* @__PURE__ */ new Map();
+  let promptName = "";
+  let systemText = "";
+  let lastUserText = "";
+  let sinceUser = 0;
+  let pendingToolResults = [];
+  let completionId;
+  let outputSampleRate = 24e3;
+  let contentEvents = 0;
+  let fault = host.fault;
+  let chain = Promise.resolve();
+  let inputChars = 0;
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    try {
+      controller.close();
+    } catch {
+    }
+  };
+  const emitRaw = (frame) => {
+    if (!closed) controller.enqueue(frame);
+  };
+  const emit = (event) => emitRaw(
+    eventFrame("chunk", { bytes: base64(new TextEncoder().encode(JSON.stringify({ event }))) })
+  );
+  const emitContent = async (event, delayMs) => {
+    if (closed) return;
+    if (fault && (fault.type === "mid_stream_exception" || fault.type === "truncated_frame")) {
+      if (contentEvents >= (fault.afterChunks ?? 1)) {
+        if (fault.type === "mid_stream_exception") {
+          emitRaw(
+            exceptionFrame(fault.exceptionType ?? "modelStreamErrorException", {
+              message: fault.message ?? "The model stream encountered an error. Try your request again."
+            })
+          );
+        } else {
+          const frame = eventFrame("chunk", {
+            bytes: base64(new TextEncoder().encode(JSON.stringify({ event })))
+          });
+          emitRaw(frame.subarray(0, Math.floor(frame.length / 2)));
+        }
+        close();
+        return;
+      }
+    }
+    if (delayMs > 0) await host.sleep(delayMs, request.signal);
+    emit(event);
+    contentEvents++;
+  };
+  const respond = async (spoken, call) => {
+    const plan = await host.resolve(call);
+    if (plan.fault && !fault) fault = plan.fault;
+    if (fault?.type === "latency") await host.sleep(fault.latencyMs ?? 1e3, request.signal);
+    const base = { sessionId, promptName };
+    if (completionId === void 0) {
+      completionId = host.nextId("completion");
+      emit({ completionStart: { ...base, completionId } });
+    }
+    const ids = { ...base, completionId };
+    if (spoken && plan.userTranscript !== void 0) {
+      const contentId = host.nextId("content");
+      emit({
+        contentStart: {
+          ...ids,
+          contentId,
+          type: "TEXT",
+          role: "USER",
+          textOutputConfiguration: { mediaType: "text/plain" }
+        }
+      });
+      await emitContent(
+        { textOutput: { ...ids, contentId, content: plan.userTranscript, role: "USER" } },
+        0
+      );
+      emit({ contentEnd: { ...ids, contentId, type: "TEXT", stopReason: "PARTIAL_TURN" } });
+    }
+    for (const block of plan.blocks) {
+      if (closed) return;
+      if (block.kind === "text") {
+        const textId = host.nextId("content");
+        emit({
+          contentStart: {
+            ...ids,
+            contentId: textId,
+            type: "TEXT",
+            role: "ASSISTANT",
+            additionalModelFields: JSON.stringify({ generationStage: "FINAL" }),
+            textOutputConfiguration: { mediaType: "text/plain" }
+          }
+        });
+        await emitContent(
+          { textOutput: { ...ids, contentId: textId, content: block.text, role: "ASSISTANT" } },
+          plan.delayMsPerChunk
+        );
+        emit({
+          contentEnd: { ...ids, contentId: textId, type: "TEXT", stopReason: "PARTIAL_TURN" }
+        });
+        const audioId = host.nextId("content");
+        emit({
+          contentStart: {
+            ...ids,
+            contentId: audioId,
+            type: "AUDIO",
+            role: "ASSISTANT",
+            audioOutputConfiguration: {
+              mediaType: "audio/lpcm",
+              sampleRateHertz: outputSampleRate,
+              sampleSizeBits: 16,
+              channelCount: 1,
+              encoding: "base64",
+              audioType: "SPEECH"
+            }
+          }
+        });
+        const audio = speechFor(block.text, outputSampleRate);
+        for (let at = 0; at < audio.length; at += AUDIO_CHUNK_BYTES) {
+          await emitContent(
+            {
+              audioOutput: {
+                ...ids,
+                contentId: audioId,
+                content: base64(audio.subarray(at, at + AUDIO_CHUNK_BYTES))
+              }
+            },
+            plan.delayMsPerChunk
+          );
+          if (closed) return;
+        }
+        emit({ contentEnd: { ...ids, contentId: audioId, type: "AUDIO", stopReason: "END_TURN" } });
+      } else if (block.kind === "toolUse") {
+        toolNames.set(block.toolUseId, block.name);
+        const toolId = host.nextId("content");
+        emit({
+          contentStart: {
+            ...ids,
+            contentId: toolId,
+            type: "TOOL",
+            role: "TOOL",
+            toolUseOutputConfiguration: { mediaType: "application/json" }
+          }
+        });
+        await emitContent(
+          {
+            toolUse: {
+              ...ids,
+              contentId: toolId,
+              toolName: block.name,
+              toolUseId: block.toolUseId,
+              content: JSON.stringify(block.input ?? {})
+            }
+          },
+          plan.delayMsPerChunk
+        );
+        emit({ contentEnd: { ...ids, contentId: toolId, type: "TOOL", stopReason: "TOOL_USE" } });
+      }
+    }
+    if (closed) return;
+    emit({
+      usageEvent: {
+        ...ids,
+        totalInputTokens: plan.usage.inputTokens,
+        totalOutputTokens: plan.usage.outputTokens,
+        totalTokens: plan.usage.totalTokens,
+        details: {
+          delta: {
+            input: { speechTokens: 0, textTokens: plan.usage.inputTokens },
+            output: { speechTokens: 0, textTokens: plan.usage.outputTokens }
+          }
+        }
+      }
+    });
+  };
+  const schedule = (spoken) => {
+    const call = {
+      operation: "InvokeModelWithBidirectionalStream",
+      modelId,
+      lastUserText,
+      systemText,
+      tools: [...tools],
+      toolSchemas: {},
+      toolChoice: void 0,
+      hasDocument: false,
+      hasImage: false,
+      hasCachePoint: false,
+      hasGuardrail: false,
+      toolResults: pendingToolResults,
+      turnIndex: sinceUser,
+      structured: void 0,
+      inputChars
+    };
+    pendingToolResults = [];
+    sinceUser++;
+    chain = chain.then(() => respond(spoken, call)).catch(() => close());
+  };
+  const handle = (event) => {
+    const [kind] = Object.keys(event);
+    const body = kind ? event[kind] : void 0;
+    if (!kind || !isRecord6(body)) return;
+    switch (kind) {
+      case "promptStart": {
+        promptName = String(body.promptName ?? "");
+        const audio = isRecord6(body.audioOutputConfiguration) ? body.audioOutputConfiguration : void 0;
+        if (typeof audio?.sampleRateHertz === "number") outputSampleRate = audio.sampleRateHertz;
+        const config = isRecord6(body.toolConfiguration) ? body.toolConfiguration : void 0;
+        for (const tool of Array.isArray(config?.tools) ? config.tools : []) {
+          if (isRecord6(tool) && isRecord6(tool.toolSpec) && typeof tool.toolSpec.name === "string") {
+            tools.push(tool.toolSpec.name);
+          }
+        }
+        return;
+      }
+      case "contentStart": {
+        const name = String(body.contentName ?? "");
+        contents.set(name, {
+          type: String(body.type ?? ""),
+          role: String(body.role ?? ""),
+          interactive: body.interactive !== false,
+          text: "",
+          audioChunks: 0
+        });
+        const config = isRecord6(body.toolResultInputConfiguration) ? body.toolResultInputConfiguration : void 0;
+        if (config && typeof config.toolUseId === "string") {
+          const tool = toolNames.get(config.toolUseId);
+          if (tool) pendingToolResults.push(tool);
+        }
+        return;
+      }
+      case "textInput": {
+        const content = contents.get(String(body.contentName ?? ""));
+        const text2 = typeof body.content === "string" ? body.content : "";
+        inputChars += text2.length;
+        if (!content) return;
+        content.text += text2;
+        if (content.role === "SYSTEM") systemText += text2;
+        return;
+      }
+      case "audioInput": {
+        const content = contents.get(String(body.contentName ?? ""));
+        if (!content) return;
+        content.audioChunks++;
+        if (host.audioTurnChunks > 0 && content.audioChunks >= host.audioTurnChunks) {
+          content.audioChunks = 0;
+          lastUserText = "";
+          sinceUser = 0;
+          schedule(true);
+        }
+        return;
+      }
+      case "toolResult": {
+        const text2 = typeof body.content === "string" ? body.content : "";
+        inputChars += text2.length;
+        return;
+      }
+      case "contentEnd": {
+        const content = contents.get(String(body.contentName ?? ""));
+        if (!content) return;
+        if (content.role === "USER" && content.type === "TEXT" && content.interactive) {
+          lastUserText = content.text;
+          sinceUser = 0;
+          schedule(false);
+        } else if (content.role === "USER" && content.type === "AUDIO" && content.audioChunks > 0) {
+          lastUserText = "";
+          sinceUser = 0;
+          schedule(true);
+        } else if (content.type === "TOOL") {
+          schedule(false);
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  };
+  void (async () => {
+    let ended = false;
+    try {
+      for await (const raw of readFrames(request.body)) {
+        const frame = unwrapSigned(raw);
+        if (frame === null) break;
+        if (headerString(frame, ":event-type") !== "chunk") continue;
+        const payload = payloadJson(frame);
+        if (!isRecord6(payload) || typeof payload.bytes !== "string") continue;
+        let decoded;
+        try {
+          decoded = JSON.parse(
+            utf83.decode(Uint8Array.from(atob(payload.bytes), (c) => c.charCodeAt(0)))
+          );
+        } catch {
+          continue;
+        }
+        const event = isRecord6(decoded) && isRecord6(decoded.event) ? decoded.event : decoded;
+        if (!isRecord6(event)) continue;
+        if ("sessionEnd" in event) {
+          ended = true;
+          break;
+        }
+        handle(event);
+      }
+    } catch {
+    }
+    await chain;
+    if (ended && completionId !== void 0 && !closed) {
+      emit({ completionEnd: { sessionId, promptName, completionId, stopReason: "END_TURN" } });
+    }
+    close();
+  })();
+  return output;
+};
+
+// src/state.ts
+var DEFAULT_SETTINGS = {
+  defaultText: "OK.",
+  chunkSize: 16,
+  delayMsPerChunk: 0,
+  audioTurnChunks: 0
+};
+var EMPTY_STATS = {
+  calls: 0,
+  scripted: 0,
+  unscripted: 0,
+  byScript: {},
+  byFallback: {},
+  byOperation: {}
+};
+var BedrockState = class {
+  constructor(sqlite, namespace, seed) {
+    this.seed = seed;
+    this.scripts = new Collection(sqlite, namespace, "scripts");
+    this.uses = new Collection(sqlite, namespace, "script_uses");
+    this.settings = new Collection(sqlite, namespace, "settings");
+    this.stats = new Collection(sqlite, namespace, "stats");
+    this.ids = new IdSequence(sqlite, namespace, "bedrock");
+    this.ensureSeeded();
+  }
+  seed;
+  scripts;
+  uses;
+  settings;
+  stats;
+  ids;
+  /** Re-apply the configured settings and scripts after a reset. */
+  ensureSeeded() {
+    if (!this.settings.has("settings")) {
+      this.settings.insert("settings", { ...DEFAULT_SETTINGS, ...this.seed.settings });
+      for (const script of this.seed.scripts) this.scripts.insert(script.id, script);
+    }
+  }
+  current() {
+    return this.settings.get("settings") ?? DEFAULT_SETTINGS;
+  }
+  update(patch) {
+    const next = { ...this.current(), ...patch };
+    this.settings.insert("settings", next);
+    return next;
+  }
+  list() {
+    return this.scripts.list({ order: "oldest" }).map((row) => row.value);
+  }
+  /** Replace every script (`PUT`) or add/overwrite by id (`POST`). */
+  put(scripts, replace) {
+    if (replace) {
+      for (const row of this.scripts.list()) this.scripts.delete(row.id);
+      for (const row of this.uses.list()) this.uses.delete(row.id);
+    }
+    for (const script of scripts) this.scripts.insert(script.id, script);
+    return this.list();
+  }
+  remove(id) {
+    const targets = id === void 0 ? this.scripts.list().map((row) => row.id) : [id];
+    let removed = 0;
+    for (const each of targets) {
+      if (this.scripts.delete(each)) removed++;
+      this.uses.delete(each);
+    }
+    return removed;
+  }
+  usesOf(id) {
+    return this.uses.get(id) ?? 0;
+  }
+  use(id) {
+    this.uses.insert(id, this.usesOf(id) + 1);
+  }
+  /** The 0-based index of this model call in the namespace, then count it. */
+  nextCallIndex() {
+    const stats = this.currentStats();
+    this.stats.insert("stats", { ...stats, calls: stats.calls + 1 });
+    return stats.calls;
+  }
+  record(operation, scriptId, fallback) {
+    const stats = this.currentStats();
+    const bump = (map, key) => ({
+      ...map,
+      [key]: (map[key] ?? 0) + 1
+    });
+    this.stats.insert("stats", {
+      ...stats,
+      scripted: stats.scripted + (scriptId !== void 0 ? 1 : 0),
+      unscripted: stats.unscripted + (scriptId === void 0 ? 1 : 0),
+      byScript: scriptId !== void 0 ? bump(stats.byScript, scriptId) : stats.byScript,
+      byFallback: scriptId === void 0 ? bump(stats.byFallback, fallback ?? "chat") : stats.byFallback,
+      byOperation: bump(stats.byOperation, operation)
+    });
+  }
+  currentStats() {
+    return this.stats.get("stats") ?? EMPTY_STATS;
+  }
+};
+
+// src/runtime.ts
+var MODEL_PATH = "/model/";
+var everyCall = (description, params) => ({
+  description,
+  rules: [
+    { pathPrefix: MODEL_PATH, effect: "bedrock_fault", params },
+    { pathPrefix: "/harnesses/", effect: "bedrock_fault", params }
+  ]
+});
+var BEDROCK_PRESETS = {
+  throttling: everyCall(
+    "429 ThrottlingException before the first chunk (our backend retries 3\xD7 with 500 ms\xB72^n backoff)",
+    { type: "throttling" }
+  ),
+  mid_stream_exception: everyCall(
+    "The stream starts, sends one content chunk, then a modelStreamErrorException frame",
+    { type: "mid_stream_exception", afterChunks: 1 }
+  ),
+  mid_stream_throttling: everyCall(
+    "The stream starts, sends one content chunk, then a throttlingException frame",
+    { type: "mid_stream_exception", afterChunks: 1, exceptionType: "throttlingException" }
+  ),
+  validation_exception: everyCall("400 ValidationException", { type: "validation" }),
+  max_tokens: everyCall("Output cut in half and stopReason max_tokens", { type: "max_tokens" }),
+  latency: everyCall("2 s (mock clock) before the response starts", {
+    type: "latency",
+    latencyMs: 2e3
+  }),
+  truncated_frame: everyCall(
+    "The stream ends half-way through a frame (the event-stream decoders throw)",
+    { type: "truncated_frame", afterChunks: 1 }
+  ),
+  model_timeout: everyCall("408 ModelTimeoutException", { type: "model_timeout" }),
+  service_unavailable: everyCall("503 ServiceUnavailableException", {
+    type: "service_unavailable"
+  }),
+  access_denied: everyCall("403 AccessDeniedException", { type: "access_denied" }),
+  internal_server: everyCall("500 InternalServerException", { type: "internal_server" })
+};
+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 isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseScripts = (body) => {
+  const list = Array.isArray(body) ? body : isRecord7(body) ? body.scripts ?? (body.id ? [body] : void 0) : void 0;
+  if (!Array.isArray(list)) return 'expected {"scripts": [{id, match?, turns: [...]}]}';
+  const out = [];
+  for (const [index, each] of list.entries()) {
+    const parsed = parseScript(each, index);
+    if (typeof parsed === "string") return parsed;
+    out.push(parsed);
+  }
+  const ids = out.map((s) => s.id);
+  const duplicate = ids.find((id, i) => ids.indexOf(id) !== i);
+  return duplicate ? `duplicate script id ${duplicate}` : out;
+};
+var SETTING_CHECKS = {
+  defaultText: (value) => typeof value === "string",
+  chunkSize: (value) => typeof value === "number" && value >= 1,
+  delayMsPerChunk: (value) => typeof value === "number" && value >= 0,
+  audioTurnChunks: (value) => typeof value === "number" && value >= 0
+};
+var adminRoutes = (runtime) => {
+  const store = (replace) => ({ body, namespace }) => {
+    const scripts = parseScripts(body);
+    if (typeof scripts === "string") return adminError3(400, scripts);
+    return json3(200, { scripts: runtime.instance(namespace).putScripts(scripts, replace) });
+  };
+  return {
+    "GET /scripts": ({ namespace }) => {
+      const api = runtime.instance(namespace);
+      return json3(200, { scripts: api.scripts(), stats: api.stats() });
+    },
+    "PUT /scripts": store(true),
+    "POST /scripts": store(false),
+    "DELETE /scripts": ({ url, namespace }) => json3(200, {
+      removed: runtime.instance(namespace).removeScripts(url.searchParams.get("id") ?? void 0)
+    }),
+    "GET /model-metrics": ({ namespace }) => json3(200, runtime.instance(namespace).stats()),
+    "GET /settings": ({ namespace }) => json3(200, runtime.instance(namespace).state.current()),
+    "PUT /settings": ({ body, namespace }) => {
+      if (!isRecord7(body)) return adminError3(400, "expected a JSON object");
+      const patch = {};
+      for (const [key, value] of Object.entries(body)) {
+        const check = SETTING_CHECKS[key];
+        if (!check) return adminError3(400, `unknown setting ${key}`);
+        if (!check(value)) return adminError3(400, `bad value for ${key}`);
+        patch[key] = value;
+      }
+      return json3(200, runtime.instance(namespace).state.update(patch));
+    }
+  };
+};
+var createRuntime2 = (options = {}) => {
+  let runtime;
+  const totals = () => {
+    let scripted = 0;
+    let unscripted = 0;
+    for (const name of runtime?.namespaces() ?? []) {
+      const stats = runtime?.instance(name).stats();
+      scripted += stats?.scripted ?? 0;
+      unscripted += stats?.unscripted ?? 0;
+    }
+    return { scripted, unscripted };
+  };
+  runtime = createRuntime({
+    name: BEDROCK_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: accessKeyCredential,
+    presets: BEDROCK_PRESETS,
+    create: ({ sqlite, namespace, clock }) => new BedrockAPI({
+      sqlite,
+      namespace,
+      now: clock.now,
+      sleep: clockSleep(clock.now),
+      ...options.settings ? { settings: options.settings } : {},
+      ...options.scripts ? { scripts: options.scripts } : {}
+    }),
+    describe: () => ({ scripts: options.scripts?.length ?? 0, modelCalls: totals() }),
+    admin: adminRoutes
+  });
+  return runtime;
+};
+
+// src/index.ts
+var BEDROCK_NAMESPACE = "bedrock";
+var ERROR_TYPE_SUFFIX = ":http://internal.amazon.com/coral/com.amazon.bedrock/";
+var TITAN_EMBED = /amazon\.titan-embed-(text|g1-text)/i;
+var FAULT_ERRORS = {
+  throttling: [429, "ThrottlingException", "Too many requests, please wait before trying again."],
+  validation: [
+    400,
+    "ValidationException",
+    "The input fails to satisfy the constraints specified by the service."
+  ],
+  access_denied: [
+    403,
+    "AccessDeniedException",
+    "You don't have access to the model with the specified model ID."
+  ],
+  model_timeout: [
+    408,
+    "ModelTimeoutException",
+    "Model has timed out in processing the request. Try your request again."
+  ],
+  service_unavailable: [
+    503,
+    "ServiceUnavailableException",
+    "Bedrock is unable to process your request."
+  ],
+  internal_server: [
+    500,
+    "InternalServerException",
+    "The system encountered an unexpected error during processing. Try your request again."
+  ]
+};
+var bedrockError = (status, type, message, requestId) => new Response(JSON.stringify({ message }), {
+  status,
+  headers: {
+    "content-type": "application/json",
+    "x-amzn-errortype": `${type}${ERROR_TYPE_SUFFIX}`,
+    ...requestId ? { "x-amzn-requestid": requestId } : {}
+  }
+});
+var presetFault = (request) => {
+  const params = faultEffect(request, "bedrock_fault");
+  return params && typeof params.type === "string" ? params : void 0;
+};
+var accessKeyCredential = sigV4AccessKeyId;
+var realSleep = (ms, signal) => new Promise((resolve) => {
+  if (ms <= 0 || signal?.aborted) return resolve();
+  const timer = setTimeout(resolve, ms);
+  signal?.addEventListener("abort", () => {
+    clearTimeout(timer);
+    resolve();
+  });
+});
+var clockSleep = (now) => (ms, signal) => {
+  if (ms <= 0) return Promise.resolve();
+  const until = now() + ms;
+  return new Promise((resolve) => {
+    const tick = () => {
+      if (signal?.aborted || now() >= until) return resolve();
+      setTimeout(tick, Math.min(5, Math.max(1, until - now())));
+    };
+    tick();
+  });
+};
+var isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var utf84 = new TextEncoder();
+var titanEmbedding = async (inputText, dims = 1024) => {
+  const seed = new Uint8Array(await crypto.subtle.digest("SHA-256", utf84.encode(inputText)));
+  const values = [];
+  for (let block = 0; values.length < dims; block++) {
+    const input = new Uint8Array(seed.length + 4);
+    input.set(seed);
+    new DataView(input.buffer).setUint32(seed.length, block, false);
+    const digest = new DataView(await crypto.subtle.digest("SHA-256", input));
+    for (let at = 0; at + 4 <= 32 && values.length < dims; at += 4) {
+      values.push(digest.getUint32(at, false) / 4294967295 * 2 - 1);
+    }
+  }
+  const norm = Math.sqrt(values.reduce((sum, v) => sum + v * v, 0)) || 1;
+  return values.map((v) => v / norm);
+};
+var BedrockAPI = class {
+  app;
+  sqlite;
+  state;
+  service;
+  now;
+  sleep;
+  constructor(options = {}) {
+    const sqlite = bootSqlite(options.sqlite);
+    const namespace = options.namespace ?? BEDROCK_NAMESPACE;
+    this.now = options.now ?? (() => Date.now());
+    this.sleep = options.sleep ?? realSleep;
+    this.state = new BedrockState(sqlite, namespace, {
+      settings: options.settings ?? {},
+      scripts: options.scripts ?? []
+    });
+    const handlers = defineOperations({
+      Converse: (context) => this.converse(context, false),
+      ConverseStream: (context) => this.converse(context, true),
+      InvokeModel: (context) => this.invokeModel(context),
+      // Served by `fetch` before routing, so the duplex body is never buffered.
+      InvokeModelWithBidirectionalStream: (context) => this.bidirectional(context.request, context.params.modelId ?? ""),
+      InvokeHarness: (context) => this.invokeHarness(context)
+    });
+    this.service = createService({
+      document,
+      handlers,
+      sqlite,
+      namespace,
+      now: this.now,
+      notFound: (request) => bedrockError(
+        404,
+        "UnknownOperationException",
+        `No operation matches ${request.method} ${new URL(request.url).pathname}`
+      ),
+      onError: (error) => {
+        if (error instanceof HttpError) return error.toResponse();
+        if (error instanceof ValidationProblem)
+          return bedrockError(400, "ValidationException", error.message);
+        throw error;
+      }
+    });
+    this.app = this.service.app;
+    this.sqlite = this.service.sqlite;
+  }
+  fetch(request) {
+    const path = new URL(request.url).pathname;
+    const bidi = /^\/model\/([^/]+)\/invoke-with-bidirectional-stream\/?$/.exec(path);
+    if (bidi && request.method === "POST") {
+      return this.bidirectional(request, decodeURIComponent(bidi[1]));
+    }
+    return this.service.fetch(request);
+  }
+  async reset() {
+    await this.service.reset();
+    this.state.ensureSeeded();
+  }
+  // ── admin surface ───────────────────────────────────────────────
+  scripts() {
+    return this.state.list();
+  }
+  putScripts(scripts, replace = true) {
+    return this.state.put(scripts, replace);
+  }
+  removeScripts(id) {
+    return this.state.remove(id);
+  }
+  stats() {
+    return this.state.currentStats();
+  }
+  // ── shared machinery ────────────────────────────────────────────
+  requestId() {
+    const hex = opaqueToken(`request:${this.state.ids.next("rq_", 8)}`, 32).split("").map((c) => (c.charCodeAt(0) % 16).toString(16)).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+  }
+  planContext(body, maxTokens) {
+    const settings = this.state.current();
+    const guardrail = isRecord8(body.guardrailConfig) ? body.guardrailConfig : void 0;
+    return {
+      nextToolUseId: () => this.state.ids.next("tooluse_", 22),
+      chunkSize: settings.chunkSize,
+      delayMsPerChunk: settings.delayMsPerChunk,
+      ...typeof guardrail?.guardrailIdentifier === "string" ? { guardrailId: guardrail.guardrailIdentifier } : {},
+      traceEnabled: guardrail?.trace === "enabled" || guardrail?.trace === "enabled_full",
+      ...maxTokens !== void 0 ? { maxTokens } : {}
+    };
+  }
+  /**
+   * First script with a turn for this call, else the default (which `unscripted` may
+   * replace with an operation-specific one); records stats either way.
+   */
+  async resolve(call, context, unscripted = (plan) => plan) {
+    const callIndex = this.state.nextCallIndex();
+    const systemHash = await sha("SHA-256", call.systemText);
+    for (const script of this.state.list()) {
+      if (script.times !== void 0 && this.state.usesOf(script.id) >= script.times) continue;
+      if (!matches2(script.match, call, { systemHash, callIndex })) continue;
+      const turn = selectTurn(script, call);
+      if (!turn) continue;
+      this.state.use(script.id);
+      this.state.record(call.operation, script.id, void 0);
+      return planTurn(script.id, turn, call, context);
+    }
+    const plan = unscripted(planDefault(call, context, this.state.current().defaultText));
+    this.state.record(call.operation, void 0, plan.fallback);
+    return plan;
+  }
+  /** Journal notes: metadata only (never message or prompt text). */
+  notes(response, call, plan) {
+    const flags = [
+      call.hasCachePoint ? "cachePoint" : void 0,
+      call.hasGuardrail ? "guardrail" : void 0,
+      call.hasDocument ? "document" : void 0,
+      call.hasImage ? "image" : void 0,
+      call.structured ? `structured:${call.structured.form}` : void 0
+    ].filter((f) => f !== void 0);
+    return annotateResponse(response, {
+      ids: {
+        modelId: call.modelId,
+        script: plan?.scriptId ?? `unscripted:${plan?.fallback ?? "chat"}`,
+        ...call.tools.length > 0 ? { tools: call.tools.join(",") } : {},
+        ...flags.length > 0 ? { flags: flags.join(",") } : {},
+        ...plan ? {
+          stopReason: plan.stopReason,
+          inputTokens: String(plan.usage.inputTokens),
+          outputTokens: String(plan.usage.outputTokens)
+        } : {}
+      }
+    });
+  }
+  jsonBody(context) {
+    const body = context.body;
+    if (body.kind === "json") return body.value;
+    if (body.kind === "bytes" || body.kind === "text") {
+      try {
+        return JSON.parse(
+          body.kind === "text" ? body.value : new TextDecoder().decode(body.value)
+        );
+      } catch {
+        return void 0;
+      }
+    }
+    return void 0;
+  }
+  /** A pre-stream fault as the vendor's error, or `undefined` to carry on. */
+  async preStream(fault, requestId, signal, streaming) {
+    if (!fault) return void 0;
+    if (fault.type === "latency") {
+      await this.sleep(fault.latencyMs ?? 1e3, signal);
+      return void 0;
+    }
+    const known = FAULT_ERRORS[fault.type];
+    if (known) return bedrockError(known[0], known[1], fault.message ?? known[2], requestId);
+    if (!streaming && (fault.type === "mid_stream_exception" || fault.type === "truncated_frame")) {
+      const [status, type, message] = FAULT_ERRORS.internal_server;
+      return bedrockError(status, type, fault.message ?? message, requestId);
+    }
+    return void 0;
+  }
+  eventStream(body, requestId) {
+    return new Response(body, {
+      status: 200,
+      headers: {
+        "content-type": "application/vnd.amazon.eventstream",
+        "x-amzn-requestid": requestId
+      }
+    });
+  }
+  // ── operations ──────────────────────────────────────────────────
+  async converse(context, streaming) {
+    const requestId = this.requestId();
+    const operation = streaming ? "ConverseStream" : "Converse";
+    const modelId = context.params.modelId ?? "";
+    const body = this.jsonBody(context);
+    if (!isRecord8(body)) {
+      return bedrockError(
+        400,
+        "ValidationException",
+        "Malformed input request, please reformat your input and try again.",
+        requestId
+      );
+    }
+    const issues = bodyIssues(context).filter(
+      (issue) => issue.message !== "request body is not valid application/json"
+    );
+    if (issues.length > 0) {
+      const first = issues[0];
+      return bedrockError(
+        400,
+        "ValidationException",
+        `${issues.length} validation error${issues.length > 1 ? "s" : ""} detected: Value at '${first.path || "body"}' failed to satisfy constraint: ${first.message}`,
+        requestId
+      );
+    }
+    let call;
+    try {
+      call = analyzeConverse(operation, modelId, body);
+    } catch (error) {
+      if (error instanceof ValidationProblem)
+        return bedrockError(400, "ValidationException", error.message, requestId);
+      throw error;
+    }
+    const inference = isRecord8(body.inferenceConfig) ? body.inferenceConfig : {};
+    const maxTokens = typeof inference.maxTokens === "number" ? inference.maxTokens : void 0;
+    let plan = await this.resolve(call, this.planContext(body, maxTokens));
+    const fault = presetFault(context.request) ?? plan.fault;
+    if (fault?.type === "max_tokens") plan = truncatePlan(plan);
+    const failed = await this.preStream(fault, requestId, context.request.signal, streaming);
+    if (failed) return this.notes(failed, call, plan);
+    if (!streaming) {
+      return this.notes(
+        jsonRes(200, converseBody(plan, 0), { "x-amzn-requestid": requestId }),
+        call,
+        plan
+      );
+    }
+    const stream = paced(converseStreamSteps(plan, 0), {
+      sleep: this.sleep,
+      delayMsPerChunk: plan.delayMsPerChunk,
+      fault,
+      defaultException: "modelStreamErrorException",
+      signal: context.request.signal
+    });
+    return this.notes(this.eventStream(stream, requestId), call, plan);
+  }
+  async invokeModel(context) {
+    const requestId = this.requestId();
+    const modelId = context.params.modelId ?? "";
+    const body = this.jsonBody(context);
+    if (!isRecord8(body)) {
+      return bedrockError(
+        400,
+        "ValidationException",
+        "Malformed input request, please reformat your input and try again.",
+        requestId
+      );
+    }
+    if (TITAN_EMBED.test(modelId)) return this.titan(context, modelId, body, requestId);
+    if (!/anthropic|claude/i.test(modelId)) {
+      return bedrockError(
+        400,
+        "ValidationException",
+        "The provided model identifier is invalid.",
+        requestId
+      );
+    }
+    let call;
+    try {
+      call = analyzeAnthropic(modelId, body);
+    } catch (error) {
+      if (error instanceof ValidationProblem)
+        return bedrockError(400, "ValidationException", error.message, requestId);
+      throw error;
+    }
+    const maxTokens = typeof body.max_tokens === "number" ? body.max_tokens : void 0;
+    let plan = await this.resolve(call, this.planContext(body, maxTokens));
+    const fault = presetFault(context.request) ?? plan.fault;
+    if (fault?.type === "max_tokens") plan = truncatePlan(plan);
+    const failed = await this.preStream(fault, requestId, context.request.signal, false);
+    if (failed) return this.notes(failed, call, plan);
+    return this.notes(
+      jsonRes(200, anthropicBody(plan, modelId, `msg_bdrk_${this.state.ids.next("", 24)}`), {
+        "x-amzn-requestid": requestId,
+        "x-amzn-bedrock-input-token-count": String(plan.usage.inputTokens),
+        "x-amzn-bedrock-output-token-count": String(plan.usage.outputTokens),
+        "x-amzn-bedrock-invocation-latency": "0"
+      }),
+      call,
+      plan
+    );
+  }
+  async titan(context, modelId, body, requestId) {
+    const v2 = /v2/i.test(modelId);
+    const inputText = body.inputText;
+    if (typeof inputText !== "string" || inputText.length === 0) {
+      return bedrockError(
+        400,
+        "ValidationException",
+        "Malformed input request: #/inputText: expected minLength: 1, actual: 0, please reformat your input and try again.",
+        requestId
+      );
+    }
+    const dimensions = body.dimensions ?? (v2 ? 1024 : 1536);
+    if (v2 && ![256, 512, 1024].includes(dimensions)) {
+      return bedrockError(
+        400,
+        "ValidationException",
+        `Malformed input request: #/dimensions: ${String(dimensions)} is not a valid enum value, please reformat your input and try again.`,
+        requestId
+      );
+    }
+    this.state.nextCallIndex();
+    this.state.record("InvokeModel", void 0, "titan");
+    const fault = presetFault(context.request);
+    const failed = await this.preStream(fault, requestId, context.request.signal, false);
+    const inputTextTokenCount = Math.max(1, Math.ceil(inputText.length / 4));
+    const notes2 = (response) => annotateResponse(response, {
+      ids: { modelId, script: "unscripted:titan", inputTokens: String(inputTextTokenCount) }
+    });
+    if (failed) return notes2(failed);
+    const embedding = await titanEmbedding(inputText, dimensions);
+    return notes2(
+      jsonRes(
+        200,
+        {
+          embedding,
+          inputTextTokenCount,
+          ...Array.isArray(body.embeddingTypes) ? { embeddingsByType: { float: embedding } } : {}
+        },
+        {
+          "x-amzn-requestid": requestId,
+          "x-amzn-bedrock-input-token-count": String(inputTextTokenCount),
+          "x-amzn-bedrock-invocation-latency": "0"
+        }
+      )
+    );
+  }
+  async invokeHarness(context) {
+    const requestId = this.requestId();
+    const harnessArn = context.url.searchParams.get("harnessArn") ?? "";
+    if (!harnessArn) {
+      return bedrockError(
+        400,
+        "ValidationException",
+        "1 validation error detected: Value null at 'harnessArn' failed to satisfy constraint: Member must not be null",
+        requestId
+      );
+    }
+    const body = this.jsonBody(context);
+    let call;
+    try {
+      call = analyzeHarness(harnessArn, body);
+    } catch (error) {
+      if (error instanceof ValidationProblem)
+        return bedrockError(400, "ValidationException", error.message, requestId);
+      throw error;
+    }
+    let plan = await this.resolve(
+      call,
+      this.planContext({}, void 0),
+      (fallback) => this.harnessDefault(call, fallback)
+    );
+    const fault = presetFault(context.request) ?? plan.fault;
+    if (fault?.type === "max_tokens") plan = truncatePlan(plan);
+    const failed = await this.preStream(fault, requestId, context.request.signal, true);
+    if (failed) return this.notes(failed, call, plan);
+    const stream = paced(harnessSteps(plan, 0), {
+      sleep: this.sleep,
+      delayMsPerChunk: plan.delayMsPerChunk,
+      fault,
+      defaultException: "internalServerException",
+      signal: context.request.signal
+    });
+    const response = this.eventStream(stream, requestId);
+    const session = context.request.headers.get("x-amzn-bedrock-agentcore-runtime-session-id");
+    if (session) response.headers.set("x-amzn-bedrock-agentcore-runtime-session-id", session);
+    return this.notes(response, call, plan);
+  }
+  /** The unscripted eRx prescreen answer: eligible for clinician review. */
+  harnessDefault(call, plan) {
+    let productKey = "unknown";
+    try {
+      const parsed = JSON.parse(call.lastUserText);
+      if (typeof parsed.product_key === "string") productKey = parsed.product_key;
+    } catch {
+    }
+    const summary = {
+      status: "eligible_for_clinician_review",
+      summary: "Mock prescreen: no hard stops found; ready for clinician review.",
+      narrative: "Generated by the Mockingbird Bedrock mock. No clinical rules were evaluated.",
+      protocolVersion: `${productKey}-mock-1`,
+      ranAt: new Date(this.now()).toISOString(),
+      hardStops: [],
+      cautions: [],
+      missingData: []
+    };
+    return {
+      ...plan,
+      fallback: "harness",
+      blocks: [{ kind: "text", text: JSON.stringify(summary) }],
+      stopReason: "end_turn"
+    };
+  }
+  async bidirectional(request, modelId) {
+    const requestId = this.requestId();
+    if (!/sonic/i.test(modelId)) {
+      return bedrockError(
+        400,
+        "ValidationException",
+        `The model ${modelId} does not support bidirectional streaming.`,
+        requestId
+      );
+    }
+    const fault = presetFault(request);
+    if (fault && FAULT_ERRORS[fault.type]) {
+      const failed = await this.preStream(fault, requestId, request.signal, true);
+      if (failed) return annotateResponse(failed, { ids: { modelId } });
+    }
+    const settings = this.state.current();
+    const body = sonicSession(request, modelId, {
+      resolve: (call) => this.resolve(
+        call,
+        {
+          nextToolUseId: () => this.state.ids.next("tooluse_", 22),
+          chunkSize: settings.chunkSize,
+          delayMsPerChunk: settings.delayMsPerChunk,
+          traceEnabled: false
+        },
+        (plan) => ({ ...plan, fallback: "sonic" })
+      ),
+      sleep: this.sleep,
+      nextId: (prefix) => {
+        const hex = opaqueToken(`${prefix}:${this.state.ids.next(`${prefix}_`, 8)}`, 32).split("").map((c) => (c.charCodeAt(0) % 16).toString(16)).join("");
+        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+      },
+      audioTurnChunks: settings.audioTurnChunks,
+      ...fault && !FAULT_ERRORS[fault.type] ? { fault } : {}
+    });
+    return annotateResponse(this.eventStream(body, requestId), { ids: { modelId } });
+  }
+};
+
+export {
+  document,
+  operationIds,
+  supportedOperationIds,
+  sampleSchema,
+  MODEL_OPERATIONS,
+  STOP_REASONS,
+  TURN_FAULTS,
+  parseScript,
+  GUARDRAIL_BLOCKED_TEXT,
+  DEFAULT_CHAT_TEXT,
+  DEFAULT_CLASSIFIER,
+  DEFAULT_SOAP_NOTE,
+  EventStreamError,
+  crc32,
+  encodeMessage,
+  decodeMessage,
+  FrameReader,
+  unwrapSigned,
+  eventFrame,
+  exceptionFrame,
+  readFrames,
+  DEFAULT_SETTINGS,
+  BEDROCK_PRESETS,
+  createRuntime2 as createRuntime,
+  BEDROCK_NAMESPACE,
+  bedrockError,
+  accessKeyCredential,
+  clockSleep,
+  titanEmbedding,
+  BedrockAPI
+};
+//# sourceMappingURL=chunk-O5ZO5KMR.js.map