@adatechnology/meta-whatsapp-module 0.2.0-rc.2 → 0.2.0-rc.21

package/dist/index.js

@@ -10,6 +10,7 @@ var __dirname = /* @__PURE__ */ getDirname();
 
 // src/createMetaWhatsAppModule.ts
 import { WhatsAppMessageProvider } from "@adatechnology/meta-whatsapp-provider";
+import { FLOW_ACTION_KIND } from "@adatechnology/meta-whatsapp-contracts";
 
 // src/repositories/SessionRepository.ts
 import { and, desc, eq, sql as sql2 } from "drizzle-orm";
@@ -85,9 +86,14 @@ var messages = metaWhatsAppSchema.table("messages", {
     length: 12
   }).notNull(),
   agentUserId: uuid("agent_user_id"),
-  type: varchar("type", {
-    length: 16
-  }).notNull().default("text"),
+  // 32, não 16: os tipos da própria Meta são curtos ('text', 'interactive'), mas o host rotula
+  type: (
+    // a saída com o subtipo que enviou ('interactive_buttons' já tem 19). Apertar aqui só
+    // transfere para o consumidor a escolha entre truncar o rótulo e estourar o insert.
+    varchar("type", {
+      length: 32
+    }).notNull().default("text")
+  ),
   content: text("content"),
   // T5.4 — nunca base64 aqui; mídia vive no ObjectStorageInterface do host, referenciada por
   // uploadId dentro deste jsonb.
