@takosjp/yurucommu-core 3.0.0

package/src/backend/lib/crypto.ts

@@ -0,0 +1,424 @@
+/**
+ * Cryptography utilities for sensitive data encryption
+ *
+ * Uses AES-GCM for symmetric encryption of OAuth tokens and other sensitive data.
+ * The encryption key should be set via ENCRYPTION_KEY environment variable.
+ */
+
+import { logger } from "./logger.ts";
+import { bytesToHex } from "./hex.ts";
+
+const log = logger.child({ component: "crypto" });
+
+function isValidHexString(hex: string, expectedLength?: number): boolean {
+  if (!/^[0-9a-fA-F]+$/.test(hex)) return false;
+  if (hex.length % 2 !== 0) return false;
+  if (expectedLength !== undefined && hex.length !== expectedLength) {
+    return false;
+  }
+  return true;
+}
+
+function hexToBytes(hex: string): Uint8Array {
+  if (!isValidHexString(hex)) {
+    throw new Error(
+      "Invalid hex string: must contain only hexadecimal characters (0-9, a-f, A-F) with even length",
+    );
+  }
+
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    const byte = parseInt(hex.substring(i, i + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error(`Invalid hex character at position ${i}`);
+    }
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
+
+/**
+ * Dev-only fallback salt used when YURUCOMMU_SESSION_HASH_SALT is unset.
+ * Mirrors the takosumi F7 pattern: fresh-DB tests still work, but a
+ * loud warning fires in strict / production mode so operators notice.
+ */
+const DEV_SESSION_HASH_SALT = "yurucommu:dev-only-session-hash-salt";
+
+let warnedMissingSessionSalt = false;
+
+/**
+ * Hash a session id for at-rest storage / lookup. The persisted session-row
+ * key is `sha256:<hex>` of `salt:sessionId`; the raw session id only ever
+ * lives in the client cookie. A read-only leak of the session table therefore
+ * cannot be replayed against the API without also recovering the raw id.
+ *
+ * BREAKING CHANGE: rows written before this change stored the raw id as the
+ * key, so existing sessions no longer resolve and users must re-login. This is
+ * acceptable; truncating the sessions table has the same effect.
+ *
+ * `salt` should be the per-deployment YURUCOMMU_SESSION_HASH_SALT env value.
+ * When unset we fall back to a fixed dev salt and (in strict mode) warn.
+ */
+export async function hashSessionId(
+  sessionId: string,
+  salt: string | undefined,
+  strict = false,
+): Promise<string> {
+  let effectiveSalt = salt;
+  if (!effectiveSalt) {
+    if (strict && !warnedMissingSessionSalt) {
+      warnedMissingSessionSalt = true;
+      log.error(
+        "YURUCOMMU_SESSION_HASH_SALT is unset in strict/production mode; " +
+          "using an insecure shared dev fallback salt. Set a high-entropy " +
+          "value to make leaked session rows non-replayable.",
+        { event: "crypto.session_salt.missing" },
+      );
+    }
+    effectiveSalt = DEV_SESSION_HASH_SALT;
+  }
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(`${effectiveSalt}:${sessionId}`),
+  );
+  return `sha256:${bytesToHex(new Uint8Array(digest))}`;
+}
+
+/**
+ * Resolve the session-hash salt + strict flag from an Env-like object and hash
+ * the raw session id. Centralises the salt/strict derivation so every lookup
+ * and write site hashes identically.
+ */
+export function hashSessionIdForEnv(
+  env: {
+    YURUCOMMU_SESSION_HASH_SALT?: string;
+    YURUCOMMU_STRICT_READINESS?: string;
+  },
+  sessionId: string,
+): Promise<string> {
+  const strictValue = env.YURUCOMMU_STRICT_READINESS?.trim().toLowerCase();
+  const strict =
+    strictValue === "1" || strictValue === "true" || strictValue === "yes";
+  return hashSessionId(sessionId, env.YURUCOMMU_SESSION_HASH_SALT, strict);
+}
+
+export class EncryptionKeyError extends Error {
+  override name = "EncryptionKeyError";
+}
+
+export class DecryptionError extends Error {
+  override name = "DecryptionError";
+}
+
+async function getEncryptionKey(
+  keyHex: string | undefined,
+): Promise<CryptoKey | null> {
+  if (!keyHex) return null;
+
+  if (!isValidHexString(keyHex, 64)) {
+    log.error("Invalid encryption key format", {
+      event: "crypto.key.invalid_format",
+      reason: "must be exactly 64 hex characters (0-9, a-f, A-F)",
+    });
+    return null;
+  }
+
+  try {
+    const keyBytes = hexToBytes(keyHex);
+    if (keyBytes.byteLength !== 32) {
+      log.error("Invalid encryption key length", {
+        event: "crypto.key.invalid_length",
+        reason: "must decode to exactly 32 bytes",
+        actualLength: keyBytes.byteLength,
+      });
+      return null;
+    }
+    return await crypto.subtle.importKey(
+      "raw",
+      keyBytes.buffer as ArrayBuffer,
+      { name: "AES-GCM" },
+      false,
+      ["encrypt", "decrypt"],
+    );
+  } catch (error) {
+    log.error("Failed to import encryption key", {
+      event: "crypto.key.import_failed",
+      error,
+    });
+    return null;
+  }
+}
+
+async function requireEncryptionKey(
+  keyHex: string | undefined,
+  errorMessage: string,
+): Promise<CryptoKey> {
+  const key = await getEncryptionKey(keyHex);
+  if (!key) throw new EncryptionKeyError(errorMessage);
+  return key;
+}
+
+/**
+ * Encrypt a string value using AES-GCM.
+ * Returns format: iv:ciphertext (both hex encoded)
+ *
+ * AAD NOTE (deferred, by design): this AES-GCM call binds no associated data, so
+ * a ciphertext is not cryptographically tied to the record it lives in. That
+ * would only matter for an attacker with DB WRITE access who relocates a
+ * ciphertext between rows — and today the only thing encrypted is the OAuth
+ * providerAccessToken/RefreshToken, which is WRITE-ONLY: `decrypt` has no callers
+ * and the stored token is merely presence-checked (`!!providerAccessToken`).
+ * AAD has no value until a decrypt-and-USE path exists; bind it THEN (to the
+ * member/session context that consumes the token) so the binding matches the
+ * use, rather than guessing the context now.
+ */
+export async function encrypt(
+  plaintext: string,
+  encryptionKey: string | undefined,
+): Promise<string> {
+  const key = await requireEncryptionKey(
+    encryptionKey,
+    "ENCRYPTION_KEY is not configured or invalid. " +
+      "A 32-byte (64 hex character) key is required to encrypt sensitive data. " +
+      "Generate one with: openssl rand -hex 32",
+  );
+
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const data = new TextEncoder().encode(plaintext);
+
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv: iv.buffer as ArrayBuffer },
+    key,
+    data.buffer as ArrayBuffer,
+  );
+
+  return `${bytesToHex(iv)}:${bytesToHex(new Uint8Array(ciphertext))}`;
+}
+
+/**
+ * Decrypt a string value encrypted with encrypt().
+ * Expects format: iv:ciphertext (both hex encoded)
+ */
+export async function decrypt(
+  encrypted: string,
+  encryptionKey: string | undefined,
+): Promise<string> {
+  const key = await requireEncryptionKey(
+    encryptionKey,
+    "ENCRYPTION_KEY is not configured or invalid. " +
+      "Cannot decrypt data without the encryption key.",
+  );
+
+  if (!encrypted.includes(":")) {
+    throw new DecryptionError(
+      "Invalid encrypted data format. Please re-authenticate.",
+    );
+  }
+
+  const parts = encrypted.split(":");
+  if (parts.length !== 2) {
+    throw new DecryptionError(
+      "Invalid encrypted data format. Please re-authenticate.",
+    );
+  }
+
+  const [ivHex, ciphertextHex] = parts;
+  if (!ivHex || !ciphertextHex) {
+    throw new DecryptionError(
+      "Invalid encrypted data format. Please re-authenticate.",
+    );
+  }
+  if (!isValidHexString(ivHex, 24)) {
+    throw new DecryptionError(
+      "Invalid encrypted data format. Please re-authenticate.",
+    );
+  }
+  if (!isValidHexString(ciphertextHex) || ciphertextHex.length < 32) {
+    throw new DecryptionError(
+      "Invalid encrypted data format. Please re-authenticate.",
+    );
+  }
+
+  try {
+    const iv = hexToBytes(ivHex);
+    const ciphertext = hexToBytes(ciphertextHex);
+
+    const decrypted = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: iv.buffer as ArrayBuffer },
+      key,
+      ciphertext.buffer as ArrayBuffer,
+    );
+
+    return new TextDecoder().decode(decrypted);
+  } catch {
+    throw new DecryptionError(
+      "Failed to decrypt data. The encryption key may be incorrect or the data is corrupted.",
+    );
+  }
+}
+
+// PBKDF2 password hashing
+
+const PBKDF2_ITERATIONS = 100000; // Cloudflare Workers caps deriveBits at 100k iterations
+const SALT_LENGTH = 32;
+const HASH_LENGTH = 32;
+
+/**
+ * Derive bits from a password and salt using PBKDF2-SHA256.
+ */
+async function derivePasswordBits(
+  password: string,
+  salt: Uint8Array,
+  hashLengthBytes: number,
+): Promise<Uint8Array> {
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(password).buffer as ArrayBuffer,
+    "PBKDF2",
+    false,
+    ["deriveBits"],
+  );
+
+  const derivedBits = await crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt: salt.buffer as ArrayBuffer,
+      iterations: PBKDF2_ITERATIONS,
+      hash: "SHA-256",
+    },
+    keyMaterial,
+    hashLengthBytes * 8,
+  );
+
+  return new Uint8Array(derivedBits);
+}
+
+/**
+ * Constant-time comparison of two byte arrays.
+ */
+function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.length !== b.length) return false;
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a[i] ^ b[i];
+  }
+  return result === 0;
+}
+
+/**
+ * Hash a password using PBKDF2-SHA256.
+ * Returns format: salt:hash (both hex encoded)
+ */
+export async function hashPassword(password: string): Promise<string> {
+  const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH));
+  const hash = await derivePasswordBits(password, salt, HASH_LENGTH);
+  return `${bytesToHex(salt)}:${bytesToHex(hash)}`;
+}
+
+/**
+ * Verify a password against a stored hash (salt:hash, hex encoded).
+ */
+export async function verifyPassword(
+  password: string,
+  storedHash: string,
+): Promise<boolean> {
+  if (!storedHash.includes(":")) return false;
+
+  const [saltHex, expectedHashHex] = storedHash.split(":");
+  if (!saltHex || !expectedHashHex) return false;
+  if (!isValidHexString(saltHex) || !isValidHexString(expectedHashHex)) {
+    return false;
+  }
+
+  try {
+    const salt = hexToBytes(saltHex);
+    const expectedHash = hexToBytes(expectedHashHex);
+    const computedHash = await derivePasswordBits(
+      password,
+      salt,
+      expectedHash.length,
+    );
+    return timingSafeEqual(computedHash, expectedHash);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Decide whether a stored AUTH_PASSWORD_HASH value is a proper PBKDF2
+ * `salt:hash` credential or a bootstrap shared secret.
+ *
+ * A fresh Capsule install generates AUTH_PASSWORD_HASH as a colon-less
+ * 64-char hex token (enough to satisfy the readiness AUTH_METHOD gate) rather
+ * than a real PBKDF2 hash. The PBKDF2 form is `<saltHex>:<hashHex>` (two
+ * hex segments separated by exactly one ':'). Anything that is not in that
+ * shape is treated as a bootstrap shared secret the operator types in as the
+ * password.
+ */
+function isPbkdf2Hash(storedHash: string): boolean {
+  const parts = storedHash.split(":");
+  if (parts.length !== 2) return false;
+  const [saltHex, hashHex] = parts;
+  if (!saltHex || !hashHex) return false;
+  return isValidHexString(saltHex) && isValidHexString(hashHex);
+}
+
+let warnedBootstrapCredential = false;
+
+/**
+ * Verify a submitted password against the configured AUTH_PASSWORD_HASH.
+ *
+ * - If the stored value is a proper PBKDF2 `salt:hash` credential, verify it
+ *   with the normal PBKDF2 path (unchanged behaviour).
+ * - Otherwise the stored value is a bootstrap shared secret (e.g. the
+ *   colon-less hex token a fresh Capsule install generates). The operator
+ *   logs in by entering that token verbatim as the password; it is compared
+ *   in constant time so a fresh install is actually loginnable while avoiding
+ *   timing leaks. A one-time warning recommends setting a real password.
+ */
+export async function verifyBootstrapOrPassword(
+  password: string,
+  storedHash: string,
+): Promise<boolean> {
+  if (isPbkdf2Hash(storedHash)) {
+    return verifyPassword(password, storedHash);
+  }
+
+  if (!warnedBootstrapCredential) {
+    warnedBootstrapCredential = true;
+    log.warn(
+      "AUTH_PASSWORD_HASH is a bootstrap shared secret, not a PBKDF2 " +
+        "salt:hash credential. Login is accepted by entering that token " +
+        "verbatim as the password. Set a real password (hashPassword) to " +
+        "replace this bootstrap credential.",
+      { event: "crypto.password.bootstrap_credential" },
+    );
+  }
+
+  // Constant-time compare over the raw UTF-8 bytes of the token. The byte
+  // arrays are unequal length when the token does not match, in which case
+  // timingSafeEqual still does length-independent work via a fixed-length
+  // comparison against the stored secret.
+  const stored = new TextEncoder().encode(storedHash);
+  const candidate = new TextEncoder().encode(password);
+  return timingSafeEqualConstantTime(candidate, stored);
+}
+
+/**
+ * Length-independent constant-time comparison: always iterates over the
+ * stored secret's length so the running time does not reveal whether the
+ * candidate matched or even how long it was.
+ */
+function timingSafeEqualConstantTime(
+  candidate: Uint8Array,
+  secret: Uint8Array,
+): boolean {
+  let diff = candidate.length ^ secret.length;
+  for (let i = 0; i < secret.length; i++) {
+    // When candidate is shorter, fold in a non-matching byte so the loop is
+    // still secret-length and never short-circuits.
+    const c = i < candidate.length ? candidate[i] : secret[i] ^ 0xff;
+    diff |= c ^ secret[i];
+  }
+  return diff === 0;
+}

package/src/backend/lib/delivery/circuit.ts

@@ -0,0 +1,265 @@
+import type { Database } from "../../../db/index.ts";
+import { eq } from "drizzle-orm";
+import { deliveryCircuit } from "../../../db/index.ts";
+import { safeParseIsoTimeMs } from "./transformers.ts";
+import { logger } from "../logger.ts";
+
+const log = logger.child({ component: "delivery.circuit" });
+
+export type CircuitState = "closed" | "open" | "half_open";
+
+const OPEN_DURATION_MS = 5 * 60 * 1000;
+const HALF_OPEN_PROBES = 3;
+const HALF_OPEN_DEFER_SECONDS = 30;
+const RECENT_WINDOW_SIZE = 20;
+const CONSECUTIVE_FAILURE_THRESHOLD = 5;
+const FAILURE_RATE_THRESHOLD = 0.6;
+
+type CircuitRow = {
+  endpoint: string;
+  state: CircuitState;
+  consecutiveFailures: number;
+  recentOutcomesJson: string; // JSON array of 0(success)/1(failure)
+  openUntil: string | null;
+  halfOpenProbeAttempts: number;
+  halfOpenProbeSuccesses: number;
+};
+
+type CircuitData = Partial<Omit<CircuitRow, "endpoint">>;
+
+const INITIAL_CIRCUIT_DATA: CircuitData = {
+  state: "closed",
+  consecutiveFailures: 0,
+  recentOutcomesJson: "[]",
+  openUntil: null,
+  halfOpenProbeAttempts: 0,
+  halfOpenProbeSuccesses: 0,
+};
+
+function parseRecentOutcomes(json: string): number[] {
+  try {
+    const parsed = JSON.parse(json) as unknown;
+    if (!Array.isArray(parsed)) return [];
+    return parsed.map((v) => (v === 1 ? 1 : 0)).slice(-RECENT_WINDOW_SIZE);
+  } catch {
+    return [];
+  }
+}
+
+function serializeRecentOutcomes(values: number[]): string {
+  return JSON.stringify(values.slice(-RECENT_WINDOW_SIZE));
+}
+
+/**
+ * Loads the circuit row for an endpoint and appends an outcome (0=success, 1=failure).
+ * Returns the row and the updated recent-outcomes array ready for persistence.
+ */
+async function loadCircuitWithOutcome(
+  db: Database,
+  endpoint: string,
+  outcome: 0 | 1,
+): Promise<{ circuit: CircuitRow; recent: number[] }> {
+  const circuit = await getOrCreateCircuit(db, endpoint);
+  const recent = parseRecentOutcomes(circuit.recentOutcomesJson);
+  recent.push(outcome);
+  return { circuit, recent };
+}
+
+function buildOpenData(
+  recent: number[],
+  consecutiveFailures: number,
+): CircuitData {
+  return {
+    state: "open",
+    consecutiveFailures,
+    recentOutcomesJson: serializeRecentOutcomes(recent),
+    openUntil: new Date(Date.now() + OPEN_DURATION_MS).toISOString(),
+    halfOpenProbeAttempts: 0,
+    halfOpenProbeSuccesses: 0,
+  };
+}
+
+async function updateCircuit(
+  db: Database,
+  endpoint: string,
+  data: CircuitData,
+): Promise<void> {
+  await db
+    .update(deliveryCircuit)
+    .set(data)
+    .where(eq(deliveryCircuit.endpoint, endpoint));
+}
+
+async function getOrCreateCircuit(
+  db: Database,
+  endpoint: string,
+): Promise<CircuitRow> {
+  const columns = {
+    endpoint: deliveryCircuit.endpoint,
+    state: deliveryCircuit.state,
+    consecutiveFailures: deliveryCircuit.consecutiveFailures,
+    recentOutcomesJson: deliveryCircuit.recentOutcomesJson,
+    openUntil: deliveryCircuit.openUntil,
+    halfOpenProbeAttempts: deliveryCircuit.halfOpenProbeAttempts,
+    halfOpenProbeSuccesses: deliveryCircuit.halfOpenProbeSuccesses,
+  };
+
+  const existing = await db
+    .select(columns)
+    .from(deliveryCircuit)
+    .where(eq(deliveryCircuit.endpoint, endpoint))
+    .get();
+  if (existing) return existing as CircuitRow;
+
+  // Race-safe create. checkCircuit() calls this BEFORE the per-host bulkhead is
+  // acquired, and deliver_endpoint messages run concurrently (Cloudflare Queues
+  // is at-least-once), so two deliveries to the SAME never-seen endpoint can both
+  // pass the SELECT and reach this INSERT. `endpoint` is the PRIMARY KEY, so the
+  // second bare INSERT would throw a UNIQUE/PK violation and force a 60s message
+  // redelivery. onConflictDoNothing makes it race-safe; if the conflict swallowed
+  // our row (returning() empty), re-select the row the winner created. (Mirrors
+  // the actor_cache cold-insert discipline.)
+  const created = await db
+    .insert(deliveryCircuit)
+    .values({ endpoint, ...INITIAL_CIRCUIT_DATA })
+    .onConflictDoNothing()
+    .returning(columns)
+    .get();
+  if (created) return created as CircuitRow;
+
+  const winner = await db
+    .select(columns)
+    .from(deliveryCircuit)
+    .where(eq(deliveryCircuit.endpoint, endpoint))
+    .get();
+  return winner as CircuitRow;
+}
+
+export async function checkCircuit(
+  db: Database,
+  endpoint: string,
+): Promise<{ allow: true } | { allow: false; deferSeconds: number }> {
+  const now = Date.now();
+  const circuit = await getOrCreateCircuit(db, endpoint);
+
+  if (circuit.state === "open") {
+    const untilMs = safeParseIsoTimeMs(circuit.openUntil);
+    if (untilMs !== null && now < untilMs) {
+      const deferSeconds = Math.max(1, Math.ceil((untilMs - now) / 1000));
+      return { allow: false, deferSeconds };
+    }
+
+    // Transition to half-open when open window elapsed.
+    await updateCircuit(db, endpoint, {
+      state: "half_open",
+      openUntil: null,
+      halfOpenProbeAttempts: 0,
+      halfOpenProbeSuccesses: 0,
+    });
+    return { allow: true };
+  }
+
+  if (
+    circuit.state === "half_open" &&
+    circuit.halfOpenProbeAttempts >= HALF_OPEN_PROBES
+  ) {
+    return { allow: false, deferSeconds: HALF_OPEN_DEFER_SECONDS };
+  }
+
+  return { allow: true };
+}
+
+export async function recordCircuitSuccess(
+  db: Database,
+  endpoint: string,
+): Promise<void> {
+  const { circuit, recent } = await loadCircuitWithOutcome(db, endpoint, 0);
+  const serialized = serializeRecentOutcomes(recent);
+
+  if (circuit.state === "half_open") {
+    const nextAttempts = circuit.halfOpenProbeAttempts + 1;
+    const nextSuccesses = circuit.halfOpenProbeSuccesses + 1;
+    const allProbesSucceeded =
+      nextAttempts >= HALF_OPEN_PROBES && nextSuccesses >= HALF_OPEN_PROBES;
+
+    await updateCircuit(
+      db,
+      endpoint,
+      allProbesSucceeded
+        ? { ...INITIAL_CIRCUIT_DATA, recentOutcomesJson: serialized }
+        : {
+            consecutiveFailures: 0,
+            recentOutcomesJson: serialized,
+            halfOpenProbeAttempts: nextAttempts,
+            halfOpenProbeSuccesses: nextSuccesses,
+          },
+    );
+    return;
+  }
+
+  await updateCircuit(db, endpoint, {
+    consecutiveFailures: 0,
+    recentOutcomesJson: serialized,
+  });
+}
+
+// CONCURRENCY NOTE (accepted, bounded): the circuit state (counter + recent-
+// outcome window + state machine) is read here and written via a blind UPDATE in
+// updateCircuit, so two concurrent deliveries to the SAME endpoint can lose one
+// of their increments / window samples (last-writer-wins). This is deliberately
+// NOT made strongly consistent: it is a delivery THROTTLE heuristic, not a
+// correctness/security invariant — the only effect of a lost increment is the
+// breaker opening a couple of failures later than CONSECUTIVE_FAILURE_THRESHOLD,
+// costing a few extra attempts to an already-failing host. The per-host bulkhead
+// (BULKHEAD_PER_DOMAIN) bounds the concurrency. A strongly-consistent version
+// would need a Durable Object (single-threaded) or a CAS+retry loop on this hot
+// path — disproportionate for a throttle, so it is left best-effort by design.
+export async function recordCircuitFailure(
+  db: Database,
+  endpoint: string,
+): Promise<void> {
+  const { circuit, recent } = await loadCircuitWithOutcome(db, endpoint, 1);
+
+  // Half-open failure: immediately re-open.
+  if (circuit.state === "half_open") {
+    await updateCircuit(
+      db,
+      endpoint,
+      buildOpenData(recent, CONSECUTIVE_FAILURE_THRESHOLD),
+    );
+    return;
+  }
+
+  const consecutiveFailures = circuit.consecutiveFailures + 1;
+  const window = recent.slice(-RECENT_WINDOW_SIZE);
+  const failures = window.reduce((sum, v) => sum + v, 0);
+  const fullWindow = window.length === RECENT_WINDOW_SIZE;
+
+  // Open conditions (contract):
+  // - N consecutive failures OR
+  // - failure rate >= threshold over a full recent window.
+  const shouldOpen =
+    consecutiveFailures >= CONSECUTIVE_FAILURE_THRESHOLD ||
+    (fullWindow && failures / RECENT_WINDOW_SIZE >= FAILURE_RATE_THRESHOLD);
+
+  if (shouldOpen) {
+    await updateCircuit(
+      db,
+      endpoint,
+      buildOpenData(recent, consecutiveFailures),
+    );
+    log.warn("Circuit opened", {
+      event: "delivery.circuit.opened",
+      endpoint,
+      consecutiveFailures,
+      failures,
+      windowSize: window.length,
+    });
+    return;
+  }
+
+  await updateCircuit(db, endpoint, {
+    consecutiveFailures,
+    recentOutcomesJson: serializeRecentOutcomes(recent),
+  });
+}