@adatechnology/meta-whatsapp-module 0.1.0

package/dist/index.js

@@ -0,0 +1,1506 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// ../../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.40_@swc+helpers@0.5.23__jiti@2.7.0_postcss@8.5.15_tsx@4.23.1_typescript@5.9.3_yaml@2.9.0/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = /* @__PURE__ */ __name(() => fileURLToPath(import.meta.url), "getFilename");
+var getDirname = /* @__PURE__ */ __name(() => path.dirname(getFilename()), "getDirname");
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/createMetaWhatsAppModule.ts
+import { WhatsAppMessageProvider } from "@adatechnology/meta-whatsapp-provider";
+
+// src/repositories/SessionRepository.ts
+import { and, desc, eq, sql as sql2 } from "drizzle-orm";
+
+// src/schema/schema.ts
+import { sql } from "drizzle-orm";
+import { pgSchema, uuid, varchar, jsonb, timestamp, text, integer, boolean, index, uniqueIndex } from "drizzle-orm/pg-core";
+var metaWhatsAppSchema = pgSchema("meta_whatsapp");
+var sessions = metaWhatsAppSchema.table("sessions", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  // Multiempresa: toda entidade carrega companyId, vindo do contexto autenticado do host —
+  // nunca de um campo livre do cliente (ver database.md "Consistência e multiempresa").
+  companyId: uuid("company_id").notNull(),
+  whatsappNumber: varchar("whatsapp_number", {
+    length: 20
+  }).notNull(),
+  // varchar (não enum): a máquina de estados de cada produto evolui de forma independente do módulo.
+  currentState: varchar("current_state", {
+    length: 64
+  }).notNull().default("start"),
+  // Posição no grafo, quando o motor de fluxo está em uso — colunas separadas em vez de
+  // convencionar "flowKey:nodeId" dentro de currentState: além de ser um contrato implícito que
+  // nada garantia, a concatenação estourava o varchar(64) (flow key já é varchar(64) sozinha).
+  flowKey: varchar("flow_key", {
+    length: 64
+  }),
+  currentNodeId: varchar("current_node_id", {
+    length: 64
+  }),
+  context: jsonb("context").$type().notNull().default({}),
+  mode: varchar("mode", {
+    length: 12
+  }).notNull().default("bot"),
+  assignedUserId: uuid("assigned_user_id"),
+  humanRequestedAt: timestamp("human_requested_at", {
+    withTimezone: true
+  }),
+  lastInboundAt: timestamp("last_inbound_at", {
+    withTimezone: true
+  }),
+  lastAgentReadAt: timestamp("last_agent_read_at", {
+    withTimezone: true
+  }),
+  lastActivity: timestamp("last_activity", {
+    withTimezone: true
+  }).notNull().defaultNow(),
+  createdAt: timestamp("created_at", {
+    withTimezone: true
+  }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", {
+    withTimezone: true
+  }).notNull().defaultNow()
+}, (table) => [
+  // Único por empresa (não globalmente) — dois hosts diferentes podem atender o mesmo número.
+  uniqueIndex("idx_sessions_company_number").on(table.companyId, table.whatsappNumber),
+  index("idx_sessions_company_mode").on(table.companyId, table.mode),
+  // Alimenta getLiveFlowPositions (agregação por nó do grafo).
+  index("idx_sessions_company_flow_node").on(table.companyId, table.flowKey, table.currentNodeId)
+]);
+var messages = metaWhatsAppSchema.table("messages", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  companyId: uuid("company_id").notNull(),
+  sessionId: uuid("session_id").notNull().references(() => sessions.id, {
+    onDelete: "cascade"
+  }),
+  whatsappNumber: varchar("whatsapp_number", {
+    length: 20
+  }).notNull(),
+  direction: varchar("direction", {
+    length: 12
+  }).notNull(),
+  sender: varchar("sender", {
+    length: 12
+  }).notNull(),
+  agentUserId: uuid("agent_user_id"),
+  type: varchar("type", {
+    length: 16
+  }).notNull().default("text"),
+  content: text("content"),
+  // T5.4 — nunca base64 aqui; mídia vive no ObjectStorageInterface do host, referenciada por
+  // uploadId dentro deste jsonb.
+  payload: jsonb("payload").$type(),
+  waMessageId: varchar("wa_message_id", {
+    length: 128
+  }),
+  status: varchar("status", {
+    length: 16
+  }),
+  readAt: timestamp("read_at", {
+    withTimezone: true
+  }),
+  createdAt: timestamp("created_at", {
+    withTimezone: true
+  }).notNull().defaultNow()
+}, (table) => [
+  index("idx_messages_session_created").on(table.sessionId, table.createdAt),
+  index("idx_messages_company_number_created").on(table.companyId, table.whatsappNumber, table.createdAt),
+  // Parcial e ÚNICO: é o que de fato garante idempotência de entrega. Um SELECT-antes-de-INSERT
+  // não basta — a Meta reenvia a mesma entrega e várias instâncias do host processam em
+  // paralelo, então as duas passariam pela checagem e inseririam duplicado. Parcial porque
+  // mensagens outbound ainda sem waMessageId (envio em curso) são legitimamente NULL, e NULLs
+  // não podem competir entre si por unicidade.
+  uniqueIndex("idx_messages_company_wa_message_id").on(table.companyId, table.waMessageId).where(sql`${table.waMessageId} is not null`)
+]);
+var flowGraphs = metaWhatsAppSchema.table("flow_graphs", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  companyId: uuid("company_id").notNull(),
+  key: varchar("key", {
+    length: 64
+  }).notNull(),
+  label: varchar("label", {
+    length: 120
+  }).notNull(),
+  startNodeId: varchar("start_node_id", {
+    length: 64
+  }).notNull(),
+  nodes: jsonb("nodes").$type().notNull().default({}),
+  // Otimista: o editor manda a versão que carregou; salvar com versão desatualizada é
+  // rejeitado pelo host (evita duas abas sobrescreverem uma a outra silenciosamente).
+  version: integer("version").notNull().default(1),
+  showInMenu: boolean("show_in_menu").notNull().default(false),
+  menuOptionLabel: varchar("menu_option_label", {
+    length: 64
+  }),
+  createdAt: timestamp("created_at", {
+    withTimezone: true
+  }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", {
+    withTimezone: true
+  }).notNull().defaultNow()
+}, (table) => [
+  uniqueIndex("idx_flow_graphs_company_key").on(table.companyId, table.key)
+]);
+var settings = metaWhatsAppSchema.table("settings", {
+  companyId: uuid("company_id").primaryKey(),
+  templateName: varchar("template_name", {
+    length: 128
+  }),
+  templateLanguage: varchar("template_language", {
+    length: 16
+  }).notNull().default("pt_BR"),
+  // Mapa posicional {{1}}, {{2}}... → token resolvido no envio (ex.: '{clientName}').
+  templateVariables: jsonb("template_variables").$type().notNull().default([]),
+  welcomeMessage: text("welcome_message"),
+  farewellMessage: text("farewell_message"),
+  createdAt: timestamp("created_at", {
+    withTimezone: true
+  }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", {
+    withTimezone: true
+  }).notNull().defaultNow()
+});
+
+// src/repositories/SessionRepository.ts
+var DEFAULT_LIMIT = 20;
+var SessionRepository = class {
+  static {
+    __name(this, "SessionRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async getContext(companyId, whatsappNumber) {
+    const [row] = await this.db.select().from(sessions).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber))).limit(1);
+    return row;
+  }
+  async getOrCreate(companyId, whatsappNumber, startState) {
+    const existing = await this.getContext(companyId, whatsappNumber);
+    if (existing) return existing;
+    const [created] = await this.db.insert(sessions).values({
+      companyId,
+      whatsappNumber,
+      currentState: startState
+    }).onConflictDoUpdate({
+      target: [
+        sessions.companyId,
+        sessions.whatsappNumber
+      ],
+      set: {
+        lastActivity: sql2`now()`
+      }
+    }).returning();
+    return created;
+  }
+  async setState(companyId, whatsappNumber, state, context) {
+    await this.db.update(sessions).set({
+      currentState: state,
+      ...context !== void 0 ? {
+        context
+      } : {},
+      lastActivity: sql2`now()`,
+      updatedAt: sql2`now()`
+    }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
+  }
+  // Posição no grafo de fluxo — chamado pelo host a cada transição do FlowInterpreter.
+  // Passar null em ambos desliga o rastreio (ex.: conversa saiu do motor de fluxo).
+  async setFlowPosition(companyId, whatsappNumber, flowKey, currentNodeId) {
+    await this.db.update(sessions).set({
+      flowKey,
+      currentNodeId,
+      lastActivity: sql2`now()`,
+      updatedAt: sql2`now()`
+    }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
+  }
+  // Marca a chegada de uma mensagem DO CLIENTE. É este carimbo — e não lastActivity, que também
+  // se move em ações do atendente/bot — que define a janela de 24h do WhatsApp: fora dela, só
+  // template aprovado reabre a conversa (ver WindowExpiredError nos contracts).
+  async touchInbound(companyId, whatsappNumber) {
+    await this.db.update(sessions).set({
+      lastInboundAt: sql2`now()`,
+      lastActivity: sql2`now()`,
+      updatedAt: sql2`now()`
+    }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
+  }
+  // Horas desde a última mensagem do cliente — undefined se ele nunca escreveu. O canal (Fase 5)
+  // usa isto para decidir entre mensagem livre e template antes de chamar a Graph API.
+  async hoursSinceLastInbound(companyId, whatsappNumber) {
+    const session = await this.getContext(companyId, whatsappNumber);
+    if (!session?.lastInboundAt) return void 0;
+    return (Date.now() - session.lastInboundAt.getTime()) / (1e3 * 60 * 60);
+  }
+  async setMode(companyId, whatsappNumber, mode, assignedUserId) {
+    await this.db.update(sessions).set({
+      mode,
+      assignedUserId: assignedUserId ?? null,
+      updatedAt: sql2`now()`
+    }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
+  }
+  // T3.3 — takeover: atendente assume a conversa, tirando-a do modo bot.
+  async takeover(companyId, whatsappNumber, agentUserId) {
+    await this.setMode(companyId, whatsappNumber, "human", agentUserId);
+  }
+  // T3.3 — release: devolve a conversa ao bot.
+  async release(companyId, whatsappNumber) {
+    await this.setMode(companyId, whatsappNumber, "bot", null);
+  }
+  async requestHuman(companyId, whatsappNumber) {
+    await this.db.update(sessions).set({
+      humanRequestedAt: sql2`now()`,
+      updatedAt: sql2`now()`
+    }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
+  }
+  async markRead(companyId, whatsappNumber) {
+    await this.db.update(sessions).set({
+      lastAgentReadAt: sql2`now()`
+    }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
+  }
+  async markAllRead(companyId, userId) {
+    const result = await this.db.update(sessions).set({
+      lastAgentReadAt: sql2`now()`
+    }).where(and(eq(sessions.companyId, companyId), eq(sessions.assignedUserId, userId)));
+    return Number(result.rowCount ?? 0);
+  }
+  async listByContextFilters(companyId, filters) {
+    const limit = filters.limit ?? DEFAULT_LIMIT;
+    const offset = ((filters.page ?? 1) - 1) * limit;
+    const conditions = [
+      eq(sessions.companyId, companyId)
+    ];
+    if (filters.waitingHuman) conditions.push(sql2`${sessions.humanRequestedAt} is not null`);
+    if (filters.search) conditions.push(sql2`${sessions.whatsappNumber} ilike ${"%" + filters.search + "%"}`);
+    const rows = await this.db.select({
+      id: sessions.id,
+      whatsappNumber: sessions.whatsappNumber,
+      mode: sessions.mode,
+      assignedUserId: sessions.assignedUserId,
+      currentState: sessions.currentState,
+      lastActivity: sessions.lastActivity,
+      lastInboundAt: sessions.lastInboundAt,
+      humanRequestedAt: sessions.humanRequestedAt
+    }).from(sessions).where(and(...conditions)).orderBy(desc(sessions.lastActivity)).limit(limit).offset(offset);
+    return rows.map((row) => ({
+      id: row.id,
+      whatsappNumber: row.whatsappNumber,
+      lastAt: row.lastActivity.toISOString(),
+      lastInboundAt: row.lastInboundAt?.toISOString() ?? null,
+      mode: row.mode,
+      assignedUserId: row.assignedUserId,
+      waitingHuman: row.humanRequestedAt !== null,
+      unread: 0,
+      currentState: row.currentState
+    }));
+  }
+  // T3.3 — export: transcript completo de uma conversa, mensagens em ordem cronológica.
+  async exportConversation(companyId, whatsappNumber) {
+    const session = await this.getContext(companyId, whatsappNumber);
+    if (!session) return null;
+    const rows = await this.db.select().from(messages).where(and(eq(messages.companyId, companyId), eq(messages.sessionId, session.id))).orderBy(messages.createdAt);
+    return {
+      session,
+      messages: rows
+    };
+  }
+};
+
+// src/repositories/MessageRepository.ts
+import { and as and2, eq as eq2, lt } from "drizzle-orm";
+var DEFAULT_LIMIT2 = 50;
+var MessageRepository = class {
+  static {
+    __name(this, "MessageRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  // Idempotente por (companyId, waMessageId) — o mesmo webhook chega mais de uma vez (a Meta
+  // reenvia em instabilidade) e várias instâncias do host processam em paralelo. A garantia é o
+  // índice único parcial no banco + onConflictDoNothing, NÃO um SELECT prévio: duas entregas
+  // concorrentes passariam as duas pela checagem e inseririam duplicado.
+  // Devolve undefined quando a mensagem já existia (nada foi inserido).
+  async insertMessage(params) {
+    const values = {
+      companyId: params.companyId,
+      sessionId: params.sessionId,
+      whatsappNumber: params.whatsappNumber,
+      direction: params.direction,
+      sender: params.sender,
+      agentUserId: params.agentUserId ?? null,
+      type: params.type,
+      content: params.content ?? null,
+      payload: params.payload ?? null,
+      waMessageId: params.waMessageId ?? null,
+      status: params.status ?? null
+    };
+    const [created] = await this.db.insert(messages).values(values).onConflictDoNothing().returning();
+    return created;
+  }
+  async updateMessageStatus(companyId, waMessageId, status) {
+    const [updated] = await this.db.update(messages).set({
+      status,
+      ...status === "read" ? {
+        readAt: /* @__PURE__ */ new Date()
+      } : {}
+    }).where(and2(eq2(messages.companyId, companyId), eq2(messages.waMessageId, waMessageId))).returning();
+    return updated;
+  }
+  async listByConversation(params) {
+    const conditions = [
+      eq2(messages.companyId, params.companyId),
+      eq2(messages.sessionId, params.sessionId)
+    ];
+    if (params.before) conditions.push(lt(messages.createdAt, new Date(params.before)));
+    return this.db.select().from(messages).where(and2(...conditions)).orderBy(messages.createdAt).limit(params.limit ?? DEFAULT_LIMIT2);
+  }
+};
+
+// src/repositories/FlowGraphRepository.ts
+import { and as and3, eq as eq3, isNotNull, sql as sql3 } from "drizzle-orm";
+import { flowGraphNodesSchema } from "@adatechnology/meta-whatsapp-contracts";
+var InvalidFlowGraphError = class extends Error {
+  static {
+    __name(this, "InvalidFlowGraphError");
+  }
+  validationMessage;
+  constructor(key, validationMessage) {
+    super(`Grafo do fluxo "${key}" est\xE1 malformado no banco: ${validationMessage}`), this.validationMessage = validationMessage;
+    this.name = "InvalidFlowGraphError";
+  }
+};
+function toContractGraph(row) {
+  const parsed = flowGraphNodesSchema.safeParse(row.nodes);
+  if (!parsed.success) throw new InvalidFlowGraphError(row.key, parsed.error.message);
+  return {
+    key: row.key,
+    label: row.label,
+    startNodeId: row.startNodeId,
+    version: row.version,
+    nodes: parsed.data
+  };
+}
+__name(toContractGraph, "toContractGraph");
+var OptimisticLockError = class extends Error {
+  static {
+    __name(this, "OptimisticLockError");
+  }
+  constructor(key) {
+    super(`Fluxo "${key}" foi alterado por outra sess\xE3o \u2014 recarregue antes de salvar.`);
+    this.name = "OptimisticLockError";
+  }
+};
+var FlowGraphRepository = class {
+  static {
+    __name(this, "FlowGraphRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async get(companyId, key) {
+    const [row] = await this.db.select().from(flowGraphs).where(and3(eq3(flowGraphs.companyId, companyId), eq3(flowGraphs.key, key))).limit(1);
+    return row ? toContractGraph(row) : void 0;
+  }
+  async list(companyId) {
+    const rows = await this.db.select().from(flowGraphs).where(eq3(flowGraphs.companyId, companyId));
+    return rows.map((row) => ({
+      key: row.key,
+      label: row.label,
+      nodeCount: Object.keys(row.nodes).length,
+      showInMenu: row.showInMenu,
+      menuOptionLabel: row.menuOptionLabel ?? void 0,
+      updatedAt: row.updatedAt.toISOString()
+    }));
+  }
+  // Valida antes de gravar: aceitar um grafo malformado e só reclamar na leitura empurraria a
+  // falha para o meio de uma conversa real, em vez de barrar quem salvou.
+  assertValidNodes(key, nodes) {
+    const parsed = flowGraphNodesSchema.safeParse(nodes);
+    if (!parsed.success) throw new InvalidFlowGraphError(key, parsed.error.message);
+  }
+  async create(companyId, graph) {
+    this.assertValidNodes(graph.key, graph.nodes);
+    const [created] = await this.db.insert(flowGraphs).values({
+      companyId,
+      key: graph.key,
+      label: graph.label,
+      startNodeId: graph.startNodeId,
+      nodes: graph.nodes,
+      showInMenu: graph.showInMenu ?? false,
+      menuOptionLabel: graph.menuOptionLabel
+    }).returning();
+    return toContractGraph(created);
+  }
+  // Lock otimista: a escrita só aplica se `expectedVersion` ainda bater com o que está salvo —
+  // senão, alguém mais salvou entretanto e o editor precisa recarregar (ver comentário no schema).
+  async save(companyId, graph, expectedVersion) {
+    this.assertValidNodes(graph.key, graph.nodes);
+    const rows = await this.db.update(flowGraphs).set({
+      label: graph.label,
+      startNodeId: graph.startNodeId,
+      nodes: graph.nodes,
+      version: expectedVersion + 1,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(and3(eq3(flowGraphs.companyId, companyId), eq3(flowGraphs.key, graph.key), eq3(flowGraphs.version, expectedVersion))).returning();
+    if (rows.length === 0) throw new OptimisticLockError(graph.key);
+    return toContractGraph(rows[0]);
+  }
+  async delete(companyId, key) {
+    await this.db.delete(flowGraphs).where(and3(eq3(flowGraphs.companyId, companyId), eq3(flowGraphs.key, key)));
+  }
+  // T4.2 — GetLiveFlowPositions: agrega sessões ativas por (flowKey, currentNodeId), lendo as
+  // colunas dedicadas gravadas por SessionRepository.setFlowPosition. Agrega no banco (GROUP BY,
+  // coberto por idx_sessions_company_flow_node) em vez de trazer toda sessão da empresa para
+  // contar em memória.
+  async getLiveFlowPositions(companyId) {
+    const rows = await this.db.select({
+      flowKey: sessions.flowKey,
+      nodeId: sessions.currentNodeId,
+      count: sql3`count(*)::int`
+    }).from(sessions).where(and3(eq3(sessions.companyId, companyId), eq3(sessions.mode, "bot"), isNotNull(sessions.flowKey), isNotNull(sessions.currentNodeId))).groupBy(sessions.flowKey, sessions.currentNodeId);
+    return rows.map((row) => ({
+      flowKey: row.flowKey,
+      nodeId: row.nodeId,
+      count: row.count
+    }));
+  }
+};
+
+// src/repositories/SettingsRepository.ts
+import { eq as eq4 } from "drizzle-orm";
+function toContractSettings(row) {
+  return {
+    templateName: row.templateName ?? "",
+    templateLanguage: row.templateLanguage,
+    templateVariables: row.templateVariables,
+    welcomeMessage: row.welcomeMessage ?? "",
+    farewellMessage: row.farewellMessage ?? ""
+  };
+}
+__name(toContractSettings, "toContractSettings");
+var EMPTY_SETTINGS = {
+  templateName: "",
+  templateLanguage: "pt_BR",
+  templateVariables: [],
+  welcomeMessage: "",
+  farewellMessage: ""
+};
+var SettingsRepository = class {
+  static {
+    __name(this, "SettingsRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  // Empresa sem linha de configuração é o estado normal logo após instalar o módulo — devolve
+  // os defaults em vez de undefined, para o chamador não precisar tratar "ainda não configurado"
+  // como caso especial em todo lugar.
+  async get(companyId) {
+    const [row] = await this.db.select().from(settings).where(eq4(settings.companyId, companyId)).limit(1);
+    return row ? toContractSettings(row) : EMPTY_SETTINGS;
+  }
+  async save(companyId, update) {
+    const current = await this.get(companyId);
+    const merged = {
+      ...current,
+      ...update
+    };
+    const [row] = await this.db.insert(settings).values({
+      companyId,
+      templateName: merged.templateName || null,
+      templateLanguage: merged.templateLanguage,
+      templateVariables: merged.templateVariables,
+      welcomeMessage: merged.welcomeMessage || null,
+      farewellMessage: merged.farewellMessage || null
+    }).onConflictDoUpdate({
+      target: settings.companyId,
+      set: {
+        templateName: merged.templateName || null,
+        templateLanguage: merged.templateLanguage,
+        templateVariables: merged.templateVariables,
+        welcomeMessage: merged.welcomeMessage || null,
+        farewellMessage: merged.farewellMessage || null,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    }).returning();
+    return toContractSettings(row);
+  }
+  // Resolve {{1}}, {{2}}... a partir do mapa configurado + o contexto da conversa. Ex.: se
+  // templateVariables = ['{clientName}', '{city}'], devolve [nome, cidade] na ordem posicional
+  // que a Graph API espera nos bodyParameters.
+  async resolveTemplateVariables(companyId, context) {
+    const { templateVariables } = await this.get(companyId);
+    return templateVariables.map((token) => {
+      const key = token.replace(/^\{|\}$/g, "");
+      const value = context[key];
+      return value === void 0 || value === null ? "" : String(value);
+    });
+  }
+};
+
+// src/use-cases/LogMessage.use-case.ts
+var LogMessageUseCase = class {
+  static {
+    __name(this, "LogMessageUseCase");
+  }
+  sessionRepository;
+  messageRepository;
+  realtime;
+  constructor(sessionRepository, messageRepository, realtime) {
+    this.sessionRepository = sessionRepository;
+    this.messageRepository = messageRepository;
+    this.realtime = realtime;
+  }
+  async execute(params) {
+    const session = await this.sessionRepository.getOrCreate(params.companyId, params.whatsappNumber, params.startState);
+    const saved = await this.messageRepository.insertMessage({
+      ...params,
+      sessionId: session.id
+    });
+    if (!saved) return void 0;
+    if (params.direction === "inbound") {
+      await this.sessionRepository.touchInbound(params.companyId, params.whatsappNumber);
+    }
+    this.realtime?.emit(`conv:${params.whatsappNumber}`, "message", {
+      direction: params.direction,
+      sender: params.sender
+    });
+    this.realtime?.emit("global", "data-changed", {});
+    return saved;
+  }
+};
+
+// src/use-cases/SendMessage.use-case.ts
+import { WindowExpiredError } from "@adatechnology/meta-whatsapp-contracts";
+var WHATSAPP_WINDOW_HOURS = 24;
+var SendMessageUseCase = class {
+  static {
+    __name(this, "SendMessageUseCase");
+  }
+  channel;
+  sessionRepository;
+  logMessage;
+  objectStorage;
+  constructor(channel, sessionRepository, logMessage, objectStorage) {
+    this.channel = channel;
+    this.sessionRepository = sessionRepository;
+    this.logMessage = logMessage;
+    this.objectStorage = objectStorage;
+  }
+  async assertWithinWindow(companyId, whatsappNumber) {
+    const hours = await this.sessionRepository.hoursSinceLastInbound(companyId, whatsappNumber);
+    if (hours === void 0) throw new WindowExpiredError();
+    if (hours >= WHATSAPP_WINDOW_HOURS) throw new WindowExpiredError(hours);
+  }
+  async sendText(params) {
+    await this.assertWithinWindow(params.companyId, params.whatsappNumber);
+    const { externalMessageId } = await this.channel.sendText(params.whatsappNumber, params.body);
+    return this.logMessage.execute({
+      companyId: params.companyId,
+      whatsappNumber: params.whatsappNumber,
+      direction: "outbound",
+      sender: params.sender,
+      agentUserId: params.agentUserId ?? null,
+      type: "text",
+      content: params.body,
+      waMessageId: externalMessageId,
+      status: "sent",
+      startState: params.startState
+    });
+  }
+  async sendMedia(params) {
+    await this.assertWithinWindow(params.companyId, params.whatsappNumber);
+    const { externalMessageId } = await this.channel.sendMedia({
+      to: params.whatsappNumber,
+      buffer: params.buffer,
+      mimeType: params.mimeType,
+      filename: params.filename,
+      caption: params.caption
+    });
+    const uploadId = this.objectStorage ? (await this.objectStorage.upload({
+      buffer: params.buffer,
+      mimeType: params.mimeType,
+      key: `meta-whatsapp/${params.companyId}/${Date.now()}-${params.filename}`
+    })).uploadId : void 0;
+    return this.logMessage.execute({
+      companyId: params.companyId,
+      whatsappNumber: params.whatsappNumber,
+      direction: "outbound",
+      sender: params.sender,
+      agentUserId: params.agentUserId ?? null,
+      type: mediaTypeFor(params.mimeType),
+      content: params.caption ?? params.filename,
+      payload: {
+        filename: params.filename,
+        mimeType: params.mimeType,
+        ...uploadId ? {
+          uploadId
+        } : {}
+      },
+      waMessageId: externalMessageId,
+      status: "sent",
+      startState: params.startState
+    });
+  }
+  // Template é o único envio que ignora a janela — é justamente o mecanismo que a Meta oferece
+  // para reabri-la.
+  async sendTemplate(params) {
+    const { externalMessageId } = await this.channel.sendTemplate({
+      to: params.whatsappNumber,
+      templateName: params.templateName,
+      languageCode: params.languageCode ?? "pt_BR",
+      bodyParameters: params.bodyParameters
+    });
+    return this.logMessage.execute({
+      companyId: params.companyId,
+      whatsappNumber: params.whatsappNumber,
+      direction: "outbound",
+      sender: params.sender,
+      agentUserId: params.agentUserId ?? null,
+      type: "template",
+      content: params.templateName,
+      payload: {
+        templateName: params.templateName,
+        bodyParameters: params.bodyParameters ?? []
+      },
+      waMessageId: externalMessageId,
+      status: "sent",
+      startState: params.startState
+    });
+  }
+};
+function mediaTypeFor(mimeType) {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("audio/")) return "audio";
+  if (mimeType.startsWith("video/")) return "video";
+  return "document";
+}
+__name(mediaTypeFor, "mediaTypeFor");
+
+// src/use-cases/TakeoverConversation.use-case.ts
+var TakeoverConversationUseCase = class {
+  static {
+    __name(this, "TakeoverConversationUseCase");
+  }
+  sessionRepository;
+  realtime;
+  constructor(sessionRepository, realtime) {
+    this.sessionRepository = sessionRepository;
+    this.realtime = realtime;
+  }
+  async execute(params) {
+    await this.sessionRepository.takeover(params.companyId, params.whatsappNumber, params.agentUserId);
+    this.realtime?.emit(`conv:${params.whatsappNumber}`, "mode-changed", {
+      mode: "human",
+      assignedUserId: params.agentUserId
+    });
+    this.realtime?.emit("global", "data-changed", {});
+  }
+};
+
+// src/use-cases/ReleaseConversation.use-case.ts
+var ReleaseConversationUseCase = class {
+  static {
+    __name(this, "ReleaseConversationUseCase");
+  }
+  sessionRepository;
+  realtime;
+  constructor(sessionRepository, realtime) {
+    this.sessionRepository = sessionRepository;
+    this.realtime = realtime;
+  }
+  async execute(params) {
+    await this.sessionRepository.release(params.companyId, params.whatsappNumber);
+    this.realtime?.emit(`conv:${params.whatsappNumber}`, "mode-changed", {
+      mode: "bot",
+      assignedUserId: null
+    });
+    this.realtime?.emit("global", "data-changed", {});
+  }
+};
+
+// src/use-cases/ListConversations.use-case.ts
+var ListConversationsUseCase = class {
+  static {
+    __name(this, "ListConversationsUseCase");
+  }
+  sessionRepository;
+  constructor(sessionRepository) {
+    this.sessionRepository = sessionRepository;
+  }
+  async execute(params) {
+    return this.sessionRepository.listByContextFilters(params.companyId, params.filters ?? {});
+  }
+};
+
+// src/use-cases/ListMessages.use-case.ts
+import { SessionNotFoundError } from "@adatechnology/meta-whatsapp-contracts";
+var ListMessagesUseCase = class {
+  static {
+    __name(this, "ListMessagesUseCase");
+  }
+  sessionRepository;
+  messageRepository;
+  constructor(sessionRepository, messageRepository) {
+    this.sessionRepository = sessionRepository;
+    this.messageRepository = messageRepository;
+  }
+  async execute(params) {
+    const session = await this.sessionRepository.getContext(params.companyId, params.whatsappNumber);
+    if (!session) throw new SessionNotFoundError(params.whatsappNumber);
+    const repoParams = {
+      companyId: params.companyId,
+      sessionId: session.id,
+      limit: params.limit,
+      before: params.before
+    };
+    return this.messageRepository.listByConversation(repoParams);
+  }
+};
+
+// src/use-cases/ExportConversation.use-case.ts
+import { SessionNotFoundError as SessionNotFoundError2 } from "@adatechnology/meta-whatsapp-contracts";
+var ExportConversationUseCase = class {
+  static {
+    __name(this, "ExportConversationUseCase");
+  }
+  sessionRepository;
+  constructor(sessionRepository) {
+    this.sessionRepository = sessionRepository;
+  }
+  async execute(params) {
+    const result = await this.sessionRepository.exportConversation(params.companyId, params.whatsappNumber);
+    if (!result) throw new SessionNotFoundError2(params.whatsappNumber);
+    return result;
+  }
+};
+
+// src/use-cases/FlowGraph.use-cases.ts
+var GetFlowGraphUseCase = class {
+  static {
+    __name(this, "GetFlowGraphUseCase");
+  }
+  flowGraphRepository;
+  constructor(flowGraphRepository) {
+    this.flowGraphRepository = flowGraphRepository;
+  }
+  async execute(params) {
+    return this.flowGraphRepository.get(params.companyId, params.key);
+  }
+};
+var ListFlowGraphsUseCase = class {
+  static {
+    __name(this, "ListFlowGraphsUseCase");
+  }
+  flowGraphRepository;
+  constructor(flowGraphRepository) {
+    this.flowGraphRepository = flowGraphRepository;
+  }
+  async execute(params) {
+    return this.flowGraphRepository.list(params.companyId);
+  }
+};
+var CreateFlowGraphUseCase = class {
+  static {
+    __name(this, "CreateFlowGraphUseCase");
+  }
+  flowGraphRepository;
+  constructor(flowGraphRepository) {
+    this.flowGraphRepository = flowGraphRepository;
+  }
+  async execute(params) {
+    return this.flowGraphRepository.create(params.companyId, params);
+  }
+};
+var SaveFlowGraphUseCase = class {
+  static {
+    __name(this, "SaveFlowGraphUseCase");
+  }
+  flowGraphRepository;
+  constructor(flowGraphRepository) {
+    this.flowGraphRepository = flowGraphRepository;
+  }
+  async execute(params) {
+    return this.flowGraphRepository.save(params.companyId, params.graph, params.expectedVersion);
+  }
+};
+var DeleteFlowGraphUseCase = class {
+  static {
+    __name(this, "DeleteFlowGraphUseCase");
+  }
+  flowGraphRepository;
+  constructor(flowGraphRepository) {
+    this.flowGraphRepository = flowGraphRepository;
+  }
+  async execute(params) {
+    return this.flowGraphRepository.delete(params.companyId, params.key);
+  }
+};
+var GetLiveFlowPositionsUseCase = class {
+  static {
+    __name(this, "GetLiveFlowPositionsUseCase");
+  }
+  flowGraphRepository;
+  constructor(flowGraphRepository) {
+    this.flowGraphRepository = flowGraphRepository;
+  }
+  async execute(params) {
+    return this.flowGraphRepository.getLiveFlowPositions(params.companyId);
+  }
+};
+
+// src/flows/FlowInterpreter.ts
+import { isCrossFlowTarget, crossFlowKey } from "@adatechnology/meta-whatsapp-contracts";
+var DEFAULT_MAX_STEPS = 50;
+function evaluateCondition(node, context) {
+  if (!node.conditionContextKey || !node.conditionOperator || !node.conditionValue) return false;
+  const actual = context[node.conditionContextKey];
+  const expected = node.conditionValue;
+  switch (node.conditionOperator) {
+    case "==":
+      return String(actual) === expected;
+    case "!=":
+      return String(actual) !== expected;
+    case "contains":
+      return typeof actual === "string" && actual.includes(expected);
+    case ">":
+    case ">=":
+    case "<":
+    case "<=": {
+      const actualNum = Number(actual);
+      const expectedNum = Number(expected);
+      if (Number.isNaN(actualNum) || Number.isNaN(expectedNum)) return false;
+      if (node.conditionOperator === ">") return actualNum > expectedNum;
+      if (node.conditionOperator === ">=") return actualNum >= expectedNum;
+      if (node.conditionOperator === "<") return actualNum < expectedNum;
+      return actualNum <= expectedNum;
+    }
+    default:
+      return false;
+  }
+}
+__name(evaluateCondition, "evaluateCondition");
+function resolveNext(node, answerId) {
+  if (!node.next) return void 0;
+  if (typeof node.next === "string") return node.next;
+  if (answerId && node.next.byAnswer[answerId]) return node.next.byAnswer[answerId];
+  return node.next.default;
+}
+__name(resolveNext, "resolveNext");
+var FlowInterpreter = class {
+  static {
+    __name(this, "FlowInterpreter");
+  }
+  actionHandlers = /* @__PURE__ */ new Map();
+  registerFlowAction(kind, handler) {
+    this.actionHandlers.set(kind, handler);
+  }
+  async step(input) {
+    const node = input.graph.nodes[input.currentNodeId];
+    if (!node) return {
+      kind: "terminal",
+      context: input.context
+    };
+    if (node.type === "condition") {
+      const branch = evaluateCondition(node, input.context) ? "true" : "false";
+      return this.moveTo(input, resolveNext(node, branch));
+    }
+    if (node.type === "action") {
+      const handler = node.actionKind ? this.actionHandlers.get(node.actionKind) : void 0;
+      if (!handler) return {
+        kind: "terminal",
+        context: input.context
+      };
+      const result = await handler({
+        node,
+        session: input.session,
+        channel: input.channel,
+        context: input.context
+      });
+      const contextAfterAction = result?.context ? {
+        ...input.context,
+        ...result.context
+      } : input.context;
+      const nextNodeId2 = result?.next ?? resolveNext(node, void 0);
+      return this.moveTo({
+        ...input,
+        context: contextAfterAction
+      }, nextNodeId2);
+    }
+    const isChoice = node.type === "menu" || node.questionType === "choice";
+    if (input.userAnswer === void 0) {
+      return {
+        kind: "awaiting-answer",
+        nodeId: input.currentNodeId,
+        context: input.context
+      };
+    }
+    const updatedContext = node.contextKey ? {
+      ...input.context,
+      [node.contextKey]: input.userAnswer
+    } : input.context;
+    const answerId = isChoice ? input.userAnswer : void 0;
+    const nextNodeId = resolveNext(node, answerId);
+    return this.moveTo({
+      ...input,
+      context: updatedContext
+    }, nextNodeId);
+  }
+  moveTo(input, nextNodeId) {
+    if (!nextNodeId) return {
+      kind: "terminal",
+      context: input.context
+    };
+    if (isCrossFlowTarget(nextNodeId)) return {
+      kind: "cross-flow",
+      flowKey: crossFlowKey(nextNodeId),
+      context: input.context
+    };
+    if (!input.graph.nodes[nextNodeId]) return {
+      kind: "terminal",
+      context: input.context
+    };
+    return {
+      kind: "advanced",
+      nodeId: nextNodeId,
+      context: input.context
+    };
+  }
+  // Avança pelo grafo até parar num ponto que exige algo de fora: uma pergunta esperando resposta
+  // do cliente, o fim do fluxo, ou um salto para outro fluxo. Nós de condição e ação não pedem
+  // input nenhum, então parar neles obrigaria o chamador a reimplementar este laço — e sem
+  // proteção, um grafo com ciclo de condições (A→B→A) o prenderia para sempre.
+  //
+  // O corte por `maxSteps` é uma rede de segurança de runtime, não a defesa principal: um ciclo é
+  // erro de autoria e deveria ser barrado na publicação. Como validateGraph (no editor) hoje
+  // detecta nó inalcançável mas NÃO detecta ciclo, um grafo cíclico é publicável — então o
+  // runtime precisa sobreviver a ele em vez de travar o processo que atende o webhook.
+  async run(input, options) {
+    const maxSteps = options?.maxSteps ?? DEFAULT_MAX_STEPS;
+    const visited = [
+      input.currentNodeId
+    ];
+    let current = input;
+    let steps = 0;
+    while (steps < maxSteps) {
+      const result = await this.step(current);
+      steps++;
+      if (result.kind !== "advanced") return {
+        ...result,
+        visited,
+        steps
+      };
+      visited.push(result.nodeId);
+      current = {
+        ...current,
+        currentNodeId: result.nodeId,
+        context: result.context,
+        userAnswer: void 0
+      };
+    }
+    return {
+      kind: "max-steps-exceeded",
+      context: current.context,
+      visited,
+      steps
+    };
+  }
+};
+
+// src/channel/WhatsAppChannelAdapter.ts
+import { WhatsAppWindowExpiredError as ProviderWindowExpiredError } from "@adatechnology/meta-graph-core";
+import { WindowExpiredError as WindowExpiredError2 } from "@adatechnology/meta-whatsapp-contracts";
+var WhatsAppChannelAdapter = class {
+  static {
+    __name(this, "WhatsAppChannelAdapter");
+  }
+  messages;
+  constructor(messages2) {
+    this.messages = messages2;
+  }
+  async translateErrors(operation) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (error instanceof ProviderWindowExpiredError) throw new WindowExpiredError2();
+      throw error;
+    }
+  }
+  async sendText(to, body) {
+    const result = await this.translateErrors(() => this.messages.sendText(to, body));
+    return {
+      externalMessageId: result.waMessageId
+    };
+  }
+  async sendMedia(params) {
+    const result = await this.translateErrors(() => this.messages.sendMedia(params));
+    return {
+      externalMessageId: result.waMessageId
+    };
+  }
+  async sendTemplate(params) {
+    const result = await this.translateErrors(() => this.messages.sendTemplate(params));
+    return {
+      externalMessageId: result.waMessageId
+    };
+  }
+  async sendInteractiveList(params) {
+    const result = await this.translateErrors(() => this.messages.sendInteractiveList({
+      to: params.to,
+      bodyText: params.body,
+      buttonText: params.buttonLabel,
+      sections: [
+        {
+          title: params.buttonLabel,
+          rows: params.rows
+        }
+      ]
+    }));
+    return {
+      externalMessageId: result.waMessageId
+    };
+  }
+  async fetchMediaAsBase64(mediaId) {
+    return this.translateErrors(() => this.messages.fetchMediaAsBase64(mediaId));
+  }
+};
+
+// src/channel/ReceiveWebhook.use-case.ts
+import { whatsAppWebhookPayloadSchema } from "@adatechnology/meta-whatsapp-contracts";
+
+// src/channel/webhookSecurity.ts
+import { createHmac, timingSafeEqual } from "crypto";
+import { InvalidWebhookSignatureError } from "@adatechnology/meta-whatsapp-contracts";
+var WEBHOOK_NONCE_TTL_SECONDS = 300;
+function safeEqualStrings(left, right) {
+  const leftDigest = createHmac("sha256", "constant-time-compare").update(left).digest();
+  const rightDigest = createHmac("sha256", "constant-time-compare").update(right).digest();
+  return timingSafeEqual(leftDigest, rightDigest);
+}
+__name(safeEqualStrings, "safeEqualStrings");
+function verifyWebhookChallenge(params) {
+  if (params.mode !== "subscribe" || !params.token || !params.challenge) {
+    throw new InvalidWebhookSignatureError();
+  }
+  if (!safeEqualStrings(params.token, params.expectedToken)) {
+    throw new InvalidWebhookSignatureError();
+  }
+  return params.challenge;
+}
+__name(verifyWebhookChallenge, "verifyWebhookChallenge");
+function verifyWebhookSignature(params) {
+  const { rawBody, signatureHeader, appSecret } = params;
+  if (!signatureHeader?.startsWith("sha256=")) throw new InvalidWebhookSignatureError();
+  const expected = createHmac("sha256", appSecret).update(rawBody).digest("hex");
+  const received = signatureHeader.slice("sha256=".length);
+  if (!safeEqualStrings(received, expected)) throw new InvalidWebhookSignatureError();
+}
+__name(verifyWebhookSignature, "verifyWebhookSignature");
+async function claimWebhookDelivery(params) {
+  const key = `meta-whatsapp:webhook:${params.signatureHeader}`;
+  return params.nonceStore.setIfAbsent(key, params.ttlSeconds ?? WEBHOOK_NONCE_TTL_SECONDS);
+}
+__name(claimWebhookDelivery, "claimWebhookDelivery");
+
+// src/channel/ReceiveWebhook.use-case.ts
+function toSessionContract(row) {
+  return {
+    id: row.id,
+    companyId: row.companyId,
+    whatsappNumber: row.whatsappNumber,
+    currentState: row.currentState,
+    context: row.context,
+    mode: row.mode,
+    assignedUserId: row.assignedUserId,
+    humanRequestedAt: row.humanRequestedAt?.toISOString() ?? null,
+    lastInboundAt: row.lastInboundAt?.toISOString() ?? null,
+    lastAgentReadAt: row.lastAgentReadAt?.toISOString() ?? null,
+    lastActivity: row.lastActivity.toISOString(),
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+__name(toSessionContract, "toSessionContract");
+function extractContent(message) {
+  if (message.text?.body) return message.text.body;
+  const interactive = message.interactive;
+  if (interactive?.button_reply) return interactive.button_reply.title || interactive.button_reply.id;
+  if (interactive?.list_reply) return interactive.list_reply.title || interactive.list_reply.id;
+  if (message.order) {
+    const items = message.order.product_items.reduce((sum, item) => sum + item.quantity, 0);
+    return `Pedido: ${items} item(ns)`;
+  }
+  return message.image?.caption ?? message.document?.caption ?? null;
+}
+__name(extractContent, "extractContent");
+function extractAnswer(message) {
+  const interactive = message.interactive;
+  if (interactive?.button_reply) return interactive.button_reply.id;
+  if (interactive?.list_reply) return interactive.list_reply.id;
+  return message.text?.body;
+}
+__name(extractAnswer, "extractAnswer");
+function extractPayload(message) {
+  const payload = {};
+  if (message.interactive) payload["interactive"] = message.interactive;
+  if (message.order) payload["order"] = message.order;
+  if (message.image) payload["image"] = message.image;
+  if (message.audio) payload["audio"] = message.audio;
+  if (message.video) payload["video"] = message.video;
+  if (message.document) payload["document"] = message.document;
+  if (message.sticker) payload["sticker"] = message.sticker;
+  if (message.context?.referred_product) payload["referredProduct"] = message.context.referred_product;
+  return Object.keys(payload).length > 0 ? payload : null;
+}
+__name(extractPayload, "extractPayload");
+var ReceiveWebhookUseCase = class {
+  static {
+    __name(this, "ReceiveWebhookUseCase");
+  }
+  params;
+  constructor(params) {
+    this.params = params;
+  }
+  async execute(input) {
+    verifyWebhookSignature({
+      rawBody: input.rawBody,
+      signatureHeader: input.signatureHeader,
+      appSecret: this.params.appSecret
+    });
+    const claimed = await claimWebhookDelivery({
+      nonceStore: this.params.nonceStore,
+      signatureHeader: input.signatureHeader
+    });
+    if (!claimed) return {
+      duplicate: true,
+      messagesProcessed: 0,
+      statusesProcessed: 0
+    };
+    const rawText = typeof input.rawBody === "string" ? input.rawBody : input.rawBody.toString("utf8");
+    const payload = whatsAppWebhookPayloadSchema.parse(JSON.parse(rawText));
+    let messagesProcessed = 0;
+    let statusesProcessed = 0;
+    for (const entry of payload.entry) {
+      for (const change of entry.changes) {
+        for (const message of change.value.messages ?? []) {
+          await this.handleMessage(input.companyId, message);
+          messagesProcessed++;
+        }
+        for (const status of change.value.statuses ?? []) {
+          await this.handleStatus(input.companyId, status);
+          statusesProcessed++;
+        }
+      }
+    }
+    return {
+      duplicate: false,
+      messagesProcessed,
+      statusesProcessed
+    };
+  }
+  async handleMessage(companyId, message) {
+    const saved = await this.params.logMessage.execute({
+      companyId,
+      whatsappNumber: message.from,
+      direction: "inbound",
+      sender: "customer",
+      type: message.type,
+      content: extractContent(message),
+      payload: extractPayload(message),
+      waMessageId: message.id,
+      status: "received",
+      startState: this.params.startState
+    });
+    if (!saved) return;
+    const sessionRow = await this.params.sessionRepository.getContext(companyId, message.from);
+    if (!sessionRow) return;
+    if (sessionRow.mode === "human") return;
+    const outcome = await this.params.hooks?.onMessageReceived?.(message, toSessionContract(sessionRow));
+    if (outcome?.outcome === "handled") return;
+    void extractAnswer(message);
+  }
+  async handleStatus(companyId, status) {
+    const updated = await this.params.messageRepository.updateMessageStatus(companyId, status.id, status.status);
+    if (!updated) return;
+    this.params.realtime?.emit(`conv:${updated.whatsappNumber}`, "message-status", {
+      waMessageId: status.id,
+      status: status.status
+    });
+    const sessionRow = await this.params.sessionRepository.getContext(companyId, updated.whatsappNumber);
+    await this.params.hooks?.onStatusUpdate?.(status, sessionRow ? toSessionContract(sessionRow) : null);
+  }
+};
+
+// src/channel/IngestInboundMedia.use-case.ts
+import { eq as eq5, and as and4 } from "drizzle-orm";
+var IngestInboundMediaUseCase = class {
+  static {
+    __name(this, "IngestInboundMediaUseCase");
+  }
+  db;
+  channel;
+  objectStorage;
+  constructor(db, channel, objectStorage) {
+    this.db = db;
+    this.channel = channel;
+    this.objectStorage = objectStorage;
+  }
+  async execute(params) {
+    const [message] = await this.db.select().from(messages).where(and4(eq5(messages.companyId, params.companyId), eq5(messages.id, params.messageId))).limit(1);
+    if (!message) throw new Error(`Mensagem ${params.messageId} n\xE3o encontrada para ingest\xE3o de m\xEDdia`);
+    const payload = message.payload ?? {};
+    if (payload["uploadId"] && payload["sourceMediaId"] === params.sourceMediaId) {
+      return {
+        uploadId: String(payload["uploadId"]),
+        alreadyIngested: true
+      };
+    }
+    const { data, mimeType } = await this.channel.fetchMediaAsBase64(params.sourceMediaId);
+    const buffer = Buffer.from(data, "base64");
+    const { uploadId } = await this.objectStorage.upload({
+      buffer,
+      mimeType: mimeType || params.mimeType,
+      key: `meta-whatsapp/${params.companyId}/inbound/${params.sourceMediaId}`
+    });
+    const updatedPayload = {
+      ...payload,
+      uploadId,
+      sourceMediaId: params.sourceMediaId,
+      mimeType: mimeType || params.mimeType,
+      ...params.filename ? {
+        filename: params.filename
+      } : {}
+    };
+    await this.db.update(messages).set({
+      payload: updatedPayload
+    }).where(and4(eq5(messages.companyId, params.companyId), eq5(messages.id, params.messageId)));
+    return {
+      uploadId,
+      alreadyIngested: false
+    };
+  }
+};
+function extractMediaDescriptor(message) {
+  const payload = message.payload ?? {};
+  for (const key of [
+    "image",
+    "audio",
+    "video",
+    "document",
+    "sticker"
+  ]) {
+    const media = payload[key];
+    if (media?.id) {
+      return {
+        sourceMediaId: media.id,
+        mimeType: media.mime_type ?? "application/octet-stream",
+        filename: media.filename
+      };
+    }
+  }
+  return void 0;
+}
+__name(extractMediaDescriptor, "extractMediaDescriptor");
+
+// src/createMetaWhatsAppModule.ts
+function createMetaWhatsAppModule(params) {
+  const { db, config, nonceStore, providers = {}, hooks } = params;
+  const startState = params.startState ?? "start";
+  const flowEngineEnabled = params.features?.flowEngine ?? true;
+  const messageProvider = new WhatsAppMessageProvider({
+    accessToken: config.accessToken,
+    phoneNumberId: config.phoneNumberId,
+    wabaId: config.wabaId,
+    apiVersion: config.apiVersion,
+    baseUrl: config.baseUrl
+  });
+  const channel = new WhatsAppChannelAdapter(messageProvider);
+  const sessionRepository = new SessionRepository(db);
+  const messageRepository = new MessageRepository(db);
+  const settingsRepository = new SettingsRepository(db);
+  const flowGraphRepository = new FlowGraphRepository(db);
+  const logMessage = new LogMessageUseCase(sessionRepository, messageRepository, providers.realtime);
+  const sendMessage = new SendMessageUseCase(channel, sessionRepository, logMessage, providers.objectStorage);
+  const receiveWebhook = new ReceiveWebhookUseCase({
+    appSecret: config.appSecret,
+    nonceStore,
+    sessionRepository,
+    messageRepository,
+    logMessage,
+    startState,
+    hooks,
+    realtime: providers.realtime
+  });
+  const flowInterpreter = flowEngineEnabled ? new FlowInterpreter() : void 0;
+  const ingestInboundMedia = providers.objectStorage ? new IngestInboundMediaUseCase(db, channel, providers.objectStorage) : void 0;
+  return {
+    channel,
+    // undefined quando providers.objectStorage não foi injetado.
+    ingestInboundMedia,
+    conversations: {
+      log: logMessage,
+      send: sendMessage,
+      takeover: new TakeoverConversationUseCase(sessionRepository, providers.realtime),
+      release: new ReleaseConversationUseCase(sessionRepository, providers.realtime),
+      list: new ListConversationsUseCase(sessionRepository),
+      listMessages: new ListMessagesUseCase(sessionRepository, messageRepository),
+      export: new ExportConversationUseCase(sessionRepository),
+      repository: sessionRepository
+    },
+    settings: settingsRepository,
+    webhook: {
+      receive: receiveWebhook,
+      // GET de verificação da Meta — o host liga na sua rota e devolve o retorno como texto puro.
+      verifyChallenge: /* @__PURE__ */ __name((query) => verifyWebhookChallenge({
+        ...query,
+        expectedToken: config.webhookVerifyToken
+      }), "verifyChallenge")
+    },
+    // undefined quando features.flowEngine === false.
+    flows: flowInterpreter ? {
+      interpreter: flowInterpreter,
+      registerFlowAction: /* @__PURE__ */ __name((kind, handler) => flowInterpreter.registerFlowAction(kind, handler), "registerFlowAction"),
+      get: new GetFlowGraphUseCase(flowGraphRepository),
+      list: new ListFlowGraphsUseCase(flowGraphRepository),
+      create: new CreateFlowGraphUseCase(flowGraphRepository),
+      save: new SaveFlowGraphUseCase(flowGraphRepository),
+      delete: new DeleteFlowGraphUseCase(flowGraphRepository),
+      livePositions: new GetLiveFlowPositionsUseCase(flowGraphRepository),
+      repository: flowGraphRepository
+    } : void 0,
+    catalog: providers.catalog
+  };
+}
+__name(createMetaWhatsAppModule, "createMetaWhatsAppModule");
+
+// src/runMigrations.ts
+import { join } from "path";
+import { migrate } from "drizzle-orm/bun-sql/migrator";
+async function runMetaWhatsAppMigrations(db) {
+  await migrate(db, {
+    migrationsFolder: join(__dirname, "migrations"),
+    migrationsTable: "meta_whatsapp_migrations"
+  });
+}
+__name(runMetaWhatsAppMigrations, "runMetaWhatsAppMigrations");
+
+// src/realtime/SseHub.ts
+import { randomUUID } from "crypto";
+var TICKET_TTL_SECONDS = 60;
+var SseHub = class {
+  static {
+    __name(this, "SseHub");
+  }
+  relay;
+  localListeners = /* @__PURE__ */ new Map();
+  // Uma assinatura de relay por CANAL, compartilhada por todos os listeners locais dele — uma
+  // por listener faria o relay entregar N cópias num canal com N conexões abertas.
+  relaySubscriptions = /* @__PURE__ */ new Map();
+  // Identifica esta instância do processo para descartar o próprio eco (pub/sub entrega a
+  // mensagem a todos os inscritos, inclusive quem publicou).
+  instanceId = randomUUID();
+  constructor(relay) {
+    this.relay = relay;
+  }
+  emit(channel, event, payload) {
+    this.dispatchLocal(channel, event, payload);
+    if (this.relay) {
+      const envelope = {
+        originId: this.instanceId,
+        event,
+        payload
+      };
+      this.relay.publish(channel, JSON.stringify(envelope)).catch(() => void 0);
+    }
+  }
+  dispatchLocal(channel, event, payload) {
+    const listeners = this.localListeners.get(channel);
+    if (!listeners) return;
+    for (const listener of listeners) listener(event, payload);
+  }
+  async subscribe(channel, listener) {
+    if (!this.localListeners.has(channel)) this.localListeners.set(channel, /* @__PURE__ */ new Set());
+    this.localListeners.get(channel).add(listener);
+    if (this.relay && !this.relaySubscriptions.has(channel)) {
+      this.relaySubscriptions.set(channel, this.relay.subscribe(channel, (message) => {
+        try {
+          const envelope = JSON.parse(message);
+          if (envelope.originId === this.instanceId) return;
+          this.dispatchLocal(channel, envelope.event, envelope.payload);
+        } catch {
+        }
+      }));
+    }
+    return () => {
+      const listeners = this.localListeners.get(channel);
+      listeners?.delete(listener);
+      if (listeners && listeners.size === 0) {
+        this.localListeners.delete(channel);
+        const pendingUnsubscribe = this.relaySubscriptions.get(channel);
+        this.relaySubscriptions.delete(channel);
+        pendingUnsubscribe?.then((unsubscribe) => unsubscribe()).catch(() => void 0);
+      }
+    };
+  }
+};
+async function issueSseTicket(store, companyId, whatsappNumber) {
+  const ticket = randomUUID();
+  await store.set(`sse:ticket:${ticket}`, JSON.stringify({
+    companyId,
+    whatsappNumber
+  }), TICKET_TTL_SECONDS);
+  return ticket;
+}
+__name(issueSseTicket, "issueSseTicket");
+async function redeemSseTicket(store, ticket) {
+  const raw = await store.get(`sse:ticket:${ticket}`);
+  if (!raw) return null;
+  await store.delete(`sse:ticket:${ticket}`);
+  return JSON.parse(raw);
+}
+__name(redeemSseTicket, "redeemSseTicket");
+export {
+  CreateFlowGraphUseCase,
+  DeleteFlowGraphUseCase,
+  ExportConversationUseCase,
+  FlowGraphRepository,
+  FlowInterpreter,
+  GetFlowGraphUseCase,
+  GetLiveFlowPositionsUseCase,
+  IngestInboundMediaUseCase,
+  InvalidFlowGraphError,
+  ListConversationsUseCase,
+  ListFlowGraphsUseCase,
+  ListMessagesUseCase,
+  LogMessageUseCase,
+  MessageRepository,
+  OptimisticLockError,
+  ReceiveWebhookUseCase,
+  ReleaseConversationUseCase,
+  SaveFlowGraphUseCase,
+  SendMessageUseCase,
+  SessionRepository,
+  SettingsRepository,
+  SseHub,
+  TakeoverConversationUseCase,
+  WEBHOOK_NONCE_TTL_SECONDS,
+  WhatsAppChannelAdapter,
+  claimWebhookDelivery,
+  createMetaWhatsAppModule,
+  extractMediaDescriptor,
+  flowGraphs,
+  issueSseTicket,
+  messages,
+  metaWhatsAppSchema,
+  redeemSseTicket,
+  runMetaWhatsAppMigrations,
+  sessions,
+  settings,
+  verifyWebhookChallenge,
+  verifyWebhookSignature
+};
+//# sourceMappingURL=index.js.map