@adatechnology/meta-whatsapp-module 0.2.0-rc.8 → 0.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 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
+// ../../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.40_@swc+helpers@0.5.23__jiti@2.7.0_postcss@8.5.26_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");
@@ -10,6 +10,7 @@ var __dirname = /* @__PURE__ */ getDirname();
 
 // src/createMetaWhatsAppModule.ts
 import { WhatsAppMessageProvider } from "@adatechnology/meta-whatsapp-provider";
+import { FLOW_ACTION_KIND } from "@adatechnology/meta-whatsapp-contracts";
 
 // src/repositories/SessionRepository.ts
 import { and, desc, eq, sql as sql2 } from "drizzle-orm";
@@ -106,6 +107,33 @@ var messages = metaWhatsAppSchema.table("messages", {
   readAt: timestamp("read_at", {
     withTimezone: true
   }),
+  // Moderação de conteúdo. `null` significa NÃO AVALIADO (moderação desligada, ou mensagem
+  // anterior ao recurso) — diferente de `false`, que é avaliado e limpo. Colunas em vez de chave
+  // dentro de `payload` porque "listar o que foi sinalizado" é consulta de operação, e índice
+  // parcial sobre boolean resolve isso sem cavar jsonb.
+  moderationFlagged: boolean("moderation_flagged"),
+  moderationTerms: jsonb("moderation_terms").$type(),
+  /**
+   * Transcrição de áudio. `null` em `transcription_status` significa NÃO AVALIADO — áudio nunca
+   * pedido (modo sob demanda), transcrição desligada, mensagem anterior ao recurso, ou mensagem
+   * que não é áudio. Diferente de `'done'` com texto vazio, que é áudio em silêncio já processado
+   * e que NÃO deve ser reprocessado.
+   *
+   * Colunas em vez de chave em `payload` pelo mesmo motivo da moderação: "quais áudios ficaram
+   * pendentes" e "quais falharam" são consultas de operação, e índice parcial resolve sem cavar
+   * jsonb. Buscar texto de áudio também deixa de exigir varredura de payload.
+   */
+  transcriptionStatus: varchar("transcription_status", {
+    length: 16
+  }).$type(),
+  transcriptionText: text("transcription_text"),
+  transcriptionLanguage: varchar("transcription_language", {
+    length: 32
+  }),
+  /** Qual engine produziu. Com uma cadeia de engines, é o que responde "por que esta saiu ruim". */
+  transcriptionEngine: varchar("transcription_engine", {
+    length: 32
+  }),
   createdAt: timestamp("created_at", {
     withTimezone: true
   }).notNull().defaultNow()
@@ -117,7 +145,54 @@ var messages = metaWhatsAppSchema.table("messages", {
   // 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`)
+  uniqueIndex("idx_messages_company_wa_message_id").on(table.companyId, table.waMessageId).where(sql`${table.waMessageId} is not null`),
+  // Parcial: só as sinalizadas entram, então o índice fica do tamanho do problema e não do
+  // tamanho do transcript.
+  index("idx_messages_moderation_flagged").on(table.companyId, table.createdAt).where(sql`${table.moderationFlagged}`),
+  // Alimenta a varredura de retomada: "quais áudios ficaram pendentes de transcrição". Parcial
+  // porque pendente é estado transitório e raro — o índice fica do tamanho da fila atrasada, não
+  // do transcript inteiro.
+  index("idx_messages_transcription_pending").on(table.companyId, table.createdAt).where(sql`${table.transcriptionStatus} = 'pending'`)
+]);
+var documents = metaWhatsAppSchema.table("documents", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  companyId: uuid("company_id").notNull(),
+  sessionId: uuid("session_id").notNull().references(() => sessions.id, {
+    onDelete: "cascade"
+  }),
+  // Anulável e `set null`: apagar a mensagem não deve apagar o arquivo da biblioteca, e arquivo
+  // do atendente nasce sem mensagem.
+  messageId: uuid("message_id").references(() => messages.id, {
+    onDelete: "set null"
+  }),
+  uploadId: varchar("upload_id", {
+    length: 256
+  }).notNull(),
+  filename: varchar("filename", {
+    length: 512
+  }).notNull(),
+  mimeType: varchar("mime_type", {
+    length: 128
+  }).notNull(),
+  sizeBytes: integer("size_bytes").notNull(),
+  // Do provider de storage, que é endereçado por conteúdo — serve para reconciliar storage
+  // contra tabela e para detectar o mesmo binário chegando duas vezes.
+  sha256: varchar("sha256", {
+    length: 64
+  }),
+  source: varchar("source", {
+    length: 12
+  }).notNull(),
+  linkedAt: timestamp("linked_at", {
+    withTimezone: true
+  }).notNull().defaultNow()
+}, (table) => [
+  index("idx_documents_session_linked").on(table.sessionId, table.linkedAt),
+  // Para varredura de retenção por idade sem passar por sessão.
+  index("idx_documents_company_linked").on(table.companyId, table.linkedAt),
+  // O mesmo objeto não pode ser linkado duas vezes na mesma empresa: o job de ingestão é
+  // reentregue por retry, e sem isto a reentrega criaria linha duplicada no painel.
+  uniqueIndex("idx_documents_company_upload").on(table.companyId, table.uploadId)
 ]);
 var flowGraphs = metaWhatsAppSchema.table("flow_graphs", {
   id: uuid("id").primaryKey().defaultRandom(),
@@ -148,6 +223,54 @@ var flowGraphs = metaWhatsAppSchema.table("flow_graphs", {
 }, (table) => [
   uniqueIndex("idx_flow_graphs_company_key").on(table.companyId, table.key)
 ]);
+var flowMedia = metaWhatsAppSchema.table("flow_media", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  companyId: uuid("company_id").notNull(),
+  flowKey: varchar("flow_key", {
+    length: 64
+  }).notNull(),
+  nodeId: varchar("node_id", {
+    length: 64
+  }).notNull(),
+  uploadId: varchar("upload_id", {
+    length: 256
+  }).notNull(),
+  filename: varchar("filename", {
+    length: 512
+  }).notNull(),
+  mimeType: varchar("mime_type", {
+    length: 128
+  }).notNull(),
+  sizeBytes: integer("size_bytes").notNull(),
+  // Legenda da mídia no WhatsApp. Por arquivo, não por nó: um nó que manda tabela de preços e
+  // um folder precisa de textos diferentes para cada um.
+  caption: text("caption"),
+  // Ordem de envio dentro do nó — o cliente recebe as mensagens em sequência, e "tabela antes
+  // do folder" é decisão de quem edita, não do banco.
+  sortOrder: integer("sort_order").notNull().default(0),
+  // Desligar sem desanexar: trocar o material da campanha é o caso comum, e apagar a linha
+  // perderia a ordem e a legenda já ajustadas.
+  active: boolean("active").notNull().default(true),
+  // Id do arquivo já subido para a Meta, por número remetente. Sem isto, o MESMO binário subia de
+  // novo para cada cliente que passava pelo nó: a Meta aceita reusar o id por 30 dias.
+  //
+  // Mapa por `phone_number_id`, e não coluna única: o id é escopado ao número que envia, e uma
+  // instalação com dois números mandaria o id de um pelo outro. A validade não é gravada de
+  // propósito — confiar em "30 dias" calculados erra nos casos de borda, e quem decide é a
+  // recusa da Meta, que devolve ao caminho de subir o binário.
+  metaMediaIds: jsonb("meta_media_ids").$type().notNull().default({}),
+  createdAt: timestamp("created_at", {
+    withTimezone: true
+  }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", {
+    withTimezone: true
+  }).notNull().defaultNow()
+}, (table) => [
+  index("idx_flow_media_node").on(table.companyId, table.flowKey, table.nodeId, table.sortOrder),
+  // O mesmo arquivo anexado duas vezes ao MESMO nó é erro de clique no editor, e o cliente
+  // receberia o documento repetido.
+  uniqueIndex("idx_flow_media_node_upload").on(table.companyId, table.flowKey, table.nodeId, table.uploadId)
+]);
 var settings = metaWhatsAppSchema.table("settings", {
   companyId: uuid("company_id").primaryKey(),
   templateName: varchar("template_name", {
@@ -160,6 +283,15 @@ var settings = metaWhatsAppSchema.table("settings", {
   templateVariables: jsonb("template_variables").$type().notNull().default([]),
   welcomeMessage: text("welcome_message"),
   farewellMessage: text("farewell_message"),
+  /**
+  * Política de transcrição desta empresa. Nulo é significativo: "o painel não decidiu", e aí vale
+  * o padrão que o host injetou. Sem a distinção, atualizar o módulo desligaria a transcrição de
+  * quem já a tinha ligada por ambiente.
+  */
+  transcriptionEnabled: boolean("transcription_enabled"),
+  transcriptionMode: varchar("transcription_mode", {
+    length: 16
+  }).$type(),
   createdAt: timestamp("created_at", {
     withTimezone: true
   }).notNull().defaultNow(),
@@ -191,6 +323,10 @@ var conversationSummaryProjection = {
       and (${sessions}.last_agent_read_at is null or m.created_at > ${sessions}.last_agent_read_at)
   )`
 };
+function sessionContextPatch(patch) {
+  return sql2`${sessions.context} || ${JSON.stringify(patch)}::jsonb`;
+}
+__name(sessionContextPatch, "sessionContextPatch");
 var SessionRepository = class {
   static {
     __name(this, "SessionRepository");
@@ -221,6 +357,9 @@ var SessionRepository = class {
     }).returning();
     return created;
   }
+  // O `context` jsonb é o ponto de extensão oficial para estado de sessão por produto: o módulo
+  // não conhece a forma, o consumidor a declara em TSessionContext. Este setter SUBSTITUI o
+  // objeto inteiro — para acumular respostas ao longo da conversa use patchContext.
   async setState(companyId, whatsappNumber, state, context) {
     await this.db.update(sessions).set({
       currentState: state,
@@ -231,6 +370,25 @@ var SessionRepository = class {
       updatedAt: sql2`now()`
     }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
   }
+  // Mescla parcial do context, feita no banco (`||`) e não por read-modify-write no host: duas
+  // mensagens do mesmo cliente processadas em paralelo sobrescreveriam uma à outra, e o campo
+  // acumula justamente as respostas coletadas ao longo da conversa. Chave presente no patch
+  // vence a existente; as demais permanecem.
+  async patchContext(companyId, whatsappNumber, patch) {
+    await this.db.update(sessions).set({
+      context: sessionContextPatch(patch),
+      lastActivity: sql2`now()`,
+      updatedAt: sql2`now()`
+    }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
+  }
+  // Leitura tipada do estado de sessão do produto. Devolve undefined quando a sessão não existe —
+  // distinto de existir com context vazio, que devolve o objeto vazio.
+  async readContext(companyId, whatsappNumber) {
+    const [row] = await this.db.select({
+      context: sessions.context
+    }).from(sessions).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber))).limit(1);
+    return row?.context;
+  }
   // 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) {
@@ -273,6 +431,16 @@ var SessionRepository = class {
   async release(companyId, whatsappNumber) {
     await this.setMode(companyId, whatsappNumber, "bot", null);
   }
+  /**
+  * Apaga a sessão; a cascata das FKs leva mensagens e documentos.
+  *
+  * Não apaga o binário no storage — isso é passo de aplicação, e é por isso que este método é
+  * chamado por `DeleteConversationUseCase` e não diretamente pelo host. Chamar daqui sem apagar os
+  * objetos antes deixa mídia órfã sendo cobrada para sempre.
+  */
+  async deleteByNumber(companyId, whatsappNumber) {
+    await this.db.delete(sessions).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
+  }
   async requestHuman(companyId, whatsappNumber) {
     await this.db.update(sessions).set({
       humanRequestedAt: sql2`now()`,
@@ -371,7 +539,9 @@ var MessageRepository = class {
       content: params.content ?? null,
       payload: params.payload ?? null,
       waMessageId: params.waMessageId ?? null,
-      status: params.status ?? null
+      status: params.status ?? null,
+      moderationFlagged: params.moderationFlagged ?? null,
+      moderationTerms: params.moderationTerms ?? null
     };
     const [created] = await this.db.insert(messages).values(values).onConflictDoNothing().returning();
     return created;
@@ -385,6 +555,58 @@ var MessageRepository = class {
     }).where(and2(eq2(messages.companyId, companyId), eq2(messages.waMessageId, waMessageId))).returning();
     return updated;
   }
+  /**
+  * Grava a transcrição endereçando pelo id da Meta, para quem só tem esse.
+  *
+  * Serve ao caso em que a transcrição acontece no próprio webhook — o grafo precisa do texto para
+  * responder ao cliente, e jogar fora o que ele já pagou para transcrever significaria transcrever
+  * o mesmo áudio uma segunda vez só para o painel ver.
+  *
+  * Devolve `undefined` quando não achou a mensagem: entrega duplicada e mensagem apagada são
+  * corridas normais, não erro.
+  */
+  async saveTranscriptionByWaMessageId(params) {
+    const [updated] = await this.db.update(messages).set({
+      transcriptionStatus: params.status,
+      ...params.text !== void 0 ? {
+        transcriptionText: params.text
+      } : {},
+      ...params.language !== void 0 ? {
+        transcriptionLanguage: params.language
+      } : {},
+      ...params.engine !== void 0 ? {
+        transcriptionEngine: params.engine
+      } : {}
+    }).where(and2(eq2(messages.companyId, params.companyId), eq2(messages.waMessageId, params.waMessageId))).returning();
+    return updated;
+  }
+  async findById(companyId, messageId) {
+    const [found] = await this.db.select().from(messages).where(and2(eq2(messages.companyId, companyId), eq2(messages.id, messageId))).limit(1);
+    return found;
+  }
+  /**
+  * Grava o resultado da transcrição. Devolve `undefined` quando a mensagem não existe (apagada
+  * entre o enfileiramento e a execução do job) — não é erro, é corrida normal.
+  *
+  * `text`/`language`/`engine` só são tocados quando informados: uma retentativa que volta a falhar
+  * atualiza o status sem apagar a transcrição parcial de uma tentativa anterior que tenha vindo de
+  * outro engine da cadeia.
+  */
+  async saveTranscription(params) {
+    const [updated] = await this.db.update(messages).set({
+      transcriptionStatus: params.status,
+      ...params.text !== void 0 ? {
+        transcriptionText: params.text
+      } : {},
+      ...params.language !== void 0 ? {
+        transcriptionLanguage: params.language
+      } : {},
+      ...params.engine !== void 0 ? {
+        transcriptionEngine: params.engine
+      } : {}
+    }).where(and2(eq2(messages.companyId, params.companyId), eq2(messages.id, params.messageId))).returning();
+    return updated;
+  }
   async listByConversation(params) {
     const conditions = [
       eq2(messages.companyId, params.companyId),
@@ -434,12 +656,21 @@ var FlowGraphRepository = class {
     __name(this, "FlowGraphRepository");
   }
   db;
-  constructor(db) {
+  cache;
+  // Cache opcional: sem ele o repositório se comporta exatamente como antes, lendo sempre do
+  // banco. É o host que decide se quer cachear e com qual provedor (ver CacheInterface).
+  constructor(db, cache) {
     this.db = db;
+    this.cache = cache;
   }
   async get(companyId, key) {
+    const cached = await this.cache?.read(companyId, key);
+    if (cached) return cached;
     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;
+    if (!row) return void 0;
+    const graph = toContractGraph(row);
+    await this.cache?.write(companyId, graph);
+    return graph;
   }
   async list(companyId) {
     const rows = await this.db.select().from(flowGraphs).where(eq3(flowGraphs.companyId, companyId));
@@ -469,7 +700,9 @@ var FlowGraphRepository = class {
       showInMenu: graph.showInMenu ?? false,
       menuOptionLabel: graph.menuOptionLabel
     }).returning();
-    return toContractGraph(created);
+    const createdGraph = toContractGraph(created);
+    await this.cache?.invalidate(companyId, createdGraph.key);
+    return createdGraph;
   }
   // 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).
@@ -483,10 +716,12 @@ var FlowGraphRepository = class {
       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);
+    await this.cache?.invalidate(companyId, 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)));
+    await this.cache?.invalidate(companyId, key);
   }
   // T4.2 — GetLiveFlowPositions: agrega sessões ativas por (flowKey, currentNodeId), lendo as
   // colunas dedicadas gravadas por SessionRepository.setFlowPosition. Agrega no banco (GROUP BY,
@@ -506,6 +741,48 @@ var FlowGraphRepository = class {
   }
 };
 
+// src/repositories/FlowGraphCache.ts
+var KEY_PREFIX = "meta-whatsapp:flow-graph";
+var DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS = 300;
+var FlowGraphCache = class {
+  static {
+    __name(this, "FlowGraphCache");
+  }
+  provider;
+  ttlSeconds;
+  constructor(provider, ttlSeconds = DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS) {
+    this.provider = provider;
+    this.ttlSeconds = ttlSeconds;
+  }
+  // companyId na chave, e não só a flowKey: a chave do fluxo é escolhida por quem edita e se
+  // repete entre empresas — 'consorcio' existe em todas — então uma chave sem tenant serviria o
+  // grafo de uma empresa para a conversa de outra.
+  keyFor(companyId, flowKey) {
+    return `${KEY_PREFIX}:${companyId}:${flowKey}`;
+  }
+  async read(companyId, flowKey) {
+    try {
+      const cached = await this.provider.get(this.keyFor(companyId, flowKey));
+      if (!cached) return void 0;
+      return JSON.parse(cached);
+    } catch {
+      return void 0;
+    }
+  }
+  async write(companyId, graph) {
+    try {
+      await this.provider.set(this.keyFor(companyId, graph.key), JSON.stringify(graph), this.ttlSeconds);
+    } catch {
+    }
+  }
+  async invalidate(companyId, flowKey) {
+    try {
+      await this.provider.delete(this.keyFor(companyId, flowKey));
+    } catch {
+    }
+  }
+};
+
 // src/repositories/SettingsRepository.ts
 import { eq as eq4 } from "drizzle-orm";
 function toContractSettings(row) {
@@ -514,7 +791,11 @@ function toContractSettings(row) {
     templateLanguage: row.templateLanguage,
     templateVariables: row.templateVariables,
     welcomeMessage: row.welcomeMessage ?? "",
-    farewellMessage: row.farewellMessage ?? ""
+    farewellMessage: row.farewellMessage ?? "",
+    // `?? null` e não `?? false`: nulo é "o painel não decidiu", e é o que faz valer o padrão do
+    // host. Colapsar para `false` desligaria quem ligou por ambiente.
+    transcriptionEnabled: row.transcriptionEnabled ?? null,
+    transcriptionMode: row.transcriptionMode ?? null
   };
 }
 __name(toContractSettings, "toContractSettings");
@@ -523,7 +804,9 @@ var EMPTY_SETTINGS = {
   templateLanguage: "pt_BR",
   templateVariables: [],
   welcomeMessage: "",
-  farewellMessage: ""
+  farewellMessage: "",
+  transcriptionEnabled: null,
+  transcriptionMode: null
 };
 var SettingsRepository = class {
   static {
@@ -552,7 +835,12 @@ var SettingsRepository = class {
       templateLanguage: merged.templateLanguage,
       templateVariables: merged.templateVariables,
       welcomeMessage: merged.welcomeMessage || null,
-      farewellMessage: merged.farewellMessage || null
+      farewellMessage: merged.farewellMessage || null,
+      // Sem `|| null`: `false` aqui é decisão explícita do painel ("desligado para esta empresa"),
+      // e colapsá-lo para nulo faria a empresa voltar a herdar o padrão do host — exatamente o
+      // oposto do que o operador acabou de pedir.
+      transcriptionEnabled: merged.transcriptionEnabled,
+      transcriptionMode: merged.transcriptionMode
     }).onConflictDoUpdate({
       target: settings.companyId,
       set: {
@@ -561,6 +849,8 @@ var SettingsRepository = class {
         templateVariables: merged.templateVariables,
         welcomeMessage: merged.welcomeMessage || null,
         farewellMessage: merged.farewellMessage || null,
+        transcriptionEnabled: merged.transcriptionEnabled,
+        transcriptionMode: merged.transcriptionMode,
         updatedAt: /* @__PURE__ */ new Date()
       }
     }).returning();
@@ -587,16 +877,19 @@ var LogMessageUseCase = class {
   sessionRepository;
   messageRepository;
   realtime;
-  constructor(sessionRepository, messageRepository, realtime) {
+  moderator;
+  constructor(sessionRepository, messageRepository, realtime, moderator) {
     this.sessionRepository = sessionRepository;
     this.messageRepository = messageRepository;
     this.realtime = realtime;
+    this.moderator = moderator;
   }
   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
+      sessionId: session.id,
+      ...this.moderationOf(params)
     });
     if (!saved) return void 0;
     if (params.direction === "inbound") {
@@ -609,6 +902,20 @@ var LogMessageUseCase = class {
     this.realtime?.emit("global", "data-changed", {});
     return saved;
   }
+  // Só o que o cliente escreveu: marcar o que o próprio atendente ou o bot enviou não sinaliza
+  // abuso, apenas sujaria o transcript com etiqueta na resposta de quem atende.
+  moderationOf(params) {
+    if (!this.moderator || params.direction !== "inbound") return {};
+    const text2 = params.content?.trim();
+    if (!text2) return {};
+    const verdict = this.moderator.inspect(text2);
+    return {
+      moderationFlagged: verdict.isOffensive,
+      moderationTerms: verdict.isOffensive ? [
+        ...verdict.matchedTerms
+      ] : null
+    };
+  }
 };
 
 // src/use-cases/SendMessage.use-case.ts
@@ -622,11 +929,13 @@ var SendMessageUseCase = class {
   sessionRepository;
   logMessage;
   objectStorage;
-  constructor(channel, sessionRepository, logMessage, objectStorage) {
+  documentRepository;
+  constructor(channel, sessionRepository, logMessage, objectStorage, documentRepository) {
     this.channel = channel;
     this.sessionRepository = sessionRepository;
     this.logMessage = logMessage;
     this.objectStorage = objectStorage;
+    this.documentRepository = documentRepository;
   }
   async assertWithinWindow(companyId, whatsappNumber) {
     const hours = await this.sessionRepository.hoursSinceLastInbound(companyId, whatsappNumber);
@@ -663,7 +972,7 @@ var SendMessageUseCase = class {
       mimeType: params.mimeType,
       key: `meta-whatsapp/${params.companyId}/${Date.now()}-${params.filename}`
     })).uploadId : void 0;
-    return this.logMessage.execute({
+    const saved = await this.logMessage.execute({
       companyId: params.companyId,
       whatsappNumber: params.whatsappNumber,
       direction: "outbound",
@@ -682,6 +991,19 @@ var SendMessageUseCase = class {
       status: "sent",
       startState: params.startState
     });
+    if (saved && uploadId) {
+      await this.documentRepository?.link({
+        companyId: params.companyId,
+        sessionId: saved.sessionId,
+        messageId: saved.id,
+        uploadId,
+        filename: params.filename,
+        mimeType: params.mimeType,
+        sizeBytes: params.buffer.length,
+        source: params.sender
+      });
+    }
+    return saved;
   }
   // Template é o único envio que ignora a janela — é justamente o mecanismo que a Meta oferece
   // para reabri-la.
@@ -799,8 +1121,330 @@ var ListMessagesUseCase = class {
   }
 };
 
-// src/use-cases/ExportConversation.use-case.ts
+// src/use-cases/ListConversationDocuments.use-case.ts
 import { SessionNotFoundError as SessionNotFoundError2 } from "@adatechnology/meta-whatsapp-contracts";
+var ListConversationDocumentsUseCase = class {
+  static {
+    __name(this, "ListConversationDocumentsUseCase");
+  }
+  sessionRepository;
+  documentRepository;
+  constructor(sessionRepository, documentRepository) {
+    this.sessionRepository = sessionRepository;
+    this.documentRepository = documentRepository;
+  }
+  async execute(params) {
+    const session = await this.sessionRepository.getContext(params.companyId, params.whatsappNumber);
+    if (!session) throw new SessionNotFoundError2(params.whatsappNumber);
+    const { rows, total } = await this.documentRepository.listByConversation({
+      companyId: params.companyId,
+      sessionId: session.id,
+      ...params.search ? {
+        search: params.search
+      } : {},
+      ...params.sources && params.sources.length > 0 ? {
+        sources: params.sources
+      } : {},
+      ...params.sortDirection ? {
+        sortDirection: params.sortDirection
+      } : {},
+      ...params.page ? {
+        page: params.page
+      } : {},
+      ...params.limit ? {
+        limit: params.limit
+      } : {}
+    });
+    return {
+      documents: rows.map((row) => ({
+        id: row.uploadId,
+        filename: row.filename,
+        mimeType: row.mimeType,
+        sizeBytes: row.sizeBytes,
+        source: row.source,
+        linkedAt: row.linkedAt.toISOString()
+      })),
+      total
+    };
+  }
+};
+
+// src/use-cases/ListCompanyDocuments.use-case.ts
+var ListCompanyDocumentsUseCase = class {
+  static {
+    __name(this, "ListCompanyDocumentsUseCase");
+  }
+  documentRepository;
+  constructor(documentRepository) {
+    this.documentRepository = documentRepository;
+  }
+  async execute(params) {
+    const { rows, total } = await this.documentRepository.listByCompany({
+      companyId: params.companyId,
+      ...params.search ? {
+        search: params.search
+      } : {},
+      ...params.sources && params.sources.length > 0 ? {
+        sources: params.sources
+      } : {},
+      ...params.sortDirection ? {
+        sortDirection: params.sortDirection
+      } : {},
+      ...params.page ? {
+        page: params.page
+      } : {},
+      ...params.limit ? {
+        limit: params.limit
+      } : {}
+    });
+    return {
+      documents: rows.map((row) => ({
+        id: row.uploadId,
+        conversationId: row.whatsappNumber,
+        filename: row.filename,
+        mimeType: row.mimeType,
+        sizeBytes: row.sizeBytes,
+        source: row.source,
+        linkedAt: row.linkedAt.toISOString()
+      })),
+      total
+    };
+  }
+};
+
+// src/use-cases/DeleteConversation.use-case.ts
+import { SessionNotFoundError as SessionNotFoundError3 } from "@adatechnology/meta-whatsapp-contracts";
+var DeleteConversationUseCase = class {
+  static {
+    __name(this, "DeleteConversationUseCase");
+  }
+  sessionRepository;
+  documentRepository;
+  objectStorage;
+  constructor(sessionRepository, documentRepository, objectStorage) {
+    this.sessionRepository = sessionRepository;
+    this.documentRepository = documentRepository;
+    this.objectStorage = objectStorage;
+  }
+  async execute(params) {
+    const session = await this.sessionRepository.getContext(params.companyId, params.whatsappNumber);
+    if (!session) throw new SessionNotFoundError3(params.whatsappNumber);
+    const uploadIds = await this.documentRepository.listUploadIdsBySession(params.companyId, session.id);
+    if (uploadIds.length > 0 && !this.objectStorage?.delete) {
+      throw new Error("storage_delete_unsupported: a conversa tem arquivos e o storage injetado n\xE3o implementa delete");
+    }
+    const failedObjects = [];
+    let deletedObjects = 0;
+    for (const uploadId of uploadIds) {
+      try {
+        await this.objectStorage?.delete?.(uploadId);
+        deletedObjects++;
+      } catch {
+        failedObjects.push(uploadId);
+      }
+    }
+    if (failedObjects.length > 0) return {
+      deletedObjects,
+      failedObjects
+    };
+    await this.sessionRepository.deleteByNumber(params.companyId, params.whatsappNumber);
+    return {
+      deletedObjects,
+      failedObjects: []
+    };
+  }
+};
+
+// src/use-cases/PurgeExpiredDocuments.use-case.ts
+var DEFAULT_BATCH_SIZE = 50;
+var HOURS_IN_DAY = 24;
+var MILLISECONDS_IN_HOUR = 60 * 60 * 1e3;
+var PurgeExpiredDocumentsUseCase = class {
+  static {
+    __name(this, "PurgeExpiredDocumentsUseCase");
+  }
+  documentRepository;
+  objectStorage;
+  constructor(documentRepository, objectStorage) {
+    this.documentRepository = documentRepository;
+    this.objectStorage = objectStorage;
+  }
+  async execute(params) {
+    if (!this.objectStorage?.delete) {
+      throw new Error("storage_delete_unsupported: reten\xE7\xE3o exige um storage que implemente delete");
+    }
+    const reference = params.now ?? /* @__PURE__ */ new Date();
+    const olderThan = new Date(reference.getTime() - params.retentionDays * HOURS_IN_DAY * MILLISECONDS_IN_HOUR);
+    const expired = await this.documentRepository.listExpired(params.companyId, olderThan, params.batchSize ?? DEFAULT_BATCH_SIZE);
+    const failed = [];
+    let purged = 0;
+    for (const document of expired) {
+      try {
+        await this.objectStorage.delete(document.uploadId);
+      } catch {
+        failed.push(document.uploadId);
+        continue;
+      }
+      await this.documentRepository.deleteById(params.companyId, document.id);
+      purged++;
+    }
+    return {
+      purged,
+      failed
+    };
+  }
+};
+
+// src/repositories/DocumentRepository.ts
+import { and as and4, asc, count, desc as desc2, eq as eq5, ilike, inArray, lt as lt2, or } from "drizzle-orm";
+var DEFAULT_LIMIT3 = 50;
+function companyDocumentSearch(search) {
+  const term = search?.trim();
+  if (!term) return void 0;
+  const digits = term.replace(/\D/g, "");
+  const byFilename = ilike(documents.filename, `%${term}%`);
+  if (!digits) return byFilename;
+  return or(byFilename, ilike(sessions.whatsappNumber, `%${digits}%`));
+}
+__name(companyDocumentSearch, "companyDocumentSearch");
+var DocumentRepository = class {
+  static {
+    __name(this, "DocumentRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+  * Idempotente por (companyId, uploadId), garantido pelo índice único e não por SELECT prévio: o
+  * job de ingestão é reentregue por retry e duas tentativas concorrentes passariam as duas por uma
+  * checagem, duplicando a linha no painel.
+  *
+  * Devolve `undefined` quando o documento já estava linkado.
+  */
+  async link(params) {
+    const values = {
+      companyId: params.companyId,
+      sessionId: params.sessionId,
+      messageId: params.messageId ?? null,
+      uploadId: params.uploadId,
+      filename: params.filename,
+      mimeType: params.mimeType,
+      sizeBytes: params.sizeBytes,
+      sha256: params.sha256 ?? null,
+      source: params.source
+    };
+    const [created] = await this.db.insert(documents).values(values).onConflictDoNothing().returning();
+    return created;
+  }
+  async listByConversation(params) {
+    const filters = [
+      eq5(documents.companyId, params.companyId),
+      eq5(documents.sessionId, params.sessionId)
+    ];
+    if (params.search) filters.push(ilike(documents.filename, `%${params.search}%`));
+    if (params.sources && params.sources.length > 0) {
+      filters.push(inArray(documents.source, [
+        ...params.sources
+      ]));
+    }
+    const where = and4(...filters);
+    const limit = params.limit ?? DEFAULT_LIMIT3;
+    const page = params.page && params.page > 0 ? params.page : 1;
+    const orderBy = params.sortDirection === "asc" ? asc(documents.linkedAt) : desc2(documents.linkedAt);
+    const [rows, counted] = await Promise.all([
+      this.db.select().from(documents).where(where).orderBy(orderBy).limit(limit).offset((page - 1) * limit),
+      this.db.select({
+        value: count()
+      }).from(documents).where(where)
+    ]);
+    return {
+      rows,
+      total: counted[0]?.value ?? 0
+    };
+  }
+  /**
+  * A biblioteca da EMPRESA inteira, não de uma conversa.
+  *
+  * A busca casa nome do arquivo OU telefone da conversa — ver `companyDocumentSearch`.
+  *
+  * Faz join com `sessions` para carregar de qual conversa cada arquivo veio — numa lista global,
+  * arquivo sem essa referência é inútil: o atendente vê "comprovante.pdf" e não sabe de quem.
+  *
+  * Ordena por `linkedAt` apoiada no índice `idx_documents_company_linked`, que já existia para a
+  * varredura de retenção.
+  */
+  async listByCompany(params) {
+    const filters = [
+      eq5(documents.companyId, params.companyId)
+    ];
+    const search = companyDocumentSearch(params.search);
+    if (search) filters.push(search);
+    if (params.sources && params.sources.length > 0) {
+      filters.push(inArray(documents.source, [
+        ...params.sources
+      ]));
+    }
+    const where = and4(...filters);
+    const limit = params.limit ?? DEFAULT_LIMIT3;
+    const page = params.page && params.page > 0 ? params.page : 1;
+    const orderBy = params.sortDirection === "asc" ? asc(documents.linkedAt) : desc2(documents.linkedAt);
+    const [rows, counted] = await Promise.all([
+      this.db.select({
+        id: documents.id,
+        uploadId: documents.uploadId,
+        filename: documents.filename,
+        mimeType: documents.mimeType,
+        sizeBytes: documents.sizeBytes,
+        source: documents.source,
+        linkedAt: documents.linkedAt,
+        // Só o número: o NOME do cliente é dado do produto (tabela própria dele), não do
+        // módulo. Quem quiser exibir "Marina Alves" enriquece na borda.
+        whatsappNumber: sessions.whatsappNumber
+      }).from(documents).innerJoin(sessions, eq5(documents.sessionId, sessions.id)).where(where).orderBy(orderBy).limit(limit).offset((page - 1) * limit),
+      // O mesmo join da listagem, e não só `from(documents)`: a busca pode citar
+      // `sessions.whatsapp_number`, e uma contagem sem a tabela na cláusula não compila — pior,
+      // se compilasse, o total divergiria das linhas e a paginação prometeria páginas vazias.
+      this.db.select({
+        value: count()
+      }).from(documents).innerJoin(sessions, eq5(documents.sessionId, sessions.id)).where(where)
+    ]);
+    return {
+      rows,
+      total: counted[0]?.value ?? 0
+    };
+  }
+  /**
+  * Um documento pela key do objeto. Serve para recuperar o nome original na hora de assinar o
+  * download: a key é caminho no bucket e salvaria o arquivo com o id da Meta.
+  */
+  async findByUploadId(companyId, uploadId) {
+    const [row] = await this.db.select().from(documents).where(and4(eq5(documents.companyId, companyId), eq5(documents.uploadId, uploadId))).limit(1);
+    return row;
+  }
+  /**
+  * Os objetos a apagar no storage antes de a linha sumir.
+  *
+  * Existe porque a cascata da FK apaga a linha e deixa o binário órfão: quem for apagar a conversa
+  * precisa desta lista primeiro, senão paga armazenamento para sempre por arquivo inalcançável.
+  */
+  async listUploadIdsBySession(companyId, sessionId) {
+    const rows = await this.db.select({
+      uploadId: documents.uploadId
+    }).from(documents).where(and4(eq5(documents.companyId, companyId), eq5(documents.sessionId, sessionId)));
+    return rows.map((row) => row.uploadId);
+  }
+  /** Varredura de retenção por idade — o par é o mesmo cuidado com o objeto no storage. */
+  async listExpired(companyId, olderThan, limit = DEFAULT_LIMIT3) {
+    return this.db.select().from(documents).where(and4(eq5(documents.companyId, companyId), lt2(documents.linkedAt, olderThan))).orderBy(documents.linkedAt).limit(limit);
+  }
+  async deleteById(companyId, id) {
+    await this.db.delete(documents).where(and4(eq5(documents.companyId, companyId), eq5(documents.id, id)));
+  }
+};
+
+// src/use-cases/ExportConversation.use-case.ts
+import { SessionNotFoundError as SessionNotFoundError4 } from "@adatechnology/meta-whatsapp-contracts";
 var ExportConversationUseCase = class {
   static {
     __name(this, "ExportConversationUseCase");
@@ -811,7 +1455,7 @@ var ExportConversationUseCase = class {
   }
   async execute(params) {
     const result = await this.sessionRepository.exportConversation(params.companyId, params.whatsappNumber);
-    if (!result) throw new SessionNotFoundError2(params.whatsappNumber);
+    if (!result) throw new SessionNotFoundError4(params.whatsappNumber);
     return result;
   }
 };
@@ -1048,45 +1692,341 @@ var FlowInterpreter = class {
   }
 };
 
-// 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;
+// src/flows/createSendMediaAction.ts
+function mediaTypeFor2(mimeType) {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("audio/")) return "audio";
+  if (mimeType.startsWith("video/")) return "video";
+  return "document";
+}
+__name(mediaTypeFor2, "mediaTypeFor");
+async function sendAttachment(params) {
+  const { attachment, channel, to, cache } = params;
+  const common = {
+    to,
+    mimeType: attachment.mimeType,
+    filename: attachment.filename,
+    caption: attachment.caption ?? void 0
+  };
+  const cacheKey = cache ? {
+    flowMediaId: attachment.id,
+    senderKey: cache.senderKey
+  } : void 0;
+  if (cache && cacheKey) {
+    const knownMediaId = await cache.store.get(cacheKey);
+    if (knownMediaId) {
+      try {
+        return await channel.sendMedia({
+          ...common,
+          mediaId: knownMediaId
+        });
+      } catch {
+        await cache.store.clear(cacheKey);
+      }
+    }
   }
-  async translateErrors(operation) {
+  const buffer = await params.objectStorage.getObject(attachment.uploadId);
+  const result = await channel.sendMedia({
+    ...common,
+    buffer
+  });
+  if (cache && cacheKey && result.mediaId) await cache.store.set({
+    ...cacheKey,
+    mediaId: result.mediaId
+  });
+  return result;
+}
+__name(sendAttachment, "sendAttachment");
+function createSendMediaAction(params) {
+  return async ({ node, session, channel }) => {
+    if (!session.flowKey) return;
+    const location = {
+      companyId: session.companyId,
+      flowKey: session.flowKey,
+      nodeId: node.id
+    };
+    const attachments = await params.flowMediaRepository.listActive(location);
+    for (const attachment of attachments) {
+      try {
+        const { externalMessageId } = await sendAttachment({
+          attachment,
+          channel,
+          to: session.whatsappNumber,
+          objectStorage: params.objectStorage,
+          ...params.mediaIdCache ? {
+            cache: params.mediaIdCache
+          } : {}
+        });
+        await params.logMessage.execute({
+          companyId: session.companyId,
+          whatsappNumber: session.whatsappNumber,
+          direction: "outbound",
+          sender: "bot",
+          agentUserId: null,
+          type: mediaTypeFor2(attachment.mimeType),
+          content: attachment.caption ?? attachment.filename,
+          payload: {
+            filename: attachment.filename,
+            mimeType: attachment.mimeType,
+            uploadId: attachment.uploadId,
+            flowMediaId: attachment.id
+          },
+          waMessageId: externalMessageId,
+          status: "sent",
+          startState: params.startState
+        });
+      } catch (error) {
+        params.onError?.(error, {
+          flowKey: location.flowKey,
+          nodeId: node.id,
+          uploadId: attachment.uploadId
+        });
+      }
+    }
+  };
+}
+__name(createSendMediaAction, "createSendMediaAction");
+
+// src/flows/createSendProductListAction.ts
+var PRODUCT_LIST_LIMIT = {
+  ITEMS: 30,
+  SECTIONS: 10
+};
+function createSendProductListAction(params) {
+  return async ({ node, session, channel }) => {
+    if (!channel.sendProductList) return;
+    const actionParams = node.actionParams ?? {};
     try {
-      return await operation();
+      const available = await listAvailableProducts({
+        catalog: params.catalog,
+        catalogId: params.catalogId,
+        ...actionParams.search ? {
+          search: actionParams.search
+        } : {}
+      });
+      if (available.length === 0) return;
+      const bodyText = actionParams.bodyText ?? "Veja o que temos dispon\xEDvel:";
+      const { externalMessageId } = await channel.sendProductList({
+        to: session.whatsappNumber,
+        headerText: actionParams.headerText ?? "Nossos produtos",
+        body: bodyText,
+        ...actionParams.footerText ? {
+          footerText: actionParams.footerText
+        } : {},
+        sections: [
+          {
+            title: actionParams.sectionTitle ?? "Dispon\xEDveis",
+            retailerIds: available.map((product) => product.retailerId)
+          }
+        ]
+      });
+      await params.logMessage.execute({
+        companyId: session.companyId,
+        whatsappNumber: session.whatsappNumber,
+        direction: "outbound",
+        sender: "bot",
+        agentUserId: null,
+        type: "interactive",
+        content: bodyText,
+        payload: {
+          kind: "product_list",
+          productCount: available.length
+        },
+        waMessageId: externalMessageId,
+        status: "sent",
+        startState: params.startState
+      });
     } catch (error) {
-      if (error instanceof ProviderWindowExpiredError) throw new WindowExpiredError2();
-      throw error;
+      params.onError?.(error, {
+        flowKey: session.flowKey ?? "",
+        nodeId: node.id
+      });
     }
+  };
+}
+__name(createSendProductListAction, "createSendProductListAction");
+async function listAvailableProducts(params) {
+  const products = await params.catalog.listProducts({
+    catalogId: params.catalogId,
+    ...params.search ? {
+      search: params.search
+    } : {}
+  });
+  return products.filter((product) => product.availability === "in stock").slice(0, PRODUCT_LIST_LIMIT.ITEMS);
+}
+__name(listAvailableProducts, "listAvailableProducts");
+
+// src/repositories/FlowMediaRepository.ts
+import { and as and5, asc as asc2, eq as eq6, sql as sql4 } from "drizzle-orm";
+var FlowMediaRepository = class {
+  static {
+    __name(this, "FlowMediaRepository");
   }
-  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
-    };
+  db;
+  constructor(db) {
+    this.db = db;
   }
-  async sendInteractiveList(params) {
-    const result = await this.translateErrors(() => this.messages.sendInteractiveList({
+  locationFilter(location) {
+    return and5(eq6(flowMedia.companyId, location.companyId), eq6(flowMedia.flowKey, location.flowKey), eq6(flowMedia.nodeId, location.nodeId));
+  }
+  // O que o nó realmente envia, na ordem de envio. `active` filtrado aqui e não no chamador:
+  // é a razão de a coluna existir, e um chamador que esquecesse do filtro mandaria ao cliente
+  // justamente o material que alguém desligou.
+  async listActive(location) {
+    return this.db.select().from(flowMedia).where(and5(this.locationFilter(location), eq6(flowMedia.active, true))).orderBy(asc2(flowMedia.sortOrder), asc2(flowMedia.createdAt));
+  }
+  // Inclui os desligados — é a visão do editor, onde desligar precisa continuar visível para
+  // poder ser religado.
+  async listAll(location) {
+    return this.db.select().from(flowMedia).where(this.locationFilter(location)).orderBy(asc2(flowMedia.sortOrder), asc2(flowMedia.createdAt));
+  }
+  /**
+  * Anexa um arquivo já existente no storage ao nó.
+  *
+  * `onConflictDoUpdate` em vez de deixar estourar: reanexar o mesmo arquivo é clique repetido no
+  * editor, e o esperado ali é atualizar a legenda/ordem — não um erro de índice único na cara de
+  * quem está montando o fluxo.
+  */
+  async attach(params) {
+    const [row] = await this.db.insert(flowMedia).values({
+      companyId: params.companyId,
+      flowKey: params.flowKey,
+      nodeId: params.nodeId,
+      uploadId: params.uploadId,
+      filename: params.filename,
+      mimeType: params.mimeType,
+      sizeBytes: params.sizeBytes,
+      caption: params.caption ?? null,
+      sortOrder: params.sortOrder ?? 0
+    }).onConflictDoUpdate({
+      target: [
+        flowMedia.companyId,
+        flowMedia.flowKey,
+        flowMedia.nodeId,
+        flowMedia.uploadId
+      ],
+      set: {
+        caption: params.caption ?? null,
+        sortOrder: params.sortOrder ?? 0,
+        active: true,
+        updatedAt: sql4`now()`
+      }
+    }).returning();
+    return row;
+  }
+  async update(params) {
+    const [row] = await this.db.update(flowMedia).set({
+      ...params.caption !== void 0 ? {
+        caption: params.caption
+      } : {},
+      ...params.sortOrder !== void 0 ? {
+        sortOrder: params.sortOrder
+      } : {},
+      ...params.active !== void 0 ? {
+        active: params.active
+      } : {},
+      updatedAt: sql4`now()`
+    }).where(and5(eq6(flowMedia.companyId, params.companyId), eq6(flowMedia.id, params.id))).returning();
+    return row;
+  }
+  /**
+  * Desanexa do nó. Não toca no storage de propósito: o mesmo `uploadId` pode estar anexado a
+  * outro nó ou a outro fluxo, e apagar o binário aqui quebraria os demais. Quem apaga objeto é o
+  * host, que é dono da biblioteca de arquivos.
+  */
+  async detach(params) {
+    await this.db.delete(flowMedia).where(and5(eq6(flowMedia.companyId, params.companyId), eq6(flowMedia.id, params.id)));
+  }
+  // Chamado ao salvar o grafo: nós apagados no editor deixam linhas que nada mais alcança.
+  async detachRemovedNodes(params) {
+    const condition = params.existingNodeIds.length === 0 ? void 0 : sql4`${flowMedia.nodeId} NOT IN ${params.existingNodeIds}`;
+    await this.db.delete(flowMedia).where(and5(eq6(flowMedia.companyId, params.companyId), eq6(flowMedia.flowKey, params.flowKey), condition));
+  }
+};
+
+// src/repositories/FlowMediaIdRepository.ts
+import { eq as eq7, sql as sql5 } from "drizzle-orm";
+var FlowMediaIdRepository = class {
+  static {
+    __name(this, "FlowMediaIdRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async get(params) {
+    const rows = await this.db.select({
+      ids: flowMedia.metaMediaIds
+    }).from(flowMedia).where(eq7(flowMedia.id, params.flowMediaId)).limit(1);
+    return rows[0]?.ids?.[params.senderKey];
+  }
+  /**
+  * Grava só a chave deste número.
+  *
+  * `jsonb_set` no banco, e não ler-alterar-escrever na aplicação: dois clientes passando pelo nó
+  * ao mesmo tempo com números diferentes leriam o mesmo mapa e o último gravaria por cima,
+  * apagando o id do outro. A escrita atômica não tem essa janela.
+  */
+  async set(params) {
+    await this.db.update(flowMedia).set({
+      metaMediaIds: sql5`jsonb_set(${flowMedia.metaMediaIds}, ARRAY[${params.senderKey}::text], to_jsonb(${params.mediaId}::text), true)`
+    }).where(eq7(flowMedia.id, params.flowMediaId));
+  }
+  /** Remove só a chave deste número — o id do outro número continua válido. */
+  async clear(params) {
+    await this.db.update(flowMedia).set({
+      metaMediaIds: sql5`${flowMedia.metaMediaIds} - ${params.senderKey}::text`
+    }).where(eq7(flowMedia.id, params.flowMediaId));
+  }
+};
+
+// src/channel/WhatsAppChannelAdapter.ts
+import { WhatsAppWindowExpiredError as ProviderWindowExpiredError } from "@adatechnology/meta-graph-core";
+import { WindowExpiredError as WindowExpiredError2 } from "@adatechnology/meta-whatsapp-contracts";
+
+// src/channel/previewMedia.ts
+import { PREVIEW_MEDIA_ID_PREFIX, toPreviewMediaId, resolvePreviewUploadId } from "@adatechnology/meta-whatsapp-contracts";
+
+// src/channel/WhatsAppChannelAdapter.ts
+var WhatsAppChannelAdapter = class {
+  static {
+    __name(this, "WhatsAppChannelAdapter");
+  }
+  messages;
+  previewMedia;
+  constructor(messages2, previewMedia) {
+    this.messages = messages2;
+    this.previewMedia = previewMedia;
+  }
+  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,
+      mediaId: result.mediaId
+    };
+  }
+  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,
@@ -1101,49 +2041,405 @@ var WhatsAppChannelAdapter = class {
       externalMessageId: result.waMessageId
     };
   }
+  async sendInteractiveButtons(params) {
+    const result = await this.translateErrors(() => this.messages.sendInteractiveButtons({
+      to: params.to,
+      bodyText: params.body,
+      buttons: params.buttons
+    }));
+    return {
+      externalMessageId: result.waMessageId
+    };
+  }
+  async sendProductList(params) {
+    const result = await this.translateErrors(() => this.messages.sendProductListMessage({
+      to: params.to,
+      headerText: params.headerText,
+      bodyText: params.body,
+      ...params.footerText ? {
+        footerText: params.footerText
+      } : {},
+      sections: params.sections
+    }));
+    return {
+      externalMessageId: result.waMessageId
+    };
+  }
+  /**
+  * Busca o binário da mídia — da Meta, ou do storage quando o id é do simulador.
+  *
+  * O desvio acontece ANTES de qualquer chamada de rede: id do simulador não existe na Meta, e
+  * tentar buscá-lo lá renderia um 404 confuso em vez do áudio que o operador acabou de gravar.
+  */
   async fetchMediaAsBase64(mediaId) {
+    const uploadId = this.previewMedia?.isEnabled ? resolvePreviewUploadId(mediaId) : void 0;
+    if (uploadId) {
+      const buffer = await this.previewMedia.objectStorage.getObject(uploadId);
+      return {
+        data: buffer.toString("base64"),
+        mimeType: this.previewMedia.defaultMimeType ?? "audio/ogg"
+      };
+    }
     return this.translateErrors(() => this.messages.fetchMediaAsBase64(mediaId));
   }
 };
 
 // src/channel/ReceiveWebhook.use-case.ts
-import { whatsAppWebhookPayloadSchema } from "@adatechnology/meta-whatsapp-contracts";
+import { whatsAppWebhookPayloadSchema, whatsAppTemplateStatusUpdateSchema, whatsAppPhoneNumberQualityUpdateSchema, WHATSAPP_WEBHOOK_FIELDS } from "@adatechnology/meta-whatsapp-contracts";
 
 // src/channel/webhookSecurity.ts
-import { createHmac, timingSafeEqual } from "crypto";
+import { WEBHOOK_CLAIM_TTL_SECONDS, WEBHOOK_NONCE_TTL_SECONDS, buildWebhookDeliveryKey, isValidWebhookChallenge, isValidWebhookSignature } from "@adatechnology/meta-graph-core";
 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");
+var WEBHOOK_NONCE_NAMESPACE = "meta-whatsapp";
 function verifyWebhookChallenge(params) {
-  if (params.mode !== "subscribe" || !params.token || !params.challenge) {
-    throw new InvalidWebhookSignatureError();
-  }
-  if (!safeEqualStrings(params.token, params.expectedToken)) {
-    throw new InvalidWebhookSignatureError();
-  }
+  if (!isValidWebhookChallenge(params)) 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();
+  if (!isValidWebhookSignature(params)) throw new InvalidWebhookSignatureError();
 }
 __name(verifyWebhookSignature, "verifyWebhookSignature");
+function deliveryKey(signatureHeader) {
+  return buildWebhookDeliveryKey({
+    namespace: WEBHOOK_NONCE_NAMESPACE,
+    signatureHeader
+  });
+}
+__name(deliveryKey, "deliveryKey");
 async function claimWebhookDelivery(params) {
-  const key = `meta-whatsapp:webhook:${params.signatureHeader}`;
-  return params.nonceStore.setIfAbsent(key, params.ttlSeconds ?? WEBHOOK_NONCE_TTL_SECONDS);
+  return params.nonceStore.setIfAbsent(deliveryKey(params.signatureHeader), params.ttlSeconds ?? WEBHOOK_CLAIM_TTL_SECONDS);
 }
 __name(claimWebhookDelivery, "claimWebhookDelivery");
+async function confirmWebhookDelivery(params) {
+  await params.nonceStore.confirm?.(deliveryKey(params.signatureHeader), params.ttlSeconds ?? WEBHOOK_NONCE_TTL_SECONDS);
+}
+__name(confirmWebhookDelivery, "confirmWebhookDelivery");
 
-// src/channel/ReceiveWebhook.use-case.ts
+// src/channel/IngestInboundMedia.use-case.ts
+import { eq as eq8, and as and6 } from "drizzle-orm";
+
+// src/use-cases/TranscribeAudio.use-case.ts
+import { AudioNotIngestedError, MessageNotAudioError, TranscriptionDisabledError } from "@adatechnology/meta-whatsapp-contracts";
+
+// src/transcription.types.ts
+var TRANSCRIPTION_STATUS = {
+  /** Falhou de forma retriável (cota, rede, 5xx) — vai sair quando alguém tentar de novo. */
+  PENDING: "pending",
+  /** Processado. Texto vazio aqui é áudio em silêncio, e NÃO deve ser reprocessado. */
+  DONE: "done",
+  /** Falha definitiva do engine (credencial, áudio corrompido, arquivo grande demais). */
+  FAILED: "failed",
+  /** Nenhum engine da cadeia aceita o formato. Retentar não conserta codec. */
+  UNSUPPORTED: "unsupported"
+};
+var TRANSCRIPTION_MODE = {
+  AUTO: "auto",
+  ON_DEMAND: "onDemand"
+};
+function isRetriableTranscriptionError(error) {
+  if (typeof error !== "object" || error === null) return true;
+  const isRetriable = error.isRetriable;
+  return typeof isRetriable === "boolean" ? isRetriable : true;
+}
+__name(isRetriableTranscriptionError, "isRetriableTranscriptionError");
+function isUnsupportedTranscriptionError(error) {
+  return typeof error === "object" && error !== null && error.name === "TranscriptionUnsupportedError";
+}
+__name(isUnsupportedTranscriptionError, "isUnsupportedTranscriptionError");
+function transcriptionRetryAfterSeconds(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const retryAfter = error.retryAfterSeconds;
+  return typeof retryAfter === "number" ? retryAfter : void 0;
+}
+__name(transcriptionRetryAfterSeconds, "transcriptionRetryAfterSeconds");
+function isAudioMimeType(mimeType) {
+  return typeof mimeType === "string" && mimeType.trim().toLowerCase().startsWith("audio/");
+}
+__name(isAudioMimeType, "isAudioMimeType");
+
+// src/use-cases/TranscribeAudio.use-case.ts
+var TranscribeAudioUseCase = class {
+  static {
+    __name(this, "TranscribeAudioUseCase");
+  }
+  dependencies;
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  async execute(params) {
+    const message = await this.dependencies.messageRepository.findById(params.companyId, params.messageId);
+    if (!message) throw new Error(`Mensagem ${params.messageId} n\xE3o encontrada para transcri\xE7\xE3o`);
+    if (message.transcriptionStatus === TRANSCRIPTION_STATUS.DONE && !params.force) {
+      return {
+        status: TRANSCRIPTION_STATUS.DONE,
+        text: message.transcriptionText,
+        language: message.transcriptionLanguage,
+        engine: message.transcriptionEngine,
+        alreadyTranscribed: true
+      };
+    }
+    if (this.dependencies.resolvePolicy) {
+      const policy = await this.dependencies.resolvePolicy(params.companyId);
+      if (!policy.isEnabled) throw new TranscriptionDisabledError();
+    }
+    const audio = extractAudioReference(message);
+    const buffer = await this.dependencies.objectStorage.getObject(audio.uploadId);
+    return this.transcribeBuffer({
+      ...params,
+      buffer,
+      mimeType: audio.mimeType,
+      uploadId: audio.uploadId,
+      message
+    });
+  }
+  async transcribeBuffer(context) {
+    try {
+      const result = await this.dependencies.transcriber.transcribe({
+        buffer: context.buffer,
+        mimeType: context.mimeType,
+        ...this.dependencies.languageHint ? {
+          languageHint: this.dependencies.languageHint
+        } : {}
+      });
+      await this.dependencies.messageRepository.saveTranscription({
+        companyId: context.companyId,
+        messageId: context.messageId,
+        status: TRANSCRIPTION_STATUS.DONE,
+        text: result.text,
+        language: result.language ?? null,
+        engine: result.engine
+      });
+      return {
+        status: TRANSCRIPTION_STATUS.DONE,
+        text: result.text,
+        language: result.language ?? null,
+        engine: result.engine,
+        alreadyTranscribed: false
+      };
+    } catch (error) {
+      await this.persistFailure(context, error);
+      throw error;
+    }
+  }
+  /**
+  * Carimba o motivo antes de propagar. O status é o que impede os dois desperdícios simétricos:
+  * reprocessar para sempre um codec impossível, e desistir de um áudio que só esbarrou na cota.
+  */
+  async persistFailure(context, error) {
+    const status = resolveFailureStatus(error);
+    await this.dependencies.messageRepository.saveTranscription({
+      companyId: context.companyId,
+      messageId: context.messageId,
+      status
+    });
+    if (status !== TRANSCRIPTION_STATUS.PENDING) return;
+    const retryAfterSeconds = transcriptionRetryAfterSeconds(error);
+    await this.dependencies.hooks?.onTranscriptionDeferred?.({
+      companyId: context.companyId,
+      messageId: context.messageId,
+      whatsappNumber: context.message.whatsappNumber,
+      uploadId: context.uploadId,
+      ...retryAfterSeconds !== void 0 ? {
+        retryAfterSeconds
+      } : {},
+      reason: retryAfterSeconds !== void 0 ? "rate-limited" : "transient-failure",
+      error
+    });
+  }
+};
+function resolveFailureStatus(error) {
+  if (isUnsupportedTranscriptionError(error)) return TRANSCRIPTION_STATUS.UNSUPPORTED;
+  return isRetriableTranscriptionError(error) ? TRANSCRIPTION_STATUS.PENDING : TRANSCRIPTION_STATUS.FAILED;
+}
+__name(resolveFailureStatus, "resolveFailureStatus");
+function extractAudioReference(message) {
+  const payload = message.payload ?? {};
+  const audio = payload["audio"];
+  const mimeType = typeof payload["mimeType"] === "string" ? payload["mimeType"] : audio?.mime_type;
+  if (!isAudioMimeType(mimeType) && !audio) {
+    throw new MessageNotAudioError(message.id, message.type);
+  }
+  const uploadId = payload["uploadId"];
+  if (typeof uploadId !== "string" || uploadId.length === 0) {
+    throw new AudioNotIngestedError(message.id);
+  }
+  return {
+    uploadId,
+    mimeType: mimeType ?? "audio/ogg"
+  };
+}
+__name(extractAudioReference, "extractAudioReference");
+
+// src/channel/IngestInboundMedia.use-case.ts
+var IngestInboundMediaUseCase = class {
+  static {
+    __name(this, "IngestInboundMediaUseCase");
+  }
+  db;
+  channel;
+  objectStorage;
+  documentRepository;
+  transcription;
+  constructor(db, channel, objectStorage, documentRepository, transcription) {
+    this.db = db;
+    this.channel = channel;
+    this.objectStorage = objectStorage;
+    this.documentRepository = documentRepository;
+    this.transcription = transcription;
+  }
+  async execute(params) {
+    const [message] = await this.db.select().from(messages).where(and6(eq8(messages.companyId, params.companyId), eq8(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,
+      // O tamanho já está na mão (é o buffer que acabou de ser copiado) e a bolha de documento o
+      // exibe ao lado do tipo. Sem gravar aqui, a UI mostraria "PDF" sem o "· 180 KB", e buscá-lo
+      // depois custaria uma consulta à tabela de documentos por mensagem renderizada.
+      sizeBytes: buffer.length,
+      ...params.filename ? {
+        filename: params.filename
+      } : {}
+    };
+    await this.db.update(messages).set({
+      payload: updatedPayload
+    }).where(and6(eq8(messages.companyId, params.companyId), eq8(messages.id, params.messageId)));
+    await this.documentRepository?.link({
+      companyId: params.companyId,
+      sessionId: message.sessionId,
+      messageId: message.id,
+      uploadId,
+      // Áudio e sticker chegam sem nome; sem um rótulo o painel mostraria linha vazia.
+      filename: params.filename ?? `${params.sourceMediaId}`,
+      mimeType: mimeType || params.mimeType,
+      sizeBytes: buffer.length,
+      source: message.sender
+    });
+    const transcription = await this.transcribeIfAuto({
+      companyId: params.companyId,
+      message,
+      uploadId,
+      buffer,
+      mimeType: mimeType || params.mimeType
+    });
+    return {
+      uploadId,
+      alreadyIngested: false,
+      ...transcription ? {
+        transcription
+      } : {}
+    };
+  }
+  /**
+  * Transcreve o áudio recém-baixado, quando o modo é `auto`.
+  *
+  * **Nunca propaga erro.** Neste ponto o binário já está no storage e já entrou na biblioteca da
+  * conversa: deixar uma falha de transcrição subir marcaria a ingestão inteira como falha, e o
+  * retry do host baixaria de novo da Meta um arquivo que está salvo — gastando banda para reproduzir
+  * um efeito que já aconteceu. O status fica gravado na mensagem e o `onTranscriptionDeferred`
+  * avisa quem sabe reenfileirar.
+  */
+  async transcribeIfAuto(context) {
+    const transcription = this.transcription;
+    if (!transcription) return void 0;
+    if (!isAudioMimeType(context.mimeType)) return void 0;
+    const policy = await transcription.resolvePolicy(context.companyId);
+    if (!policy.isEnabled || policy.mode !== TRANSCRIPTION_MODE.AUTO) return void 0;
+    const current = await transcription.messageRepository.findById(context.companyId, context.message.id);
+    if (current?.transcriptionStatus === TRANSCRIPTION_STATUS.DONE) return void 0;
+    try {
+      const result = await transcription.transcriber.transcribe({
+        buffer: context.buffer,
+        mimeType: context.mimeType,
+        ...transcription.languageHint ? {
+          languageHint: transcription.languageHint
+        } : {}
+      });
+      await transcription.messageRepository.saveTranscription({
+        companyId: context.companyId,
+        messageId: context.message.id,
+        status: TRANSCRIPTION_STATUS.DONE,
+        text: result.text,
+        language: result.language ?? null,
+        engine: result.engine
+      });
+      return {
+        status: TRANSCRIPTION_STATUS.DONE
+      };
+    } catch (error) {
+      return this.recordTranscriptionFailure(context, error);
+    }
+  }
+  async recordTranscriptionFailure(context, error) {
+    const status = resolveFailureStatus(error);
+    await this.transcription?.messageRepository.saveTranscription({
+      companyId: context.companyId,
+      messageId: context.message.id,
+      status
+    });
+    if (status === TRANSCRIPTION_STATUS.PENDING) {
+      const retryAfterSeconds = transcriptionRetryAfterSeconds(error);
+      await this.transcription?.hooks?.onTranscriptionDeferred?.({
+        companyId: context.companyId,
+        messageId: context.message.id,
+        whatsappNumber: context.message.whatsappNumber,
+        uploadId: context.uploadId,
+        ...retryAfterSeconds !== void 0 ? {
+          retryAfterSeconds
+        } : {},
+        reason: retryAfterSeconds !== void 0 ? "rate-limited" : "transient-failure",
+        error
+      });
+    }
+    return {
+      status
+    };
+  }
+};
+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/channel/inboundDispatch.ts
+function buildInboundJobId(job) {
+  return job.kind === "message" ? `wa-inbound-message:${job.message.id}` : `wa-inbound-status:${job.status.id}:${job.status.status}`;
+}
+__name(buildInboundJobId, "buildInboundJobId");
 function toSessionContract(row) {
   return {
     id: row.id,
@@ -1164,6 +2460,72 @@ function toSessionContract(row) {
   };
 }
 __name(toSessionContract, "toSessionContract");
+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");
+var InboundEffectsDispatcher = class {
+  static {
+    __name(this, "InboundEffectsDispatcher");
+  }
+  params;
+  constructor(params) {
+    this.params = params;
+  }
+  async run(job) {
+    if (job.kind === "message") return this.runMessageEffects(job);
+    return this.runStatusEffects(job);
+  }
+  async runMessageEffects(job) {
+    const { companyId, message, savedMessageId, media } = job;
+    if (media) {
+      await this.params.hooks?.onMediaReceived?.({
+        companyId,
+        messageId: savedMessageId,
+        whatsappNumber: message.from,
+        sourceMediaId: media.sourceMediaId,
+        mimeType: media.mimeType,
+        ...media.filename ? {
+          filename: media.filename
+        } : {}
+      });
+    }
+    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 runStatusEffects(job) {
+    const sessionRow = await this.params.sessionRepository.getContext(job.companyId, job.whatsappNumber);
+    await this.params.hooks?.onStatusUpdate?.(job.status, sessionRow ? toSessionContract(sessionRow) : null);
+  }
+};
+var ProcessInboundDispatchUseCase = class {
+  static {
+    __name(this, "ProcessInboundDispatchUseCase");
+  }
+  dispatcher;
+  constructor(dispatcher) {
+    this.dispatcher = dispatcher;
+  }
+  async execute(job) {
+    await this.dispatcher.run(job);
+  }
+};
+
+// src/channel/ReceiveWebhook.use-case.ts
+var EMPTY_RESULT = {
+  messagesProcessed: 0,
+  statusesProcessed: 0,
+  ignoredForeignNumber: 0,
+  accountEventsProcessed: 0,
+  unhandledEvents: 0
+};
 function extractContent(message) {
   if (message.text?.body) return message.text.body;
   const interactive = message.interactive;
@@ -1176,13 +2538,6 @@ function extractContent(message) {
   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;
@@ -1196,6 +2551,14 @@ function extractPayload(message) {
   return Object.keys(payload).length > 0 ? payload : null;
 }
 __name(extractPayload, "extractPayload");
+var ACCOUNT_EVENT_FIELDS = [
+  WHATSAPP_WEBHOOK_FIELDS.TEMPLATE_STATUS_UPDATE,
+  WHATSAPP_WEBHOOK_FIELDS.PHONE_NUMBER_QUALITY_UPDATE
+];
+function isAccountEventField(field) {
+  return field !== void 0 && ACCOUNT_EVENT_FIELDS.includes(field);
+}
+__name(isAccountEventField, "isAccountEventField");
 var ReceiveWebhookUseCase = class {
   static {
     __name(this, "ReceiveWebhookUseCase");
@@ -1203,7 +2566,17 @@ var ReceiveWebhookUseCase = class {
   params;
   constructor(params) {
     this.params = params;
+    this.dispatcher = new InboundEffectsDispatcher({
+      sessionRepository: params.sessionRepository,
+      ...params.hooks ? {
+        hooks: params.hooks
+      } : {},
+      ...params.realtime ? {
+        realtime: params.realtime
+      } : {}
+    });
   }
+  dispatcher;
   async execute(input) {
     verifyWebhookSignature({
       rawBody: input.rawBody,
@@ -1216,15 +2589,41 @@ var ReceiveWebhookUseCase = class {
     });
     if (!claimed) return {
       duplicate: true,
-      messagesProcessed: 0,
-      statusesProcessed: 0
+      ...EMPTY_RESULT
     };
     const rawText = typeof input.rawBody === "string" ? input.rawBody : input.rawBody.toString("utf8");
-    const payload = whatsAppWebhookPayloadSchema.parse(JSON.parse(rawText));
+    const parsed = whatsAppWebhookPayloadSchema.safeParse(JSON.parse(rawText));
+    if (!parsed.success) {
+      await this.params.hooks?.onUnhandledWebhookEvent?.({
+        field: void 0,
+        reason: "invalid-shape",
+        value: rawText
+      });
+      return {
+        duplicate: false,
+        ...EMPTY_RESULT,
+        unhandledEvents: 1
+      };
+    }
+    const payload = parsed.data;
     let messagesProcessed = 0;
     let statusesProcessed = 0;
+    let ignoredForeignNumber = 0;
+    let accountEventsProcessed = 0;
+    let unhandledEvents = 0;
     for (const entry of payload.entry) {
       for (const change of entry.changes) {
+        if (isAccountEventField(change.field)) {
+          const handled = await this.handleAccountEvent(change);
+          if (handled) accountEventsProcessed++;
+          else unhandledEvents++;
+          continue;
+        }
+        const targetNumber = change.value.metadata?.phone_number_id;
+        if (targetNumber && targetNumber !== this.params.phoneNumberId) {
+          ignoredForeignNumber++;
+          continue;
+        }
         for (const message of change.value.messages ?? []) {
           await this.handleMessage(input.companyId, message);
           messagesProcessed++;
@@ -1233,14 +2632,58 @@ var ReceiveWebhookUseCase = class {
           await this.handleStatus(input.companyId, status);
           statusesProcessed++;
         }
+        const carriedConversationData = (change.value.messages?.length ?? 0) > 0 || (change.value.message_echoes?.length ?? 0) > 0 || (change.value.statuses?.length ?? 0) > 0;
+        if (!carriedConversationData) {
+          unhandledEvents++;
+          await this.params.hooks?.onUnhandledWebhookEvent?.({
+            field: change.field,
+            reason: "unknown-field",
+            value: change.value
+          });
+        }
       }
     }
+    await confirmWebhookDelivery({
+      nonceStore: this.params.nonceStore,
+      signatureHeader: input.signatureHeader
+    });
     return {
       duplicate: false,
       messagesProcessed,
-      statusesProcessed
+      statusesProcessed,
+      ignoredForeignNumber,
+      accountEventsProcessed,
+      unhandledEvents
     };
   }
+  // Devolve `false` quando o corpo não bate com o schema do field — o chamador conta como não
+  // tratado. O host é avisado nos dois casos, mas com `reason` diferente.
+  async handleAccountEvent(change) {
+    if (change.field === WHATSAPP_WEBHOOK_FIELDS.TEMPLATE_STATUS_UPDATE) {
+      const update = whatsAppTemplateStatusUpdateSchema.safeParse(change.value);
+      if (!update.success) {
+        await this.params.hooks?.onUnhandledWebhookEvent?.({
+          field: change.field,
+          reason: "invalid-shape",
+          value: change.value
+        });
+        return false;
+      }
+      await this.params.hooks?.onTemplateStatusUpdate?.(update.data);
+      return true;
+    }
+    const quality = whatsAppPhoneNumberQualityUpdateSchema.safeParse(change.value);
+    if (!quality.success) {
+      await this.params.hooks?.onUnhandledWebhookEvent?.({
+        field: change.field,
+        reason: "invalid-shape",
+        value: change.value
+      });
+      return false;
+    }
+    await this.params.hooks?.onPhoneNumberQualityUpdate?.(quality.data);
+    return true;
+  }
   async handleMessage(companyId, message) {
     const saved = await this.params.logMessage.execute({
       companyId,
@@ -1255,12 +2698,17 @@ var ReceiveWebhookUseCase = class {
       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);
+    const media = extractMediaDescriptor(saved);
+    await this.dispatch({
+      kind: "message",
+      companyId,
+      message,
+      savedMessageId: saved.id,
+      ...media ? {
+        media
+      } : {},
+      receivedAt: Date.now()
+    });
   }
   async handleStatus(companyId, status) {
     const updated = await this.params.messageRepository.updateMessageStatus(companyId, status.id, status.status);
@@ -1269,81 +2717,71 @@ var ReceiveWebhookUseCase = class {
       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);
+    await this.dispatch({
+      kind: "status",
+      companyId,
+      status,
+      whatsappNumber: updated.whatsappNumber,
+      receivedAt: Date.now()
+    });
+  }
+  // Com fila configurada, os efeitos saem da requisição do webhook; sem ela, rodam aqui mesmo e o
+  // comportamento é o de sempre. É o mesmo `InboundEffectsDispatcher` nos dois caminhos.
+  async dispatch(job) {
+    if (this.params.inboundQueue) {
+      await this.params.inboundQueue.enqueue(job, {
+        jobId: buildInboundJobId(job)
+      });
+      return;
+    }
+    await this.dispatcher.run(job);
   }
 };
 
-// src/channel/IngestInboundMedia.use-case.ts
-import { eq as eq5, and as and4 } from "drizzle-orm";
-var IngestInboundMediaUseCase = class {
+// src/use-cases/resolveTranscriptionPolicy.ts
+function createTranscriptionPolicyResolver(dependencies) {
+  return /* @__PURE__ */ __name(async function resolveTranscriptionPolicy(companyId) {
+    const settings2 = await dependencies.settingsRepository.get(companyId);
+    return {
+      // `??` e não `||`: `false` gravado é decisão explícita de desligar, e `||` a trocaria pelo
+      // padrão do host — desligar no painel não faria nada num deploy com transcrição ligada.
+      isEnabled: settings2.transcriptionEnabled ?? dependencies.defaults.isEnabled,
+      mode: normalizeMode(settings2.transcriptionMode) ?? dependencies.defaults.mode
+    };
+  }, "resolveTranscriptionPolicy");
+}
+__name(createTranscriptionPolicyResolver, "createTranscriptionPolicyResolver");
+function normalizeMode(value) {
+  if (value === TRANSCRIPTION_MODE.AUTO) return TRANSCRIPTION_MODE.AUTO;
+  if (value === TRANSCRIPTION_MODE.ON_DEMAND) return TRANSCRIPTION_MODE.ON_DEMAND;
+  return void 0;
+}
+__name(normalizeMode, "normalizeMode");
+
+// src/use-cases/StorePreviewMedia.use-case.ts
+var StorePreviewMediaUseCase = class {
   static {
-    __name(this, "IngestInboundMediaUseCase");
+    __name(this, "StorePreviewMediaUseCase");
   }
-  db;
-  channel;
   objectStorage;
-  constructor(db, channel, objectStorage) {
-    this.db = db;
-    this.channel = channel;
+  generateKeySuffix;
+  constructor(objectStorage, generateKeySuffix) {
     this.objectStorage = objectStorage;
+    this.generateKeySuffix = generateKeySuffix;
   }
   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 key = `meta-whatsapp/${params.companyId}/preview/${this.generateKeySuffix()}`;
     const { uploadId } = await this.objectStorage.upload({
-      buffer,
-      mimeType: mimeType || params.mimeType,
-      key: `meta-whatsapp/${params.companyId}/inbound/${params.sourceMediaId}`
+      buffer: params.buffer,
+      mimeType: params.mimeType,
+      key
     });
-    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
+      mediaId: toPreviewMediaId(uploadId),
+      uploadId
     };
   }
 };
-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) {
@@ -1357,15 +2795,24 @@ function createMetaWhatsAppModule(params) {
     apiVersion: config.apiVersion,
     baseUrl: config.baseUrl
   });
-  const channel = new WhatsAppChannelAdapter(messageProvider);
+  const previewMediaSupport = params.features?.previewMedia && providers.objectStorage?.getObject ? {
+    isEnabled: true,
+    objectStorage: providers.objectStorage
+  } : void 0;
+  const channel = new WhatsAppChannelAdapter(messageProvider, previewMediaSupport);
   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 flowGraphCacheFeature = params.features?.flowGraphCache ?? false;
+  const flowGraphCache = flowGraphCacheFeature && providers.cache ? new FlowGraphCache(providers.cache, typeof flowGraphCacheFeature === "object" ? flowGraphCacheFeature.ttlSeconds ?? DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS : DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS) : void 0;
+  const flowGraphRepository = new FlowGraphRepository(db, flowGraphCache);
+  const documentRepository = new DocumentRepository(db);
+  const flowMediaRepository = new FlowMediaRepository(db);
+  const logMessage = new LogMessageUseCase(sessionRepository, messageRepository, providers.realtime, providers.moderator);
+  const sendMessage = new SendMessageUseCase(channel, sessionRepository, logMessage, providers.objectStorage, documentRepository);
   const receiveWebhook = new ReceiveWebhookUseCase({
     appSecret: config.appSecret,
+    phoneNumberId: config.phoneNumberId,
     nonceStore,
     sessionRepository,
     messageRepository,
@@ -1375,7 +2822,66 @@ function createMetaWhatsAppModule(params) {
     realtime: providers.realtime
   });
   const flowInterpreter = flowEngineEnabled ? new FlowInterpreter() : void 0;
-  const ingestInboundMedia = providers.objectStorage ? new IngestInboundMediaUseCase(db, channel, providers.objectStorage) : void 0;
+  if (flowInterpreter && providers.objectStorage?.getObject) {
+    flowInterpreter.registerFlowAction(FLOW_ACTION_KIND.SEND_MEDIA, createSendMediaAction({
+      flowMediaRepository,
+      objectStorage: providers.objectStorage,
+      logMessage,
+      startState,
+      // Cache ligado por padrão, com o store do próprio módulo: a tabela é daqui e a coluna é
+      // daqui, então exigir que cada host escrevesse o repositório faria todos reescreverem o
+      // mesmo código — e, até escreverem, o mesmo binário continuaria subindo por cliente. Quem
+      // quiser outro lugar (Redis) troca o `store`; quem não fizer nada já sai sem ressubir.
+      mediaIdCache: {
+        store: new FlowMediaIdRepository(db),
+        senderKey: config.phoneNumberId
+      },
+      onError: hooks?.onFlowMediaError
+    }));
+  }
+  if (flowInterpreter && providers.catalog && config.catalogId) {
+    flowInterpreter.registerFlowAction(FLOW_ACTION_KIND.SEND_PRODUCT_LIST, createSendProductListAction({
+      catalog: providers.catalog,
+      catalogId: config.catalogId,
+      logMessage,
+      startState,
+      onError: hooks?.onFlowProductListError
+    }));
+  }
+  const transcriptionMode = providers.transcription?.mode ?? TRANSCRIPTION_MODE.ON_DEMAND;
+  const resolveTranscriptionPolicy = providers.transcription ? createTranscriptionPolicyResolver({
+    settingsRepository,
+    defaults: {
+      isEnabled: providers.transcription.isEnabledByDefault ?? true,
+      mode: transcriptionMode
+    }
+  }) : void 0;
+  const ingestInboundMedia = providers.objectStorage ? new IngestInboundMediaUseCase(db, channel, providers.objectStorage, documentRepository, providers.transcription && resolveTranscriptionPolicy ? {
+    transcriber: providers.transcription.transcriber,
+    resolvePolicy: resolveTranscriptionPolicy,
+    messageRepository,
+    ...providers.transcription.languageHint ? {
+      languageHint: providers.transcription.languageHint
+    } : {},
+    ...hooks ? {
+      hooks
+    } : {}
+  } : void 0) : void 0;
+  const transcribeAudio = providers.transcription && providers.objectStorage?.getObject ? new TranscribeAudioUseCase({
+    messageRepository,
+    objectStorage: providers.objectStorage,
+    transcriber: providers.transcription.transcriber,
+    ...resolveTranscriptionPolicy ? {
+      resolvePolicy: resolveTranscriptionPolicy
+    } : {},
+    ...providers.transcription.languageHint ? {
+      languageHint: providers.transcription.languageHint
+    } : {},
+    ...hooks ? {
+      hooks
+    } : {}
+  }) : void 0;
+  const listDocuments = new ListConversationDocumentsUseCase(sessionRepository, documentRepository);
   return {
     channel,
     // undefined quando providers.objectStorage não foi injetado.
@@ -1387,10 +2893,36 @@ function createMetaWhatsAppModule(params) {
       release: new ReleaseConversationUseCase(sessionRepository, providers.realtime),
       list: new ListConversationsUseCase(sessionRepository),
       listMessages: new ListMessagesUseCase(sessionRepository, messageRepository),
+      listDocuments,
+      // Biblioteca da empresa inteira, para uma tela de Documentos fora da conversa.
+      listCompanyDocuments: new ListCompanyDocumentsUseCase(documentRepository),
+      // Apaga a mídia no storage antes das linhas — a cascata da FK sozinha deixaria os binários
+      // órfãos, já que a lista de uploadId vive justamente nas linhas que ela derruba.
+      delete: new DeleteConversationUseCase(sessionRepository, documentRepository, providers.objectStorage),
+      purgeExpiredDocuments: new PurgeExpiredDocumentsUseCase(documentRepository, providers.objectStorage),
       export: new ExportConversationUseCase(sessionRepository),
-      repository: sessionRepository
+      // undefined quando transcrição não foi injetada, ou quando o storage não sabe ler de volta.
+      // O painel consulta a ausência para decidir se desenha o botão "transcrever".
+      transcribeAudio,
+      repository: sessionRepository,
+      messageRepository,
+      documentRepository
     },
+    /**
+    * `undefined` = o host não injetou transcritor, e nenhuma configuração de empresa muda isso: a
+    * capacidade não existe. Presente, `resolvePolicy` responde o que vale para uma empresa —
+    * é o que a rota de configurações usa para dizer ao painel se desenha o interruptor.
+    */
+    transcription: providers.transcription && resolveTranscriptionPolicy ? {
+      defaultMode: transcriptionMode,
+      resolvePolicy: resolveTranscriptionPolicy
+    } : void 0,
     settings: settingsRepository,
+    /**
+    * `undefined` quando o recurso não está ligado (ou falta storage legível). O host consulta a
+    * ausência para não registrar a rota de upload — e o preview, sem a rota, esconde o microfone.
+    */
+    previewMedia: previewMediaSupport ? new StorePreviewMediaUseCase(providers.objectStorage, () => `${Date.now()}-${Math.random().toString(36).slice(2)}`) : void 0,
     webhook: {
       receive: receiveWebhook,
       // GET de verificação da Meta — o host liga na sua rota e devolve o retorno como texto puro.
@@ -1409,7 +2941,11 @@ function createMetaWhatsAppModule(params) {
       save: new SaveFlowGraphUseCase(flowGraphRepository),
       delete: new DeleteFlowGraphUseCase(flowGraphRepository),
       livePositions: new GetLiveFlowPositionsUseCase(flowGraphRepository),
-      repository: flowGraphRepository
+      repository: flowGraphRepository,
+      // Biblioteca de mídia dos nós `send_media` — o host liga nas rotas do editor
+      // (anexar/reordenar/desligar). Existe mesmo sem storage injetado: gerenciar anexos é
+      // consultar a tabela, e só o ENVIO precisa dos bytes.
+      mediaRepository: flowMediaRepository
     } : void 0,
     catalog: providers.catalog
   };
@@ -1508,14 +3044,23 @@ async function redeemSseTicket(store, ticket) {
 __name(redeemSseTicket, "redeemSseTicket");
 export {
   CreateFlowGraphUseCase,
+  DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS,
+  DeleteConversationUseCase,
   DeleteFlowGraphUseCase,
+  DocumentRepository,
   ExportConversationUseCase,
+  FlowGraphCache,
   FlowGraphRepository,
   FlowInterpreter,
+  FlowMediaIdRepository,
+  FlowMediaRepository,
   GetFlowGraphUseCase,
   GetLiveFlowPositionsUseCase,
+  InboundEffectsDispatcher,
   IngestInboundMediaUseCase,
   InvalidFlowGraphError,
+  ListCompanyDocumentsUseCase,
+  ListConversationDocumentsUseCase,
   ListConversationsUseCase,
   ListFlowGraphsUseCase,
   ListMessagesUseCase,
@@ -1523,6 +3068,10 @@ export {
   META_WHATSAPP_MIGRATIONS_TABLE,
   MessageRepository,
   OptimisticLockError,
+  PREVIEW_MEDIA_ID_PREFIX,
+  PRODUCT_LIST_LIMIT,
+  ProcessInboundDispatchUseCase,
+  PurgeExpiredDocumentsUseCase,
   ReceiveWebhookUseCase,
   ReleaseConversationUseCase,
   SaveFlowGraphUseCase,
@@ -1530,21 +3079,41 @@ export {
   SessionRepository,
   SettingsRepository,
   SseHub,
+  StorePreviewMediaUseCase,
+  TRANSCRIPTION_MODE,
+  TRANSCRIPTION_STATUS,
   TakeoverConversationUseCase,
+  TranscribeAudioUseCase,
+  WEBHOOK_CLAIM_TTL_SECONDS,
   WEBHOOK_NONCE_TTL_SECONDS,
   WhatsAppChannelAdapter,
+  buildInboundJobId,
   claimWebhookDelivery,
+  confirmWebhookDelivery,
   createMetaWhatsAppModule,
+  createSendMediaAction,
+  createSendProductListAction,
+  createTranscriptionPolicyResolver,
+  documents,
   extractMediaDescriptor,
   flowGraphs,
+  flowMedia,
+  isAudioMimeType,
+  isRetriableTranscriptionError,
+  isUnsupportedTranscriptionError,
   issueSseTicket,
   messages,
   metaWhatsAppMigrationsFolder,
   metaWhatsAppSchema,
   redeemSseTicket,
+  resolveFailureStatus,
+  resolvePreviewUploadId,
   runMetaWhatsAppMigrations,
   sessions,
   settings,
+  toPreviewMediaId,
+  toSessionContract,
+  transcriptionRetryAfterSeconds,
   verifyWebhookChallenge,
   verifyWebhookSignature
 };