@crvouga/mockingbird-service-junction 0.3.0 → 0.5.0

package/dist/{chunk-NFWUEPW4.js → chunk-ICINEQ7D.js}

@@ -213,8 +213,21 @@ var createControlPlane = (context) => {
     },
     "GET /faults": () => json(200, { faults: context.faults.list() }),
     "POST /faults": ({ body, namespace }) => {
-      if (!isRecord(body) || typeof body.status !== "number") {
-        return adminError(400, "a fault needs a numeric status");
+      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
@@ -333,6 +346,21 @@ var createControlPlane = (context) => {
   };
 };
 
+// ../core/dist/credentials.js
+var createCredentialRegistry = () => {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    set: (credential, namespace) => {
+      map.set(credential, namespace);
+    },
+    get: (credential) => map.get(credential),
+    remove: (credential) => map.delete(credential),
+    clear: () => map.clear(),
+    entries: () => [...map].map(([credential, namespace]) => ({ credential, namespace })).sort((a, b) => a.credential.localeCompare(b.credential))
+  };
+};
+var maskCredential = (credential) => credential.length <= 8 ? `${credential.slice(0, 2)}\u2026` : `${credential.slice(0, 6)}\u2026${credential.slice(-2)}`;
+
 // ../core/dist/rng.js
 var seedFrom = (value) => {
   let hash = 2166136261;
@@ -377,11 +405,14 @@ var matches = (rule, candidate) => {
   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: rule.status, headers });
+    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: rule.status, headers });
+  return new Response(JSON.stringify(body), { status, headers });
 };
 var createFaultRegistry = (rng = createRng(0)) => {
   const entries = [];
@@ -407,6 +438,7 @@ var createFaultRegistry = (rng = createRng(0)) => {
       entries.length = 0;
     },
     async take(candidate) {
+      const hits = [];
       for (const entry of entries) {
         if (entry.remaining === 0)
           continue;
@@ -418,12 +450,23 @@ var createFaultRegistry = (rng = createRng(0)) => {
         entry.hits++;
         if (entry.remaining !== null)
           entry.remaining--;
-        if (entry.rule.delayMs !== void 0 && entry.rule.delayMs > 0) {
-          await new Promise((resolve) => setTimeout(resolve, entry.rule.delayMs));
+        const delay = entry.rule.delayMs ?? entry.rule.latencyMs;
+        if (delay !== void 0 && delay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, delay));
         }
-        return { id: entry.rule.id, response: faultResponse(entry.rule) };
+        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 void 0;
+      return hits;
     }
   };
 };
@@ -996,6 +1039,7 @@ var createService = (options) => {
         sqlite: options.sqlite,
         namespace: options.namespace,
         operation,
+        document: options.document,
         now
       };
       const short = await options.before?.(context);
@@ -1038,12 +1082,123 @@ var restoreNamespace = (sqlite, namespace, snapshot) => {
 };
 
 // ../core/dist/version.js
-var PACKAGE_VERSION = true ? "0.3.0" : UNRELEASED_VERSION;
+var PACKAGE_VERSION = true ? "0.5.0" : UNRELEASED_VERSION;
+
+// ../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 DEFAULT_NAMESPACE = "default";
 var NAMESPACE_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
