@adatechnology/meta-whatsapp-module 0.2.0-rc.9 → 0.3.0

package/dist/index.cjs

@@ -8,11 +8,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc2) => {
+var __copyProps = (to, from, except, desc3) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc3 = __getOwnPropDesc(from, key)) || desc3.enumerable });
   }
   return to;
 };
@@ -22,14 +22,23 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   CreateFlowGraphUseCase: () => CreateFlowGraphUseCase,
+  DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS: () => DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS,
+  DeleteConversationUseCase: () => DeleteConversationUseCase,
   DeleteFlowGraphUseCase: () => DeleteFlowGraphUseCase,
+  DocumentRepository: () => DocumentRepository,
   ExportConversationUseCase: () => ExportConversationUseCase,
+  FlowGraphCache: () => FlowGraphCache,
   FlowGraphRepository: () => FlowGraphRepository,
   FlowInterpreter: () => FlowInterpreter,
+  FlowMediaIdRepository: () => FlowMediaIdRepository,
+  FlowMediaRepository: () => FlowMediaRepository,
   GetFlowGraphUseCase: () => GetFlowGraphUseCase,
   GetLiveFlowPositionsUseCase: () => GetLiveFlowPositionsUseCase,
+  InboundEffectsDispatcher: () => InboundEffectsDispatcher,
   IngestInboundMediaUseCase: () => IngestInboundMediaUseCase,
   InvalidFlowGraphError: () => InvalidFlowGraphError,
+  ListCompanyDocumentsUseCase: () => ListCompanyDocumentsUseCase,
+  ListConversationDocumentsUseCase: () => ListConversationDocumentsUseCase,
   ListConversationsUseCase: () => ListConversationsUseCase,
   ListFlowGraphsUseCase: () => ListFlowGraphsUseCase,
   ListMessagesUseCase: () => ListMessagesUseCase,
