chatwoot-router 0.1.0

package/lib/packages/chatwoot-router/src/index.js

@@ -0,0 +1,1201 @@
+// src/index.ts
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+
+// ../../shared/chatwoot/signature.ts
+var TIMESTAMP_TOLERANCE_SECONDS = 300;
+var encoder = new TextEncoder();
+function isFreshTimestamp(timestamp, nowSeconds) {
+  if (!timestamp || !/^\d{1,12}$/.test(timestamp)) return false;
+  return Math.abs(nowSeconds - Number(timestamp)) <= TIMESTAMP_TOLERANCE_SECONDS;
+}
+async function verifyChatwootSignature(secret, timestamp, body, signatureHeader) {
+  const match = /^sha256=([0-9a-f]{64})$/i.exec(signatureHeader ?? "");
+  const hex = match?.[1];
+  if (!hex) return false;
+  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, [
+    "verify"
+  ]);
+  const prefix = encoder.encode(`${timestamp}.`);
+  const signed = new Uint8Array(prefix.length + body.length);
+  signed.set(prefix);
+  signed.set(body, prefix.length);
+  return crypto.subtle.verify("HMAC", key, Uint8Array.fromHex(hex), signed);
+}
+
+// ../../shared/config.ts
+import { z } from "zod";
+var jsonRecord = z.string().transform((value, ctx) => {
+  try {
+    return JSON.parse(value);
+  } catch {
+    ctx.addIssue({ code: "custom", message: "must be a JSON object" });
+    return z.NEVER;
+  }
+}).pipe(z.record(z.string(), z.string().min(1)));
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+function describe(error) {
+  return error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+}
+var reconcileSchema = z.strictObject({
+  /** The sweep looks at conversations with activity within at least this window. */
+  lookbackSeconds: z.number().int().min(60).default(3600),
+  /** After downtime, the sweep catches up at most this far back. */
+  maxCatchUpSeconds: z.number().int().min(60).default(7 * 24 * 3600)
+}).prefault({});
+
+// ../../shared/log.ts
+function write(level, message, fields = {}) {
+  const line = JSON.stringify({ level, message, ...fields });
+  if (level === "error") console.error(line);
+  else if (level === "warn") console.warn(line);
+  else console.log(line);
+}
+var log = {
+  info: (message, fields) => write("info", message, fields),
+  warn: (message, fields) => write("warn", message, fields),
+  error: (message, fields) => write("error", message, fields)
+};
+function errorFields(error) {
+  return error instanceof Error ? { error: error.name, detail: error.message } : { error: String(error) };
+}
+
+// src/router.ts
+import { DurableObject } from "cloudflare:workers";
+import { z as z7 } from "zod";
+
+// ../../shared/budget.ts
+var BudgetExhaustedError = class extends Error {
+  constructor() {
+    super("Subrequest budget for this invocation is used up");
+    this.name = "BudgetExhaustedError";
+  }
+};
+var REQUEST_TIMEOUT_MS = 6e4;
+var Budget = class {
+  constructor(limit, fetchImpl = (request) => fetch(request), timeoutMs = REQUEST_TIMEOUT_MS) {
+    this.limit = limit;
+    this.fetchImpl = fetchImpl;
+    this.timeoutMs = timeoutMs;
+  }
+  limit;
+  fetchImpl;
+  timeoutMs;
+  used = 0;
+  get remaining() {
+    return this.limit - this.used;
+  }
+  fetch = (request) => {
+    if (this.used >= this.limit) return Promise.reject(new BudgetExhaustedError());
+    this.used += 1;
+    return this.fetchImpl(new Request(request, { signal: AbortSignal.timeout(this.timeoutMs) }));
+  };
+};
+
+// ../../shared/chatwoot/api.ts
+import createClient from "openapi-fetch";
+import { z as z2 } from "zod";
+var ChatwootError = class extends Error {
+  status;
+  conversationMissing;
+  constructor(status, operation, conversationMissing = false) {
+    super(`Chatwoot ${operation} failed with HTTP ${status}`);
+    this.name = "ChatwootError";
+    this.status = status;
+    this.conversationMissing = conversationMissing;
+  }
+};
+var text = z2.string().nullish();
+var attachmentSchema = z2.object({
+  file_type: text,
+  data_url: text,
+  fallback_title: text,
+  coordinates_lat: z2.number().nullish(),
+  coordinates_long: z2.number().nullish(),
+  meta: z2.object({ firstName: text, lastName: text, first_name: text, last_name: text }).nullish().catch(null)
+});
+var itemText = text.catch(null);
+var itemSchema = z2.object({
+  title: itemText,
+  value: itemText,
+  description: itemText,
+  media_url: itemText,
+  link: itemText,
+  actions: z2.array(z2.object({ text: itemText, uri: itemText })).nullish().catch(null)
+});
+var emailSchema = z2.object({
+  subject: text,
+  auto_reply: z2.boolean().nullish(),
+  text_content: z2.object({ quoted: text }).nullish().catch(null),
+  html_content: z2.object({ quoted: text }).nullish().catch(null)
+});
+var messageSchema = z2.object({
+  id: z2.number(),
+  content: text,
+  message_type: z2.number(),
+  content_type: text,
+  /** sent, delivered, read, or failed. */
+  status: text,
+  /** Unix seconds. */
+  created_at: z2.number().nullish(),
+  private: z2.boolean().nullish(),
+  content_attributes: z2.object({
+    email: emailSchema.nullish(),
+    deleted: z2.boolean().nullish(),
+    external_error: text,
+    submitted_values: z2.unknown().optional(),
+    submitted_email: z2.unknown().optional(),
+    items: z2.unknown().optional()
+  }).nullish().catch(null),
+  // A user's or contact's picture is `thumbnail`; an agent bot's is `avatar_url` ("" without one).
+  sender: z2.object({ id: z2.number().nullish(), name: text, email: text, type: text, thumbnail: text, avatar_url: text }).nullish(),
+  attachments: z2.array(attachmentSchema).nullish()
+});
+var messageListSchema = z2.object({ payload: z2.array(messageSchema) });
+var MESSAGE_PAGE_SIZE = 100;
+function chatwootClient(baseUrl, token, fetch2) {
+  const client = createClient({
+    baseUrl: baseUrl.replace(/\/+$/, ""),
+    headers: { api_access_token: token },
+    // A redirect is an error, never followed: it could carry the token to another host, and each
+    // hop would be a subrequest the budget does not count. Configure Chatwoot's final URL.
+    fetch: (request) => fetch2(new Request(request, { redirect: "manual" }))
+  });
+  async function data(operation, pending) {
+    const { data: data2, response } = await pending;
+    if (!response.ok || data2 === void 0) throw new ChatwootError(response.status, operation);
+    return data2;
+  }
+  async function dataUnlessNotFound(operation, pending) {
+    const { data: data2, response } = await pending;
+    if (notFound(response)) {
+      log.info("conversation deleted", { operation });
+      return void 0;
+    }
+    if (!response.ok || data2 === void 0) throw new ChatwootError(response.status, operation);
+    return data2;
+  }
+  async function ensureOk(operation, pending, conversation = true) {
+    const { response } = await pending;
+    if (!response.ok) throw new ChatwootError(response.status, operation, conversation && notFound(response));
+  }
+  async function listMessages(accountId2, conversationId, query) {
+    const list = await dataUnlessNotFound(
+      "list messages",
+      client.GET("/api/v1/accounts/{account_id}/conversations/{conversation_id}/messages", {
+        params: { path: { account_id: accountId2, conversation_id: conversationId }, query }
+      })
+    );
+    return list && messageListSchema.parse(list).payload.toSorted((a, b) => a.id - b.id);
+  }
+  function setCustomAttributes(accountId2, conversationId, attributes) {
+    return ensureOk(
+      "set custom attribute",
+      client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/custom_attributes", {
+        params: { path: { account_id: accountId2, conversation_id: conversationId } },
+        body: { custom_attributes: attributes, merge: true }
+      })
+    );
+  }
+  return {
+    /** The conversation, or undefined when it does not exist (it was deleted). */
+    getConversation(accountId2, conversationId) {
+      return dataUnlessNotFound(
+        "get conversation",
+        client.GET("/api/v1/accounts/{account_id}/conversations/{conversation_id}", {
+          params: { path: { account_id: accountId2, conversation_id: conversationId } }
+        })
+      );
+    },
+    /** Messages with an id above `after`, oldest first; without `after`, the latest page. */
+    async listMessages(accountId2, conversationId, query = {}) {
+      const messages = await listMessages(accountId2, conversationId, query);
+      if (!messages) throw new ChatwootError(404, "list messages", true);
+      return messages;
+    },
+    /**
+     * One message, or undefined if it or its conversation does not exist. Asks for the ids between
+     * `messageId - 1` and `messageId + 1`, which contains it whether `after` is read inclusively
+     * (MessageFinder#messages_between at v4.18.0) or exclusively (as the spec describes it).
+     */
+    async getMessage(accountId2, conversationId, messageId) {
+      const messages = await listMessages(accountId2, conversationId, { after: messageId - 1, before: messageId + 1 });
+      return messages?.find((message) => message.id === messageId);
+    },
+    async inboxName(accountId2, inboxId) {
+      const inbox = await data(
+        "get inbox",
+        client.GET("/api/v1/accounts/{account_id}/inboxes/{id}", {
+          params: { path: { account_id: accountId2, id: inboxId } }
+        })
+      );
+      return inbox.name;
+    },
+    /**
+     * One page (CONVERSATIONS_PER_PAGE) of conversations of any assignee and the given status
+     * (default: any), most recent activity first (Conversations::SortService's default,
+     * `last_activity_at_desc`, at v4.18.0).
+     */
+    async listConversations(accountId2, page, status = "all") {
+      const list = await data(
+        "list conversations",
+        client.GET("/api/v1/accounts/{account_id}/conversations", {
+          params: { path: { account_id: accountId2 }, query: { status, assignee_type: "all", page } }
+        })
+      );
+      return list.data?.payload ?? [];
+    },
+    /** The content of the account's canned response with this short code, if it exists. */
+    async cannedResponse(accountId2, shortCode) {
+      const responses = await data(
+        "list canned responses",
+        client.GET("/api/v1/accounts/{account_id}/canned_responses", { params: { path: { account_id: accountId2 } } })
+      );
+      return responses.find((response) => response.short_code === shortCode)?.content;
+    },
+    getProfile() {
+      return data("get profile", client.GET("/api/v1/profile"));
+    },
+    listAgents(accountId2) {
+      return data(
+        "list agents",
+        client.GET("/api/v1/accounts/{account_id}/agents", { params: { path: { account_id: accountId2 } } })
+      );
+    },
+    setStatus(accountId2, conversationId, change) {
+      return ensureOk(
+        "toggle status",
+        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/toggle_status", {
+          params: { path: { account_id: accountId2, conversation_id: conversationId } },
+          body: change
+        })
+      );
+    },
+    setPriority(accountId2, conversationId, priority) {
+      return ensureOk(
+        "toggle priority",
+        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/toggle_priority", {
+          params: { path: { account_id: accountId2, conversation_id: conversationId } },
+          body: { priority }
+        })
+      );
+    },
+    setContactBlocked(accountId2, contactId, blocked) {
+      return ensureOk(
+        blocked ? "block contact" : "unblock contact",
+        client.PUT("/api/v1/accounts/{account_id}/contacts/{id}", {
+          params: { path: { account_id: accountId2, id: contactId } },
+          body: { blocked }
+        }),
+        false
+      );
+    },
+    assign(accountId2, conversationId, assigneeId) {
+      return ensureOk(
+        "assign conversation",
+        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/assignments", {
+          params: { path: { account_id: accountId2, conversation_id: conversationId } },
+          body: { assignee_id: assigneeId }
+        })
+      );
+    },
+    /**
+     * Removes the conversation's assignee the way Chatwoot's dashboard does (ConversationAction.vue
+     * posts `assignee_id: null`, which AssignmentsController#create applies, at v4.18.0). The
+     * spec types `assignee_id` as a number only, so this body is serialized here.
+     */
+    unassign(accountId2, conversationId) {
+      return ensureOk(
+        "unassign conversation",
+        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/assignments", {
+          params: { path: { account_id: accountId2, conversation_id: conversationId } },
+          body: {},
+          bodySerializer: () => JSON.stringify({ assignee_id: null })
+        })
+      );
+    },
+    /** The account's label names (Chatwoot saves them in lower case). */
+    async listLabels(accountId2) {
+      const list = await data(
+        "list labels",
+        client.GET("/api/v1/accounts/{account_id}/labels", { params: { path: { account_id: accountId2 } } })
+      );
+      return (list.payload ?? []).flatMap((label) => label.title ? [label.title] : []);
+    },
+    async conversationLabels(accountId2, conversationId) {
+      const list = await data(
+        "list conversation labels",
+        client.GET("/api/v1/accounts/{account_id}/conversations/{conversation_id}/labels", {
+          params: { path: { account_id: accountId2, conversation_id: conversationId } }
+        })
+      );
+      return list.payload ?? [];
+    },
+    /** Replaces the conversation's labels (the spec's "Add Labels" overwrites the list). */
+    setLabels(accountId2, conversationId, labels) {
+      return ensureOk(
+        "set labels",
+        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/labels", {
+          params: { path: { account_id: accountId2, conversation_id: conversationId } },
+          body: { labels }
+        })
+      );
+    },
+    setCustomAttributes,
+    /**
+     * Sends an outgoing message (or private note). With files it is sent as the spec's
+     * multipart/form-data body; the generated type renders its `attachments[]` binaries as
+     * strings, so the serializer appends the files itself.
+     */
+    createMessage(accountId2, conversationId, message) {
+      const fields = {
+        content: message.content,
+        message_type: "outgoing",
+        private: message.private,
+        ...message.sendAsAgent ? { content_attributes: { send_as_agent: true } } : {}
+      };
+      const multipart = (body) => {
+        const form = new FormData();
+        if (body.content) form.append("content", body.content);
+        if (body.message_type) form.append("message_type", body.message_type);
+        form.append("private", String(body.private ?? false));
+        if (body.content_attributes) form.append("content_attributes", JSON.stringify(body.content_attributes));
+        for (const file of message.files) form.append("attachments[]", file.blob, file.filename);
+        return form;
+      };
+      return ensureOk(
+        "create message",
+        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/messages", {
+          params: { path: { account_id: accountId2, conversation_id: conversationId } },
+          body: fields,
+          ...message.files.length === 0 ? {} : { bodySerializer: () => multipart(fields) }
+        })
+      );
+    }
+  };
+}
+function notFound(response) {
+  return response.status === 404 && (response.headers.get("content-type")?.includes("application/json") ?? false);
+}
+function toRelayConversation(conversationId, conversation) {
+  const meta = conversation.meta;
+  const assignee = meta?.assignee;
+  return {
+    id: conversationId,
+    status: conversation.status,
+    channel: meta?.channel ?? null,
+    priority: conversation.priority ?? null,
+    labels: conversation.labels ?? [],
+    contact: {
+      name: meta?.sender?.name ?? null,
+      email: meta?.sender?.email ?? null,
+      phone: meta?.sender?.phone_number ?? null,
+      blocked: meta?.sender?.blocked ?? false,
+      avatarUrl: meta?.sender?.thumbnail ?? null
+    },
+    assignee: assignee ? { id: assignee.id, name: assignee.name } : null,
+    customAttributes: conversation.custom_attributes ?? {}
+  };
+}
+function messageContent(message) {
+  const email = message.content_attributes?.email;
+  return email?.text_content?.quoted ?? email?.html_content?.quoted ?? message.content ?? "";
+}
+
+// ../../shared/json.ts
+function parseJson(text2) {
+  if (text2 === void 0) return void 0;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return void 0;
+  }
+}
+
+// ../../shared/store.ts
+function retryDelay(attempts) {
+  return Math.min(5e3 * 2 ** attempts, 30 * 60 * 1e3);
+}
+var QueueStore = class {
+  constructor(sql, now = Date.now) {
+    this.sql = sql;
+    this.now = now;
+  }
+  sql;
+  now;
+  migrate() {
+    this.sql.exec(`CREATE TABLE IF NOT EXISTS jobs (
+      key TEXT PRIMARY KEY, priority INTEGER NOT NULL, payload TEXT NOT NULL,
+      version INTEGER NOT NULL DEFAULT 1, attempts INTEGER NOT NULL DEFAULT 0,
+      not_before INTEGER NOT NULL, created_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS jobs_due ON jobs (not_before);
+    CREATE TABLE IF NOT EXISTS cache (key TEXT PRIMARY KEY, value TEXT NOT NULL, expires_at INTEGER);`);
+  }
+  // Cache
+  get(key) {
+    const row = this.sql.exec("SELECT value, expires_at FROM cache WHERE key = ?", key).toArray()[0];
+    if (!row || row.expires_at !== null && row.expires_at <= this.now()) return void 0;
+    return row.value;
+  }
+  set(key, value, ttlMs) {
+    this.sql.exec(
+      "INSERT INTO cache (key, value, expires_at) VALUES (?, ?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value, expires_at = excluded.expires_at",
+      key,
+      value,
+      ttlMs === void 0 ? null : this.now() + ttlMs
+    );
+  }
+  delete(key) {
+    this.sql.exec("DELETE FROM cache WHERE key = ?", key);
+  }
+  list(start, end) {
+    return this.sql.exec(
+      "SELECT value FROM cache WHERE key >= ? AND key < ? AND (expires_at IS NULL OR expires_at > ?) ORDER BY key",
+      start,
+      end,
+      this.now()
+    ).toArray().map((row) => row.value);
+  }
+  // Jobs
+  /**
+   * Adds a job, or marks an existing one as needing another run (its version changes). A job
+   * that is backing off after failures keeps its schedule.
+   */
+  enqueue(key, priority, payload, notBefore = this.now()) {
+    this.sql.exec(
+      `INSERT INTO jobs (key, priority, payload, not_before, created_at) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT (key) DO UPDATE SET version = version + 1, payload = excluded.payload,
+         not_before = CASE WHEN attempts > 0 THEN not_before ELSE MIN(not_before, excluded.not_before) END`,
+      key,
+      priority,
+      payload,
+      notBefore,
+      this.now()
+    );
+  }
+  nextDueJob() {
+    const row = this.sql.exec(
+      `SELECT key, payload, version, attempts, created_at FROM jobs WHERE not_before <= ?
+         ORDER BY priority, not_before, created_at LIMIT 1`,
+      this.now()
+    ).toArray()[0];
+    if (!row) return void 0;
+    const { created_at: createdAt, ...job } = row;
+    return { ...job, createdAt };
+  }
+  /** Earliest due time. */
+  nextWakeup() {
+    const row = this.sql.exec("SELECT MIN(not_before) AS at FROM jobs").toArray()[0];
+    return row?.at ?? void 0;
+  }
+  /** Removes a finished job unless it was enqueued again while running. */
+  completeJob(job) {
+    const removed = this.sql.exec("DELETE FROM jobs WHERE key = ? AND version = ?", job.key, job.version).rowsWritten;
+    if (removed === 0) this.sql.exec("UPDATE jobs SET attempts = 0, not_before = ? WHERE key = ?", this.now(), job.key);
+  }
+  deleteJob(key) {
+    this.sql.exec("DELETE FROM jobs WHERE key = ?", key);
+  }
+  retryJob(job, delayMs) {
+    this.sql.exec(
+      "UPDATE jobs SET attempts = attempts + 1, not_before = ? WHERE key = ?",
+      this.now() + delayMs,
+      job.key
+    );
+  }
+  /**
+   * Makes a job due after `delayMs` without counting an attempt: when an invocation runs out of
+   * budget, or Discord rate limits it.
+   */
+  deferJob(job, delayMs = 0) {
+    this.sql.exec("UPDATE jobs SET not_before = ? WHERE key = ?", this.now() + delayMs, job.key);
+  }
+  prune() {
+    this.sql.exec("DELETE FROM cache WHERE expires_at IS NOT NULL AND expires_at <= ?", this.now());
+  }
+};
+
+// ../../shared/sweep.ts
+import { z as z3 } from "zod";
+var passSchema = z3.object({ cutoff: z3.number(), page: z3.number().int().positive(), startedAt: z3.number() });
+var PASS_TTL_MS = 24 * 60 * 60 * 1e3;
+function readSweepPass(store, accountId2, reconcile) {
+  const parsed = passSchema.safeParse(parseJson(store.get(`sweep:${accountId2}:pass`)));
+  if (parsed.success) return parsed.data;
+  const now = Date.now();
+  const last = Number(store.get(`sweep:${accountId2}:last`) ?? 0);
+  const { lookbackSeconds, maxCatchUpSeconds } = reconcile;
+  const sinceLast = last > 0 ? (now - last) / 1e3 + 60 : lookbackSeconds;
+  const window = Math.min(Math.max(sinceLast, lookbackSeconds), maxCatchUpSeconds);
+  return { cutoff: now / 1e3 - window, page: 1, startedAt: now };
+}
+function saveSweepPass(store, accountId2, pass, nextPage) {
+  const key = `sweep:${accountId2}:pass`;
+  if (nextPage === void 0) {
+    store.set(`sweep:${accountId2}:last`, String(pass.startedAt));
+    store.delete(key);
+  } else {
+    store.set(key, JSON.stringify({ ...pass, page: nextPage }), PASS_TTL_MS);
+  }
+}
+
+// src/routing.ts
+import ipRegex from "ip-regex";
+import { z as z5 } from "zod";
+
+// ../../shared/attributes.ts
+var ROUTING_ATTRIBUTES = {
+  seen: "routing_seen",
+  handled: "routing_handled",
+  kind: "routing_kind"
+};
+function messageWatermark(value) {
+  const number = typeof value === "string" ? Number(value) : value;
+  return typeof number === "number" && Number.isSafeInteger(number) && number >= 0 ? number : 0;
+}
+
+// src/effects.ts
+import { z as z4 } from "zod";
+var effectSchema = z4.object({
+  inputId: z4.number().int().min(0),
+  kind: z4.string().nullable(),
+  handled: z4.number().int().min(0)
+});
+async function actOnce(ctx, key, effect, record, act) {
+  if (ctx.store.get(key) !== void 0) return;
+  if (record === "before") ctx.store.set(key, JSON.stringify({ ...effect, handled: 0 }));
+  await act();
+  ctx.store.set(key, JSON.stringify(effect));
+}
+function readEffects(store, accountId2, conversationId) {
+  return [
+    store.get(`reply:${accountId2}:${conversationId}`),
+    ...["assign", "labels", "status"].flatMap(
+      (effect) => store.list(`${effect}:${accountId2}:${conversationId}:`, `${effect}:${accountId2}:${conversationId};`)
+    )
+  ].flatMap((value) => {
+    const parsed = effectSchema.safeParse(parseJson(value));
+    return parsed.success ? [parsed.data] : [];
+  }).sort((left, right) => left.inputId - right.inputId);
+}
+
+// src/routing.ts
+var UNCLEAR = "unclear";
+var UNCLEAR_CRITERION = "The message has no concrete request, mixes several of the other areas, concerns another product, or cannot be assigned to exactly one of them.";
+var REQUEST_CRITERIA = {
+  request: "The customer asks for support, information, or an action: a question about a product or service, a problem, or something to do, however briefly.",
+  none: 'No request yet: a greeting or a check that someone is there (such as "hi" or "hello, anyone there?"), a test, a name or contact details alone, or a few words that ask for nothing.'
+};
+var NO_KIND = "none";
+var NO_KIND_CRITERION = "None of the other kinds.";
+var JEV_URL = "https://api.typesafe.ai/v1/systemone";
+var MAX_MESSAGES = 3;
+var MAX_TEXT = 1600;
+var REDACTIONS = [
+  /(?<![\w.+-])[\w.+-]+@[\w.-]+\.[a-z]{2,}(?!\w)/gi,
+  // email
+  /\b(?:https?|ftp):\/\/[^\s<>()]+|\bwww\.[^\s<>()]+/gi,
+  // URL
+  /\b(?:0x)?[0-9a-f]{20,}\b/gi,
+  // hex ids, EVM addresses, hashes
+  /(?<![1-9A-HJ-NP-Za-km-z])[1-9A-HJ-NP-Za-km-z]{32,64}(?![1-9A-HJ-NP-Za-km-z])/g,
+  // base58 addresses
+  /(?<![A-Za-z0-9_+/=-])[A-Za-z0-9_+/=-]{40,}(?![A-Za-z0-9_+/=-])/g,
+  // keys and tokens
+  /(?<!\w)\+?\d[\d ()-]{8,}\d(?!\w)/g,
+  // phone numbers
+  // IPv6 (with a zone id), whole: not inside a word or a path such as std::io, and not followed by a
+  // colon (an address with a port is bracketed). Before IPv4, which an IPv6 address may end with.
+  new RegExp(`(?<!\\w)(?:${ipRegex.v6().source})(?![\\w:])`, "g"),
+  // IPv4, also after `key:` and before `:port`, but not inside a word or a longer dotted number (a
+  // four-part version number reads as an address and is redacted too).
+  new RegExp(`(?<!\\w|\\d\\.)(?:${ipRegex.v4().source})(?!\\w|\\.\\d)`, "g"),
+  /(?<!\w)@[A-Za-z0-9_.-]{2,}/g
+  // handles
+];
+var decisionSchema = z5.object({
+  owner: z5.string().nullable(),
+  ownerConfidence: z5.number(),
+  topic: z5.string().nullable(),
+  topicConfidence: z5.number(),
+  kind: z5.string().nullable().default(null),
+  kindConfidence: z5.number().default(0),
+  /** Jev is confident the customer asked for nothing yet (asked with `snoozeUnclear` only). */
+  noRequest: z5.boolean().default(false)
+});
+var jevResponseSchema = z5.object({
+  answers: z5.record(
+    z5.string(),
+    z5.object({
+      choice: z5.string(),
+      probabilities: z5.record(z5.string(), z5.number()).optional(),
+      confidence: z5.number().optional()
+    })
+  )
+});
+var JevError = class extends Error {
+  constructor(detail) {
+    super(`TypeSafe Jev: ${detail}`);
+    this.name = "JevError";
+  }
+};
+function routesAccount(settings, accountId2) {
+  return settings.config.routing.accounts[String(accountId2)] !== void 0;
+}
+async function routeConversation(ctx, accountId2, conversationId) {
+  const { settings, store, chatwoot } = ctx;
+  const routing = settings.config.routing;
+  const owners = routing.accounts[String(accountId2)];
+  if (!owners) return;
+  const kinds = routing.kinds?.[String(accountId2)] ?? {};
+  const raw = await chatwoot.getConversation(accountId2, conversationId);
+  if (!raw) return;
+  const conversation = toRelayConversation(conversationId, raw);
+  const latest = await chatwoot.listMessages(accountId2, conversationId, { filter_internal_messages: true });
+  const identities = [conversation.contact?.name, conversation.contact?.email];
+  const inputs = await customerInputs(ctx, accountId2, conversationId, identities);
+  let seen = Math.max(inputs.seen, ...latest.filter(isCustomer).map((message) => message.id));
+  const key = inputs.ids.join(",");
+  const memoKey = `decision:${accountId2}:${conversationId}:${key}`;
+  const cached = inputs.ids.map(
+    (_, index) => readDecision(store.get(`decision:${accountId2}:${conversationId}:${inputs.ids.slice(0, index + 1).join(",")}`))
+  );
+  let decision = cached.at(-1);
+  const previous = cached.findLast((entry) => entry !== void 0);
+  const kindFor = (answer) => answer?.kind && answer.kindConfidence >= routing.minConfidence ? kinds[answer.kind] : void 0;
+  const assigneeFor = (answer) => answer?.owner && answer.ownerConfidence >= routing.minConfidence ? owners[answer.owner]?.assignee : void 0;
+  const eligible = (observed2, answer) => conversationId > (settings.config.startAfterConversationId[String(accountId2)] ?? 0) && !observed2.contact?.blocked && observed2.status === "open" && (!observed2.assignee || observed2.assignee.id === assigneeFor(answer));
+  let observed = raw;
+  if (inputs.ids.length > 0 && eligible(conversation, previous)) {
+    if (!decision) {
+      decision = await decide(ctx, owners, routing.kinds?.[String(accountId2)], inputs.text);
+      store.set(memoKey, JSON.stringify(decision));
+    }
+    const freshInputs = await customerInputs(ctx, accountId2, conversationId, identities);
+    if (freshInputs.ids.join(",") !== key) return "defer";
+    seen = Math.max(seen, freshInputs.seen);
+    const fresh = await chatwoot.getConversation(accountId2, conversationId);
+    if (!fresh) return;
+    observed = fresh;
+    const current = toRelayConversation(conversationId, fresh);
+    if (eligible(current, decision)) {
+      const kind = kindFor(decision);
+      const kindName = kind ? decision.kind : null;
+      const assignee = kind?.status ? void 0 : assigneeFor(decision);
+      const inputId = inputs.ids.at(-1) ?? 0;
+      if (assignee !== void 0) {
+        await actOnce(
+          ctx,
+          `assign:${accountId2}:${conversationId}:${key}`,
+          { inputId, kind: null, handled: 0 },
+          "after",
+          async () => {
+            if (!current.assignee) await chatwoot.assign(accountId2, conversationId, assignee);
+          }
+        );
+      }
+      const topic = !kind?.status && decision.topic !== null && Object.hasOwn(routing.topics ?? {}, decision.topic) && decision.topicConfidence >= routing.minConfidence && current.labels.every((label) => Object.hasOwn(kinds, label)) ? decision.topic : null;
+      const labels = [.../* @__PURE__ */ new Set([...current.labels, ...[topic, kindName].filter((label) => label !== null)])];
+      await actOnce(
+        ctx,
+        `labels:${accountId2}:${conversationId}:${key}`,
+        { inputId, kind: kindName, handled: 0 },
+        "after",
+        async () => {
+          if (labels.length !== current.labels.length) await chatwoot.setLabels(accountId2, conversationId, labels);
+        }
+      );
+      const replyKey = `reply:${accountId2}:${conversationId}`;
+      const botToken = settings.botToken(accountId2);
+      if (kind?.cannedResponse && botToken && store.get(replyKey) === void 0) {
+        const content = await chatwoot.cannedResponse(accountId2, kind.cannedResponse);
+        if (content === void 0) throw new Error("Chatwoot canned response is missing");
+        const bot = chatwootClient(settings.config.chatwoot.baseUrl, botToken, ctx.fetch);
+        await actOnce(
+          ctx,
+          replyKey,
+          { inputId, kind: kindName, handled: inputId },
+          "before",
+          () => bot.createMessage(accountId2, conversationId, { content, private: false, files: [] })
+        );
+      }
+      const snooze = !assignee && inputs.ids.length < MAX_MESSAGES && routing.snoozeUnclear && decision.noRequest;
+      const status = freshInputs.complete ? kind?.status ?? (snooze ? "snoozed" : void 0) : void 0;
+      if (status) {
+        await actOnce(
+          ctx,
+          `status:${accountId2}:${conversationId}:${key}`,
+          { inputId, kind: kindName, handled: kind?.status ? inputId : 0 },
+          "before",
+          () => chatwoot.setStatus(accountId2, conversationId, { status })
+        );
+      }
+    }
+  }
+  await syncAttributes(ctx, accountId2, conversationId, observed, seen);
+}
+async function syncAttributes(ctx, accountId2, conversationId, observed, seen) {
+  const current = observed.custom_attributes ?? {};
+  const names = ROUTING_ATTRIBUTES;
+  const key = `seen:${accountId2}:${conversationId}`;
+  const checkpoint = Math.max(messageWatermark(ctx.store.get(key)), seen, messageWatermark(current[names.seen]));
+  ctx.store.set(key, String(checkpoint));
+  const effects = readEffects(ctx.store, accountId2, conversationId);
+  const handled = Math.max(0, ...effects.map((effect) => effect.handled));
+  const kind = effects.findLast((effect) => effect.kind !== null)?.kind ?? null;
+  const attributes = {
+    [names.seen]: checkpoint,
+    ...handled > 0 ? { [names.handled]: Math.max(handled, messageWatermark(current[names.handled])) } : {},
+    ...kind === null ? {} : { [names.kind]: kind }
+  };
+  if (Object.entries(attributes).some(
+    ([name, value]) => (name === names.kind ? current[name] : messageWatermark(current[name])) !== value
+  ))
+    await ctx.chatwoot.setCustomAttributes(accountId2, conversationId, attributes);
+}
+function isCustomer(message) {
+  return message.message_type === 0 && !message.private;
+}
+async function customerInputs(ctx, accountId2, conversationId, identities) {
+  const ids = [];
+  const parts = [];
+  let after = 0;
+  let seen = 0;
+  let complete = false;
+  for (let page = 0; page < 3 && ids.length < MAX_MESSAGES; page += 1) {
+    const messages = await ctx.chatwoot.listMessages(accountId2, conversationId, {
+      after,
+      filter_internal_messages: true
+    });
+    for (const message of messages.filter(isCustomer)) {
+      seen = Math.max(seen, message.id);
+      const text2 = sanitize(
+        [message.content_attributes?.email?.subject ?? "", messageContent(message)].join("\n"),
+        identities
+      );
+      if (ids.length < MAX_MESSAGES && text2.replaceAll("[REDACTED]", "").trim()) {
+        ids.push(message.id);
+        parts.push(text2);
+      }
+    }
+    complete = ids.length === MAX_MESSAGES || messages.length < MESSAGE_PAGE_SIZE;
+    if (complete) break;
+    after = messages.at(-1)?.id ?? after;
+  }
+  return { ids, text: parts.join(" ").slice(0, MAX_TEXT), complete, seen };
+}
+function sanitize(text2, identities) {
+  let value = text2.normalize("NFKC");
+  for (const pattern of REDACTIONS) value = value.replace(pattern, "[REDACTED]");
+  const names = identities.flatMap((identity) => identity ? [identity, ...identity.split(/\s+/)] : []);
+  for (const name of [...new Set(names)].filter((item) => item.length >= 2).sort((a, b) => b.length - a.length)) {
+    const escaped = RegExp.escape(name);
+    value = value.replace(new RegExp(`(?<!\\w)${escaped}(?!\\w)`, "giu"), "[REDACTED]");
+  }
+  return value.replace(/\s+/g, " ").trim().slice(0, MAX_TEXT);
+}
+async function decide(ctx, owners, kinds, text2) {
+  const routing = ctx.settings.config.routing;
+  const apiKey = ctx.settings.secrets.TYPESAFE_API_KEY;
+  if (!routing || !apiKey) throw new JevError("routing is not configured");
+  const ownerCriteria = Object.fromEntries(
+    Object.entries(owners).map(([route, owner2]) => [route, owner2.covers])
+  );
+  ownerCriteria[UNCLEAR] = UNCLEAR_CRITERION;
+  const questions = {
+    owner: {
+      type: "choice",
+      instructions: "Select who should handle this support ticket, using only the ticket.",
+      criteria: ownerCriteria
+    }
+  };
+  if (routing.topics) {
+    questions.topic = {
+      type: "choice",
+      instructions: "Select the topic of this support ticket, using only the ticket.",
+      criteria: routing.topics
+    };
+  }
+  if (routing.snoozeUnclear) {
+    questions.request = {
+      type: "choice",
+      instructions: "Select whether the customer asks for anything in this support ticket, using only the ticket.",
+      criteria: REQUEST_CRITERIA
+    };
+  }
+  if (kinds) {
+    questions.kind = {
+      type: "choice",
+      instructions: "Select the kind of this support ticket, using only the ticket.",
+      criteria: {
+        ...Object.fromEntries(Object.entries(kinds).map(([name, kind2]) => [name, kind2.covers])),
+        [NO_KIND]: NO_KIND_CRITERION
+      }
+    };
+  }
+  const response = await ctx.fetch(
+    new Request(JEV_URL, {
+      method: "POST",
+      redirect: "manual",
+      headers: { authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
+      body: JSON.stringify({ model: routing.model, state: { ticket: text2 }, questions })
+    })
+  );
+  if (!response.ok) throw new JevError(`HTTP ${response.status}`);
+  const parsed = jevResponseSchema.safeParse(await response.json().catch(() => void 0));
+  if (!parsed.success) throw new JevError("invalid response");
+  const answer = (question) => {
+    const criteria = questions[question]?.criteria;
+    if (!criteria) return { choice: null, confidence: 0 };
+    const given = parsed.data.answers[question];
+    if (!given || !Object.hasOwn(criteria, given.choice)) throw new JevError(`no valid ${question}`);
+    return { choice: given.choice, confidence: given.probabilities?.[given.choice] ?? given.confidence ?? 0 };
+  };
+  const owner = answer("owner");
+  const topic = answer("topic");
+  const kind = answer("kind");
+  const request = answer("request");
+  return {
+    owner: owner.choice === UNCLEAR ? null : owner.choice,
+    ownerConfidence: owner.confidence,
+    topic: topic.choice,
+    topicConfidence: topic.confidence,
+    kind: kind.choice === NO_KIND ? null : kind.choice,
+    kindConfidence: kind.confidence,
+    noRequest: request.choice === "none" && request.confidence >= routing.minConfidence
+  };
+}
+function readDecision(stored) {
+  const parsed = decisionSchema.safeParse(parseJson(stored));
+  return parsed.success ? parsed.data : void 0;
+}
+
+// ../../shared/settings.ts
+function settingsLoader(parse) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return (env) => {
+    let settings = cache.get(env);
+    if (!settings) {
+      settings = readConfig(env).then((config) => parse(config, env));
+      cache.set(env, settings);
+      settings.catch(() => cache.delete(env));
+    }
+    return settings;
+  };
+}
+async function readConfig(env) {
+  if (env.CONFIG_KEY === void 0) return typeof env.CONFIG === "string" ? parseJson(env.CONFIG) : env.CONFIG;
+  if (env.CONFIG !== void 0) throw new ConfigError("Invalid CONFIG: set either CONFIG or CONFIG_KEY");
+  if (!env.CONFIG_STORE) throw new ConfigError("Invalid CONFIG_KEY: requires the CONFIG_STORE KV namespace");
+  const config = await env.CONFIG_STORE.get(env.CONFIG_KEY, "json");
+  if (config === null) throw new ConfigError("Invalid CONFIG_KEY: not in CONFIG_STORE");
+  return config;
+}
+
+// src/config.ts
+import { z as z6 } from "zod";
+var accountId = z6.string().regex(/^[1-9]\d*$/, "must be a Chatwoot account id").refine((value) => Number.isSafeInteger(Number(value)), "must be a safe integer");
+var configSchema = z6.strictObject({
+  chatwoot: z6.strictObject({ baseUrl: z6.url({ protocol: /^https?$/ }) }),
+  reconcile: reconcileSchema,
+  startAfterConversationId: z6.record(accountId, z6.number().int().min(0)).default({}),
+  subrequestBudget: z6.number().int().min(20).max(1e3).default(45),
+  routing: z6.strictObject({
+    model: z6.string().min(1).default("jev-1.13.0"),
+    /** Jev's probability an answer needs before it is applied. */
+    minConfidence: z6.number().min(0.5).max(1).default(0.7),
+    /**
+     * Snooze a ticket Jev cannot assign yet, and in which the customer asked for nothing yet, until
+     * their next message (see src/routing.ts).
+     */
+    snoozeUnclear: z6.boolean().default(false),
+    /** Per Chatwoot account id: the owners Jev chooses from, by a short name. */
+    accounts: z6.record(
+      accountId,
+      z6.record(
+        z6.string().regex(/^[a-z0-9_]{1,40}$/, "must be a short lower-case name").refine((name) => name !== "unclear", "unclear is reserved"),
+        z6.strictObject({
+          /** Chatwoot user id to assign. */
+          assignee: z6.number().int().positive(),
+          /** What the owner handles, as Jev's criterion for choosing them. */
+          covers: z6.string().min(1).max(1e3)
+        })
+      ).refine((owners) => Object.keys(owners).length > 0, "needs at least one owner")
+    ),
+    /** Topic labels (Chatwoot label names, lower case) and what each covers. Unset: no topic. */
+    topics: z6.record(
+      z6.string().regex(/^[a-z0-9_-]{1,255}$/, "must be a Chatwoot label name (lower case)"),
+      z6.string().min(1).max(1e3)
+    ).optional(),
+    /**
+     * Per Chatwoot account id: kinds of ticket Jev recognizes, by a short name, and what is done,
+     * once, when it does (see src/routing.ts). Unset: none.
+     */
+    kinds: z6.record(
+      accountId,
+      z6.record(
+        z6.string().regex(/^[a-z0-9_-]{1,40}$/, "must be a short lower-case name").refine((name) => name !== "none", "none is reserved"),
+        z6.strictObject({
+          /** What the kind is, as Jev's criterion for recognizing it. */
+          covers: z6.string().min(1).max(1e3),
+          /**
+           * Short code of the account's Chatwoot canned response sent to the customer once, as
+           * the account's agent bot (CHATWOOT_BOT_TOKENS). None is sent while it does not exist.
+           */
+          cannedResponse: z6.string().trim().min(1).max(255).optional(),
+          /**
+           * Set instead of routing the ticket (after the reply, with cannedResponse): `resolved`,
+           * or `snoozed` until the customer's next message. A new message from the customer
+           * reopens either.
+           */
+          status: z6.enum(["resolved", "snoozed"]).optional()
+        })
+      )
+    ).optional()
+  })
+}).refine((config) => Object.keys(config.startAfterConversationId).every((id3) => config.routing.accounts[id3]), {
+  path: ["startAfterConversationId"],
+  message: "must only name routed accounts"
+}).refine((config) => Object.keys(config.routing?.kinds ?? {}).every((id3) => config.routing?.accounts[id3]), {
+  path: ["routing", "kinds"],
+  message: "must only name routed accounts"
+}).refine(
+  (config) => Object.values(config.routing?.kinds ?? {}).every(
+    (kinds) => Object.keys(kinds).every((kind) => !Object.hasOwn(config.routing?.topics ?? {}, kind))
+  ),
+  { path: ["routing", "kinds"], message: "a kind cannot be named as a topic: they are labels of two families" }
+);
+var secretsSchema = z6.object({
+  CHATWOOT_TOKEN: z6.string().min(1),
+  CHATWOOT_WEBHOOK_SECRETS: jsonRecord,
+  TYPESAFE_API_KEY: z6.string().min(1),
+  CHATWOOT_BOT_TOKENS: jsonRecord.default({})
+});
+function parseSettings(rawConfig, rawSecrets) {
+  const config = configSchema.safeParse(rawConfig);
+  if (!config.success) throw new ConfigError(`Invalid CONFIG: ${describe(config.error)}`);
+  const secrets = secretsSchema.safeParse(rawSecrets);
+  if (!secrets.success) throw new ConfigError(`Invalid secrets: ${describe(secrets.error)}`);
+  return buildSettings(config.data, secrets.data);
+}
+function buildSettings(config, secrets) {
+  for (const accountId2 of Object.keys(config.routing.accounts)) {
+    if (!secrets.CHATWOOT_WEBHOOK_SECRETS[accountId2]) {
+      throw new ConfigError(`Invalid secrets: CHATWOOT_WEBHOOK_SECRETS: account ${accountId2} needs a webhook secret`);
+    }
+  }
+  for (const [accountId2, kinds] of Object.entries(config.routing.kinds ?? {})) {
+    if (Object.values(kinds).some((kind) => kind.cannedResponse) && !secrets.CHATWOOT_BOT_TOKENS[accountId2]) {
+      throw new ConfigError(`Invalid secrets: CHATWOOT_BOT_TOKENS: account ${accountId2} has kinds that reply`);
+    }
+  }
+  return { config, secrets, botToken: (accountId2) => secrets.CHATWOOT_BOT_TOKENS[String(accountId2)] };
+}
+
+// src/settings.ts
+var loadSettings = settingsLoader(parseSettings);
+
+// src/router.ts
+var ROUTER_NAME = "global";
+var ROUTE_BUDGET = 15;
+var BUDGET = { route: ROUTE_BUDGET, sweep: 1 };
+var RUN_WALL_MS = 5 * 60 * 1e3;
+var id = z7.number().int().positive();
+var jobSchema = z7.discriminatedUnion("type", [
+  z7.object({ type: z7.literal("route"), accountId: id, conversationId: id }),
+  z7.object({ type: z7.literal("sweep"), accountId: id })
+]);
+var Router = class extends DurableObject {
+  store;
+  constructor(context, env) {
+    super(context, env);
+    this.store = new QueueStore(context.storage.sql);
+    context.blockConcurrencyWhile(async () => this.store.migrate());
+  }
+  async enqueueConversation(accountId2, conversationId) {
+    const settings = await loadSettings(this.env);
+    if (!routesAccount(settings, accountId2)) return;
+    this.enqueue({ type: "route", accountId: accountId2, conversationId });
+    await this.schedule();
+  }
+  async requestSweep() {
+    for (const accountId2 of Object.keys((await loadSettings(this.env)).config.routing.accounts)) {
+      this.enqueue({ type: "sweep", accountId: Number(accountId2) });
+    }
+    await this.schedule();
+  }
+  async alarm() {
+    const settings = await loadSettings(this.env);
+    const budget = new Budget(settings.config.subrequestBudget);
+    const chatwoot = chatwootClient(settings.config.chatwoot.baseUrl, settings.secrets.CHATWOOT_TOKEN, budget.fetch);
+    const started = Date.now();
+    let yielded = false;
+    this.store.prune();
+    for (let job = this.store.nextDueJob(); job; job = this.store.nextDueJob()) {
+      const parsed = jobSchema.safeParse(parseJson(job.payload));
+      if (!parsed.success) {
+        log.warn("unreadable job dropped", { job: job.key });
+        this.store.deleteJob(job.key);
+        continue;
+      }
+      const payload = parsed.data;
+      if (budget.remaining < BUDGET[payload.type] || Date.now() - started > RUN_WALL_MS) {
+        yielded = true;
+        break;
+      }
+      try {
+        const ctx = { settings, chatwoot, store: this.store, fetch: budget.fetch };
+        if (payload.type === "route") {
+          if (await routeConversation(ctx, payload.accountId, payload.conversationId) === "defer") {
+            this.store.deferJob(job);
+            yielded = true;
+            break;
+          }
+        } else if (routesAccount(settings, payload.accountId)) {
+          await this.sweep(settings, chatwoot, payload.accountId);
+        }
+        this.store.completeJob(job);
+      } catch (error) {
+        if (error instanceof ChatwootError && error.conversationMissing) {
+          log.info("conversation deleted; job dropped", { job: job.key });
+          this.store.deleteJob(job.key);
+          continue;
+        }
+        if (error instanceof BudgetExhaustedError) {
+          this.store.deferJob(job);
+          yielded = true;
+          break;
+        }
+        const delay = retryDelay(job.attempts);
+        const logAt = job.attempts + 1 >= 3 ? log.error : log.warn;
+        logAt("job failed; will retry", {
+          job: job.key,
+          attempts: job.attempts + 1,
+          delayMs: delay,
+          ...errorFields(error)
+        });
+        this.store.retryJob(job, delay);
+      }
+    }
+    await this.schedule(yielded ? Date.now() : void 0);
+  }
+  async sweep(settings, chatwoot, accountId2) {
+    const pass = readSweepPass(this.store, accountId2, settings.config.reconcile);
+    const conversations = await chatwoot.listConversations(accountId2, pass.page);
+    let finished = conversations.length === 0;
+    for (const conversation of conversations) {
+      if ((conversation.last_activity_at ?? 0) < pass.cutoff) {
+        finished = true;
+        break;
+      }
+      const conversationId = conversation.id;
+      if (conversationId === void 0) continue;
+      this.enqueue({ type: "route", accountId: accountId2, conversationId });
+    }
+    if (finished) {
+      saveSweepPass(this.store, accountId2, pass);
+    } else {
+      saveSweepPass(this.store, accountId2, pass, pass.page + 1);
+      this.enqueue({ type: "sweep", accountId: accountId2 });
+    }
+  }
+  enqueue(payload) {
+    const key = payload.type === "sweep" ? `sweep:${payload.accountId}` : `${payload.type}:${payload.accountId}:${payload.conversationId}`;
+    this.store.enqueue(key, payload.type === "sweep" ? 1 : 0, JSON.stringify(payload));
+  }
+  async schedule(at) {
+    const next = at ?? this.store.nextWakeup();
+    if (next === void 0) return;
+    const current = await this.ctx.storage.getAlarm();
+    if (current === null || current > next) await this.ctx.storage.setAlarm(next);
+  }
+};
+
+// src/webhook.ts
+import { z as z8 } from "zod";
+var id2 = z8.number().int().positive();
+var eventSchema = z8.object({
+  event: z8.string(),
+  account: z8.object({ id: id2 }),
+  id: id2.optional(),
+  conversation: z8.object({ id: id2 }).optional(),
+  message_type: z8.union([z8.string(), z8.number()]).optional(),
+  private: z8.boolean().optional(),
+  sender: z8.object({ type: z8.string().optional() }).nullish()
+});
+var CONVERSATION_EVENTS = /* @__PURE__ */ new Set(["conversation_created", "conversation_updated", "conversation_status_changed"]);
+function eventTarget(payload) {
+  const parsed = eventSchema.safeParse(payload);
+  if (!parsed.success) return void 0;
+  const event = parsed.data;
+  if (CONVERSATION_EVENTS.has(event.event) && event.id !== void 0) {
+    return { accountId: event.account.id, conversationId: event.id };
+  }
+  if (event.event === "message_created" && (event.message_type === "incoming" || event.message_type === 0) && !event.private && event.sender?.type === "contact" && event.id !== void 0 && event.conversation) {
+    return { accountId: event.account.id, conversationId: event.conversation.id };
+  }
+  return void 0;
+}
+
+// src/index.ts
+var app = new Hono();
+app.get("/healthz", async (context) => {
+  try {
+    await loadSettings(context.env);
+    return context.json({ ok: true });
+  } catch (error) {
+    log.error(error instanceof ConfigError ? "configuration invalid" : "configuration unavailable", errorFields(error));
+    return context.json({ ok: false }, 503);
+  }
+});
+app.post("/chatwoot/webhook", bodyLimit({ maxSize: 2 * 1024 * 1024 }), async (context) => {
+  const settings = await loadSettings(context.env);
+  const timestamp = context.req.header("x-chatwoot-timestamp");
+  if (!timestamp || !isFreshTimestamp(timestamp, Math.floor(Date.now() / 1e3))) {
+    return context.text("invalid or stale timestamp", 401);
+  }
+  const body = new Uint8Array(await context.req.arrayBuffer());
+  const signature = context.req.header("x-chatwoot-signature");
+  let signedBy;
+  for (const [accountId2, secret] of Object.entries(settings.secrets.CHATWOOT_WEBHOOK_SECRETS)) {
+    if (await verifyChatwootSignature(secret, timestamp, body, signature)) {
+      signedBy = Number(accountId2);
+      break;
+    }
+  }
+  if (signedBy === void 0) return context.text("invalid signature", 401);
+  let payload;
+  try {
+    payload = JSON.parse(new TextDecoder().decode(body));
+  } catch {
+    return context.text("bad request", 400);
+  }
+  const target = eventTarget(payload);
+  if (!target) return context.json({ ok: true, ignored: true });
+  if (target.accountId !== signedBy || !routesAccount(settings, target.accountId)) {
+    return context.text("account does not match the webhook secret", 403);
+  }
+  await context.env.ROUTER.getByName(ROUTER_NAME).enqueueConversation(target.accountId, target.conversationId);
+  return context.json({ ok: true });
+});
+app.notFound((context) => context.text("not found", 404));
+app.onError((error, context) => {
+  log.error("request failed", { path: context.req.path, ...errorFields(error) });
+  return context.text("internal error", 500);
+});
+var src_default = {
+  fetch: app.fetch,
+  async scheduled(_controller, env, context) {
+    context.waitUntil(env.ROUTER.getByName(ROUTER_NAME).requestSweep());
+  }
+};
+export {
+  Router,
+  src_default as default
+};