+var PATH_PREFIX = /^\/ns\/([^/]+)(\/.*)?$/;
+var effects = /* @__PURE__ */ new WeakMap();
+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,
@@ -1062,6 +1217,7 @@ var createRuntime = (options) => {
   const journal = createJournal(options.journalSize ?? DEFAULT_JOURNAL_SIZE);
   const version = options.version ?? PACKAGE_VERSION;
   const instances = /* @__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 instance = (name = DEFAULT_NAMESPACE) => {
@@ -1083,10 +1239,12 @@ var createRuntime = (options) => {
   };
   const reset = async (name = DEFAULT_NAMESPACE) => {
     if (name === "*") {
+      options.webhooks?.clear();
       for (const each of instances.values())
         await each.reset();
       return;
     }
+    options.webhooks?.clear(name);
     const target = instances.get(name);
     if (target)
       await target.reset();
@@ -1109,13 +1267,57 @@ var createRuntime = (options) => {
     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: () => [...instances.keys()].sort(),
     reset,
     snapshot,
     restore,
-    fetch: async (request2) => {
-      const namespace = control.namespaceOf(request2);
+    fetch: async (incoming) => {
+      let request2 = incoming;
+      const prefixed = PATH_PREFIX.exec(new URL(request2.url).pathname);
+      if (prefixed) {
+        const url2 = new URL(request2.url);
+        url2.pathname = prefixed[2] ?? "/";
+        const headers = new Headers(request2.headers);
+        if (!headers.has(NAMESPACE_HEADER)) {
+          headers.set(NAMESPACE_HEADER, decodeURIComponent(prefixed[1]));
+        }
+        const hasBody = request2.method !== "GET" && request2.method !== "HEAD";
+        request2 = new Request(url2, {
+          method: request2.method,
+          headers,
+          ...hasBody ? { body: await request2.arrayBuffer() } : {},
+          signal: request2.signal
+        });
+      }
+      let namespace = control.namespaceOf(request2);
+      if (!request2.headers.has(NAMESPACE_HEADER) && options.credential) {
+        const credential = options.credential(request2);
+        const mapped = credential !== void 0 ? credentials.get(credential) : void 0;
+        if (mapped !== void 0)
+          namespace = mapped;
+      }
       const stamp = (response2) => {
         const value = NAMESPACE_PATTERN.test(namespace) ? `${options.name}@${version}; ns=${namespace}` : `${options.name}@${version}`;
         try {
@@ -1161,18 +1363,26 @@ var createRuntime = (options) => {
           }
         }), { status: 400, headers: { "content-type": "application/json" } }));
       }
-      const faulted = await faults.take({
+      const hits = await faults.take({
         operationId,
         method: request2.method,
         path: url.pathname,
         namespace
       });
-      if (faulted) {
-        log(faulted.response.status, faulted.id);
-        return stamp(faulted.response);
+      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(request2, fired.map((hit) => hit.effect));
       const response = await instance(namespace).fetch(request2);
-      log(response.status, void 0, response);
+      log(response.status, fired[0]?.id, response);
       return stamp(response);
     }
   };
@@ -1189,11 +1399,83 @@ var createRuntime = (options) => {
     snapshot: (name) => snapshot(name),
     restore: (name, from) => restore(from, name),
     describe: options.describe ?? (() => ({})),
-    routes: options.admin?.(runtime) ?? {},
+    ...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 adminJson = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+var adminFail = (status, message) => adminJson(status, { error: { type: "mockingbird_admin", message } });
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var credentialRoutes = (registry) => ({
+  "GET /credentials": () => adminJson(200, {
+    credentials: registry.entries().map(({ credential, namespace }) => ({
+      credential: maskCredential(credential),
+      namespace
+    }))
+  }),
+  "PUT /credentials": ({ body, namespace }) => {
+    const pairs = [];
+    const list = Array.isArray(body) ? body : isObject(body) ? body.credentials : void 0;
+    if (Array.isArray(list)) {
+      for (const each of list) {
+        if (typeof each === "string")
+          pairs.push([each, namespace]);
+        else if (isObject(each) && typeof each.credential === "string") {
+          pairs.push([
+            each.credential,
+            typeof each.namespace === "string" ? each.namespace : namespace
+          ]);
+        } else
+          return adminFail(400, "each entry is a credential string or {credential, namespace}");
+      }
+    } else if (isObject(list)) {
+      for (const [credential, target] of Object.entries(list)) {
+        if (typeof target !== "string")
+          return adminFail(400, `namespace for ${credential} must be a string`);
+        pairs.push([credential, target]);
+      }
+    } else if (isObject(body) && typeof body.credential === "string") {
+      pairs.push([body.credential, typeof body.namespace === "string" ? body.namespace : namespace]);
+    } else {
+      return adminFail(400, 'expected {"credentials": {"<credential>": "<namespace>"}}');
+    }
+    for (const [credential, target] of pairs) {
+      if (!NAMESPACE_PATTERN.test(target))
+        return adminFail(400, `bad namespace ${JSON.stringify(target)}`);
+      registry.set(credential, target);
+    }
+    return adminJson(200, { mapped: pairs.length });
+  },
+  "DELETE /credentials": ({ url }) => {
+    const credential = url.searchParams.get("credential");
+    if (credential === null)
+      registry.clear();
+    else
+      registry.remove(credential);
+    return adminJson(200, { status: "ok" });
+  }
+});
+var presetRoutes = (presets, runtime) => ({
+  "GET /faults/presets": () => adminJson(200, {
+    presets: Object.entries(presets).map(([name, preset]) => ({ name, ...preset }))
+  }),
+  "POST /faults/presets/:name": ({ params, body, namespace }) => {
+    const name = params.name;
+    if (!presets[name])
+      return adminFail(404, `no fault preset ${name}; GET /__admin/faults/presets`);
+    const overrides = isObject(body) ? body : {};
+    return adminJson(201, { preset: name, rules: runtime.applyPreset(name, namespace, overrides) });
+  }
+});
 
 // src/catalog.ts
 var LAB_TEST_CATALOG = [
@@ -2626,7 +2908,7 @@ var renderLabAccount = (entry) => ({
   ),
   team_id_allowlist: [...entry.team_id_allowlist]
 });
-var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var DELEGATED_FLOWS = [
   "order_delegated",
   "result_delegated",
@@ -2642,7 +2924,7 @@ var checkStates = (value, where) => {
 };
 var stringList = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string") ? [...value] : void 0;
 var labAccountFromInput = (input, teamId = MOCK_TEAM_ID) => {
-  if (!isRecord3(input)) throw new TypeError("lab account must be an object");
+  if (!isRecord4(input)) throw new TypeError("lab account must be an object");
   if (typeof input.id !== "string" || input.id === "")
     throw new TypeError("lab account needs a non-empty id");
   const where = `lab account ${input.id}`;
@@ -2654,7 +2936,7 @@ var labAccountFromInput = (input, teamId = MOCK_TEAM_ID) => {
     throw new TypeError(`${where}: delegated_flow must be one of ${DELEGATED_FLOWS.join(", ")}`);
   if (input.states !== void 0) checkStates(input.states, `${where}: states`);
   if (input.allowed_billing !== void 0) {
-    if (!isRecord3(input.allowed_billing))
+    if (!isRecord4(input.allowed_billing))
       throw new TypeError(`${where}: allowed_billing must map billing types to state lists`);
     for (const [type, states] of Object.entries(input.allowed_billing)) {
       if (!BILLING_TYPES.includes(type))
@@ -2693,7 +2975,7 @@ var labAccountFromInput = (input, teamId = MOCK_TEAM_ID) => {
   };
 };
 var patchLabAccount = (existing, patch, teamId) => {
-  if (!isRecord3(patch)) throw new TypeError("lab account patch must be an object");
+  if (!isRecord4(patch)) throw new TypeError("lab account patch must be an object");
   if (patch.id !== void 0 && patch.id !== existing.id)
     throw new TypeError(`lab account ${existing.id}: id cannot be changed`);
   const { states, ...rest } = patch;
@@ -2713,7 +2995,7 @@ var patchLabAccount = (existing, patch, teamId) => {
 var labAccountFromClientFacing = (value, recordedTeamId) => {
   if (typeof value.id !== "string" || typeof value.lab !== "string") return void 0;
   const billing = {};
-  if (isRecord3(value.allowed_billing)) {
+  if (isRecord4(value.allowed_billing)) {
     for (const [type, states] of Object.entries(value.allowed_billing)) {
       const list = stringList(states);
       if (list) billing[type] = list;
@@ -2967,18 +3249,18 @@ var resolveTransition = (method, target) => {
     error: `${JSON.stringify(target)} is not a ${method} status. Use one of: ${names.join(", ")}, or a full status such as ${allowed.slice(0, 2).map((s) => `${s.split(".")[0]}.${method}.${s.split(".")[1]}`).join(", ")}`
   };
 };
-var adminError2 = (status, message) => jsonRes(status, { error: { type: "mockingbird_admin", message } });
-var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var adminError3 = (status, message) => jsonRes(status, { error: { type: "mockingbird_admin", message } });
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var guarded = (run) => {
   try {
     return run();
   } catch (error) {
-    if (error instanceof TypeError) return adminError2(400, error.message);
+    if (error instanceof TypeError) return adminError3(400, error.message);
     if (error instanceof Error && error.name === "LabAccountConflict") {
-      return adminError2(409, error.message);
+      return adminError3(409, error.message);
     }
     const { status, message } = fixtureErrorMessage(error);
-    return adminError2(status, message);
+    return adminError3(status, message);
   }
 };
 var junctionAdminRoutes = (options) => (runtime) => {
@@ -2994,20 +3276,20 @@ var junctionAdminRoutes = (options) => (runtime) => {
       }))
     }),
     "POST /orders/:id/transition": (request2) => {
-      const body = isRecord4(request2.body) ? request2.body : {};
+      const body = isRecord5(request2.body) ? request2.body : {};
       const order = api(request2).order(request2.params.id);
-      if (!order) return adminError2(404, `no order ${request2.params.id} in ${request2.namespace}`);
+      if (!order) return adminError3(404, `no order ${request2.params.id} in ${request2.namespace}`);
       if (typeof body.to !== "string") {
-        return adminError2(400, 'body needs "to": a status like "completed" or "at_lab"');
+        return adminError3(400, 'body needs "to": a status like "completed" or "at_lab"');
       }
       const method = methodOf(order);
       const resolved = resolveTransition(method, body.to);
-      if ("error" in resolved) return adminError2(400, resolved.error);
-      let flags = isRecord4(body.flags) ? body.flags : null;
+      if ("error" in resolved) return adminError3(400, resolved.error);
+      let flags = isRecord5(body.flags) ? body.flags : null;
       if (typeof body.result === "string") {
         const named = RESULT_FIXTURES[body.result];
         if (!named) {
-          return adminError2(
+          return adminError3(
             400,
             `no result fixture ${body.result}; one of ${Object.keys(RESULT_FIXTURES).join(", ")}`
           );
@@ -3027,23 +3309,23 @@ var junctionAdminRoutes = (options) => (runtime) => {
     "GET /result-fixtures": () => jsonRes(200, { fixtures: RESULT_FIXTURES }),
     "GET /results/:id": (request2) => {
       const fixture = api(request2).resultFixture(request2.params.id);
-      return fixture ? jsonRes(200, fixture) : adminError2(404, "no result fixture for that order");
+      return fixture ? jsonRes(200, fixture) : adminError3(404, "no result fixture for that order");
     },
     "PUT /results/:id": (request2) => {
-      if (!isRecord4(request2.body)) return adminError2(400, "expected a result fixture object");
+      if (!isRecord5(request2.body)) return adminError3(400, "expected a result fixture object");
       const fixture = { name: "custom", ...request2.body };
       if (fixture.results !== void 0 && !Array.isArray(fixture.results)) {
-        return adminError2(400, "results must be an array of result lines");
+        return adminError3(400, "results must be an array of result lines");
       }
-      return api(request2).installResultFixture(request2.params.id, fixture) ? jsonRes(200, fixture) : adminError2(404, `no order ${request2.params.id} in ${request2.namespace}`);
+      return api(request2).installResultFixture(request2.params.id, fixture) ? jsonRes(200, fixture) : adminError3(404, `no order ${request2.params.id} in ${request2.namespace}`);
     },
     "GET /lab-accounts": (request2) => jsonRes(200, { data: api(request2).labAccounts() }),
     "PUT /lab-accounts": (request2) => {
-      const body = isRecord4(request2.body) ? request2.body : {};
+      const body = isRecord5(request2.body) ? request2.body : {};
       const accounts = body.accounts;
       const presets = body.presets;
       if (accounts === void 0 && presets === void 0 || accounts !== void 0 && accounts !== null && !Array.isArray(accounts) || presets !== void 0 && !Array.isArray(presets)) {
-        return adminError2(
+        return adminError3(
           400,
           'body needs "accounts": an array (or null to restore the default), and/or "presets": an array of preset names'
         );
@@ -3055,20 +3337,20 @@ var junctionAdminRoutes = (options) => (runtime) => {
       return guarded(() => jsonRes(200, { data: api(request2).configureLabAccounts(layout) }));
     },
     "POST /lab-accounts": (request2) => {
-      if (!isRecord4(request2.body)) return adminError2(400, "expected one lab account object");
+      if (!isRecord5(request2.body)) return adminError3(400, "expected one lab account object");
       const input = request2.body;
       return guarded(() => jsonRes(201, api(request2).addLabAccount(input)));
     },
     "PATCH /lab-accounts/:id": (request2) => {
-      if (!isRecord4(request2.body))
-        return adminError2(400, "expected an object of fields to change");
+      if (!isRecord5(request2.body))
+        return adminError3(400, "expected an object of fields to change");
       const patch = request2.body;
       return guarded(() => {
         const updated = api(request2).patchLabAccount(request2.params.id, patch);
-        return updated ? jsonRes(200, updated) : adminError2(404, `no lab account ${request2.params.id} in ${request2.namespace}`);
+        return updated ? jsonRes(200, updated) : adminError3(404, `no lab account ${request2.params.id} in ${request2.namespace}`);
       });
     },
-    "DELETE /lab-accounts/:id": (request2) => api(request2).removeLabAccount(request2.params.id) ? jsonRes(200, { status: "ok" }) : adminError2(404, `no lab account ${request2.params.id} in ${request2.namespace}`),
+    "DELETE /lab-accounts/:id": (request2) => api(request2).removeLabAccount(request2.params.id) ? jsonRes(200, { status: "ok" }) : adminError3(404, `no lab account ${request2.params.id} in ${request2.namespace}`),
     "GET /lab-accounts/presets": (request2) => jsonRes(200, {
       presets: Object.fromEntries(
         Object.keys(LAB_ACCOUNT_PRESETS).map((name) => {
@@ -3078,14 +3360,14 @@ var junctionAdminRoutes = (options) => (runtime) => {
       )
     }),
     "POST /lab-accounts/presets/:name": (request2) => {
-      const body = isRecord4(request2.body) ? request2.body : {};
+      const body = isRecord5(request2.body) ? request2.body : {};
       if (body.id !== void 0 && typeof body.id !== "string") {
-        return adminError2(400, "id must be a string");
+        return adminError3(400, "id must be a string");
       }
       const name = request2.params.name;
       return guarded(() => {
         const record = api(request2).addLabAccountPreset(name, body.id);
-        return record ? jsonRes(201, record) : adminError2(
+        return record ? jsonRes(201, record) : adminError3(
           404,
           `no lab-account preset ${name}; one of ${Object.keys(LAB_ACCOUNT_PRESETS).join(", ")}`
         );
@@ -3094,34 +3376,34 @@ var junctionAdminRoutes = (options) => (runtime) => {
     "GET /team": (request2) => jsonRes(200, { teamId: api(request2).teamId }),
     "GET /limits": (request2) => jsonRes(200, { limits: api(request2).limits }),
     "PUT /limits": (request2) => {
-      if (!isRecord4(request2.body)) return adminError2(400, "expected an object of limits");
+      if (!isRecord5(request2.body)) return adminError3(400, "expected an object of limits");
       const input = request2.body;
       return guarded(() => jsonRes(200, { limits: api(request2).configureLimits(input) }));
     },
     "GET /identity": (request2) => jsonRes(200, { identity: api(request2).identity }),
     "PUT /identity": (request2) => {
-      const mode = isRecord4(request2.body) ? request2.body.mode : void 0;
+      const mode = isRecord5(request2.body) ? request2.body.mode : void 0;
       if (!IDENTITY_MODES.includes(mode)) {
-        return adminError2(400, `body needs "mode": one of ${IDENTITY_MODES.join(", ")}`);
+        return adminError3(400, `body needs "mode": one of ${IDENTITY_MODES.join(", ")}`);
       }
       api(request2).identity = mode;
       return jsonRes(200, { identity: mode });
     },
     "POST /users": (request2) => {
-      if (!isRecord4(request2.body)) return adminError2(400, "expected one user object");
+      if (!isRecord5(request2.body)) return adminError3(400, "expected one user object");
       const input = request2.body;
       return guarded(() => jsonRes(201, api(request2).insertUsers([input])[0]));
     },
     "POST /users/bulk": (request2) => {
-      const users = isRecord4(request2.body) ? request2.body.users : void 0;
-      if (!Array.isArray(users)) return adminError2(400, 'body needs "users": an array');
+      const users = isRecord5(request2.body) ? request2.body.users : void 0;
+      if (!Array.isArray(users)) return adminError3(400, 'body needs "users": an array');
       return guarded(
         () => jsonRes(201, { users: api(request2).insertUsers(users) })
       );
     },
-    "DELETE /users/:id": (request2) => api(request2).hardDeleteUser(request2.params.id) ? jsonRes(200, { status: "ok" }) : adminError2(404, `no user ${request2.params.id} in ${request2.namespace}`),
+    "DELETE /users/:id": (request2) => api(request2).hardDeleteUser(request2.params.id) ? jsonRes(200, { status: "ok" }) : adminError3(404, `no user ${request2.params.id} in ${request2.namespace}`),
     "POST /orders": (request2) => {
-      if (!isRecord4(request2.body)) return adminError2(400, "expected one order object");
+      if (!isRecord5(request2.body)) return adminError3(400, "expected one order object");
       const { emitWebhooks, ...input } = request2.body;
       return guarded(
         () => jsonRes(
@@ -3133,8 +3415,8 @@ var junctionAdminRoutes = (options) => (runtime) => {
       );
     },
     "POST /import": (request2) => {
-      if (!isRecord4(request2.body)) {
-        return adminError2(400, 'expected { "users": [...], "orders": [...] }');
+      if (!isRecord5(request2.body)) {
+        return adminError3(400, 'expected { "users": [...], "orders": [...] }');
       }
       const { emitWebhooks, ...fixtures } = request2.body;
       return guarded(() => {
@@ -3149,25 +3431,25 @@ var junctionAdminRoutes = (options) => (runtime) => {
       geo: api(request2).geoMode
     }),
     "PUT /geo": (request2) => {
-      const mode = isRecord4(request2.body) ? request2.body.mode : void 0;
+      const mode = isRecord5(request2.body) ? request2.body.mode : void 0;
       if (mode !== "corpus" && mode !== "synthetic") {
-        return adminError2(400, 'body needs "mode": "corpus" or "synthetic"');
+        return adminError3(400, 'body needs "mode": "corpus" or "synthetic"');
       }
       api(request2).geoMode = mode;
       return jsonRes(200, { geo: mode });
     },
     "GET /webhooks/events": (request2) => jsonRes(200, { events: api(request2).webhookEvents() }),
-    "GET /webhooks": (request2) => options.webhooks ? jsonRes(200, { deliveries: options.webhooks.deliveries(request2.namespace) }) : adminError2(
+    "GET /webhooks": (request2) => options.webhooks ? jsonRes(200, { deliveries: options.webhooks.deliveries(request2.namespace) }) : adminError3(
       409,
       "webhook delivery is off; serve with --webhook-url and --webhook-secret"
     ),
     "POST /webhooks/:id/replay": async (request2) => {
-      if (!options.webhooks) return adminError2(409, "webhook delivery is off");
+      if (!options.webhooks) return adminError3(409, "webhook delivery is off");
       const delivery = await options.webhooks.replay(request2.params.id);
-      return delivery ? jsonRes(200, delivery) : adminError2(404, `no message ${request2.params.id}`);
+      return delivery ? jsonRes(200, delivery) : adminError3(404, `no message ${request2.params.id}`);
     },
     "POST /webhooks/flush": async () => {
-      if (!options.webhooks) return adminError2(409, "webhook delivery is off");
+      if (!options.webhooks) return adminError3(409, "webhook delivery is off");
       await options.webhooks.flush();
       return jsonRes(200, { status: "ok" });
     },
@@ -3175,12 +3457,12 @@ var junctionAdminRoutes = (options) => (runtime) => {
     "POST /faults/presets/:name": (request2) => {
       const preset = FAULT_PRESETS[request2.params.name];
       if (!preset) {
-        return adminError2(
+        return adminError3(
           404,
           `no preset ${request2.params.name}; one of ${Object.keys(FAULT_PRESETS).join(", ")}`
         );
       }
-      const overrides = isRecord4(request2.body) ? request2.body : {};
+      const overrides = isRecord5(request2.body) ? request2.body : {};
       const rule = runtime.faults.add({
         namespace: request2.namespace,
         ...preset,
@@ -5807,7 +6089,7 @@ var FixtureError = class extends Error {
   }
   status;
 };
-var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var instant = (value, field, fallback) => {
   if (value === void 0) return fallback;
   if (typeof value !== "string" || Number.isNaN(Date.parse(value)))
@@ -5831,7 +6113,7 @@ var DEFAULT_PATIENT_ADDRESS = {
   country: "US"
 };
 var buildUser = (state, input, now) => {
-  if (!isRecord5(input)) throw new FixtureError(400, "a user fixture must be an object");
+  if (!isRecord6(input)) throw new FixtureError(400, "a user fixture must be an object");
   if (typeof input.client_user_id !== "string" || input.client_user_id === "")
     throw new FixtureError(400, "client_user_id must be a non-empty string");
   if (input.user_id !== void 0 && (typeof input.user_id !== "string" || !isUuid3(input.user_id)))
@@ -5881,7 +6163,7 @@ var insertOrders = (state, inputs, now, options = {}) => {
   const prepared = [];
   const ids = /* @__PURE__ */ new Set();
   for (const input of inputs) {
-    if (!isRecord5(input)) throw new FixtureError(400, "an order fixture must be an object");
+    if (!isRecord6(input)) throw new FixtureError(400, "an order fixture must be an object");
     if (typeof input.user_id !== "string") throw new FixtureError(400, "user_id is required");
     if (typeof input.lab_test_id !== "string")
       throw new FixtureError(400, "lab_test_id is required");
@@ -5951,7 +6233,7 @@ var insertOrders = (state, inputs, now, options = {}) => {
   return prepared.flatMap(({ order }) => state.orders.get(order.id) ?? []);
 };
 var importFixtures = (state, fixtures, now, options = {}) => {
-  if (!isRecord5(fixtures))
+  if (!isRecord6(fixtures))
     throw new FixtureError(400, 'fixtures must be { "users": [...], "orders": [...] }');
   const { users = [], orders = [] } = fixtures;
   if (!Array.isArray(users)) throw new FixtureError(400, "users must be an array");
@@ -5976,7 +6258,7 @@ var requireUser = (state, userId, context, detail = "User does not exist on this
 var fixtureErrorMessage = (error) => {
   if (error instanceof FixtureError) return { status: error.status, message: error.message };
   if (error instanceof HttpError) {
-    const detail = isRecord5(error.body) ? error.body.detail : error.body;
+    const detail = isRecord6(error.body) ? error.body.detail : error.body;
     return {
       status: error.status,
       message: typeof detail === "string" ? detail : JSON.stringify(detail)
@@ -8846,4 +9128,4 @@ export {
   JunctionAPI,
   LabAccountConflict
 };
-//# sourceMappingURL=chunk-NFWUEPW4.js.map
+//# sourceMappingURL=chunk-ICINEQ7D.js.map