@@ -37,6 +46,10 @@ __export(index_exports, {
   META_WHATSAPP_MIGRATIONS_TABLE: () => META_WHATSAPP_MIGRATIONS_TABLE,
   MessageRepository: () => MessageRepository,
   OptimisticLockError: () => OptimisticLockError,
+  PREVIEW_MEDIA_ID_PREFIX: () => import_meta_whatsapp_contracts8.PREVIEW_MEDIA_ID_PREFIX,
+  PRODUCT_LIST_LIMIT: () => PRODUCT_LIST_LIMIT,
+  ProcessInboundDispatchUseCase: () => ProcessInboundDispatchUseCase,
+  PurgeExpiredDocumentsUseCase: () => PurgeExpiredDocumentsUseCase,
   ReceiveWebhookUseCase: () => ReceiveWebhookUseCase,
   ReleaseConversationUseCase: () => ReleaseConversationUseCase,
   SaveFlowGraphUseCase: () => SaveFlowGraphUseCase,
@@ -44,21 +57,41 @@ __export(index_exports, {
   SessionRepository: () => SessionRepository,
   SettingsRepository: () => SettingsRepository,
   SseHub: () => SseHub,
+  StorePreviewMediaUseCase: () => StorePreviewMediaUseCase,
+  TRANSCRIPTION_MODE: () => TRANSCRIPTION_MODE,
+  TRANSCRIPTION_STATUS: () => TRANSCRIPTION_STATUS,
   TakeoverConversationUseCase: () => TakeoverConversationUseCase,
-  WEBHOOK_NONCE_TTL_SECONDS: () => WEBHOOK_NONCE_TTL_SECONDS,
+  TranscribeAudioUseCase: () => TranscribeAudioUseCase,
+  WEBHOOK_CLAIM_TTL_SECONDS: () => import_meta_graph_core2.WEBHOOK_CLAIM_TTL_SECONDS,
+  WEBHOOK_NONCE_TTL_SECONDS: () => import_meta_graph_core2.WEBHOOK_NONCE_TTL_SECONDS,
   WhatsAppChannelAdapter: () => WhatsAppChannelAdapter,
+  buildInboundJobId: () => buildInboundJobId,
   claimWebhookDelivery: () => claimWebhookDelivery,
+  confirmWebhookDelivery: () => confirmWebhookDelivery,
   createMetaWhatsAppModule: () => createMetaWhatsAppModule,
+  createSendMediaAction: () => createSendMediaAction,
+  createSendProductListAction: () => createSendProductListAction,
+  createTranscriptionPolicyResolver: () => createTranscriptionPolicyResolver,
+  documents: () => documents,
   extractMediaDescriptor: () => extractMediaDescriptor,
   flowGraphs: () => flowGraphs,
+  flowMedia: () => flowMedia,
+  isAudioMimeType: () => isAudioMimeType,
+  isRetriableTranscriptionError: () => isRetriableTranscriptionError,
+  isUnsupportedTranscriptionError: () => isUnsupportedTranscriptionError,
   issueSseTicket: () => issueSseTicket,
   messages: () => messages,
   metaWhatsAppMigrationsFolder: () => metaWhatsAppMigrationsFolder,
   metaWhatsAppSchema: () => metaWhatsAppSchema,
   redeemSseTicket: () => redeemSseTicket,
+  resolveFailureStatus: () => resolveFailureStatus,
+  resolvePreviewUploadId: () => import_meta_whatsapp_contracts8.resolvePreviewUploadId,
   runMetaWhatsAppMigrations: () => runMetaWhatsAppMigrations,
   sessions: () => sessions,
   settings: () => settings,
+  toPreviewMediaId: () => import_meta_whatsapp_contracts8.toPreviewMediaId,
+  toSessionContract: () => toSessionContract,
+  transcriptionRetryAfterSeconds: () => transcriptionRetryAfterSeconds,
   verifyWebhookChallenge: () => verifyWebhookChallenge,
   verifyWebhookSignature: () => verifyWebhookSignature
 });
@@ -66,6 +99,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/createMetaWhatsAppModule.ts
 var import_meta_whatsapp_provider = require("@adatechnology/meta-whatsapp-provider");
+var import_meta_whatsapp_contracts13 = require("@adatechnology/meta-whatsapp-contracts");
 
 // src/repositories/SessionRepository.ts
 var import_drizzle_orm2 = require("drizzle-orm");
@@ -168,6 +202,27 @@ var messages = metaWhatsAppSchema.table("messages", {
   // parcial sobre boolean resolve isso sem cavar jsonb.
   moderationFlagged: (0, import_pg_core.boolean)("moderation_flagged"),
   moderationTerms: (0, import_pg_core.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: (0, import_pg_core.varchar)("transcription_status", {
+    length: 16
+  }).$type(),
+  transcriptionText: (0, import_pg_core.text)("transcription_text"),
+  transcriptionLanguage: (0, import_pg_core.varchar)("transcription_language", {
+    length: 32
+  }),
+  /** Qual engine produziu. Com uma cadeia de engines, é o que responde "por que esta saiu ruim". */
+  transcriptionEngine: (0, import_pg_core.varchar)("transcription_engine", {
+    length: 32
+  }),
   createdAt: (0, import_pg_core.timestamp)("created_at", {
     withTimezone: true
   }).notNull().defaultNow()
@@ -182,7 +237,51 @@ var messages = metaWhatsAppSchema.table("messages", {
   (0, import_pg_core.uniqueIndex)("idx_messages_company_wa_message_id").on(table.companyId, table.waMessageId).where(import_drizzle_orm.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.
-  (0, import_pg_core.index)("idx_messages_moderation_flagged").on(table.companyId, table.createdAt).where(import_drizzle_orm.sql`${table.moderationFlagged}`)
+  (0, import_pg_core.index)("idx_messages_moderation_flagged").on(table.companyId, table.createdAt).where(import_drizzle_orm.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.
+  (0, import_pg_core.index)("idx_messages_transcription_pending").on(table.companyId, table.createdAt).where(import_drizzle_orm.sql`${table.transcriptionStatus} = 'pending'`)
+]);
+var documents = metaWhatsAppSchema.table("documents", {
+  id: (0, import_pg_core.uuid)("id").primaryKey().defaultRandom(),
+  companyId: (0, import_pg_core.uuid)("company_id").notNull(),
+  sessionId: (0, import_pg_core.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: (0, import_pg_core.uuid)("message_id").references(() => messages.id, {
+    onDelete: "set null"
+  }),
+  uploadId: (0, import_pg_core.varchar)("upload_id", {
+    length: 256
+  }).notNull(),
+  filename: (0, import_pg_core.varchar)("filename", {
+    length: 512
+  }).notNull(),
+  mimeType: (0, import_pg_core.varchar)("mime_type", {
+    length: 128
+  }).notNull(),
+  sizeBytes: (0, import_pg_core.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: (0, import_pg_core.varchar)("sha256", {
+    length: 64
+  }),
+  source: (0, import_pg_core.varchar)("source", {
+    length: 12
+  }).notNull(),
+  linkedAt: (0, import_pg_core.timestamp)("linked_at", {
+    withTimezone: true
+  }).notNull().defaultNow()
+}, (table) => [
+  (0, import_pg_core.index)("idx_documents_session_linked").on(table.sessionId, table.linkedAt),
+  // Para varredura de retenção por idade sem passar por sessão.
+  (0, import_pg_core.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.
+  (0, import_pg_core.uniqueIndex)("idx_documents_company_upload").on(table.companyId, table.uploadId)
 ]);
 var flowGraphs = metaWhatsAppSchema.table("flow_graphs", {
   id: (0, import_pg_core.uuid)("id").primaryKey().defaultRandom(),
@@ -213,6 +312,54 @@ var flowGraphs = metaWhatsAppSchema.table("flow_graphs", {
 }, (table) => [
   (0, import_pg_core.uniqueIndex)("idx_flow_graphs_company_key").on(table.companyId, table.key)
 ]);
+var flowMedia = metaWhatsAppSchema.table("flow_media", {
+  id: (0, import_pg_core.uuid)("id").primaryKey().defaultRandom(),
+  companyId: (0, import_pg_core.uuid)("company_id").notNull(),
+  flowKey: (0, import_pg_core.varchar)("flow_key", {
+    length: 64
+  }).notNull(),
+  nodeId: (0, import_pg_core.varchar)("node_id", {
+    length: 64
+  }).notNull(),
+  uploadId: (0, import_pg_core.varchar)("upload_id", {
+    length: 256
+  }).notNull(),
+  filename: (0, import_pg_core.varchar)("filename", {
+    length: 512
+  }).notNull(),
+  mimeType: (0, import_pg_core.varchar)("mime_type", {
+    length: 128
+  }).notNull(),
+  sizeBytes: (0, import_pg_core.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: (0, import_pg_core.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: (0, import_pg_core.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: (0, import_pg_core.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: (0, import_pg_core.jsonb)("meta_media_ids").$type().notNull().default({}),
+  createdAt: (0, import_pg_core.timestamp)("created_at", {
+    withTimezone: true
+  }).notNull().defaultNow(),
+  updatedAt: (0, import_pg_core.timestamp)("updated_at", {
+    withTimezone: true
+  }).notNull().defaultNow()
+}, (table) => [
+  (0, import_pg_core.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.
+  (0, import_pg_core.uniqueIndex)("idx_flow_media_node_upload").on(table.companyId, table.flowKey, table.nodeId, table.uploadId)
+]);
 var settings = metaWhatsAppSchema.table("settings", {
   companyId: (0, import_pg_core.uuid)("company_id").primaryKey(),
   templateName: (0, import_pg_core.varchar)("template_name", {
@@ -225,6 +372,15 @@ var settings = metaWhatsAppSchema.table("settings", {
   templateVariables: (0, import_pg_core.jsonb)("template_variables").$type().notNull().default([]),
   welcomeMessage: (0, import_pg_core.text)("welcome_message"),
   farewellMessage: (0, import_pg_core.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: (0, import_pg_core.boolean)("transcription_enabled"),
+  transcriptionMode: (0, import_pg_core.varchar)("transcription_mode", {
+    length: 16
+  }).$type(),
   createdAt: (0, import_pg_core.timestamp)("created_at", {
     withTimezone: true
   }).notNull().defaultNow(),
@@ -256,6 +412,10 @@ var conversationSummaryProjection = {
       and (${sessions}.last_agent_read_at is null or m.created_at > ${sessions}.last_agent_read_at)
   )`
 };
+function sessionContextPatch(patch) {
+  return import_drizzle_orm2.sql`${sessions.context} || ${JSON.stringify(patch)}::jsonb`;
+}
+__name(sessionContextPatch, "sessionContextPatch");
 var SessionRepository = class {
   static {
     __name(this, "SessionRepository");
@@ -286,6 +446,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,
@@ -296,6 +459,25 @@ var SessionRepository = class {
       updatedAt: import_drizzle_orm2.sql`now()`
     }).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(sessions.companyId, companyId), (0, import_drizzle_orm2.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: import_drizzle_orm2.sql`now()`,
+      updatedAt: import_drizzle_orm2.sql`now()`
+    }).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(sessions.companyId, companyId), (0, import_drizzle_orm2.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((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(sessions.companyId, companyId), (0, import_drizzle_orm2.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) {
@@ -338,6 +520,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((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(sessions.companyId, companyId), (0, import_drizzle_orm2.eq)(sessions.whatsappNumber, whatsappNumber)));
+  }
   async requestHuman(companyId, whatsappNumber) {
     await this.db.update(sessions).set({
       humanRequestedAt: import_drizzle_orm2.sql`now()`,
@@ -452,6 +644,58 @@ var MessageRepository = class {
     }).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(messages.companyId, companyId), (0, import_drizzle_orm3.eq)(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((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(messages.companyId, params.companyId), (0, import_drizzle_orm3.eq)(messages.waMessageId, params.waMessageId))).returning();
+    return updated;
+  }
+  async findById(companyId, messageId) {
+    const [found] = await this.db.select().from(messages).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(messages.companyId, companyId), (0, import_drizzle_orm3.eq)(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((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(messages.companyId, params.companyId), (0, import_drizzle_orm3.eq)(messages.id, params.messageId))).returning();
+    return updated;
+  }
   async listByConversation(params) {
     const conditions = [
       (0, import_drizzle_orm3.eq)(messages.companyId, params.companyId),
@@ -501,12 +745,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((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(flowGraphs.companyId, companyId), (0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(flowGraphs.companyId, companyId));
@@ -536,7 +789,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).
@@ -550,10 +805,12 @@ var FlowGraphRepository = class {
       updatedAt: /* @__PURE__ */ new Date()
     }).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(flowGraphs.companyId, companyId), (0, import_drizzle_orm4.eq)(flowGraphs.key, graph.key), (0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(flowGraphs.companyId, companyId), (0, import_drizzle_orm4.eq)(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,
@@ -573,6 +830,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
 var import_drizzle_orm5 = require("drizzle-orm");
 function toContractSettings(row) {
@@ -581,7 +880,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");
@@ -590,7 +893,9 @@ var EMPTY_SETTINGS = {
   templateLanguage: "pt_BR",
   templateVariables: [],
   welcomeMessage: "",
-  farewellMessage: ""
+  farewellMessage: "",
+  transcriptionEnabled: null,
+  transcriptionMode: null
 };
 var SettingsRepository = class {
   static {
@@ -619,7 +924,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: {
@@ -628,6 +938,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();
@@ -706,11 +1018,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);
@@ -747,7 +1061,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",
@@ -766,6 +1080,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.
@@ -883,8 +1210,330 @@ var ListMessagesUseCase = class {
   }
 };
 
-// src/use-cases/ExportConversation.use-case.ts
+// src/use-cases/ListConversationDocuments.use-case.ts
 var import_meta_whatsapp_contracts4 = require("@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 import_meta_whatsapp_contracts4.SessionNotFoundError(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
+var import_meta_whatsapp_contracts5 = require("@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 import_meta_whatsapp_contracts5.SessionNotFoundError(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
+var import_drizzle_orm6 = require("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 = (0, import_drizzle_orm6.ilike)(documents.filename, `%${term}%`);
+  if (!digits) return byFilename;
+  return (0, import_drizzle_orm6.or)(byFilename, (0, import_drizzle_orm6.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 = [
+      (0, import_drizzle_orm6.eq)(documents.companyId, params.companyId),
+      (0, import_drizzle_orm6.eq)(documents.sessionId, params.sessionId)
+    ];
+    if (params.search) filters.push((0, import_drizzle_orm6.ilike)(documents.filename, `%${params.search}%`));
+    if (params.sources && params.sources.length > 0) {
+      filters.push((0, import_drizzle_orm6.inArray)(documents.source, [
+        ...params.sources
+      ]));
+    }
+    const where = (0, import_drizzle_orm6.and)(...filters);
+    const limit = params.limit ?? DEFAULT_LIMIT3;
+    const page = params.page && params.page > 0 ? params.page : 1;
+    const orderBy = params.sortDirection === "asc" ? (0, import_drizzle_orm6.asc)(documents.linkedAt) : (0, import_drizzle_orm6.desc)(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: (0, import_drizzle_orm6.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 = [
+      (0, import_drizzle_orm6.eq)(documents.companyId, params.companyId)
+    ];
+    const search = companyDocumentSearch(params.search);
+    if (search) filters.push(search);
+    if (params.sources && params.sources.length > 0) {
+      filters.push((0, import_drizzle_orm6.inArray)(documents.source, [
+        ...params.sources
+      ]));
+    }
+    const where = (0, import_drizzle_orm6.and)(...filters);
+    const limit = params.limit ?? DEFAULT_LIMIT3;
+    const page = params.page && params.page > 0 ? params.page : 1;
+    const orderBy = params.sortDirection === "asc" ? (0, import_drizzle_orm6.asc)(documents.linkedAt) : (0, import_drizzle_orm6.desc)(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, (0, import_drizzle_orm6.eq)(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: (0, import_drizzle_orm6.count)()
+      }).from(documents).innerJoin(sessions, (0, import_drizzle_orm6.eq)(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((0, import_drizzle_orm6.and)((0, import_drizzle_orm6.eq)(documents.companyId, companyId), (0, import_drizzle_orm6.eq)(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((0, import_drizzle_orm6.and)((0, import_drizzle_orm6.eq)(documents.companyId, companyId), (0, import_drizzle_orm6.eq)(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((0, import_drizzle_orm6.and)((0, import_drizzle_orm6.eq)(documents.companyId, companyId), (0, import_drizzle_orm6.lt)(documents.linkedAt, olderThan))).orderBy(documents.linkedAt).limit(limit);
+  }
+  async deleteById(companyId, id) {
+    await this.db.delete(documents).where((0, import_drizzle_orm6.and)((0, import_drizzle_orm6.eq)(documents.companyId, companyId), (0, import_drizzle_orm6.eq)(documents.id, id)));
+  }
+};
+
+// src/use-cases/ExportConversation.use-case.ts
+var import_meta_whatsapp_contracts6 = require("@adatechnology/meta-whatsapp-contracts");
 var ExportConversationUseCase = class {
   static {
     __name(this, "ExportConversationUseCase");
@@ -895,7 +1544,7 @@ var ExportConversationUseCase = class {
   }
   async execute(params) {
     const result = await this.sessionRepository.exportConversation(params.companyId, params.whatsappNumber);
-    if (!result) throw new import_meta_whatsapp_contracts4.SessionNotFoundError(params.whatsappNumber);
+    if (!result) throw new import_meta_whatsapp_contracts6.SessionNotFoundError(params.whatsappNumber);
     return result;
   }
 };
@@ -975,7 +1624,7 @@ var GetLiveFlowPositionsUseCase = class {
 };
 
 // src/flows/FlowInterpreter.ts
-var import_meta_whatsapp_contracts5 = require("@adatechnology/meta-whatsapp-contracts");
+var import_meta_whatsapp_contracts7 = require("@adatechnology/meta-whatsapp-contracts");
 var DEFAULT_MAX_STEPS = 50;
 function evaluateCondition(node, context) {
   if (!node.conditionContextKey || !node.conditionOperator || !node.conditionValue) return false;
@@ -1076,9 +1725,9 @@ var FlowInterpreter = class {
       kind: "terminal",
       context: input.context
     };
-    if ((0, import_meta_whatsapp_contracts5.isCrossFlowTarget)(nextNodeId)) return {
+    if ((0, import_meta_whatsapp_contracts7.isCrossFlowTarget)(nextNodeId)) return {
       kind: "cross-flow",
-      flowKey: (0, import_meta_whatsapp_contracts5.crossFlowKey)(nextNodeId),
+      flowKey: (0, import_meta_whatsapp_contracts7.crossFlowKey)(nextNodeId),
       context: input.context
     };
     if (!input.graph.nodes[nextNodeId]) return {
@@ -1132,45 +1781,341 @@ var FlowInterpreter = class {
   }
 };
 
-// src/channel/WhatsAppChannelAdapter.ts
-var import_meta_graph_core = require("@adatechnology/meta-graph-core");
-var import_meta_whatsapp_contracts6 = require("@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 import_meta_graph_core.WhatsAppWindowExpiredError) throw new import_meta_whatsapp_contracts6.WindowExpiredError();
-      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
+var import_drizzle_orm7 = require("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 (0, import_drizzle_orm7.and)((0, import_drizzle_orm7.eq)(flowMedia.companyId, location.companyId), (0, import_drizzle_orm7.eq)(flowMedia.flowKey, location.flowKey), (0, import_drizzle_orm7.eq)(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((0, import_drizzle_orm7.and)(this.locationFilter(location), (0, import_drizzle_orm7.eq)(flowMedia.active, true))).orderBy((0, import_drizzle_orm7.asc)(flowMedia.sortOrder), (0, import_drizzle_orm7.asc)(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((0, import_drizzle_orm7.asc)(flowMedia.sortOrder), (0, import_drizzle_orm7.asc)(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: import_drizzle_orm7.sql`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: import_drizzle_orm7.sql`now()`
+    }).where((0, import_drizzle_orm7.and)((0, import_drizzle_orm7.eq)(flowMedia.companyId, params.companyId), (0, import_drizzle_orm7.eq)(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((0, import_drizzle_orm7.and)((0, import_drizzle_orm7.eq)(flowMedia.companyId, params.companyId), (0, import_drizzle_orm7.eq)(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 : import_drizzle_orm7.sql`${flowMedia.nodeId} NOT IN ${params.existingNodeIds}`;
+    await this.db.delete(flowMedia).where((0, import_drizzle_orm7.and)((0, import_drizzle_orm7.eq)(flowMedia.companyId, params.companyId), (0, import_drizzle_orm7.eq)(flowMedia.flowKey, params.flowKey), condition));
+  }
+};
+
+// src/repositories/FlowMediaIdRepository.ts
+var import_drizzle_orm8 = require("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((0, import_drizzle_orm8.eq)(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: import_drizzle_orm8.sql`jsonb_set(${flowMedia.metaMediaIds}, ARRAY[${params.senderKey}::text], to_jsonb(${params.mediaId}::text), true)`
+    }).where((0, import_drizzle_orm8.eq)(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: import_drizzle_orm8.sql`${flowMedia.metaMediaIds} - ${params.senderKey}::text`
+    }).where((0, import_drizzle_orm8.eq)(flowMedia.id, params.flowMediaId));
+  }
+};
+
+// src/channel/WhatsAppChannelAdapter.ts
+var import_meta_graph_core = require("@adatechnology/meta-graph-core");
+var import_meta_whatsapp_contracts9 = require("@adatechnology/meta-whatsapp-contracts");
+
+// src/channel/previewMedia.ts
+var import_meta_whatsapp_contracts8 = require("@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 import_meta_graph_core.WhatsAppWindowExpiredError) throw new import_meta_whatsapp_contracts9.WindowExpiredError();
+      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,
@@ -1185,49 +2130,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 ? (0, import_meta_whatsapp_contracts8.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
-var import_meta_whatsapp_contracts8 = require("@adatechnology/meta-whatsapp-contracts");
+var import_meta_whatsapp_contracts12 = require("@adatechnology/meta-whatsapp-contracts");
 
 // src/channel/webhookSecurity.ts
-var import_node_crypto = require("crypto");
-var import_meta_whatsapp_contracts7 = require("@adatechnology/meta-whatsapp-contracts");
-var WEBHOOK_NONCE_TTL_SECONDS = 300;
-function safeEqualStrings(left, right) {
-  const leftDigest = (0, import_node_crypto.createHmac)("sha256", "constant-time-compare").update(left).digest();
-  const rightDigest = (0, import_node_crypto.createHmac)("sha256", "constant-time-compare").update(right).digest();
-  return (0, import_node_crypto.timingSafeEqual)(leftDigest, rightDigest);
-}
-__name(safeEqualStrings, "safeEqualStrings");
+var import_meta_graph_core2 = require("@adatechnology/meta-graph-core");
+var import_meta_whatsapp_contracts10 = require("@adatechnology/meta-whatsapp-contracts");
+var WEBHOOK_NONCE_NAMESPACE = "meta-whatsapp";
 function verifyWebhookChallenge(params) {
-  if (params.mode !== "subscribe" || !params.token || !params.challenge) {
-    throw new import_meta_whatsapp_contracts7.InvalidWebhookSignatureError();
-  }
-  if (!safeEqualStrings(params.token, params.expectedToken)) {
-    throw new import_meta_whatsapp_contracts7.InvalidWebhookSignatureError();
-  }
+  if (!(0, import_meta_graph_core2.isValidWebhookChallenge)(params)) throw new import_meta_whatsapp_contracts10.InvalidWebhookSignatureError();
   return params.challenge;
 }
 __name(verifyWebhookChallenge, "verifyWebhookChallenge");
 function verifyWebhookSignature(params) {
-  const { rawBody, signatureHeader, appSecret } = params;
-  if (!signatureHeader?.startsWith("sha256=")) throw new import_meta_whatsapp_contracts7.InvalidWebhookSignatureError();
-  const expected = (0, import_node_crypto.createHmac)("sha256", appSecret).update(rawBody).digest("hex");
-  const received = signatureHeader.slice("sha256=".length);
-  if (!safeEqualStrings(received, expected)) throw new import_meta_whatsapp_contracts7.InvalidWebhookSignatureError();
+  if (!(0, import_meta_graph_core2.isValidWebhookSignature)(params)) throw new import_meta_whatsapp_contracts10.InvalidWebhookSignatureError();
 }
 __name(verifyWebhookSignature, "verifyWebhookSignature");
+function deliveryKey(signatureHeader) {
+  return (0, import_meta_graph_core2.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 ?? import_meta_graph_core2.WEBHOOK_CLAIM_TTL_SECONDS);
 }
 __name(claimWebhookDelivery, "claimWebhookDelivery");
+async function confirmWebhookDelivery(params) {
+  await params.nonceStore.confirm?.(deliveryKey(params.signatureHeader), params.ttlSeconds ?? import_meta_graph_core2.WEBHOOK_NONCE_TTL_SECONDS);
+}
+__name(confirmWebhookDelivery, "confirmWebhookDelivery");
 
-// src/channel/ReceiveWebhook.use-case.ts
+// src/channel/IngestInboundMedia.use-case.ts
+var import_drizzle_orm9 = require("drizzle-orm");
+
+// src/use-cases/TranscribeAudio.use-case.ts
+var import_meta_whatsapp_contracts11 = require("@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 import_meta_whatsapp_contracts11.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 import_meta_whatsapp_contracts11.MessageNotAudioError(message.id, message.type);
+  }
+  const uploadId = payload["uploadId"];
+  if (typeof uploadId !== "string" || uploadId.length === 0) {
+    throw new import_meta_whatsapp_contracts11.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((0, import_drizzle_orm9.and)((0, import_drizzle_orm9.eq)(messages.companyId, params.companyId), (0, import_drizzle_orm9.eq)(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((0, import_drizzle_orm9.and)((0, import_drizzle_orm9.eq)(messages.companyId, params.companyId), (0, import_drizzle_orm9.eq)(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,
@@ -1248,6 +2549,74 @@ 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), job.profileName === void 0 ? {} : {
+      profileName: job.profileName
+    });
+    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;
@@ -1260,13 +2629,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;
@@ -1280,6 +2642,14 @@ function extractPayload(message) {
   return Object.keys(payload).length > 0 ? payload : null;
 }
 __name(extractPayload, "extractPayload");
+var ACCOUNT_EVENT_FIELDS = [
+  import_meta_whatsapp_contracts12.WHATSAPP_WEBHOOK_FIELDS.TEMPLATE_STATUS_UPDATE,
+  import_meta_whatsapp_contracts12.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");
@@ -1287,7 +2657,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,
@@ -1300,32 +2680,106 @@ 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 = import_meta_whatsapp_contracts8.whatsAppWebhookPayloadSchema.parse(JSON.parse(rawText));
+    const parsed = import_meta_whatsapp_contracts12.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);
+          const profileName = (0, import_meta_whatsapp_contracts12.resolveContactProfileName)({
+            contacts: change.value.contacts,
+            from: message.from
+          });
+          await this.handleMessage(input.companyId, message, profileName);
           messagesProcessed++;
         }
         for (const status of change.value.statuses ?? []) {
           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
     };
   }
-  async handleMessage(companyId, message) {
+  // 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 === import_meta_whatsapp_contracts12.WHATSAPP_WEBHOOK_FIELDS.TEMPLATE_STATUS_UPDATE) {
+      const update = import_meta_whatsapp_contracts12.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 = import_meta_whatsapp_contracts12.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, profileName) {
     const saved = await this.params.logMessage.execute({
       companyId,
       whatsappNumber: message.from,
@@ -1339,12 +2793,20 @@ 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
+      } : {},
+      ...profileName ? {
+        profileName
+      } : {},
+      receivedAt: Date.now()
+    });
   }
   async handleStatus(companyId, status) {
     const updated = await this.params.messageRepository.updateMessageStatus(companyId, status.id, status.status);
@@ -1353,81 +2815,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
-var import_drizzle_orm6 = require("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((0, import_drizzle_orm6.and)((0, import_drizzle_orm6.eq)(messages.companyId, params.companyId), (0, import_drizzle_orm6.eq)(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((0, import_drizzle_orm6.and)((0, import_drizzle_orm6.eq)(messages.companyId, params.companyId), (0, import_drizzle_orm6.eq)(messages.id, params.messageId)));
     return {
-      uploadId,
-      alreadyIngested: false
+      mediaId: (0, import_meta_whatsapp_contracts8.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) {
@@ -1441,15 +2893,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 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);
+  const sendMessage = new SendMessageUseCase(channel, sessionRepository, logMessage, providers.objectStorage, documentRepository);
   const receiveWebhook = new ReceiveWebhookUseCase({
     appSecret: config.appSecret,
+    phoneNumberId: config.phoneNumberId,
     nonceStore,
     sessionRepository,
     messageRepository,
@@ -1459,7 +2920,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(import_meta_whatsapp_contracts13.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(import_meta_whatsapp_contracts13.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.
@@ -1471,10 +2991,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.
@@ -1493,7 +3039,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
   };
@@ -1516,7 +3066,7 @@ async function runMetaWhatsAppMigrations(params) {
 __name(runMetaWhatsAppMigrations, "runMetaWhatsAppMigrations");
 
 // src/realtime/SseHub.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto = require("crypto");
 var TICKET_TTL_SECONDS = 60;
 var SseHub = class {
   static {
@@ -1529,7 +3079,7 @@ var SseHub = class {
   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 = (0, import_node_crypto2.randomUUID)();
+  instanceId = (0, import_node_crypto.randomUUID)();
   constructor(relay) {
     this.relay = relay;
   }
@@ -1575,7 +3125,7 @@ var SseHub = class {
   }
 };
 async function issueSseTicket(store, companyId, whatsappNumber) {
-  const ticket = (0, import_node_crypto2.randomUUID)();
+  const ticket = (0, import_node_crypto.randomUUID)();
   await store.set(`sse:ticket:${ticket}`, JSON.stringify({
     companyId,
     whatsappNumber
@@ -1593,14 +3143,23 @@ __name(redeemSseTicket, "redeemSseTicket");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   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,
@@ -1608,6 +3167,10 @@ __name(redeemSseTicket, "redeemSseTicket");
   META_WHATSAPP_MIGRATIONS_TABLE,
   MessageRepository,
   OptimisticLockError,
+  PREVIEW_MEDIA_ID_PREFIX,
+  PRODUCT_LIST_LIMIT,
+  ProcessInboundDispatchUseCase,
+  PurgeExpiredDocumentsUseCase,
   ReceiveWebhookUseCase,
   ReleaseConversationUseCase,
   SaveFlowGraphUseCase,
@@ -1615,21 +3178,41 @@ __name(redeemSseTicket, "redeemSseTicket");
   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
 });