@@ -101,6 +107,33 @@ var messages = metaWhatsAppSchema.table("messages", {
   readAt: timestamp("read_at", {
     withTimezone: true
   }),
+  // Moderação de conteúdo. `null` significa NÃO AVALIADO (moderação desligada, ou mensagem
+  // anterior ao recurso) — diferente de `false`, que é avaliado e limpo. Colunas em vez de chave
+  // dentro de `payload` porque "listar o que foi sinalizado" é consulta de operação, e índice
+  // parcial sobre boolean resolve isso sem cavar jsonb.
+  moderationFlagged: boolean("moderation_flagged"),
+  moderationTerms: jsonb("moderation_terms").$type(),
+  /**
+   * Transcrição de áudio. `null` em `transcription_status` significa NÃO AVALIADO — áudio nunca
+   * pedido (modo sob demanda), transcrição desligada, mensagem anterior ao recurso, ou mensagem
+   * que não é áudio. Diferente de `'done'` com texto vazio, que é áudio em silêncio já processado
+   * e que NÃO deve ser reprocessado.
+   *
+   * Colunas em vez de chave em `payload` pelo mesmo motivo da moderação: "quais áudios ficaram
+   * pendentes" e "quais falharam" são consultas de operação, e índice parcial resolve sem cavar
+   * jsonb. Buscar texto de áudio também deixa de exigir varredura de payload.
+   */
+  transcriptionStatus: varchar("transcription_status", {
+    length: 16
+  }).$type(),
+  transcriptionText: text("transcription_text"),
+  transcriptionLanguage: varchar("transcription_language", {
+    length: 32
+  }),
+  /** Qual engine produziu. Com uma cadeia de engines, é o que responde "por que esta saiu ruim". */
+  transcriptionEngine: varchar("transcription_engine", {
+    length: 32
+  }),
   createdAt: timestamp("created_at", {
     withTimezone: true
   }).notNull().defaultNow()
@@ -112,7 +145,54 @@ var messages = metaWhatsAppSchema.table("messages", {
   // paralelo, então as duas passariam pela checagem e inseririam duplicado. Parcial porque
   // mensagens outbound ainda sem waMessageId (envio em curso) são legitimamente NULL, e NULLs
   // não podem competir entre si por unicidade.
-  uniqueIndex("idx_messages_company_wa_message_id").on(table.companyId, table.waMessageId).where(sql`${table.waMessageId} is not null`)
+  uniqueIndex("idx_messages_company_wa_message_id").on(table.companyId, table.waMessageId).where(sql`${table.waMessageId} is not null`),
+  // Parcial: só as sinalizadas entram, então o índice fica do tamanho do problema e não do
+  // tamanho do transcript.
+  index("idx_messages_moderation_flagged").on(table.companyId, table.createdAt).where(sql`${table.moderationFlagged}`),
+  // Alimenta a varredura de retomada: "quais áudios ficaram pendentes de transcrição". Parcial
+  // porque pendente é estado transitório e raro — o índice fica do tamanho da fila atrasada, não
+  // do transcript inteiro.
+  index("idx_messages_transcription_pending").on(table.companyId, table.createdAt).where(sql`${table.transcriptionStatus} = 'pending'`)
+]);
+var documents = metaWhatsAppSchema.table("documents", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  companyId: uuid("company_id").notNull(),
+  sessionId: uuid("session_id").notNull().references(() => sessions.id, {
+    onDelete: "cascade"
+  }),
+  // Anulável e `set null`: apagar a mensagem não deve apagar o arquivo da biblioteca, e arquivo
+  // do atendente nasce sem mensagem.
+  messageId: uuid("message_id").references(() => messages.id, {
+    onDelete: "set null"
+  }),
+  uploadId: varchar("upload_id", {
+    length: 256
+  }).notNull(),
+  filename: varchar("filename", {
+    length: 512
+  }).notNull(),
+  mimeType: varchar("mime_type", {
+    length: 128
+  }).notNull(),
+  sizeBytes: integer("size_bytes").notNull(),
+  // Do provider de storage, que é endereçado por conteúdo — serve para reconciliar storage
+  // contra tabela e para detectar o mesmo binário chegando duas vezes.
+  sha256: varchar("sha256", {
+    length: 64
+  }),
+  source: varchar("source", {
+    length: 12
+  }).notNull(),
+  linkedAt: timestamp("linked_at", {
+    withTimezone: true
+  }).notNull().defaultNow()
+}, (table) => [
+  index("idx_documents_session_linked").on(table.sessionId, table.linkedAt),
+  // Para varredura de retenção por idade sem passar por sessão.
+  index("idx_documents_company_linked").on(table.companyId, table.linkedAt),
+  // O mesmo objeto não pode ser linkado duas vezes na mesma empresa: o job de ingestão é
+  // reentregue por retry, e sem isto a reentrega criaria linha duplicada no painel.
+  uniqueIndex("idx_documents_company_upload").on(table.companyId, table.uploadId)
 ]);
 var flowGraphs = metaWhatsAppSchema.table("flow_graphs", {
   id: uuid("id").primaryKey().defaultRandom(),
@@ -143,6 +223,46 @@ var flowGraphs = metaWhatsAppSchema.table("flow_graphs", {
 }, (table) => [
   uniqueIndex("idx_flow_graphs_company_key").on(table.companyId, table.key)
 ]);
+var flowMedia = metaWhatsAppSchema.table("flow_media", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  companyId: uuid("company_id").notNull(),
+  flowKey: varchar("flow_key", {
+    length: 64
+  }).notNull(),
+  nodeId: varchar("node_id", {
+    length: 64
+  }).notNull(),
+  uploadId: varchar("upload_id", {
+    length: 256
+  }).notNull(),
+  filename: varchar("filename", {
+    length: 512
+  }).notNull(),
+  mimeType: varchar("mime_type", {
+    length: 128
+  }).notNull(),
+  sizeBytes: integer("size_bytes").notNull(),
+  // Legenda da mídia no WhatsApp. Por arquivo, não por nó: um nó que manda tabela de preços e
+  // um folder precisa de textos diferentes para cada um.
+  caption: text("caption"),
+  // Ordem de envio dentro do nó — o cliente recebe as mensagens em sequência, e "tabela antes
+  // do folder" é decisão de quem edita, não do banco.
+  sortOrder: integer("sort_order").notNull().default(0),
+  // Desligar sem desanexar: trocar o material da campanha é o caso comum, e apagar a linha
+  // perderia a ordem e a legenda já ajustadas.
+  active: boolean("active").notNull().default(true),
+  createdAt: timestamp("created_at", {
+    withTimezone: true
+  }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", {
+    withTimezone: true
+  }).notNull().defaultNow()
+}, (table) => [
+  index("idx_flow_media_node").on(table.companyId, table.flowKey, table.nodeId, table.sortOrder),
+  // O mesmo arquivo anexado duas vezes ao MESMO nó é erro de clique no editor, e o cliente
+  // receberia o documento repetido.
+  uniqueIndex("idx_flow_media_node_upload").on(table.companyId, table.flowKey, table.nodeId, table.uploadId)
+]);
 var settings = metaWhatsAppSchema.table("settings", {
   companyId: uuid("company_id").primaryKey(),
   templateName: varchar("template_name", {
@@ -155,6 +275,15 @@ var settings = metaWhatsAppSchema.table("settings", {
   templateVariables: jsonb("template_variables").$type().notNull().default([]),
   welcomeMessage: text("welcome_message"),
   farewellMessage: text("farewell_message"),
+  /**
+  * Política de transcrição desta empresa. Nulo é significativo: "o painel não decidiu", e aí vale
+  * o padrão que o host injetou. Sem a distinção, atualizar o módulo desligaria a transcrição de
+  * quem já a tinha ligada por ambiente.
+  */
+  transcriptionEnabled: boolean("transcription_enabled"),
+  transcriptionMode: varchar("transcription_mode", {
+    length: 16
+  }).$type(),
   createdAt: timestamp("created_at", {
     withTimezone: true
   }).notNull().defaultNow(),
@@ -165,6 +294,31 @@ var settings = metaWhatsAppSchema.table("settings", {
 
 // src/repositories/SessionRepository.ts
 var DEFAULT_LIMIT = 20;
+var conversationSummaryProjection = {
+  lastContent: sql2`(
+    select m.content from ${messages} m
+    where m.company_id = ${sessions}.company_id and m.session_id = ${sessions}.id
+    order by m.created_at desc limit 1
+  )`,
+  lastDirection: sql2`(
+    select m.direction from ${messages} m
+    where m.company_id = ${sessions}.company_id and m.session_id = ${sessions}.id
+    order by m.created_at desc limit 1
+  )`,
+  // Entradas do cliente depois da última leitura do atendente. Sessão nunca lida conta
+  // tudo — é o comportamento esperado de uma conversa que ninguém abriu ainda.
+  unread: sql2`(
+    select count(*)::int from ${messages} m
+    where m.company_id = ${sessions}.company_id
+      and m.session_id = ${sessions}.id
+      and m.direction = 'inbound'
+      and (${sessions}.last_agent_read_at is null or m.created_at > ${sessions}.last_agent_read_at)
+  )`
+};
+function sessionContextPatch(patch) {
+  return sql2`${sessions.context} || ${JSON.stringify(patch)}::jsonb`;
+}
+__name(sessionContextPatch, "sessionContextPatch");
 var SessionRepository = class {
   static {
     __name(this, "SessionRepository");
@@ -195,6 +349,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,
@@ -205,6 +362,25 @@ var SessionRepository = class {
       updatedAt: sql2`now()`
     }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
   }
+  // Mescla parcial do context, feita no banco (`||`) e não por read-modify-write no host: duas
+  // mensagens do mesmo cliente processadas em paralelo sobrescreveriam uma à outra, e o campo
+  // acumula justamente as respostas coletadas ao longo da conversa. Chave presente no patch
+  // vence a existente; as demais permanecem.
+  async patchContext(companyId, whatsappNumber, patch) {
+    await this.db.update(sessions).set({
+      context: sessionContextPatch(patch),
+      lastActivity: sql2`now()`,
+      updatedAt: sql2`now()`
+    }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
+  }
+  // Leitura tipada do estado de sessão do produto. Devolve undefined quando a sessão não existe —
+  // distinto de existir com context vazio, que devolve o objeto vazio.
+  async readContext(companyId, whatsappNumber) {
+    const [row] = await this.db.select({
+      context: sessions.context
+    }).from(sessions).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber))).limit(1);
+    return row?.context;
+  }
   // Posição no grafo de fluxo — chamado pelo host a cada transição do FlowInterpreter.
   // Passar null em ambos desliga o rastreio (ex.: conversa saiu do motor de fluxo).
   async setFlowPosition(companyId, whatsappNumber, flowKey, currentNodeId) {
@@ -247,6 +423,16 @@ var SessionRepository = class {
   async release(companyId, whatsappNumber) {
     await this.setMode(companyId, whatsappNumber, "bot", null);
   }
+  /**
+  * Apaga a sessão; a cascata das FKs leva mensagens e documentos.
+  *
+  * Não apaga o binário no storage — isso é passo de aplicação, e é por isso que este método é
+  * chamado por `DeleteConversationUseCase` e não diretamente pelo host. Chamar daqui sem apagar os
+  * objetos antes deixa mídia órfã sendo cobrada para sempre.
+  */
+  async deleteByNumber(companyId, whatsappNumber) {
+    await this.db.delete(sessions).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
+  }
   async requestHuman(companyId, whatsappNumber) {
     await this.db.update(sessions).set({
       humanRequestedAt: sql2`now()`,
@@ -280,17 +466,28 @@ var SessionRepository = class {
       currentState: sessions.currentState,
       lastActivity: sessions.lastActivity,
       lastInboundAt: sessions.lastInboundAt,
-      humanRequestedAt: sessions.humanRequestedAt
+      humanRequestedAt: sessions.humanRequestedAt,
+      // Prévia e contagem saem de subquery correlacionada em vez de N+1 na volta: uma inbox
+      // lista dezenas de conversas por página, e uma query por linha é o gargalo clássico
+      // dessa tela. Ambos os campos são dados do próprio módulo — deixá-los para o host
+      // obrigaria todo consumidor a reescrever o mesmo join contra tabelas que não são dele.
+      ...conversationSummaryProjection
     }).from(sessions).where(and(...conditions)).orderBy(desc(sessions.lastActivity)).limit(limit).offset(offset);
     return rows.map((row) => ({
       id: row.id,
       whatsappNumber: row.whatsappNumber,
+      ...row.lastContent !== null ? {
+        lastContent: row.lastContent
+      } : {},
+      ...row.lastDirection !== null ? {
+        lastDirection: row.lastDirection
+      } : {},
       lastAt: row.lastActivity.toISOString(),
       lastInboundAt: row.lastInboundAt?.toISOString() ?? null,
       mode: row.mode,
       assignedUserId: row.assignedUserId,
       waitingHuman: row.humanRequestedAt !== null,
-      unread: 0,
+      unread: Number(row.unread),
       currentState: row.currentState
     }));
   }
@@ -334,7 +531,9 @@ var MessageRepository = class {
       content: params.content ?? null,
       payload: params.payload ?? null,
       waMessageId: params.waMessageId ?? null,
-      status: params.status ?? null
+      status: params.status ?? null,
+      moderationFlagged: params.moderationFlagged ?? null,
+      moderationTerms: params.moderationTerms ?? null
     };
     const [created] = await this.db.insert(messages).values(values).onConflictDoNothing().returning();
     return created;
@@ -348,6 +547,58 @@ var MessageRepository = class {
     }).where(and2(eq2(messages.companyId, companyId), eq2(messages.waMessageId, waMessageId))).returning();
     return updated;
   }
+  /**
+  * Grava a transcrição endereçando pelo id da Meta, para quem só tem esse.
+  *
+  * Serve ao caso em que a transcrição acontece no próprio webhook — o grafo precisa do texto para
+  * responder ao cliente, e jogar fora o que ele já pagou para transcrever significaria transcrever
+  * o mesmo áudio uma segunda vez só para o painel ver.
+  *
+  * Devolve `undefined` quando não achou a mensagem: entrega duplicada e mensagem apagada são
+  * corridas normais, não erro.
+  */
+  async saveTranscriptionByWaMessageId(params) {
+    const [updated] = await this.db.update(messages).set({
+      transcriptionStatus: params.status,
+      ...params.text !== void 0 ? {
+        transcriptionText: params.text
+      } : {},
+      ...params.language !== void 0 ? {
+        transcriptionLanguage: params.language
+      } : {},
+      ...params.engine !== void 0 ? {
+        transcriptionEngine: params.engine
+      } : {}
+    }).where(and2(eq2(messages.companyId, params.companyId), eq2(messages.waMessageId, params.waMessageId))).returning();
+    return updated;
+  }
+  async findById(companyId, messageId) {
+    const [found] = await this.db.select().from(messages).where(and2(eq2(messages.companyId, companyId), eq2(messages.id, messageId))).limit(1);
+    return found;
+  }
+  /**
+  * Grava o resultado da transcrição. Devolve `undefined` quando a mensagem não existe (apagada
+  * entre o enfileiramento e a execução do job) — não é erro, é corrida normal.
+  *
+  * `text`/`language`/`engine` só são tocados quando informados: uma retentativa que volta a falhar
+  * atualiza o status sem apagar a transcrição parcial de uma tentativa anterior que tenha vindo de
+  * outro engine da cadeia.
+  */
+  async saveTranscription(params) {
+    const [updated] = await this.db.update(messages).set({
+      transcriptionStatus: params.status,
+      ...params.text !== void 0 ? {
+        transcriptionText: params.text
+      } : {},
+      ...params.language !== void 0 ? {
+        transcriptionLanguage: params.language
+      } : {},
+      ...params.engine !== void 0 ? {
+        transcriptionEngine: params.engine
+      } : {}
+    }).where(and2(eq2(messages.companyId, params.companyId), eq2(messages.id, params.messageId))).returning();
+    return updated;
+  }
   async listByConversation(params) {
     const conditions = [
       eq2(messages.companyId, params.companyId),
@@ -397,12 +648,21 @@ var FlowGraphRepository = class {
     __name(this, "FlowGraphRepository");
   }
   db;
-  constructor(db) {
+  cache;
+  // Cache opcional: sem ele o repositório se comporta exatamente como antes, lendo sempre do
+  // banco. É o host que decide se quer cachear e com qual provedor (ver CacheInterface).
+  constructor(db, cache) {
     this.db = db;
+    this.cache = cache;
   }
   async get(companyId, key) {
+    const cached = await this.cache?.read(companyId, key);
+    if (cached) return cached;
     const [row] = await this.db.select().from(flowGraphs).where(and3(eq3(flowGraphs.companyId, companyId), eq3(flowGraphs.key, key))).limit(1);
-    return row ? toContractGraph(row) : void 0;
+    if (!row) return void 0;
+    const graph = toContractGraph(row);
+    await this.cache?.write(companyId, graph);
+    return graph;
   }
   async list(companyId) {
     const rows = await this.db.select().from(flowGraphs).where(eq3(flowGraphs.companyId, companyId));
@@ -432,7 +692,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).
@@ -446,10 +708,12 @@ var FlowGraphRepository = class {
       updatedAt: /* @__PURE__ */ new Date()
     }).where(and3(eq3(flowGraphs.companyId, companyId), eq3(flowGraphs.key, graph.key), eq3(flowGraphs.version, expectedVersion))).returning();
     if (rows.length === 0) throw new OptimisticLockError(graph.key);
+    await this.cache?.invalidate(companyId, graph.key);
     return toContractGraph(rows[0]);
   }
   async delete(companyId, key) {
     await this.db.delete(flowGraphs).where(and3(eq3(flowGraphs.companyId, companyId), eq3(flowGraphs.key, key)));
+    await this.cache?.invalidate(companyId, key);
   }
   // T4.2 — GetLiveFlowPositions: agrega sessões ativas por (flowKey, currentNodeId), lendo as
   // colunas dedicadas gravadas por SessionRepository.setFlowPosition. Agrega no banco (GROUP BY,
@@ -469,6 +733,48 @@ var FlowGraphRepository = class {
   }
 };
 
+// src/repositories/FlowGraphCache.ts
+var KEY_PREFIX = "meta-whatsapp:flow-graph";
+var DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS = 300;
+var FlowGraphCache = class {
+  static {
+    __name(this, "FlowGraphCache");
+  }
+  provider;
+  ttlSeconds;
+  constructor(provider, ttlSeconds = DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS) {
+    this.provider = provider;
+    this.ttlSeconds = ttlSeconds;
+  }
+  // companyId na chave, e não só a flowKey: a chave do fluxo é escolhida por quem edita e se
+  // repete entre empresas — 'consorcio' existe em todas — então uma chave sem tenant serviria o
+  // grafo de uma empresa para a conversa de outra.
+  keyFor(companyId, flowKey) {
+    return `${KEY_PREFIX}:${companyId}:${flowKey}`;
+  }
+  async read(companyId, flowKey) {
+    try {
+      const cached = await this.provider.get(this.keyFor(companyId, flowKey));
+      if (!cached) return void 0;
+      return JSON.parse(cached);
+    } catch {
+      return void 0;
+    }
+  }
+  async write(companyId, graph) {
+    try {
+      await this.provider.set(this.keyFor(companyId, graph.key), JSON.stringify(graph), this.ttlSeconds);
+    } catch {
+    }
+  }
+  async invalidate(companyId, flowKey) {
+    try {
+      await this.provider.delete(this.keyFor(companyId, flowKey));
+    } catch {
+    }
+  }
+};
+
 // src/repositories/SettingsRepository.ts
 import { eq as eq4 } from "drizzle-orm";
 function toContractSettings(row) {
@@ -477,7 +783,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");
@@ -486,7 +796,9 @@ var EMPTY_SETTINGS = {
   templateLanguage: "pt_BR",
   templateVariables: [],
   welcomeMessage: "",
-  farewellMessage: ""
+  farewellMessage: "",
+  transcriptionEnabled: null,
+  transcriptionMode: null
 };
 var SettingsRepository = class {
   static {
@@ -515,7 +827,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: {
@@ -524,6 +841,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();
@@ -550,16 +869,19 @@ var LogMessageUseCase = class {
   sessionRepository;
   messageRepository;
   realtime;
-  constructor(sessionRepository, messageRepository, realtime) {
+  moderator;
+  constructor(sessionRepository, messageRepository, realtime, moderator) {
     this.sessionRepository = sessionRepository;
     this.messageRepository = messageRepository;
     this.realtime = realtime;
+    this.moderator = moderator;
   }
   async execute(params) {
     const session = await this.sessionRepository.getOrCreate(params.companyId, params.whatsappNumber, params.startState);
     const saved = await this.messageRepository.insertMessage({
       ...params,
-      sessionId: session.id
+      sessionId: session.id,
+      ...this.moderationOf(params)
     });
     if (!saved) return void 0;
     if (params.direction === "inbound") {
@@ -572,6 +894,20 @@ var LogMessageUseCase = class {
     this.realtime?.emit("global", "data-changed", {});
     return saved;
   }
+  // Só o que o cliente escreveu: marcar o que o próprio atendente ou o bot enviou não sinaliza
+  // abuso, apenas sujaria o transcript com etiqueta na resposta de quem atende.
+  moderationOf(params) {
+    if (!this.moderator || params.direction !== "inbound") return {};
+    const text2 = params.content?.trim();
+    if (!text2) return {};
+    const verdict = this.moderator.inspect(text2);
+    return {
+      moderationFlagged: verdict.isOffensive,
+      moderationTerms: verdict.isOffensive ? [
+        ...verdict.matchedTerms
+      ] : null
+    };
+  }
 };
 
 // src/use-cases/SendMessage.use-case.ts
@@ -585,11 +921,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);
@@ -626,7 +964,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",
@@ -645,6 +983,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.
@@ -762,8 +1113,330 @@ var ListMessagesUseCase = class {
   }
 };
 
-// src/use-cases/ExportConversation.use-case.ts
+// src/use-cases/ListConversationDocuments.use-case.ts
 import { SessionNotFoundError as SessionNotFoundError2 } from "@adatechnology/meta-whatsapp-contracts";
+var ListConversationDocumentsUseCase = class {
+  static {
+    __name(this, "ListConversationDocumentsUseCase");
+  }
+  sessionRepository;
+  documentRepository;
+  constructor(sessionRepository, documentRepository) {
+    this.sessionRepository = sessionRepository;
+    this.documentRepository = documentRepository;
+  }
+  async execute(params) {
+    const session = await this.sessionRepository.getContext(params.companyId, params.whatsappNumber);
+    if (!session) throw new SessionNotFoundError2(params.whatsappNumber);
+    const { rows, total } = await this.documentRepository.listByConversation({
+      companyId: params.companyId,
+      sessionId: session.id,
+      ...params.search ? {
+        search: params.search
+      } : {},
+      ...params.sources && params.sources.length > 0 ? {
+        sources: params.sources
+      } : {},
+      ...params.sortDirection ? {
+        sortDirection: params.sortDirection
+      } : {},
+      ...params.page ? {
+        page: params.page
+      } : {},
+      ...params.limit ? {
+        limit: params.limit
+      } : {}
+    });
+    return {
+      documents: rows.map((row) => ({
+        id: row.uploadId,
+        filename: row.filename,
+        mimeType: row.mimeType,
+        sizeBytes: row.sizeBytes,
+        source: row.source,
+        linkedAt: row.linkedAt.toISOString()
+      })),
+      total
+    };
+  }
+};
+
+// src/use-cases/ListCompanyDocuments.use-case.ts
+var ListCompanyDocumentsUseCase = class {
+  static {
+    __name(this, "ListCompanyDocumentsUseCase");
+  }
+  documentRepository;
+  constructor(documentRepository) {
+    this.documentRepository = documentRepository;
+  }
+  async execute(params) {
+    const { rows, total } = await this.documentRepository.listByCompany({
+      companyId: params.companyId,
+      ...params.search ? {
+        search: params.search
+      } : {},
+      ...params.sources && params.sources.length > 0 ? {
+        sources: params.sources
+      } : {},
+      ...params.sortDirection ? {
+        sortDirection: params.sortDirection
+      } : {},
+      ...params.page ? {
+        page: params.page
+      } : {},
+      ...params.limit ? {
+        limit: params.limit
+      } : {}
+    });
+    return {
+      documents: rows.map((row) => ({
+        id: row.uploadId,
+        conversationId: row.whatsappNumber,
+        filename: row.filename,
+        mimeType: row.mimeType,
+        sizeBytes: row.sizeBytes,
+        source: row.source,
+        linkedAt: row.linkedAt.toISOString()
+      })),
+      total
+    };
+  }
+};
+
+// src/use-cases/DeleteConversation.use-case.ts
+import { SessionNotFoundError as SessionNotFoundError3 } from "@adatechnology/meta-whatsapp-contracts";
+var DeleteConversationUseCase = class {
+  static {
+    __name(this, "DeleteConversationUseCase");
+  }
+  sessionRepository;
+  documentRepository;
+  objectStorage;
+  constructor(sessionRepository, documentRepository, objectStorage) {
+    this.sessionRepository = sessionRepository;
+    this.documentRepository = documentRepository;
+    this.objectStorage = objectStorage;
+  }
+  async execute(params) {
+    const session = await this.sessionRepository.getContext(params.companyId, params.whatsappNumber);
+    if (!session) throw new SessionNotFoundError3(params.whatsappNumber);
+    const uploadIds = await this.documentRepository.listUploadIdsBySession(params.companyId, session.id);
+    if (uploadIds.length > 0 && !this.objectStorage?.delete) {
+      throw new Error("storage_delete_unsupported: a conversa tem arquivos e o storage injetado n\xE3o implementa delete");
+    }
+    const failedObjects = [];
+    let deletedObjects = 0;
+    for (const uploadId of uploadIds) {
+      try {
+        await this.objectStorage?.delete?.(uploadId);
+        deletedObjects++;
+      } catch {
+        failedObjects.push(uploadId);
+      }
+    }
+    if (failedObjects.length > 0) return {
+      deletedObjects,
+      failedObjects
+    };
+    await this.sessionRepository.deleteByNumber(params.companyId, params.whatsappNumber);
+    return {
+      deletedObjects,
+      failedObjects: []
+    };
+  }
+};
+
+// src/use-cases/PurgeExpiredDocuments.use-case.ts
+var DEFAULT_BATCH_SIZE = 50;
+var HOURS_IN_DAY = 24;
+var MILLISECONDS_IN_HOUR = 60 * 60 * 1e3;
+var PurgeExpiredDocumentsUseCase = class {
+  static {
+    __name(this, "PurgeExpiredDocumentsUseCase");
+  }
+  documentRepository;
+  objectStorage;
+  constructor(documentRepository, objectStorage) {
+    this.documentRepository = documentRepository;
+    this.objectStorage = objectStorage;
+  }
+  async execute(params) {
+    if (!this.objectStorage?.delete) {
+      throw new Error("storage_delete_unsupported: reten\xE7\xE3o exige um storage que implemente delete");
+    }
+    const reference = params.now ?? /* @__PURE__ */ new Date();
+    const olderThan = new Date(reference.getTime() - params.retentionDays * HOURS_IN_DAY * MILLISECONDS_IN_HOUR);
+    const expired = await this.documentRepository.listExpired(params.companyId, olderThan, params.batchSize ?? DEFAULT_BATCH_SIZE);
+    const failed = [];
+    let purged = 0;
+    for (const document of expired) {
+      try {
+        await this.objectStorage.delete(document.uploadId);
+      } catch {
+        failed.push(document.uploadId);
+        continue;
+      }
+      await this.documentRepository.deleteById(params.companyId, document.id);
+      purged++;
+    }
+    return {
+      purged,
+      failed
+    };
+  }
+};
+
+// src/repositories/DocumentRepository.ts
+import { and as and4, asc, count, desc as desc2, eq as eq5, ilike, inArray, lt as lt2, or } from "drizzle-orm";
+var DEFAULT_LIMIT3 = 50;
+function companyDocumentSearch(search) {
+  const term = search?.trim();
+  if (!term) return void 0;
+  const digits = term.replace(/\D/g, "");
+  const byFilename = ilike(documents.filename, `%${term}%`);
+  if (!digits) return byFilename;
+  return or(byFilename, ilike(sessions.whatsappNumber, `%${digits}%`));
+}
+__name(companyDocumentSearch, "companyDocumentSearch");
+var DocumentRepository = class {
+  static {
+    __name(this, "DocumentRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+  * Idempotente por (companyId, uploadId), garantido pelo índice único e não por SELECT prévio: o
+  * job de ingestão é reentregue por retry e duas tentativas concorrentes passariam as duas por uma
+  * checagem, duplicando a linha no painel.
+  *
+  * Devolve `undefined` quando o documento já estava linkado.
+  */
+  async link(params) {
+    const values = {
+      companyId: params.companyId,
+      sessionId: params.sessionId,
+      messageId: params.messageId ?? null,
+      uploadId: params.uploadId,
+      filename: params.filename,
+      mimeType: params.mimeType,
+      sizeBytes: params.sizeBytes,
+      sha256: params.sha256 ?? null,
+      source: params.source
+    };
+    const [created] = await this.db.insert(documents).values(values).onConflictDoNothing().returning();
+    return created;
+  }
+  async listByConversation(params) {
+    const filters = [
+      eq5(documents.companyId, params.companyId),
+      eq5(documents.sessionId, params.sessionId)
+    ];
+    if (params.search) filters.push(ilike(documents.filename, `%${params.search}%`));
+    if (params.sources && params.sources.length > 0) {
+      filters.push(inArray(documents.source, [
+        ...params.sources
+      ]));
+    }
+    const where = and4(...filters);
+    const limit = params.limit ?? DEFAULT_LIMIT3;
+    const page = params.page && params.page > 0 ? params.page : 1;
+    const orderBy = params.sortDirection === "asc" ? asc(documents.linkedAt) : desc2(documents.linkedAt);
+    const [rows, counted] = await Promise.all([
+      this.db.select().from(documents).where(where).orderBy(orderBy).limit(limit).offset((page - 1) * limit),
+      this.db.select({
+        value: count()
+      }).from(documents).where(where)
+    ]);
+    return {
+      rows,
+      total: counted[0]?.value ?? 0
+    };
+  }
+  /**
+  * A biblioteca da EMPRESA inteira, não de uma conversa.
+  *
+  * A busca casa nome do arquivo OU telefone da conversa — ver `companyDocumentSearch`.
+  *
+  * Faz join com `sessions` para carregar de qual conversa cada arquivo veio — numa lista global,
+  * arquivo sem essa referência é inútil: o atendente vê "comprovante.pdf" e não sabe de quem.
+  *
+  * Ordena por `linkedAt` apoiada no índice `idx_documents_company_linked`, que já existia para a
+  * varredura de retenção.
+  */
+  async listByCompany(params) {
+    const filters = [
+      eq5(documents.companyId, params.companyId)
+    ];
+    const search = companyDocumentSearch(params.search);
+    if (search) filters.push(search);
+    if (params.sources && params.sources.length > 0) {
+      filters.push(inArray(documents.source, [
+        ...params.sources
+      ]));
+    }
+    const where = and4(...filters);
+    const limit = params.limit ?? DEFAULT_LIMIT3;
+    const page = params.page && params.page > 0 ? params.page : 1;
+    const orderBy = params.sortDirection === "asc" ? asc(documents.linkedAt) : desc2(documents.linkedAt);
+    const [rows, counted] = await Promise.all([
+      this.db.select({
+        id: documents.id,
+        uploadId: documents.uploadId,
+        filename: documents.filename,
+        mimeType: documents.mimeType,
+        sizeBytes: documents.sizeBytes,
+        source: documents.source,
+        linkedAt: documents.linkedAt,
+        // Só o número: o NOME do cliente é dado do produto (tabela própria dele), não do
+        // módulo. Quem quiser exibir "Marina Alves" enriquece na borda.
+        whatsappNumber: sessions.whatsappNumber
+      }).from(documents).innerJoin(sessions, eq5(documents.sessionId, sessions.id)).where(where).orderBy(orderBy).limit(limit).offset((page - 1) * limit),
+      // O mesmo join da listagem, e não só `from(documents)`: a busca pode citar
+      // `sessions.whatsapp_number`, e uma contagem sem a tabela na cláusula não compila — pior,
+      // se compilasse, o total divergiria das linhas e a paginação prometeria páginas vazias.
+      this.db.select({
+        value: count()
+      }).from(documents).innerJoin(sessions, eq5(documents.sessionId, sessions.id)).where(where)
+    ]);
+    return {
+      rows,
+      total: counted[0]?.value ?? 0
+    };
+  }
+  /**
+  * Um documento pela key do objeto. Serve para recuperar o nome original na hora de assinar o
+  * download: a key é caminho no bucket e salvaria o arquivo com o id da Meta.
+  */
+  async findByUploadId(companyId, uploadId) {
+    const [row] = await this.db.select().from(documents).where(and4(eq5(documents.companyId, companyId), eq5(documents.uploadId, uploadId))).limit(1);
+    return row;
+  }
+  /**
+  * Os objetos a apagar no storage antes de a linha sumir.
+  *
+  * Existe porque a cascata da FK apaga a linha e deixa o binário órfão: quem for apagar a conversa
+  * precisa desta lista primeiro, senão paga armazenamento para sempre por arquivo inalcançável.
+  */
+  async listUploadIdsBySession(companyId, sessionId) {
+    const rows = await this.db.select({
+      uploadId: documents.uploadId
+    }).from(documents).where(and4(eq5(documents.companyId, companyId), eq5(documents.sessionId, sessionId)));
+    return rows.map((row) => row.uploadId);
+  }
+  /** Varredura de retenção por idade — o par é o mesmo cuidado com o objeto no storage. */
+  async listExpired(companyId, olderThan, limit = DEFAULT_LIMIT3) {
+    return this.db.select().from(documents).where(and4(eq5(documents.companyId, companyId), lt2(documents.linkedAt, olderThan))).orderBy(documents.linkedAt).limit(limit);
+  }
+  async deleteById(companyId, id) {
+    await this.db.delete(documents).where(and4(eq5(documents.companyId, companyId), eq5(documents.id, id)));
+  }
+};
+
+// src/use-cases/ExportConversation.use-case.ts
+import { SessionNotFoundError as SessionNotFoundError4 } from "@adatechnology/meta-whatsapp-contracts";
 var ExportConversationUseCase = class {
   static {
     __name(this, "ExportConversationUseCase");
@@ -774,7 +1447,7 @@ var ExportConversationUseCase = class {
   }
   async execute(params) {
     const result = await this.sessionRepository.exportConversation(params.companyId, params.whatsappNumber);
-    if (!result) throw new SessionNotFoundError2(params.whatsappNumber);
+    if (!result) throw new SessionNotFoundError4(params.whatsappNumber);
     return result;
   }
 };
@@ -1011,16 +1684,168 @@ var FlowInterpreter = class {
   }
 };
 
+// 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");
+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 buffer = await params.objectStorage.getObject(attachment.uploadId);
+        const { externalMessageId } = await channel.sendMedia({
+          to: session.whatsappNumber,
+          buffer,
+          mimeType: attachment.mimeType,
+          filename: attachment.filename,
+          caption: attachment.caption ?? void 0
+        });
+        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/repositories/FlowMediaRepository.ts
+import { and as and5, asc as asc2, eq as eq6, sql as sql4 } from "drizzle-orm";
+var FlowMediaRepository = class {
+  static {
+    __name(this, "FlowMediaRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  locationFilter(location) {
+    return and5(eq6(flowMedia.companyId, location.companyId), eq6(flowMedia.flowKey, location.flowKey), eq6(flowMedia.nodeId, location.nodeId));
+  }
+  // O que o nó realmente envia, na ordem de envio. `active` filtrado aqui e não no chamador:
+  // é a razão de a coluna existir, e um chamador que esquecesse do filtro mandaria ao cliente
+  // justamente o material que alguém desligou.
+  async listActive(location) {
+    return this.db.select().from(flowMedia).where(and5(this.locationFilter(location), eq6(flowMedia.active, true))).orderBy(asc2(flowMedia.sortOrder), asc2(flowMedia.createdAt));
+  }
+  // Inclui os desligados — é a visão do editor, onde desligar precisa continuar visível para
+  // poder ser religado.
+  async listAll(location) {
+    return this.db.select().from(flowMedia).where(this.locationFilter(location)).orderBy(asc2(flowMedia.sortOrder), asc2(flowMedia.createdAt));
+  }
+  /**
+  * Anexa um arquivo já existente no storage ao nó.
+  *
+  * `onConflictDoUpdate` em vez de deixar estourar: reanexar o mesmo arquivo é clique repetido no
+  * editor, e o esperado ali é atualizar a legenda/ordem — não um erro de índice único na cara de
+  * quem está montando o fluxo.
+  */
+  async attach(params) {
+    const [row] = await this.db.insert(flowMedia).values({
+      companyId: params.companyId,
+      flowKey: params.flowKey,
+      nodeId: params.nodeId,
+      uploadId: params.uploadId,
+      filename: params.filename,
+      mimeType: params.mimeType,
+      sizeBytes: params.sizeBytes,
+      caption: params.caption ?? null,
+      sortOrder: params.sortOrder ?? 0
+    }).onConflictDoUpdate({
+      target: [
+        flowMedia.companyId,
+        flowMedia.flowKey,
+        flowMedia.nodeId,
+        flowMedia.uploadId
+      ],
+      set: {
+        caption: params.caption ?? null,
+        sortOrder: params.sortOrder ?? 0,
+        active: true,
+        updatedAt: sql4`now()`
+      }
+    }).returning();
+    return row;
+  }
+  async update(params) {
+    const [row] = await this.db.update(flowMedia).set({
+      ...params.caption !== void 0 ? {
+        caption: params.caption
+      } : {},
+      ...params.sortOrder !== void 0 ? {
+        sortOrder: params.sortOrder
+      } : {},
+      ...params.active !== void 0 ? {
+        active: params.active
+      } : {},
+      updatedAt: sql4`now()`
+    }).where(and5(eq6(flowMedia.companyId, params.companyId), eq6(flowMedia.id, params.id))).returning();
+    return row;
+  }
+  /**
+  * Desanexa do nó. Não toca no storage de propósito: o mesmo `uploadId` pode estar anexado a
+  * outro nó ou a outro fluxo, e apagar o binário aqui quebraria os demais. Quem apaga objeto é o
+  * host, que é dono da biblioteca de arquivos.
+  */
+  async detach(params) {
+    await this.db.delete(flowMedia).where(and5(eq6(flowMedia.companyId, params.companyId), eq6(flowMedia.id, params.id)));
+  }
+  // Chamado ao salvar o grafo: nós apagados no editor deixam linhas que nada mais alcança.
+  async detachRemovedNodes(params) {
+    const condition = params.existingNodeIds.length === 0 ? void 0 : sql4`${flowMedia.nodeId} NOT IN ${params.existingNodeIds}`;
+    await this.db.delete(flowMedia).where(and5(eq6(flowMedia.companyId, params.companyId), eq6(flowMedia.flowKey, params.flowKey), condition));
+  }
+};
+
 // src/channel/WhatsAppChannelAdapter.ts
 import { WhatsAppWindowExpiredError as ProviderWindowExpiredError } from "@adatechnology/meta-graph-core";
 import { WindowExpiredError as WindowExpiredError2 } from "@adatechnology/meta-whatsapp-contracts";
+
+// src/channel/previewMedia.ts
+import { PREVIEW_MEDIA_ID_PREFIX, toPreviewMediaId, resolvePreviewUploadId } from "@adatechnology/meta-whatsapp-contracts";
+
+// src/channel/WhatsAppChannelAdapter.ts
 var WhatsAppChannelAdapter = class {
   static {
     __name(this, "WhatsAppChannelAdapter");
   }
   messages;
-  constructor(messages2) {
+  previewMedia;
+  constructor(messages2, previewMedia) {
     this.messages = messages2;
+    this.previewMedia = previewMedia;
   }
   async translateErrors(operation) {
     try {
@@ -1064,7 +1889,31 @@ 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
+    };
+  }
+  /**
+  * Busca o binário da mídia — da Meta, ou do storage quando o id é do simulador.
+  *
+  * O desvio acontece ANTES de qualquer chamada de rede: id do simulador não existe na Meta, e
+  * tentar buscá-lo lá renderia um 404 confuso em vez do áudio que o operador acabou de gravar.
+  */
   async fetchMediaAsBase64(mediaId) {
+    const uploadId = this.previewMedia?.isEnabled ? resolvePreviewUploadId(mediaId) : void 0;
+    if (uploadId) {
+      const buffer = await this.previewMedia.objectStorage.getObject(uploadId);
+      return {
+        data: buffer.toString("base64"),
+        mimeType: this.previewMedia.defaultMimeType ?? "audio/ogg"
+      };
+    }
     return this.translateErrors(() => this.messages.fetchMediaAsBase64(mediaId));
   }
 };
@@ -1106,6 +1955,325 @@ async function claimWebhookDelivery(params) {
 }
 __name(claimWebhookDelivery, "claimWebhookDelivery");
 
+// src/channel/IngestInboundMedia.use-case.ts
+import { eq as eq7, and as and6 } from "drizzle-orm";
+
+// src/use-cases/TranscribeAudio.use-case.ts
+import { AudioNotIngestedError, MessageNotAudioError, TranscriptionDisabledError } from "@adatechnology/meta-whatsapp-contracts";
+
+// src/transcription.types.ts
+var TRANSCRIPTION_STATUS = {
+  /** Falhou de forma retriável (cota, rede, 5xx) — vai sair quando alguém tentar de novo. */
+  PENDING: "pending",
+  /** Processado. Texto vazio aqui é áudio em silêncio, e NÃO deve ser reprocessado. */
+  DONE: "done",
+  /** Falha definitiva do engine (credencial, áudio corrompido, arquivo grande demais). */
+  FAILED: "failed",
+  /** Nenhum engine da cadeia aceita o formato. Retentar não conserta codec. */
+  UNSUPPORTED: "unsupported"
+};
+var TRANSCRIPTION_MODE = {
+  AUTO: "auto",
+  ON_DEMAND: "onDemand"
+};
+function isRetriableTranscriptionError(error) {
+  if (typeof error !== "object" || error === null) return true;
+  const isRetriable = error.isRetriable;
+  return typeof isRetriable === "boolean" ? isRetriable : true;
+}
+__name(isRetriableTranscriptionError, "isRetriableTranscriptionError");
+function isUnsupportedTranscriptionError(error) {
+  return typeof error === "object" && error !== null && error.name === "TranscriptionUnsupportedError";
+}
+__name(isUnsupportedTranscriptionError, "isUnsupportedTranscriptionError");
+function transcriptionRetryAfterSeconds(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const retryAfter = error.retryAfterSeconds;
+  return typeof retryAfter === "number" ? retryAfter : void 0;
+}
+__name(transcriptionRetryAfterSeconds, "transcriptionRetryAfterSeconds");
+function isAudioMimeType(mimeType) {
+  return typeof mimeType === "string" && mimeType.trim().toLowerCase().startsWith("audio/");
+}
+__name(isAudioMimeType, "isAudioMimeType");
+
+// src/use-cases/TranscribeAudio.use-case.ts
+var TranscribeAudioUseCase = class {
+  static {
+    __name(this, "TranscribeAudioUseCase");
+  }
+  dependencies;
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  async execute(params) {
+    const message = await this.dependencies.messageRepository.findById(params.companyId, params.messageId);
+    if (!message) throw new Error(`Mensagem ${params.messageId} n\xE3o encontrada para transcri\xE7\xE3o`);
+    if (message.transcriptionStatus === TRANSCRIPTION_STATUS.DONE && !params.force) {
+      return {
+        status: TRANSCRIPTION_STATUS.DONE,
+        text: message.transcriptionText,
+        language: message.transcriptionLanguage,
+        engine: message.transcriptionEngine,
+        alreadyTranscribed: true
+      };
+    }
+    if (this.dependencies.resolvePolicy) {
+      const policy = await this.dependencies.resolvePolicy(params.companyId);
+      if (!policy.isEnabled) throw new TranscriptionDisabledError();
+    }
+    const audio = extractAudioReference(message);
+    const buffer = await this.dependencies.objectStorage.getObject(audio.uploadId);
+    return this.transcribeBuffer({
+      ...params,
+      buffer,
+      mimeType: audio.mimeType,
+      uploadId: audio.uploadId,
+      message
+    });
+  }
+  async transcribeBuffer(context) {
+    try {
+      const result = await this.dependencies.transcriber.transcribe({
+        buffer: context.buffer,
+        mimeType: context.mimeType,
+        ...this.dependencies.languageHint ? {
+          languageHint: this.dependencies.languageHint
+        } : {}
+      });
+      await this.dependencies.messageRepository.saveTranscription({
+        companyId: context.companyId,
+        messageId: context.messageId,
+        status: TRANSCRIPTION_STATUS.DONE,
+        text: result.text,
+        language: result.language ?? null,
+        engine: result.engine
+      });
+      return {
+        status: TRANSCRIPTION_STATUS.DONE,
+        text: result.text,
+        language: result.language ?? null,
+        engine: result.engine,
+        alreadyTranscribed: false
+      };
+    } catch (error) {
+      await this.persistFailure(context, error);
+      throw error;
+    }
+  }
+  /**
+  * Carimba o motivo antes de propagar. O status é o que impede os dois desperdícios simétricos:
+  * reprocessar para sempre um codec impossível, e desistir de um áudio que só esbarrou na cota.
+  */
+  async persistFailure(context, error) {
+    const status = resolveFailureStatus(error);
+    await this.dependencies.messageRepository.saveTranscription({
+      companyId: context.companyId,
+      messageId: context.messageId,
+      status
+    });
+    if (status !== TRANSCRIPTION_STATUS.PENDING) return;
+    const retryAfterSeconds = transcriptionRetryAfterSeconds(error);
+    await this.dependencies.hooks?.onTranscriptionDeferred?.({
+      companyId: context.companyId,
+      messageId: context.messageId,
+      whatsappNumber: context.message.whatsappNumber,
+      uploadId: context.uploadId,
+      ...retryAfterSeconds !== void 0 ? {
+        retryAfterSeconds
+      } : {},
+      reason: retryAfterSeconds !== void 0 ? "rate-limited" : "transient-failure",
+      error
+    });
+  }
+};
+function resolveFailureStatus(error) {
+  if (isUnsupportedTranscriptionError(error)) return TRANSCRIPTION_STATUS.UNSUPPORTED;
+  return isRetriableTranscriptionError(error) ? TRANSCRIPTION_STATUS.PENDING : TRANSCRIPTION_STATUS.FAILED;
+}
+__name(resolveFailureStatus, "resolveFailureStatus");
+function extractAudioReference(message) {
+  const payload = message.payload ?? {};
+  const audio = payload["audio"];
+  const mimeType = typeof payload["mimeType"] === "string" ? payload["mimeType"] : audio?.mime_type;
+  if (!isAudioMimeType(mimeType) && !audio) {
+    throw new MessageNotAudioError(message.id, message.type);
+  }
+  const uploadId = payload["uploadId"];
+  if (typeof uploadId !== "string" || uploadId.length === 0) {
+    throw new AudioNotIngestedError(message.id);
+  }
+  return {
+    uploadId,
+    mimeType: mimeType ?? "audio/ogg"
+  };
+}
+__name(extractAudioReference, "extractAudioReference");
+
+// src/channel/IngestInboundMedia.use-case.ts
+var IngestInboundMediaUseCase = class {
+  static {
+    __name(this, "IngestInboundMediaUseCase");
+  }
+  db;
+  channel;
+  objectStorage;
+  documentRepository;
+  transcription;
+  constructor(db, channel, objectStorage, documentRepository, transcription) {
+    this.db = db;
+    this.channel = channel;
+    this.objectStorage = objectStorage;
+    this.documentRepository = documentRepository;
+    this.transcription = transcription;
+  }
+  async execute(params) {
+    const [message] = await this.db.select().from(messages).where(and6(eq7(messages.companyId, params.companyId), eq7(messages.id, params.messageId))).limit(1);
+    if (!message) throw new Error(`Mensagem ${params.messageId} n\xE3o encontrada para ingest\xE3o de m\xEDdia`);
+    const payload = message.payload ?? {};
+    if (payload["uploadId"] && payload["sourceMediaId"] === params.sourceMediaId) {
+      return {
+        uploadId: String(payload["uploadId"]),
+        alreadyIngested: true
+      };
+    }
+    const { data, mimeType } = await this.channel.fetchMediaAsBase64(params.sourceMediaId);
+    const buffer = Buffer.from(data, "base64");
+    const { uploadId } = await this.objectStorage.upload({
+      buffer,
+      mimeType: mimeType || params.mimeType,
+      key: `meta-whatsapp/${params.companyId}/inbound/${params.sourceMediaId}`
+    });
+    const updatedPayload = {
+      ...payload,
+      uploadId,
+      sourceMediaId: params.sourceMediaId,
+      mimeType: mimeType || params.mimeType,
+      // O tamanho já está na mão (é o buffer que acabou de ser copiado) e a bolha de documento o
+      // exibe ao lado do tipo. Sem gravar aqui, a UI mostraria "PDF" sem o "· 180 KB", e buscá-lo
+      // depois custaria uma consulta à tabela de documentos por mensagem renderizada.
+      sizeBytes: buffer.length,
+      ...params.filename ? {
+        filename: params.filename
+      } : {}
+    };
+    await this.db.update(messages).set({
+      payload: updatedPayload
+    }).where(and6(eq7(messages.companyId, params.companyId), eq7(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/ReceiveWebhook.use-case.ts
 function toSessionContract(row) {
   return {
@@ -1113,6 +2281,8 @@ function toSessionContract(row) {
     companyId: row.companyId,
     whatsappNumber: row.whatsappNumber,
     currentState: row.currentState,
+    flowKey: row.flowKey,
+    currentNodeId: row.currentNodeId,
     context: row.context,
     mode: row.mode,
     assignedUserId: row.assignedUserId,
@@ -1178,14 +2348,21 @@ var ReceiveWebhookUseCase = class {
     if (!claimed) return {
       duplicate: true,
       messagesProcessed: 0,
-      statusesProcessed: 0
+      statusesProcessed: 0,
+      ignoredForeignNumber: 0
     };
     const rawText = typeof input.rawBody === "string" ? input.rawBody : input.rawBody.toString("utf8");
     const payload = whatsAppWebhookPayloadSchema.parse(JSON.parse(rawText));
     let messagesProcessed = 0;
     let statusesProcessed = 0;
+    let ignoredForeignNumber = 0;
     for (const entry of payload.entry) {
       for (const change of entry.changes) {
+        const targetNumber = change.value.metadata?.phone_number_id;
+        if (targetNumber && targetNumber !== this.params.phoneNumberId) {
+          ignoredForeignNumber++;
+          continue;
+        }
         for (const message of change.value.messages ?? []) {
           await this.handleMessage(input.companyId, message);
           messagesProcessed++;
@@ -1199,7 +2376,8 @@ var ReceiveWebhookUseCase = class {
     return {
       duplicate: false,
       messagesProcessed,
-      statusesProcessed
+      statusesProcessed,
+      ignoredForeignNumber
     };
   }
   async handleMessage(companyId, message) {
@@ -1216,6 +2394,19 @@ var ReceiveWebhookUseCase = class {
       startState: this.params.startState
     });
     if (!saved) return;
+    const media = extractMediaDescriptor(saved);
+    if (media) {
+      await this.params.hooks?.onMediaReceived?.({
+        companyId,
+        messageId: saved.id,
+        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;
@@ -1235,76 +2426,50 @@ var ReceiveWebhookUseCase = class {
   }
 };
 
-// src/channel/IngestInboundMedia.use-case.ts
-import { eq as eq5, and as and4 } from "drizzle-orm";
-var IngestInboundMediaUseCase = class {
+// src/use-cases/resolveTranscriptionPolicy.ts
+function createTranscriptionPolicyResolver(dependencies) {
+  return /* @__PURE__ */ __name(async function resolveTranscriptionPolicy(companyId) {
+    const settings2 = await dependencies.settingsRepository.get(companyId);
+    return {
+      // `??` e não `||`: `false` gravado é decisão explícita de desligar, e `||` a trocaria pelo
+      // padrão do host — desligar no painel não faria nada num deploy com transcrição ligada.
+      isEnabled: settings2.transcriptionEnabled ?? dependencies.defaults.isEnabled,
+      mode: normalizeMode(settings2.transcriptionMode) ?? dependencies.defaults.mode
+    };
+  }, "resolveTranscriptionPolicy");
+}
+__name(createTranscriptionPolicyResolver, "createTranscriptionPolicyResolver");
+function normalizeMode(value) {
+  if (value === TRANSCRIPTION_MODE.AUTO) return TRANSCRIPTION_MODE.AUTO;
+  if (value === TRANSCRIPTION_MODE.ON_DEMAND) return TRANSCRIPTION_MODE.ON_DEMAND;
+  return void 0;
+}
+__name(normalizeMode, "normalizeMode");
+
+// src/use-cases/StorePreviewMedia.use-case.ts
+var StorePreviewMediaUseCase = class {
   static {
-    __name(this, "IngestInboundMediaUseCase");
+    __name(this, "StorePreviewMediaUseCase");
   }
-  db;
-  channel;
   objectStorage;
-  constructor(db, channel, objectStorage) {
-    this.db = db;
-    this.channel = channel;
+  generateKeySuffix;
+  constructor(objectStorage, generateKeySuffix) {
     this.objectStorage = objectStorage;
+    this.generateKeySuffix = generateKeySuffix;
   }
   async execute(params) {
-    const [message] = await this.db.select().from(messages).where(and4(eq5(messages.companyId, params.companyId), eq5(messages.id, params.messageId))).limit(1);
-    if (!message) throw new Error(`Mensagem ${params.messageId} n\xE3o encontrada para ingest\xE3o de m\xEDdia`);
-    const payload = message.payload ?? {};
-    if (payload["uploadId"] && payload["sourceMediaId"] === params.sourceMediaId) {
-      return {
-        uploadId: String(payload["uploadId"]),
-        alreadyIngested: true
-      };
-    }
-    const { data, mimeType } = await this.channel.fetchMediaAsBase64(params.sourceMediaId);
-    const buffer = Buffer.from(data, "base64");
+    const key = `meta-whatsapp/${params.companyId}/preview/${this.generateKeySuffix()}`;
     const { uploadId } = await this.objectStorage.upload({
-      buffer,
-      mimeType: mimeType || params.mimeType,
-      key: `meta-whatsapp/${params.companyId}/inbound/${params.sourceMediaId}`
+      buffer: params.buffer,
+      mimeType: params.mimeType,
+      key
     });
-    const updatedPayload = {
-      ...payload,
-      uploadId,
-      sourceMediaId: params.sourceMediaId,
-      mimeType: mimeType || params.mimeType,
-      ...params.filename ? {
-        filename: params.filename
-      } : {}
-    };
-    await this.db.update(messages).set({
-      payload: updatedPayload
-    }).where(and4(eq5(messages.companyId, params.companyId), eq5(messages.id, params.messageId)));
     return {
-      uploadId,
-      alreadyIngested: false
+      mediaId: toPreviewMediaId(uploadId),
+      uploadId
     };
   }
 };
-function extractMediaDescriptor(message) {
-  const payload = message.payload ?? {};
-  for (const key of [
-    "image",
-    "audio",
-    "video",
-    "document",
-    "sticker"
-  ]) {
-    const media = payload[key];
-    if (media?.id) {
-      return {
-        sourceMediaId: media.id,
-        mimeType: media.mime_type ?? "application/octet-stream",
-        filename: media.filename
-      };
-    }
-  }
-  return void 0;
-}
-__name(extractMediaDescriptor, "extractMediaDescriptor");
 
 // src/createMetaWhatsAppModule.ts
 function createMetaWhatsAppModule(params) {
@@ -1318,15 +2483,24 @@ function createMetaWhatsAppModule(params) {
     apiVersion: config.apiVersion,
     baseUrl: config.baseUrl
   });
-  const channel = new WhatsAppChannelAdapter(messageProvider);
+  const previewMediaSupport = params.features?.previewMedia && providers.objectStorage?.getObject ? {
+    isEnabled: true,
+    objectStorage: providers.objectStorage
+  } : void 0;
+  const channel = new WhatsAppChannelAdapter(messageProvider, previewMediaSupport);
   const sessionRepository = new SessionRepository(db);
   const messageRepository = new MessageRepository(db);
   const settingsRepository = new SettingsRepository(db);
-  const flowGraphRepository = new FlowGraphRepository(db);
-  const logMessage = new LogMessageUseCase(sessionRepository, messageRepository, providers.realtime);
-  const sendMessage = new SendMessageUseCase(channel, sessionRepository, logMessage, providers.objectStorage);
+  const flowGraphCacheFeature = params.features?.flowGraphCache ?? false;
+  const flowGraphCache = flowGraphCacheFeature && providers.cache ? new FlowGraphCache(providers.cache, typeof flowGraphCacheFeature === "object" ? flowGraphCacheFeature.ttlSeconds ?? DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS : DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS) : void 0;
+  const flowGraphRepository = new FlowGraphRepository(db, flowGraphCache);
+  const documentRepository = new DocumentRepository(db);
+  const flowMediaRepository = new FlowMediaRepository(db);
+  const logMessage = new LogMessageUseCase(sessionRepository, messageRepository, providers.realtime, providers.moderator);
+  const sendMessage = new SendMessageUseCase(channel, sessionRepository, logMessage, providers.objectStorage, documentRepository);
   const receiveWebhook = new ReceiveWebhookUseCase({
     appSecret: config.appSecret,
+    phoneNumberId: config.phoneNumberId,
     nonceStore,
     sessionRepository,
     messageRepository,
@@ -1336,7 +2510,49 @@ function createMetaWhatsAppModule(params) {
     realtime: providers.realtime
   });
   const flowInterpreter = flowEngineEnabled ? new FlowInterpreter() : void 0;
-  const ingestInboundMedia = providers.objectStorage ? new IngestInboundMediaUseCase(db, channel, providers.objectStorage) : void 0;
+  if (flowInterpreter && providers.objectStorage?.getObject) {
+    flowInterpreter.registerFlowAction(FLOW_ACTION_KIND.SEND_MEDIA, createSendMediaAction({
+      flowMediaRepository,
+      objectStorage: providers.objectStorage,
+      logMessage,
+      startState,
+      onError: hooks?.onFlowMediaError
+    }));
+  }
+  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.
@@ -1348,10 +2564,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.
@@ -1370,7 +2612,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
   };
@@ -1379,11 +2625,15 @@ __name(createMetaWhatsAppModule, "createMetaWhatsAppModule");
 
 // src/runMigrations.ts
 import { join } from "path";
-import { migrate } from "drizzle-orm/bun-sql/migrator";
-async function runMetaWhatsAppMigrations(db) {
-  await migrate(db, {
-    migrationsFolder: join(__dirname, "migrations"),
-    migrationsTable: "meta_whatsapp_migrations"
+var META_WHATSAPP_MIGRATIONS_TABLE = "meta_whatsapp_migrations";
+function metaWhatsAppMigrationsFolder() {
+  return join(__dirname, "migrations");
+}
+__name(metaWhatsAppMigrationsFolder, "metaWhatsAppMigrationsFolder");
+async function runMetaWhatsAppMigrations(params) {
+  await params.migrate(params.db, {
+    migrationsFolder: metaWhatsAppMigrationsFolder(),
+    migrationsTable: META_WHATSAPP_MIGRATIONS_TABLE
   });
 }
 __name(runMetaWhatsAppMigrations, "runMetaWhatsAppMigrations");
@@ -1465,20 +2715,30 @@ async function redeemSseTicket(store, ticket) {
 __name(redeemSseTicket, "redeemSseTicket");
 export {
   CreateFlowGraphUseCase,
+  DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS,
+  DeleteConversationUseCase,
   DeleteFlowGraphUseCase,
+  DocumentRepository,
   ExportConversationUseCase,
+  FlowGraphCache,
   FlowGraphRepository,
   FlowInterpreter,
+  FlowMediaRepository,
   GetFlowGraphUseCase,
   GetLiveFlowPositionsUseCase,
   IngestInboundMediaUseCase,
   InvalidFlowGraphError,
+  ListCompanyDocumentsUseCase,
+  ListConversationDocumentsUseCase,
   ListConversationsUseCase,
   ListFlowGraphsUseCase,
   ListMessagesUseCase,
   LogMessageUseCase,
+  META_WHATSAPP_MIGRATIONS_TABLE,
   MessageRepository,
   OptimisticLockError,
+  PREVIEW_MEDIA_ID_PREFIX,
+  PurgeExpiredDocumentsUseCase,
   ReceiveWebhookUseCase,
   ReleaseConversationUseCase,
   SaveFlowGraphUseCase,
@@ -1486,20 +2746,36 @@ export {
   SessionRepository,
   SettingsRepository,
   SseHub,
+  StorePreviewMediaUseCase,
+  TRANSCRIPTION_MODE,
+  TRANSCRIPTION_STATUS,
   TakeoverConversationUseCase,
+  TranscribeAudioUseCase,
   WEBHOOK_NONCE_TTL_SECONDS,
   WhatsAppChannelAdapter,
   claimWebhookDelivery,
   createMetaWhatsAppModule,
+  createSendMediaAction,
+  createTranscriptionPolicyResolver,
+  documents,
   extractMediaDescriptor,
   flowGraphs,
+  flowMedia,
+  isAudioMimeType,
+  isRetriableTranscriptionError,
+  isUnsupportedTranscriptionError,
   issueSseTicket,
   messages,
+  metaWhatsAppMigrationsFolder,
   metaWhatsAppSchema,
   redeemSseTicket,
+  resolveFailureStatus,
+  resolvePreviewUploadId,
   runMetaWhatsAppMigrations,
   sessions,
   settings,
+  toPreviewMediaId,
+  transcriptionRetryAfterSeconds,
   verifyWebhookChallenge,
   verifyWebhookSignature
 };