@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-5RP3QTRL.js

@@ -0,0 +1,1223 @@
+import {
+  AGENT_STALE_MS,
+  AUTO_COMPACT_DEFAULT_TTL_MS,
+  AUTO_COMPACT_INTERVAL_MS,
+  AUTO_COMPACT_READ_MAX_AGE_MS,
+  AUTO_COMPACT_TYPE_TTL_MS,
+  CLIENT_STALE_MS,
+  HEARTBEAT_THROTTLE_MS,
+  MAX_CREDENTIAL_TTL,
+  ROTATION_OVERLAP_MS,
+  createMailboxCredential,
+  deleteMessages,
+  initializeSchema,
+  isFanOutRecipient,
+  loadDatabaseSync,
+  materializeMessageRows,
+  migrateLegacyFiles,
+  normalizeMailboxMessageType,
+  persistAgent,
+  persistClient,
+  persistCredential,
+  persistMessage,
+  persistReceipt,
+  pruneAgents,
+  pruneClients,
+  readAgents,
+  readClients,
+  verifyMailboxCredential,
+  withoutAggregateCompletion
+} from "./chunk-GM54GJBU.js";
+import {
+  acceptMailboxMessageForSession,
+  isMailboxLeader,
+  isMailboxMessageVisibleTo,
+  mailboxIdentityBase,
+  normalizeRecipient,
+  sessionRecipient,
+  validateSendType
+} from "./chunk-W4A6QA3D.js";
+
+// src/coordination/mailbox-project-server-protocol.ts
+var MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION = 4;
+var MAILBOX_PROJECT_SERVER_MAX_FRAME_CHARS = 16 * 1024 * 1024;
+var MAILBOX_SERVER_OPERATION_NAMES = {
+  ping: true,
+  send: true,
+  sendRuntimeControl: true,
+  query: true,
+  ack: true,
+  ackMany: true,
+  unreadCount: true,
+  softDelete: true,
+  restore: true,
+  registerAgent: true,
+  deregisterAgent: true,
+  heartbeat: true,
+  getAgentStatuses: true,
+  getOnlineAgents: true,
+  purgeAgents: true,
+  registerClient: true,
+  deregisterClient: true,
+  clientHeartbeat: true,
+  getClientStatuses: true,
+  purgeClients: true,
+  clearAll: true,
+  purgeStale: true,
+  autoCompact: true,
+  credentialIssue: true,
+  credentialVerify: true,
+  credentialRevoke: true,
+  credentialRotate: true,
+  credentialGet: true,
+  credentialList: true,
+  credentialStatusCounts: true
+};
+function isRequestId(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasString(record, key) {
+  return typeof record[key] === "string" && record[key].length > 0;
+}
+function hasRecord(record, key) {
+  return isRecord(record[key]);
+}
+function isMailboxServerOperationArgs(op, value) {
+  if (!isRecord(value)) return false;
+  switch (op) {
+    case "ping":
+    case "getAgentStatuses":
+    case "getOnlineAgents":
+    case "getClientStatuses":
+    case "purgeClients":
+    case "clearAll":
+    case "credentialList":
+    case "credentialStatusCounts":
+      return true;
+    case "send":
+    case "sendRuntimeControl":
+    case "ack":
+    case "ackMany":
+    case "registerAgent":
+    case "heartbeat":
+    case "registerClient":
+    case "clientHeartbeat":
+      return hasRecord(value, "input");
+    case "query":
+      return hasRecord(value, "query");
+    case "unreadCount":
+      return hasString(value, "forAgentId");
+    case "softDelete":
+      return hasString(value, "mailId") && hasString(value, "by");
+    case "restore":
+      return hasString(value, "mailId");
+    case "deregisterAgent":
+      return hasString(value, "agentId");
+    case "purgeAgents":
+    case "purgeStale":
+    case "autoCompact":
+      return true;
+    case "deregisterClient":
+      return hasString(value, "clientId");
+    case "credentialIssue":
+      return hasRecord(value, "options");
+    case "credentialVerify":
+      return hasString(value, "credentialId") && hasString(value, "secret");
+    case "credentialRevoke":
+    case "credentialRotate":
+    case "credentialGet":
+      return hasString(value, "credentialId");
+  }
+}
+function isMailboxProjectServerClientMessage(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const message = value;
+  if (message["type"] === "heartbeat") return true;
+  if (message["type"] === "shutdown") {
+    return isRequestId(message["id"]) && (message["reason"] === void 0 || typeof message["reason"] === "string");
+  }
+  if (message["type"] !== "request" || !isRequestId(message["id"])) return false;
+  const op = message["op"];
+  return typeof op === "string" && Object.hasOwn(MAILBOX_SERVER_OPERATION_NAMES, op) && isMailboxServerOperationArgs(op, message["args"]);
+}
+function isMailboxProjectServerMessage(value) {
+  if (!isRecord(value) || typeof value["type"] !== "string") return false;
+  if (value["type"] === "hello") {
+    return Number.isInteger(value["protocolVersion"]) && Number.isInteger(value["pid"]) && hasString(value, "projectDir") && hasString(value, "endpoint") && hasString(value, "startedAt");
+  }
+  if (value["type"] === "event") return hasString(value, "event");
+  if (value["type"] === "mailbox-event") return isRecord(value["event"]);
+  if (value["type"] !== "response" || !isRequestId(value["id"])) return false;
+  if (value["ok"] === true) return Object.hasOwn(value, "result");
+  return value["ok"] === false && typeof value["error"] === "string";
+}
+function encodeMailboxProjectServerMessage(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+
+// src/coordination/mailbox-project-server-endpoint.ts
+import { createHash } from "node:crypto";
+import * as os from "node:os";
+import * as path from "node:path";
+var MAILBOX_PROJECT_SERVER_METADATA_FILE = ".mailbox-server.json";
+function normalizeLocalPath(value) {
+  const resolved = path.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function mailboxProjectServerKey(projectDir) {
+  return createHash("sha256").update(normalizeLocalPath(projectDir)).digest("hex").slice(0, 24);
+}
+function mailboxProjectServerEndpoint(projectDir) {
+  const key = mailboxProjectServerKey(projectDir);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\wrongstack-mailbox-v${MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION}-${key}`;
+  }
+  return path.join(
+    os.tmpdir(),
+    `wsmb-v${MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION}`,
+    `${key}.sock`
+  );
+}
+function mailboxProjectServerMetadataPath(projectDir) {
+  return path.join(path.resolve(projectDir), MAILBOX_PROJECT_SERVER_METADATA_FILE);
+}
+
+// src/coordination/mailbox-credential-throttle.ts
+var CREDENTIAL_VERIFY_MAX_FAILURES = 10;
+var CREDENTIAL_VERIFY_WINDOW_MS = 6e4;
+var CREDENTIAL_VERIFY_COOLDOWN_MS = 6e4;
+var MAX_TRACKED_IDS = 4096;
+var CredentialVerifyThrottle = class {
+  constructor(maxFailures = CREDENTIAL_VERIFY_MAX_FAILURES, windowMs = CREDENTIAL_VERIFY_WINDOW_MS, cooldownMs = CREDENTIAL_VERIFY_COOLDOWN_MS) {
+    this.maxFailures = maxFailures;
+    this.windowMs = windowMs;
+    this.cooldownMs = cooldownMs;
+  }
+  maxFailures;
+  windowMs;
+  cooldownMs;
+  records = /* @__PURE__ */ new Map();
+  /** Is this credential id allowed another attempt right now? */
+  check(credentialId, now = Date.now()) {
+    const record = this.records.get(credentialId);
+    if (record === void 0) return { allowed: true, retryAfterMs: 0 };
+    if (record.blockedUntil > now) {
+      return { allowed: false, retryAfterMs: record.blockedUntil - now };
+    }
+    return { allowed: true, retryAfterMs: 0 };
+  }
+  /** Record a failed verification. Starts the cooldown once the limit is hit. */
+  recordFailure(credentialId, now = Date.now()) {
+    const record = this.records.get(credentialId);
+    if (record === void 0 || now - record.windowStartedAt > this.windowMs) {
+      this.evictIfFull();
+      this.records.set(credentialId, { failures: 1, windowStartedAt: now, blockedUntil: 0 });
+      return;
+    }
+    record.failures += 1;
+    if (record.failures >= this.maxFailures) {
+      record.blockedUntil = now + this.cooldownMs;
+      record.failures = 0;
+      record.windowStartedAt = now;
+    }
+  }
+  /**
+   * Clear the counter after a successful verification. A legitimate holder who
+   * fluffed a few attempts is not left in a cooldown they cannot exit.
+   */
+  recordSuccess(credentialId) {
+    this.records.delete(credentialId);
+  }
+  /** Test seam. */
+  reset() {
+    this.records.clear();
+  }
+  evictIfFull() {
+    if (this.records.size < MAX_TRACKED_IDS) return;
+    const oldest = this.records.keys().next();
+    if (!oldest.done) this.records.delete(oldest.value);
+  }
+};
+var credentialVerifyThrottle = new CredentialVerifyThrottle();
+
+// src/coordination/sqlite-mailbox.ts
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+
+// src/coordination/global-mailbox-completion.ts
+function isMailboxMessageProjection(msg) {
+  if (!("recipientState" in msg)) return false;
+  const recipientState = msg.recipientState;
+  return typeof recipientState === "object" && recipientState !== null && !Array.isArray(recipientState);
+}
+function isMessageCompletedForActor(msg, actorId) {
+  if (!isMailboxMessageProjection(msg)) return msg.completed === true;
+  if (msg.legacyGlobalCompletion) return true;
+  if (actorId !== void 0) {
+    const state = msg.recipientState[actorId];
+    if (state !== void 0) return state.completedAt !== void 0;
+    if (Object.keys(msg.recipientState).length > 0) return false;
+  }
+  return msg.completed === true;
+}
+
+// src/coordination/mailbox-retention-state.ts
+function resolveMailboxRetentionState(message, agentStatuses) {
+  const projection = message;
+  if (projection.legacyGlobalCompletion) {
+    return { completed: true, completedAt: message.completedAt ?? message.timestamp };
+  }
+  const recipientState = projection.recipientState;
+  if (recipientState === void 0) {
+    return message.completed ? { completed: true, completedAt: message.completedAt ?? message.timestamp } : { completed: false };
+  }
+  const relevantRecipients = resolveRelevantRecipients(message, recipientState, agentStatuses);
+  if (relevantRecipients.length === 0) return { completed: false };
+  const completionTimes = [];
+  for (const actorId of relevantRecipients) {
+    const completedAt = recipientState[actorId]?.completedAt;
+    if (completedAt === void 0) return { completed: false };
+    completionTimes.push(completedAt);
+  }
+  return {
+    completed: true,
+    // Retention starts only after the last intended recipient completed.
+    completedAt: completionTimes.reduce((latest, time) => time > latest ? time : latest)
+  };
+}
+function projectMailboxCompletion(message, actorId, agentStatuses) {
+  const projection = message;
+  let state;
+  if (actorId === void 0) {
+    state = resolveMailboxRetentionState(message, agentStatuses);
+  } else if (projection.legacyGlobalCompletion) {
+    state = { completed: true, completedAt: message.completedAt ?? message.timestamp };
+  } else if (projection.recipientState !== void 0) {
+    const completedAt = projection.recipientState[actorId]?.completedAt;
+    state = completedAt === void 0 ? { completed: false } : { completed: true, completedAt };
+  } else {
+    state = message.completed ? { completed: true, completedAt: message.completedAt ?? message.timestamp } : { completed: false };
+  }
+  const result = {
+    ...projection,
+    completed: state.completed,
+    readBy: { ...message.readBy }
+  };
+  if (state.completedAt === void 0) delete result.completedAt;
+  else result.completedAt = state.completedAt;
+  return result;
+}
+function resolveRelevantRecipients(message, recipientState, agentStatuses) {
+  const statuses = agentStatuses ?? [];
+  const receiptActors = Object.keys(recipientState);
+  if (message.to === "*") {
+    if (statuses.length === 0) return [];
+    const registeredRecipients = statuses.filter((status) => isMailboxMessageVisibleTo(message, status.agentId, status.role)).map((status) => status.agentId);
+    return [.../* @__PURE__ */ new Set([...registeredRecipients, ...receiptActors])];
+  }
+  if (message.to.startsWith("@session:")) {
+    if (statuses.length === 0) return [];
+    const sessionId = message.to.slice("@session:".length);
+    const registeredRecipients = statuses.filter(
+      (status) => status.sessionId === sessionId && isMailboxMessageVisibleTo(message, status.agentId, status.role)
+    ).map((status) => status.agentId);
+    return [.../* @__PURE__ */ new Set([...registeredRecipients, ...receiptActors])];
+  }
+  if (message.to.includes("@")) return [message.to];
+  if (statuses.length === 0) return [];
+  const aliasRecipients = statuses.filter(
+    (status) => (status.role?.toLowerCase() === message.to.toLowerCase() || mailboxIdentityBase(status.agentId) === message.to.toLowerCase()) && isMailboxMessageVisibleTo(message, status.agentId, status.role)
+  ).map((status) => status.agentId);
+  return [.../* @__PURE__ */ new Set([...aliasRecipients, ...receiptActors])];
+}
+
+// src/coordination/mailbox-status-mappers.ts
+function mapRegisteredAgentsToStatuses(registry, now, staleMs) {
+  return Array.from(registry.values()).map((agent) => ({
+    agentId: agent.agentId,
+    name: agent.name,
+    role: agent.role,
+    sessionId: agent.sessionId,
+    status: agent.status,
+    currentTool: agent.currentTool,
+    currentTask: agent.currentTask,
+    iterations: agent.iterations,
+    toolCalls: agent.toolCalls,
+    lastActivityAt: agent.lastSeenAt,
+    lastSeenAt: agent.lastSeenAt,
+    online: now - new Date(agent.lastSeenAt).getTime() < staleMs,
+    pid: agent.pid,
+    source: agent.source
+  })).sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt));
+}
+function mapRegisteredClientsToStatuses(registry, now, staleMs) {
+  return Array.from(registry.values()).map((client) => ({
+    clientId: client.clientId,
+    name: client.name,
+    source: client.source,
+    sessionId: client.sessionId,
+    lastSeenAt: client.lastSeenAt,
+    online: now - new Date(client.lastSeenAt).getTime() < staleMs,
+    pid: client.pid
+  })).sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt));
+}
+
+// src/coordination/sqlite-mailbox-compaction.ts
+async function purgeStale(ctx, options) {
+  const completedMaxAgeMs = options?.completedMaxAgeMs ?? 864e5;
+  const incompleteMaxAgeMs = options?.incompleteMaxAgeMs ?? 6048e5;
+  const statuses = await ctx.getAgentStatuses();
+  const now = Date.now();
+  let completedPurged = 0;
+  let incompletePurged = 0;
+  const ids = [];
+  const messages = ctx.readMessages();
+  for (const message of messages) {
+    const retention = resolveMailboxRetentionState(message, statuses);
+    const messageTime = new Date(message.timestamp).getTime();
+    const completionTime = new Date(retention.completedAt ?? 0).getTime();
+    if (retention.completed && completionTime < now - completedMaxAgeMs) {
+      completedPurged++;
+      ids.push(message.id);
+    } else if (!retention.completed && messageTime < now - incompleteMaxAgeMs) {
+      incompletePurged++;
+      ids.push(message.id);
+    }
+  }
+  ctx.deleteMessages(ids);
+  return {
+    completedPurged,
+    incompletePurged,
+    totalPurged: ids.length,
+    remaining: messages.length - ids.length
+  };
+}
+async function autoCompact(ctx, options) {
+  const readMaxAgeMs = options?.readMaxAgeMs ?? AUTO_COMPACT_READ_MAX_AGE_MS;
+  const defaultTtlMs = options?.defaultTtlMs ?? AUTO_COMPACT_DEFAULT_TTL_MS;
+  const typeTtlMs = options?.typeTtlMs ?? AUTO_COMPACT_TYPE_TTL_MS;
+  const completedMaxAgeMs = options?.completedMaxAgeMs ?? 864e5;
+  const incompleteMaxAgeMs = options?.incompleteMaxAgeMs ?? 6048e5;
+  const statuses = await ctx.getAgentStatuses();
+  const online = statuses.filter((status) => status.online);
+  const now = Date.now();
+  let readByAllRemoved = 0;
+  let expiredRemoved = 0;
+  let stalePurged = 0;
+  const ids = [];
+  const messages = ctx.readMessages();
+  for (const message of messages) {
+    const messageTime = new Date(message.timestamp).getTime();
+    const expiry = message.expiresAt !== void 0 ? new Date(message.expiresAt).getTime() : messageTime + (typeTtlMs[message.type] ?? defaultTtlMs);
+    if (expiry < now) {
+      expiredRemoved++;
+      ids.push(message.id);
+      continue;
+    }
+    const retention = resolveMailboxRetentionState(message, statuses);
+    const eligible = online.filter(
+      (status) => isMailboxMessageVisibleTo(message, status.agentId, status.role)
+    );
+    if (!retention.completed && eligible.length > 0) {
+      const readByAll = eligible.every((status) => status.agentId in message.readBy);
+      const latestRead = Math.max(
+        ...eligible.map((status) => new Date(message.readBy[status.agentId] ?? 0).getTime())
+      );
+      if (readByAll && latestRead < now - readMaxAgeMs) {
+        readByAllRemoved++;
+        ids.push(message.id);
+        continue;
+      }
+    }
+    const completionTime = new Date(retention.completedAt ?? 0).getTime();
+    if (retention.completed && completionTime < now - completedMaxAgeMs || !retention.completed && messageTime < now - incompleteMaxAgeMs) {
+      stalePurged++;
+      ids.push(message.id);
+    }
+  }
+  ctx.deleteMessages(ids);
+  return {
+    readByAllRemoved,
+    expiredRemoved,
+    stalePurged,
+    totalRemoved: ids.length,
+    remaining: messages.length - ids.length
+  };
+}
+
+// src/coordination/sqlite-mailbox-credentials.ts
+function credentialGet(db, credentialId) {
+  const row = db.prepare("SELECT data FROM credentials WHERE credential_id = ?").get(credentialId);
+  return row === void 0 ? null : JSON.parse(row.data);
+}
+function credentialList(db) {
+  const rows = db.prepare("SELECT data FROM credentials").all();
+  return rows.map((row) => JSON.parse(row.data)).sort((left, right) => {
+    if (left.status === "active" && right.status !== "active") return -1;
+    if (left.status !== "active" && right.status === "active") return 1;
+    return right.issuedAt.localeCompare(left.issuedAt);
+  });
+}
+function credentialStatusCounts(db) {
+  const rows = db.prepare("SELECT status, COUNT(*) AS count FROM credentials GROUP BY status").all();
+  return Object.fromEntries(rows.map((row) => [row.status, row.count]));
+}
+function credentialIssue(db, transaction, options) {
+  const now = Date.now();
+  const issued = createMailboxCredential(options, now);
+  transaction(() => {
+    if (options.supersedes !== void 0) {
+      const old = credentialGet(db, options.supersedes);
+      if (old?.status === "active") {
+        old.status = "rotated_out";
+        old.statusChangedAt = new Date(now).toISOString();
+        old.statusReason = "superseded by rotation";
+        old.rotationValidUntil = new Date(now + ROTATION_OVERLAP_MS).toISOString();
+        persistCredential(db, old);
+      }
+    }
+    persistCredential(db, issued.credential);
+  });
+  return issued;
+}
+function credentialVerify(db, credentialId, secret) {
+  const decision = credentialVerifyThrottle.check(credentialId);
+  if (!decision.allowed) {
+    return {
+      valid: false,
+      reason: `too many failed verification attempts \u2014 retry in ${Math.ceil(decision.retryAfterMs / 1e3)}s`
+    };
+  }
+  const result = verifyMailboxCredential(credentialGet(db, credentialId) ?? void 0, secret);
+  if (result.valid) credentialVerifyThrottle.recordSuccess(credentialId);
+  else credentialVerifyThrottle.recordFailure(credentialId);
+  return result;
+}
+function credentialRevoke(db, credentialId, reason, by) {
+  const credential = credentialGet(db, credentialId);
+  if (credential === null || credential.status === "revoked") return false;
+  credential.status = "revoked";
+  credential.statusChangedAt = (/* @__PURE__ */ new Date()).toISOString();
+  credential.statusReason = reason ?? "revoked";
+  credential.lastModifiedBy = by;
+  persistCredential(db, credential);
+  return true;
+}
+function credentialRotate(db, transaction, credentialId, options) {
+  const old = credentialGet(db, credentialId);
+  if (old === null) return null;
+  if (old.status === "revoked") return null;
+  return credentialIssue(db, transaction, {
+    principalId: old.principalId,
+    projectId: old.projectId ?? options?.projectId,
+    kind: old.kind,
+    capabilities: options?.capabilities ?? old.capabilities,
+    ttlMs: options?.ttlMs ?? previousCredentialTtlMs(old),
+    notBefore: options?.notBefore,
+    supersedes: credentialId,
+    issuedBy: options?.issuedBy
+  });
+}
+function previousCredentialTtlMs(credential) {
+  const issuedAt = new Date(credential.issuedAt).getTime();
+  const expiresAt = new Date(credential.expiresAt).getTime();
+  const ttlMs = expiresAt - issuedAt;
+  return Number.isFinite(ttlMs) && ttlMs > 0 ? ttlMs : MAX_CREDENTIAL_TTL[credential.kind];
+}
+
+// src/coordination/sqlite-mailbox.ts
+var SQLITE_MAILBOX_FILE = "_mailbox.sqlite";
+var HEARTBEAT_TRACKING_MAX_ENTRIES = 512;
+var HEARTBEAT_TRACKING_TTL_MS = 30 * 6e4;
+var SqliteMailbox = class {
+  constructor(projectDir, events, eventEmitter) {
+    this.projectDir = projectDir;
+    fs.mkdirSync(projectDir, { recursive: true });
+    this.databasePath = path2.join(projectDir, SQLITE_MAILBOX_FILE);
+    this.messagePath = this.databasePath;
+    this.events = events;
+    this.eventEmitter = eventEmitter;
+    const Database = loadDatabaseSync();
+    this.db = new Database(this.databasePath);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA synchronous = NORMAL");
+    this.db.exec("PRAGMA foreign_keys = ON");
+    this.db.exec("PRAGMA busy_timeout = 5000");
+    initializeSchema(this.schemaCtx());
+    migrateLegacyFiles(this.schemaCtx());
+  }
+  projectDir;
+  databasePath;
+  /** Compatibility alias used by project-server health/status consumers. */
+  messagePath;
+  eventEmitter;
+  db;
+  events;
+  lastHeartbeat = /* @__PURE__ */ new Map();
+  lastClientHeartbeat = /* @__PURE__ */ new Map();
+  autoCompactTimer = null;
+  autoCompactInFlight;
+  closed = false;
+  stmt(sql) {
+    return this.db.prepare(sql);
+  }
+  transaction(run) {
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const result = run();
+      this.db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  /** Bundle of store state the schema/migration module operates on. */
+  schemaCtx() {
+    return {
+      db: this.db,
+      projectDir: this.projectDir,
+      transaction: (run) => this.transaction(run)
+    };
+  }
+  persistMessage(message, legacyGlobalCompletion = false) {
+    persistMessage(this.db, message, legacyGlobalCompletion);
+  }
+  persistReceipt(messageId, state) {
+    persistReceipt(this.db, messageId, state);
+  }
+  materializeMessageRows(rows) {
+    return materializeMessageRows(this.db, rows);
+  }
+  readMessages() {
+    const rows = this.stmt(
+      "SELECT id, data, legacy_global_completion FROM messages"
+    ).all();
+    return this.materializeMessageRows(rows);
+  }
+  findMessage(messageId) {
+    const row = this.stmt(
+      "SELECT id, data, legacy_global_completion FROM messages WHERE id = ?"
+    ).get(messageId);
+    return row === void 0 ? void 0 : this.materializeMessageRows([row])[0];
+  }
+  async send(input) {
+    return this.sendMessage(input, false);
+  }
+  async sendRuntimeControl(input) {
+    return this.sendMessage({ ...input, type: "control" }, true);
+  }
+  async sendMessage(input, allowRuntimeControl) {
+    const type = normalizeMailboxMessageType(input.type);
+    const to = normalizeRecipient(input.to, input.senderSessionId);
+    if (!(allowRuntimeControl && type === "control")) validateSendType(type, to);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const message = {
+      id: randomUUID(),
+      from: input.from,
+      to,
+      type,
+      ...input.audience !== void 0 && input.audience !== "all" ? { audience: input.audience } : {},
+      subject: input.subject,
+      body: input.body,
+      priority: input.priority ?? "normal",
+      readBy: {},
+      completed: false,
+      timestamp,
+      ...input.replyTo !== void 0 ? { replyTo: input.replyTo } : {},
+      ...input.taskContext !== void 0 ? { taskContext: input.taskContext } : {},
+      ...input.senderSessionId !== void 0 ? { senderSessionId: input.senderSessionId } : {},
+      ...input.sessionAffinity !== void 0 ? { sessionAffinity: input.sessionAffinity } : {},
+      ...input.ttlMs !== void 0 ? { expiresAt: new Date(Date.now() + input.ttlMs).toISOString() } : {}
+    };
+    this.persistMessage(message);
+    this.events?.emitCustom("mailbox.message_sent", {
+      messageId: message.id,
+      from: message.from,
+      to: message.to,
+      type: message.type,
+      subject: message.subject
+    });
+    this.eventEmitter?.emit({
+      type: "message.sent",
+      messageId: message.id,
+      from: message.from,
+      to: message.to,
+      audience: message.audience,
+      timestamp
+    });
+    return message;
+  }
+  async query(query) {
+    const type = query.type === void 0 ? void 0 : normalizeMailboxMessageType(query.type);
+    const priorityRank = { low: 0, normal: 1, high: 2 };
+    const minimumRank = query.minPriority === void 0 ? 0 : priorityRank[query.minPriority];
+    if (query.ids !== void 0 && query.ids.length === 0) return [];
+    const statuses = query.unreadBy === void 0 ? await this.getAgentStatuses() : void 0;
+    const where = [];
+    const params = [];
+    if (query.ids !== void 0) {
+      where.push(`id IN (${query.ids.map(() => "?").join(", ")})`);
+      params.push(...query.ids);
+    }
+    if (query.to !== void 0) {
+      where.push("(to_id = ? OR to_id = ?)");
+      params.push(query.to, "*");
+    }
+    if (query.from !== void 0) {
+      where.push("from_id = ?");
+      params.push(query.from);
+    }
+    if (query.sessionId !== void 0) {
+      where.push("sender_session_id = ?");
+      params.push(query.sessionId);
+    }
+    if (type !== void 0) {
+      where.push("type = ?");
+      params.push(type);
+    }
+    if (query.minPriority !== void 0) {
+      where.push(`CASE priority WHEN 'high' THEN 2 WHEN 'low' THEN 0 ELSE 1 END >= ?`);
+      params.push(minimumRank);
+    }
+    if (query.since !== void 0) {
+      where.push("timestamp > ?");
+      params.push(query.since);
+    }
+    if (!query.includeDeleted) where.push("deleted_at IS NULL");
+    if (query.replyTo !== void 0) {
+      where.push("reply_to = ?");
+      params.push(query.replyTo);
+    }
+    if (query.unreadBy !== void 0) {
+      if (!isMailboxLeader(query.unreadBy, query.readerRole)) {
+        where.push("COALESCE(json_extract(data, '$.audience'), 'all') <> 'leaders'");
+      }
+      if (!query.incompleteOnly) {
+        where.push(`NOT EXISTS (
+          SELECT 1 FROM message_receipts AS unread_receipt
+          WHERE unread_receipt.message_id = messages.id
+            AND unread_receipt.actor_id = ?
+            AND unread_receipt.read_at IS NOT NULL
+        )`);
+        params.push(query.unreadBy);
+        where.push(`NOT EXISTS (
+          SELECT 1 FROM json_each(json_extract(data, '$.readBy')) AS legacy_read
+          WHERE legacy_read.key = ?
+        )`);
+        params.push(query.unreadBy);
+      } else {
+        where.push("legacy_global_completion = 0");
+        where.push(`NOT EXISTS (
+          SELECT 1 FROM message_receipts AS completed_receipt
+          WHERE completed_receipt.message_id = messages.id
+            AND completed_receipt.actor_id = ?
+            AND completed_receipt.completed_at IS NOT NULL
+        )`);
+        params.push(query.unreadBy);
+        where.push(`(
+          completed = 0 OR EXISTS (
+            SELECT 1 FROM message_receipts AS any_receipt
+            WHERE any_receipt.message_id = messages.id
+          )
+        )`);
+      }
+    }
+    const canPreLimit = !query.incompleteOnly || query.unreadBy !== void 0;
+    let sql = "SELECT id, data, legacy_global_completion FROM messages";
+    if (where.length > 0) sql += ` WHERE ${where.join(" AND ")}`;
+    sql += " ORDER BY timestamp DESC, rowid DESC";
+    if (canPreLimit) {
+      sql += " LIMIT ?";
+      params.push(query.limit ?? 50);
+    }
+    const rows = this.stmt(sql).all(...params);
+    const idFilter = query.ids === void 0 ? void 0 : new Set(query.ids);
+    const filtered = this.materializeMessageRows(rows).filter((message) => {
+      if (idFilter !== void 0 && !idFilter.has(message.id)) return false;
+      if (query.to !== void 0 && message.to !== query.to && message.to !== "*") return false;
+      if (query.from !== void 0 && message.from !== query.from) return false;
+      if (query.sessionId !== void 0 && message.senderSessionId !== query.sessionId)
+        return false;
+      if (query.unreadBy !== void 0 && !isMailboxMessageVisibleTo(message, query.unreadBy, query.readerRole))
+        return false;
+      if (!query.incompleteOnly && query.unreadBy !== void 0 && query.unreadBy in message.readBy)
+        return false;
+      if (query.incompleteOnly && (query.unreadBy === void 0 ? projectMailboxCompletion(message, void 0, statuses).completed : isMessageCompletedForActor(message, query.unreadBy)))
+        return false;
+      if (type !== void 0 && message.type !== type) return false;
+      if (priorityRank[message.priority] < minimumRank) return false;
+      if (query.since !== void 0 && message.timestamp <= query.since) return false;
+      if (!query.includeDeleted && message.deletedAt !== void 0) return false;
+      if (query.replyTo !== void 0 && message.replyTo !== query.replyTo) return false;
+      return true;
+    });
+    let messages = filtered;
+    if (query.currentSessionId !== void 0 || query.sessionAffinityCtx !== void 0) {
+      const kept = [];
+      for (const message of filtered) {
+        if (await acceptMailboxMessageForSession(
+          message,
+          query.currentSessionId,
+          query.sessionAffinityCtx
+        )) {
+          kept.push(message);
+        }
+      }
+      messages = kept;
+    }
+    messages.sort((left, right) => right.timestamp.localeCompare(left.timestamp));
+    return messages.slice(0, query.limit ?? 50).map((message) => {
+      const copy = {
+        ...projectMailboxCompletion(message, query.unreadBy, statuses),
+        readBy: { ...message.readBy }
+      };
+      if (!query.includeReceiptState) {
+        delete copy.recipientState;
+        delete copy.legacyGlobalCompletion;
+      }
+      return copy;
+    });
+  }
+  async ack(input) {
+    const results = await this.ackMany({ acks: [input] });
+    return results[0] ?? null;
+  }
+  async ackMany(input) {
+    if (input.acks.length === 0) return [];
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const changed = /* @__PURE__ */ new Set();
+    const updated = this.transaction(() => {
+      const results = [];
+      for (const ack of input.acks) {
+        const message = this.findMessage(ack.messageId);
+        if (message === void 0) continue;
+        const current = message.recipientState[ack.readerId] ?? { actorId: ack.readerId };
+        const state = { ...current };
+        let didChange = false;
+        if (ack.read !== false && state.readAt === void 0) {
+          state.readAt = timestamp;
+          message.readBy[ack.readerId] = timestamp;
+          didChange = true;
+        }
+        if (ack.completed === true && state.completedAt === void 0 && message.legacyGlobalCompletion !== true) {
+          state.completedAt = timestamp;
+          state.completedBy = ack.readerId;
+          didChange = true;
+        }
+        if (ack.read === false && ack.completed === false && state.completedAt !== void 0) {
+          delete state.completedAt;
+          delete state.completedBy;
+          didChange = true;
+        }
+        if (ack.outcome !== void 0 && state.outcome !== ack.outcome) {
+          state.outcome = ack.outcome;
+          didChange = true;
+        }
+        message.recipientState = {
+          ...message.recipientState,
+          [ack.readerId]: state
+        };
+        const actorCompleted = state.completedAt !== void 0;
+        message.completed = message.legacyGlobalCompletion === true || actorCompleted;
+        if (actorCompleted) {
+          message.completedBy = state.completedBy ?? ack.readerId;
+          message.completedAt = state.completedAt;
+        } else if (message.legacyGlobalCompletion !== true) {
+          delete message.completedBy;
+          delete message.completedAt;
+        }
+        message.outcome = state.outcome;
+        if (didChange) {
+          this.persistReceipt(message.id, state);
+          this.persistMessage(
+            isFanOutRecipient(message.to) ? withoutAggregateCompletion(message) : message,
+            message.legacyGlobalCompletion === true
+          );
+          changed.add(message.id);
+        }
+        results.push({ ...message, readBy: { ...message.readBy } });
+      }
+      return results;
+    });
+    for (const message of updated) {
+      if (!changed.has(message.id)) continue;
+      this.eventEmitter?.emit({
+        type: "message.acked",
+        messageId: message.id,
+        from: message.from,
+        to: message.to,
+        audience: message.audience,
+        timestamp
+      });
+    }
+    return updated;
+  }
+  /**
+   * Count the messages this actor has neither read nor completed.
+   *
+   * Pushed into SQL rather than filtering `readMessages()`. The pre-tool hook
+   * asks for this repeatedly — `mailbox-hooks.ts` throttles it to once a
+   * second, which bounds the frequency but not the cost — and the JS form
+   * materialized EVERY row in `messages`, joined the whole `message_receipts`
+   * table, and folded per-actor receipt state across all of them just to
+   * return an integer.
+   *
+   * The predicate is deliberately the same one {@link query} builds for
+   * `{ unreadBy, incompleteOnly }`, because it has to agree exactly with
+   * `isMessageCompletedForActor` and `isMailboxMessageVisibleTo`:
+   *
+   * - **unread** — no per-actor receipt carrying `read_at`, and no legacy
+   *   `readBy` key. Both are checked: `ackMany` writes the receipt row AND
+   *   mirrors the timestamp into the message's `readBy` JSON.
+   * - **incomplete** — not `legacy_global_completion`, no per-actor receipt
+   *   carrying `completed_at`, and the aggregate `completed` flag counts only
+   *   when the message has no receipts at all (once any actor has a receipt,
+   *   completion is per-actor and the aggregate flag is not authoritative).
+   * - **audience** — `leaders` mail is invisible unless the actor's base
+   *   identity is `leader`. This call path carries no role, matching the
+   *   `isMailboxMessageVisibleTo(message, forAgentId)` it replaces.
+   */
+  async unreadCount(forAgentId, sessionId, ctx) {
+    const sessionAddress = sessionId === void 0 ? void 0 : sessionRecipient(sessionId);
+    const where = [];
+    const params = [];
+    const recipients = ["to_id = ?", "to_id = '*'"];
+    params.push(forAgentId);
+    if (sessionAddress !== void 0) {
+      recipients.push("to_id = ?");
+      params.push(sessionAddress);
+    }
+    where.push(`(${recipients.join(" OR ")})`);
+    where.push("deleted_at IS NULL");
+    if (!isMailboxLeader(forAgentId)) {
+      where.push("COALESCE(json_extract(data, '$.audience'), 'all') <> 'leaders'");
+    }
+    where.push(`NOT EXISTS (
+      SELECT 1 FROM message_receipts AS read_receipt
+      WHERE read_receipt.message_id = messages.id
+        AND read_receipt.actor_id = ?
+        AND read_receipt.read_at IS NOT NULL
+    )`);
+    params.push(forAgentId);
+    where.push(`NOT EXISTS (
+      SELECT 1 FROM json_each(json_extract(data, '$.readBy')) AS legacy_read
+      WHERE legacy_read.key = ?
+    )`);
+    params.push(forAgentId);
+    where.push("legacy_global_completion = 0");
+    where.push(`NOT EXISTS (
+      SELECT 1 FROM message_receipts AS completed_receipt
+      WHERE completed_receipt.message_id = messages.id
+        AND completed_receipt.actor_id = ?
+        AND completed_receipt.completed_at IS NOT NULL
+    )`);
+    params.push(forAgentId);
+    where.push(`(
+      completed = 0 OR EXISTS (
+        SELECT 1 FROM message_receipts AS any_receipt
+        WHERE any_receipt.message_id = messages.id
+      )
+    )`);
+    if (sessionId === void 0 && ctx === void 0) {
+      const row = this.stmt(
+        `SELECT COUNT(*) AS total FROM messages WHERE ${where.join(" AND ")}`
+      ).get(...params);
+      return Number(row?.total ?? 0);
+    }
+    const rows = this.stmt(
+      `SELECT id, data, legacy_global_completion FROM messages WHERE ${where.join(" AND ")}`
+    ).all(...params);
+    let total = 0;
+    for (const message of this.materializeMessageRows(rows)) {
+      if (await acceptMailboxMessageForSession(message, sessionId, ctx)) total += 1;
+    }
+    return total;
+  }
+  async softDelete(mailId, by) {
+    const message = this.findMessage(mailId);
+    if (message === void 0) return null;
+    if (message.deletedAt !== void 0) return { ...message, readBy: { ...message.readBy } };
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    message.deletedAt = timestamp;
+    message.deletedBy = by;
+    const previousState = message.recipientState[by] ?? { actorId: by };
+    const state = {
+      ...previousState,
+      readAt: previousState.readAt ?? timestamp
+    };
+    message.readBy[by] = state.readAt;
+    message.recipientState = { ...message.recipientState, [by]: state };
+    this.transaction(() => {
+      this.persistReceipt(message.id, state);
+      this.persistMessage(message, message.legacyGlobalCompletion === true);
+    });
+    this.eventEmitter?.emit({
+      type: "message.deleted",
+      messageId: message.id,
+      from: message.from,
+      to: message.to,
+      audience: message.audience,
+      timestamp
+    });
+    return { ...message, readBy: { ...message.readBy } };
+  }
+  async restore(mailId) {
+    const message = this.findMessage(mailId);
+    if (message === void 0) return null;
+    if (message.deletedAt === void 0 && message.deletedBy === void 0) {
+      return { ...message, readBy: { ...message.readBy } };
+    }
+    delete message.deletedAt;
+    delete message.deletedBy;
+    this.persistMessage(message, message.legacyGlobalCompletion === true);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    this.eventEmitter?.emit({
+      type: "message.restored",
+      messageId: message.id,
+      from: message.from,
+      to: message.to,
+      audience: message.audience,
+      timestamp
+    });
+    return { ...message, readBy: { ...message.readBy } };
+  }
+  persistAgent(agent) {
+    persistAgent(this.db, agent);
+  }
+  readAgents() {
+    return readAgents(this.db);
+  }
+  pruneAgents(maxAgeMs = AGENT_STALE_MS) {
+    return pruneAgents(this.db, maxAgeMs);
+  }
+  async registerAgent(input) {
+    this.pruneAgents();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.persistAgent({
+      agentId: input.agentId,
+      sessionId: input.sessionId,
+      name: input.name,
+      ...input.role !== void 0 ? { role: input.role } : {},
+      status: "idle",
+      iterations: 0,
+      toolCalls: 0,
+      registeredAt: now,
+      lastSeenAt: now,
+      pid: input.pid ?? process.pid,
+      ...input.source !== void 0 ? { source: input.source } : {}
+    });
+    this.events?.emitCustom("mailbox.agent_registered", {
+      agentId: input.agentId,
+      sessionId: input.sessionId,
+      name: input.name,
+      role: input.role,
+      source: input.source
+    });
+  }
+  /**
+   * Throttle bookkeeping only: `agentId`/`clientId` -> last accepted heartbeat.
+   *
+   * Entries are deleted on a clean deregister, but a crashed or forcibly killed
+   * peer never deregisters, so over a long-lived daemon's life these maps grew
+   * with every distinct id ever seen. Dropping a stale entry is free: the next
+   * heartbeat from that id simply is not throttled and writes once more.
+   */
+  pruneHeartbeats(map, nowMs) {
+    for (const [id, at] of map) {
+      if (nowMs - at > HEARTBEAT_TRACKING_TTL_MS) map.delete(id);
+    }
+    while (map.size > HEARTBEAT_TRACKING_MAX_ENTRIES) {
+      const oldest = map.keys().next().value;
+      if (oldest === void 0) break;
+      map.delete(oldest);
+    }
+  }
+  async deregisterAgent(agentId) {
+    this.stmt("DELETE FROM agents WHERE agent_id = ?").run(agentId);
+    this.lastHeartbeat.delete(agentId);
+    this.events?.emitCustom("mailbox.agent_deregistered", { agentId });
+  }
+  async heartbeat(input) {
+    const nowMs = Date.now();
+    if (nowMs - (this.lastHeartbeat.get(input.agentId) ?? 0) < HEARTBEAT_THROTTLE_MS) return;
+    this.lastHeartbeat.set(input.agentId, nowMs);
+    this.pruneHeartbeats(this.lastHeartbeat, nowMs);
+    this.pruneAgents();
+    const agent = this.readAgents().get(input.agentId);
+    if (agent !== void 0) {
+      agent.lastSeenAt = new Date(nowMs).toISOString();
+      if (input.status !== void 0) agent.status = input.status;
+      if (input.currentTool !== void 0) agent.currentTool = input.currentTool;
+      if (input.currentTask !== void 0) agent.currentTask = input.currentTask;
+      if (input.iterations !== void 0) agent.iterations = input.iterations;
+      if (input.toolCalls !== void 0) agent.toolCalls = input.toolCalls;
+      this.persistAgent(agent);
+    }
+    this.events?.emitCustom("mailbox.agent_heartbeat", {
+      agentId: input.agentId,
+      status: input.status,
+      currentTool: input.currentTool,
+      currentTask: input.currentTask
+    });
+  }
+  async getAgentStatuses() {
+    this.pruneAgents();
+    return mapRegisteredAgentsToStatuses(this.readAgents(), Date.now(), AGENT_STALE_MS);
+  }
+  async purgeAgents(maxAgeMs = AGENT_STALE_MS) {
+    return this.pruneAgents(maxAgeMs);
+  }
+  async getOnlineAgents() {
+    return (await this.getAgentStatuses()).filter((agent) => agent.online);
+  }
+  persistClient(client) {
+    persistClient(this.db, client);
+  }
+  readClients() {
+    return readClients(this.db);
+  }
+  pruneClientsInPlace() {
+    return pruneClients(this.db);
+  }
+  async registerClient(input) {
+    this.pruneClientsInPlace();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.persistClient({
+      clientId: input.clientId,
+      sessionId: input.sessionId,
+      name: input.name,
+      source: input.source,
+      registeredAt: now,
+      lastSeenAt: now,
+      pid: input.pid ?? process.pid
+    });
+    this.events?.emitCustom("mailbox.client_registered", {
+      clientId: input.clientId,
+      sessionId: input.sessionId,
+      name: input.name,
+      source: input.source
+    });
+  }
+  async deregisterClient(clientId) {
+    this.stmt("DELETE FROM clients WHERE client_id = ?").run(clientId);
+    this.lastClientHeartbeat.delete(clientId);
+    this.events?.emitCustom("mailbox.client_deregistered", { clientId });
+  }
+  async clientHeartbeat(input) {
+    const nowMs = Date.now();
+    if (nowMs - (this.lastClientHeartbeat.get(input.clientId) ?? 0) < HEARTBEAT_THROTTLE_MS) return;
+    this.lastClientHeartbeat.set(input.clientId, nowMs);
+    this.pruneHeartbeats(this.lastClientHeartbeat, nowMs);
+    this.pruneClientsInPlace();
+    const client = this.readClients().get(input.clientId);
+    if (client !== void 0) {
+      client.lastSeenAt = new Date(nowMs).toISOString();
+      if (input.sessionId) client.sessionId = input.sessionId;
+      this.persistClient(client);
+    }
+    this.events?.emitCustom("mailbox.client_heartbeat", {
+      clientId: input.clientId,
+      ...input.sessionId ? { sessionId: input.sessionId } : {}
+    });
+  }
+  async getClientStatuses() {
+    this.pruneClientsInPlace();
+    return mapRegisteredClientsToStatuses(this.readClients(), Date.now(), CLIENT_STALE_MS);
+  }
+  async purgeClients() {
+    return this.pruneClientsInPlace();
+  }
+  async clearAll() {
+    this.stmt("DELETE FROM messages").run();
+  }
+  async purgeStale(options) {
+    return purgeStale(this.compactionCtx(), options);
+  }
+  async autoCompact(options) {
+    if (this.autoCompactInFlight !== void 0) return this.autoCompactInFlight;
+    const inFlight = autoCompact(this.compactionCtx(), options);
+    this.autoCompactInFlight = inFlight;
+    try {
+      return await inFlight;
+    } finally {
+      if (this.autoCompactInFlight === inFlight) this.autoCompactInFlight = void 0;
+    }
+  }
+  /** Bundle of store operations the retention sweeps drive. */
+  compactionCtx() {
+    return {
+      getAgentStatuses: () => this.getAgentStatuses(),
+      readMessages: () => this.readMessages(),
+      deleteMessages: (ids) => this.deleteMessages(ids)
+    };
+  }
+  deleteMessages(ids) {
+    if (ids.length === 0) return;
+    this.transaction(() => deleteMessages(this.db, ids));
+  }
+  credentialGet(credentialId) {
+    return credentialGet(this.db, credentialId);
+  }
+  credentialList() {
+    return credentialList(this.db);
+  }
+  credentialStatusCounts() {
+    return credentialStatusCounts(this.db);
+  }
+  credentialIssue(options) {
+    return credentialIssue(this.db, (run) => this.transaction(run), options);
+  }
+  credentialVerify(credentialId, secret) {
+    return credentialVerify(this.db, credentialId, secret);
+  }
+  credentialRevoke(credentialId, reason, by) {
+    return credentialRevoke(this.db, credentialId, reason, by);
+  }
+  credentialRotate(credentialId, options) {
+    return credentialRotate(this.db, (run) => this.transaction(run), credentialId, options);
+  }
+  startAutoCompactTimer(options) {
+    if (this.autoCompactTimer !== null) clearInterval(this.autoCompactTimer);
+    const timer = setInterval(() => {
+      void this.autoCompact(options).catch(() => {
+      });
+    }, options?.intervalMs ?? AUTO_COMPACT_INTERVAL_MS);
+    timer.unref?.();
+    this.autoCompactTimer = timer;
+    return () => {
+      clearInterval(timer);
+      if (this.autoCompactTimer === timer) this.autoCompactTimer = null;
+    };
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.autoCompactTimer !== null) clearInterval(this.autoCompactTimer);
+    this.autoCompactTimer = null;
+    this.db.close();
+  }
+};
+
+export {
+  MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION,
+  MAILBOX_PROJECT_SERVER_MAX_FRAME_CHARS,
+  isMailboxProjectServerClientMessage,
+  isMailboxProjectServerMessage,
+  encodeMailboxProjectServerMessage,
+  mailboxProjectServerEndpoint,
+  mailboxProjectServerMetadataPath,
+  CREDENTIAL_VERIFY_MAX_FAILURES,
+  CREDENTIAL_VERIFY_WINDOW_MS,
+  CREDENTIAL_VERIFY_COOLDOWN_MS,
+  CredentialVerifyThrottle,
+  credentialVerifyThrottle,
+  SQLITE_MAILBOX_FILE,
+  SqliteMailbox
+};
+//# sourceMappingURL=chunk-5RP3QTRL.js.map