@baruk/core 0.3.0 → 0.4.2

package/dist/communication/sender-profile.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Perfil de remetente — de quem a mensagem PARECE ser.
+ *
+ * `identity.ts` responde "existe conta deste tenant para este canal?" e não tem
+ * fallback nenhum, de propósito. Este módulo responde a pergunta seguinte, que a
+ * operação real obriga a enfrentar: **e quando o tenant não configurou conta
+ * própria, mas o produto já entrega e-mail hoje?**
+ *
+ * A resposta preguiçosa é `?? contaDaPlataforma`, escrita dentro de um adapter.
+ * Foi assim no Manga Verde, e o custo é conhecido: reputação de domínio
+ * compartilhada em e-mail, e uma WABA respondendo pelo comportamento de outra
+ * marca em WhatsApp — com bloqueio que se propaga para todos os tenants do
+ * número.
+ *
+ * Aqui o fallback existe, mas com quatro amarras que o tornam outra coisa:
+ *
+ *   1. É DECLARADO pelo produto, canal a canal. Não há default implícito.
+ *   2. Nunca vale para canal de telefone. WhatsApp e SMS falham fechado, ponto.
+ *   3. A IDENTIDADE VISÍVEL continua sendo a do tenant que está enviando — o
+ *      nome de exibição vem da marca dele. A SC nunca sai parecendo Manga Verde.
+ *   4. A origem é devolvida junto e vai para a trilha. "Saiu pelo remetente da
+ *      plataforma" tem de ser uma coisa que o escritório consegue VER, não uma
+ *      linha de código que ninguém lê.
+ */
+import type { ChannelKey } from './channel.js';
+import type { CommunicationContext } from './context.js';
+import type { ChannelAccount, ChannelAccountStore } from './identity.js';
+/**
+ * De onde veio a conta que vai assinar a mensagem.
+ *
+ * Duas palavras, e a diferença entre elas é a pergunta que o Codex fez e o
+ * código não sabia responder.
+ */
+export type SenderOrigin = 'tenant' | 'platform_fallback';
+export interface ResolvedSenderProfile {
+    account: ChannelAccount;
+    origin: SenderOrigin;
+}
+/**
+ * Fallback de plataforma, declarado pelo produto.
+ *
+ * `displayNameFor` recebe o contexto e devolve o nome exibido — é o que garante
+ * a amarra 3. Um fallback com nome fixo faria todo escritório assinar igual, que
+ * é o defeito que `senderFor` já tinha corrigido no caminho legado.
+ */
+export interface PlatformSenderFallback {
+    senderId: string;
+    credentialRef: string;
+    displayNameFor: (ctx: CommunicationContext) => string | undefined;
+}
+export type SenderFallbackPolicy = Partial<Record<ChannelKey, PlatformSenderFallback>>;
+export type SenderRejection = 'no_account' | 'fallback_forbidden_for_channel';
+export type SenderResolution = {
+    ok: true;
+    profile: ResolvedSenderProfile;
+} | {
+    ok: false;
+    reason: SenderRejection;
+    detail: string;
+};
+/**
+ * Resolve o remetente: conta do tenant primeiro, fallback declarado depois.
+ *
+ * A ordem não é preferência, é regra. A conta do tenant, quando existe, é a
+ * única que pode ser usada — mesmo que esteja `paused` ou com erro. Cair para a
+ * plataforma porque a conta PRÓPRIA está com problema seria o pior caso
+ * possível: o escritório que configurou a identidade dele passaria a enviar com
+ * a da plataforma, justamente quando alguém está mexendo na configuração.
+ */
+export declare function resolveSenderProfile(store: ChannelAccountStore, ctx: CommunicationContext, channel: ChannelKey, fallback?: SenderFallbackPolicy): Promise<SenderResolution>;
+/**
+ * Store de contas com o fallback do produto já aplicado.
+ *
+ * Existe porque o fallback tem de valer na RESOLUÇÃO DE IDENTIDADE, e não só na
+ * construção do adapter. Registrar o canal com a conta de fallback e deixar
+ * `deps.accounts` devolvendo `null` produz um motor que pula o canal com
+ * `no_identity` antes de chegar ao adapter — o canal existe, o remetente existe,
+ * e a mensagem não sai. O sintoma é mudo: a trilha diz "sem conta", que é
+ * exatamente o que quem configurou o fallback acredita ter resolvido.
+ *
+ * `identity.ts` continua sem fallback nenhum, e é o ponto: quem decide que a
+ * plataforma pode assinar por um tenant é o PRODUTO, declarando a política, e a
+ * decisão fica visível numa decoração explícita em vez de num `??` dentro do
+ * motor.
+ */
+export declare function withSenderFallback(store: ChannelAccountStore, fallback: SenderFallbackPolicy): ChannelAccountStore;
+/**
+ * Resolvedor de credencial preso a UMA conta.
+ *
+ * Envolve o resolvedor do processo e só deixa passar a referência que a conta
+ * resolvida declarou. Sem isto, o resolvedor injetado é uma função que traduz
+ * qualquer nome em qualquer segredo, e basta um adapter passar a referência
+ * errada — por bug, por conta trocada, por um `??` mal colocado — para um tenant
+ * enviar com a credencial de outro.
+ *
+ * A trava é barata e fecha a classe inteira: nenhuma referência que não seja a
+ * daquela conta resolve, por construção.
+ */
+export declare function credentialResolverFor(account: ChannelAccount, resolve: (ref: string) => Promise<string | undefined>): (ref: string) => Promise<string | undefined>;
+//# sourceMappingURL=sender-profile.d.ts.map

package/dist/communication/sender-profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sender-profile.d.ts","sourceRoot":"","sources":["../../src/communication/sender-profile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEzE;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,mBAAmB,CAAC;AAE1D,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,cAAc,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,CAAC,GAAG,EAAE,oBAAoB,KAAK,MAAM,GAAG,SAAS,CAAC;CACnE;AAYD,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,sBAAsB,CAAC,CAAC,CAAC;AAEvF,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,gCAAgC,CAAC;AAE9E,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,qBAAqB,CAAA;CAAE,GAC5C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,oBAAoB,EACzB,OAAO,EAAE,UAAU,EACnB,QAAQ,GAAE,oBAAyB,GAClC,OAAO,CAAC,gBAAgB,CAAC,CA2C3B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,mBAAmB,EAC1B,QAAQ,EAAE,oBAAoB,GAC7B,mBAAmB,CAOrB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GACpD,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAE9C"}

package/dist/communication/sender-profile.js

@@ -0,0 +1,123 @@
+/**
+ * Perfil de remetente — de quem a mensagem PARECE ser.
+ *
+ * `identity.ts` responde "existe conta deste tenant para este canal?" e não tem
+ * fallback nenhum, de propósito. Este módulo responde a pergunta seguinte, que a
+ * operação real obriga a enfrentar: **e quando o tenant não configurou conta
+ * própria, mas o produto já entrega e-mail hoje?**
+ *
+ * A resposta preguiçosa é `?? contaDaPlataforma`, escrita dentro de um adapter.
+ * Foi assim no Manga Verde, e o custo é conhecido: reputação de domínio
+ * compartilhada em e-mail, e uma WABA respondendo pelo comportamento de outra
+ * marca em WhatsApp — com bloqueio que se propaga para todos os tenants do
+ * número.
+ *
+ * Aqui o fallback existe, mas com quatro amarras que o tornam outra coisa:
+ *
+ *   1. É DECLARADO pelo produto, canal a canal. Não há default implícito.
+ *   2. Nunca vale para canal de telefone. WhatsApp e SMS falham fechado, ponto.
+ *   3. A IDENTIDADE VISÍVEL continua sendo a do tenant que está enviando — o
+ *      nome de exibição vem da marca dele. A SC nunca sai parecendo Manga Verde.
+ *   4. A origem é devolvida junto e vai para a trilha. "Saiu pelo remetente da
+ *      plataforma" tem de ser uma coisa que o escritório consegue VER, não uma
+ *      linha de código que ninguém lê.
+ */
+/**
+ * Canais que NUNCA aceitam fallback de plataforma.
+ *
+ * Lista fechada no motor, e não configuração do produto, porque a consequência
+ * não é do produto: uma WABA bloqueada por comportamento de um tenant derruba
+ * todos os outros que compartilham o número. Não existe configuração que torne
+ * isso aceitável, então não existe configuração.
+ */
+const FALLBACK_FORBIDDEN = ['whatsapp', 'sms'];
+/**
+ * Resolve o remetente: conta do tenant primeiro, fallback declarado depois.
+ *
+ * A ordem não é preferência, é regra. A conta do tenant, quando existe, é a
+ * única que pode ser usada — mesmo que esteja `paused` ou com erro. Cair para a
+ * plataforma porque a conta PRÓPRIA está com problema seria o pior caso
+ * possível: o escritório que configurou a identidade dele passaria a enviar com
+ * a da plataforma, justamente quando alguém está mexendo na configuração.
+ */
+export async function resolveSenderProfile(store, ctx, channel, fallback = {}) {
+    const own = await store.find(ctx, channel);
+    if (own)
+        return { ok: true, profile: { account: own, origin: 'tenant' } };
+    const declared = fallback[channel];
+    if (!declared) {
+        return {
+            ok: false,
+            reason: 'no_account',
+            detail: `sem conta de ${channel} para este tenant/produto e sem fallback declarado`,
+        };
+    }
+    if (FALLBACK_FORBIDDEN.includes(channel)) {
+        // Produto que declarou fallback para telefone cometeu um erro de
+        // configuração perigoso. Recusar em silêncio o esconderia; recusar com
+        // motivo próprio o expõe na trilha.
+        return {
+            ok: false,
+            reason: 'fallback_forbidden_for_channel',
+            detail: `fallback de plataforma é proibido em ${channel}`,
+        };
+    }
+    return {
+        ok: true,
+        profile: {
+            account: {
+                channel,
+                // O contexto pedido, SEMPRE. É o que faz `assertOwnership` continuar
+                // valendo e o que impede a conta de plataforma de carregar a marca de
+                // outro tenant para dentro de um envio deste.
+                tenantId: ctx.tenantId,
+                product: ctx.product,
+                brand: ctx.brand,
+                senderId: declared.senderId,
+                displayName: declared.displayNameFor(ctx),
+                credentialRef: declared.credentialRef,
+                status: 'active',
+            },
+            origin: 'platform_fallback',
+        },
+    };
+}
+/**
+ * Store de contas com o fallback do produto já aplicado.
+ *
+ * Existe porque o fallback tem de valer na RESOLUÇÃO DE IDENTIDADE, e não só na
+ * construção do adapter. Registrar o canal com a conta de fallback e deixar
+ * `deps.accounts` devolvendo `null` produz um motor que pula o canal com
+ * `no_identity` antes de chegar ao adapter — o canal existe, o remetente existe,
+ * e a mensagem não sai. O sintoma é mudo: a trilha diz "sem conta", que é
+ * exatamente o que quem configurou o fallback acredita ter resolvido.
+ *
+ * `identity.ts` continua sem fallback nenhum, e é o ponto: quem decide que a
+ * plataforma pode assinar por um tenant é o PRODUTO, declarando a política, e a
+ * decisão fica visível numa decoração explícita em vez de num `??` dentro do
+ * motor.
+ */
+export function withSenderFallback(store, fallback) {
+    return {
+        async find(ctx, channel) {
+            const resolved = await resolveSenderProfile(store, ctx, channel, fallback);
+            return resolved.ok ? resolved.profile.account : null;
+        },
+    };
+}
+/**
+ * Resolvedor de credencial preso a UMA conta.
+ *
+ * Envolve o resolvedor do processo e só deixa passar a referência que a conta
+ * resolvida declarou. Sem isto, o resolvedor injetado é uma função que traduz
+ * qualquer nome em qualquer segredo, e basta um adapter passar a referência
+ * errada — por bug, por conta trocada, por um `??` mal colocado — para um tenant
+ * enviar com a credencial de outro.
+ *
+ * A trava é barata e fecha a classe inteira: nenhuma referência que não seja a
+ * daquela conta resolve, por construção.
+ */
+export function credentialResolverFor(account, resolve) {
+    return async (ref) => (ref === account.credentialRef ? resolve(ref) : undefined);
+}
+//# sourceMappingURL=sender-profile.js.map

package/dist/communication/sender-profile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sender-profile.js","sourceRoot":"","sources":["../../src/communication/sender-profile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAgCH;;;;;;;GAOG;AACH,MAAM,kBAAkB,GAA0B,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;AAUtE;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,KAA0B,EAC1B,GAAyB,EACzB,OAAmB,EACnB,WAAiC,EAAE;IAEnC,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC3C,IAAI,GAAG;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC;IAE1E,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,YAAY;YACpB,MAAM,EAAE,gBAAgB,OAAO,oDAAoD;SACpF,CAAC;IACJ,CAAC;IAED,IAAI,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACzC,iEAAiE;QACjE,uEAAuE;QACvE,oCAAoC;QACpC,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,gCAAgC;YACxC,MAAM,EAAE,wCAAwC,OAAO,EAAE;SAC1D,CAAC;IACJ,CAAC;IAED,OAAO;QACL,EAAE,EAAE,IAAI;QACR,OAAO,EAAE;YACP,OAAO,EAAE;gBACP,OAAO;gBACP,qEAAqE;gBACrE,sEAAsE;gBACtE,8CAA8C;gBAC9C,QAAQ,EAAE,GAAG,CAAC,QAAQ;gBACtB,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;gBAC3B,WAAW,EAAE,QAAQ,CAAC,cAAc,CAAC,GAAG,CAAC;gBACzC,aAAa,EAAE,QAAQ,CAAC,aAAa;gBACrC,MAAM,EAAE,QAAQ;aACjB;YACD,MAAM,EAAE,mBAAmB;SAC5B;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAA0B,EAC1B,QAA8B;IAE9B,OAAO;QACL,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO;YACrB,MAAM,QAAQ,GAAG,MAAM,oBAAoB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;YAC3E,OAAO,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;QACvD,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,qBAAqB,CACnC,OAAuB,EACvB,OAAqD;IAErD,OAAO,KAAK,EAAE,GAAW,EAAE,EAAE,CAAC,CAAC,GAAG,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;AAC3F,CAAC"}

package/dist/communication/status.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Estados de entrega e classificação de falha.
+ *
+ * `sent` significa "o provider aceitou" — o único desfecho que o e-mail
+ * consegue afirmar. WhatsApp e SMS informam depois, por webhook, se a mensagem
+ * chegou ao aparelho, e só o WhatsApp informa se foi aberta.
+ *
+ * Colapsar "aceito" e "entregue" faria a tela afirmar entrega que ninguém
+ * confirmou — que é precisamente a pergunta do escritório quando o cliente diz
+ * "não recebi nada".
+ */
+import type { ChannelKey, DeliveryOutcomeKind } from './channel.js';
+export type DeliveryStatus = 'queued' | 'sent' | 'delivered' | 'read' | 'failed' | 'opted_out';
+/**
+ * Até onde cada canal consegue informar.
+ *
+ * SMS nunca alcança `read`, e nenhum provider de SMS devolve isso — mapear um
+ * `delivered` de SMS para `read` "para uniformizar" produziria uma tela
+ * afirmando que o cliente LEU uma cobrança que ninguém sabe se ele leu. É a
+ * equivalência falsa que este mapa existe para impedir.
+ */
+export declare const CHANNEL_REPORTS: Record<ChannelKey, readonly DeliveryStatus[]>;
+/** O canal é capaz de relatar este estado? Consultado ANTES de gravar um webhook. */
+export declare function channelReports(channel: ChannelKey, status: DeliveryStatus): boolean;
+/**
+ * Aplica um estado novo sobre o atual.
+ *
+ * Webhooks chegam fora de ordem — `delivered` depois de `read` acontece, e
+ * aceitar cegamente faria a mensagem "desler". `failed` e `opted_out` são
+ * terminais e nunca são sobrescritos por progresso: um `delivered` que chega
+ * depois de uma falha registrada é ruído do provider, não correção.
+ */
+export declare function advanceStatus(current: DeliveryStatus, incoming: DeliveryStatus): DeliveryStatus;
+/**
+ * Erro permanente nunca deve ser retentado, por mais que o contador permita.
+ *
+ * `unavailable` e `opted_out` também retornam falso, mas por razão oposta: não
+ * são falhas de entrega, e não devem sequer consumir uma tentativa.
+ */
+export declare function isRetryable(kind: DeliveryOutcomeKind): boolean;
+/**
+ * Estado que o desfecho assenta, ou `null` quando não assenta nenhum.
+ *
+ * `temporary` não assenta: a ação continua agendada para nova tentativa.
+ * `unavailable` não é tentativa — não gasta retry e não marca falha de entrega.
+ */
+export declare function statusForOutcome(kind: DeliveryOutcomeKind): DeliveryStatus | null;
+//# sourceMappingURL=status.d.ts.map

package/dist/communication/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/communication/status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEpE,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE/F;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAKzE,CAAC;AAEF,qFAAqF;AACrF,wBAAgB,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAEnF;AAYD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,GAAG,cAAc,CAG/F;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,mBAAmB,GAAG,cAAc,GAAG,IAAI,CAWjF"}

package/dist/communication/status.js

@@ -0,0 +1,79 @@
+/**
+ * Estados de entrega e classificação de falha.
+ *
+ * `sent` significa "o provider aceitou" — o único desfecho que o e-mail
+ * consegue afirmar. WhatsApp e SMS informam depois, por webhook, se a mensagem
+ * chegou ao aparelho, e só o WhatsApp informa se foi aberta.
+ *
+ * Colapsar "aceito" e "entregue" faria a tela afirmar entrega que ninguém
+ * confirmou — que é precisamente a pergunta do escritório quando o cliente diz
+ * "não recebi nada".
+ */
+/**
+ * Até onde cada canal consegue informar.
+ *
+ * SMS nunca alcança `read`, e nenhum provider de SMS devolve isso — mapear um
+ * `delivered` de SMS para `read` "para uniformizar" produziria uma tela
+ * afirmando que o cliente LEU uma cobrança que ninguém sabe se ele leu. É a
+ * equivalência falsa que este mapa existe para impedir.
+ */
+export const CHANNEL_REPORTS = {
+    email: ['queued', 'sent', 'failed'],
+    whatsapp: ['queued', 'sent', 'delivered', 'read', 'failed', 'opted_out'],
+    sms: ['queued', 'sent', 'delivered', 'failed', 'opted_out'],
+    notification: ['queued', 'sent', 'read', 'failed'],
+};
+/** O canal é capaz de relatar este estado? Consultado ANTES de gravar um webhook. */
+export function channelReports(channel, status) {
+    return CHANNEL_REPORTS[channel].includes(status);
+}
+/** Ordem de progresso. Um webhook atrasado nunca deve REGREDIR o estado. */
+const RANK = {
+    queued: 0,
+    sent: 1,
+    delivered: 2,
+    read: 3,
+    failed: 4,
+    opted_out: 5,
+};
+/**
+ * Aplica um estado novo sobre o atual.
+ *
+ * Webhooks chegam fora de ordem — `delivered` depois de `read` acontece, e
+ * aceitar cegamente faria a mensagem "desler". `failed` e `opted_out` são
+ * terminais e nunca são sobrescritos por progresso: um `delivered` que chega
+ * depois de uma falha registrada é ruído do provider, não correção.
+ */
+export function advanceStatus(current, incoming) {
+    if (current === 'failed' || current === 'opted_out')
+        return current;
+    return RANK[incoming] > RANK[current] ? incoming : current;
+}
+/**
+ * Erro permanente nunca deve ser retentado, por mais que o contador permita.
+ *
+ * `unavailable` e `opted_out` também retornam falso, mas por razão oposta: não
+ * são falhas de entrega, e não devem sequer consumir uma tentativa.
+ */
+export function isRetryable(kind) {
+    return kind === 'temporary';
+}
+/**
+ * Estado que o desfecho assenta, ou `null` quando não assenta nenhum.
+ *
+ * `temporary` não assenta: a ação continua agendada para nova tentativa.
+ * `unavailable` não é tentativa — não gasta retry e não marca falha de entrega.
+ */
+export function statusForOutcome(kind) {
+    switch (kind) {
+        case 'sent':
+            return 'sent';
+        case 'opted_out':
+            return 'opted_out';
+        case 'permanent':
+            return 'failed';
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/communication/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../../src/communication/status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAkD;IAC5E,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC;IACnC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,CAAC;IACxE,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,CAAC;IAC3D,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC;CACnD,CAAC;AAEF,qFAAqF;AACrF,MAAM,UAAU,cAAc,CAAC,OAAmB,EAAE,MAAsB;IACxE,OAAO,eAAe,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AACnD,CAAC;AAED,4EAA4E;AAC5E,MAAM,IAAI,GAAmC;IAC3C,MAAM,EAAE,CAAC;IACT,IAAI,EAAE,CAAC;IACP,SAAS,EAAE,CAAC;IACZ,IAAI,EAAE,CAAC;IACP,MAAM,EAAE,CAAC;IACT,SAAS,EAAE,CAAC;CACb,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,OAAuB,EAAE,QAAwB;IAC7E,IAAI,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,WAAW;QAAE,OAAO,OAAO,CAAC;IACpE,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC;AAC7D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,IAAyB;IACnD,OAAO,IAAI,KAAK,WAAW,CAAC;AAC9B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAyB;IACxD,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,MAAM;YACT,OAAO,MAAM,CAAC;QAChB,KAAK,WAAW;YACd,OAAO,WAAW,CAAC;QACrB,KAAK,WAAW;YACd,OAAO,QAAQ,CAAC;QAClB;YACE,OAAO,IAAI,CAAC;IAChB,CAAC;AACH,CAAC"}

package/dist/communication/stores/onboarding.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Persistência da sessão de Embedded Signup (migração 0044).
+ *
+ * Duas operações, e a segunda é a que carrega toda a segurança do fluxo:
+ * `consumeOnboardingSession` é **atômica e única**. Ela não lê para depois
+ * decidir — ela escreve com a condição embutida, e quem não conseguir escrever
+ * não consumiu. Um `SELECT` seguido de `UPDATE` deixaria uma janela em que duas
+ * requisições simultâneas com o mesmo `state` passariam as duas, e o desfecho
+ * disso é dois vínculos criados para uma autorização só.
+ */
+import type { Tx } from '../../db/client.js';
+export interface OnboardingSession {
+    id: string;
+    tenantId: string;
+    product: string;
+    brand: string;
+    channel: 'whatsapp';
+    provider: 'meta_whatsapp';
+    status: 'pending' | 'consumed' | 'failed' | 'expired';
+    expiresAt: string;
+    createdAt: string;
+    wabaRef: string | null;
+    phoneRef: string | null;
+    failureCode: string | null;
+}
+/**
+ * Janela de vida da sessão.
+ *
+ * Curta porque o fluxo do Embedded Signup leva minutos, não horas, e uma janela
+ * generosa só amplia o intervalo em que um `state` capturado ainda vale. Longa o
+ * bastante para o cliente terminar a verificação do número, que é o passo lento.
+ */
+export declare const ONBOARDING_SESSION_TTL_MS: number;
+export interface OpenOnboardingSessionInput {
+    tenantId: string;
+    product: string;
+    brand: string;
+    stateHash: string;
+    createdBy?: string | null;
+    ttlMs?: number;
+    now?: Date;
+}
+/** Abre uma sessão `pending`. Roda dentro do contexto do tenant (RLS FORCE). */
+export declare function openOnboardingSession(tx: Tx, input: OpenOnboardingSessionInput): Promise<OnboardingSession>;
+export type ConsumeRejection = 
+/** Nenhuma sessão com este state neste tenant. Inclui o state de outro tenant. */
+'unknown_state'
+/** Existe, mas já foi consumida, já falhou, ou a janela passou. */
+ | 'not_pending';
+export type ConsumeResult = {
+    ok: true;
+    session: OnboardingSession;
+} | {
+    ok: false;
+    reason: ConsumeRejection;
+};
+/**
+ * Consome o `state` — uma vez, e só se ainda estiver na janela.
+ *
+ * O `UPDATE ... WHERE status = 'pending' AND expires_at > now()` é a garantia:
+ * duas requisições concorrentes disputam a mesma linha e apenas uma vê
+ * `count = 1`. A segunda recebe `not_pending`, que é a verdade.
+ *
+ * A distinção entre `unknown_state` e `not_pending` fica no servidor e **não vai
+ * para a resposta HTTP**: dizer ao cliente qual das duas foi transformaria a
+ * rota num oráculo de "este state existe neste tenant".
+ */
+export declare function consumeOnboardingSession(tx: Tx, input: {
+    state: string;
+    now?: Date;
+}): Promise<ConsumeResult>;
+/**
+ * Marca uma sessão já consumida como falha, com a CLASSE do erro.
+ *
+ * Chamada depois de o `state` ter sido consumido e a troca com a Meta ter
+ * falhado. O status não volta para `pending`: o `code` pode ter sido gasto na
+ * tentativa, e reabrir a sessão convidaria a uma segunda troca que a Meta
+ * recusaria por motivo diferente do real.
+ */
+export declare function failOnboardingSession(tx: Tx, id: string, failureCode: string): Promise<void>;
+/** Registra os identificadores devolvidos pelo fluxo. Não são segredo. */
+export declare function recordOnboardingAssets(tx: Tx, id: string, refs: {
+    wabaRef?: string | null;
+    phoneRef?: string | null;
+}): Promise<void>;
+/** A última sessão do tenant neste canal — é o que a tela mostra. */
+export declare function latestOnboardingSession(tx: Tx): Promise<OnboardingSession | null>;
+//# sourceMappingURL=onboarding.d.ts.map

package/dist/communication/stores/onboarding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding.d.ts","sourceRoot":"","sources":["../../../src/communication/stores/onboarding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAG7C,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,UAAU,CAAC;IACpB,QAAQ,EAAE,eAAe,CAAC;IAC1B,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAuCD;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,QAAiB,CAAC;AAExD,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,IAAI,CAAC;CACZ;AAED,gFAAgF;AAChF,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,EAAE,EACN,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,iBAAiB,CAAC,CAc5B;AAED,MAAM,MAAM,gBAAgB;AAC1B,kFAAkF;AAChF,eAAe;AACjB,mEAAmE;GACjE,aAAa,CAAC;AAElB,MAAM,MAAM,aAAa,GACvB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,iBAAiB,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAErF;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,EAAE,EAAE,EAAE,EACN,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,CAAA;CAAE,GACnC,OAAO,CAAC,aAAa,CAAC,CAwBxB;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,EAAE,EACN,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAMf;AAED,0EAA0E;AAC1E,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,EAAE,EACN,EAAE,EAAE,MAAM,EACV,IAAI,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAC1D,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,qEAAqE;AACrE,wBAAsB,uBAAuB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CASvF"}

package/dist/communication/stores/onboarding.js

@@ -0,0 +1,127 @@
+/**
+ * Persistência da sessão de Embedded Signup (migração 0044).
+ *
+ * Duas operações, e a segunda é a que carrega toda a segurança do fluxo:
+ * `consumeOnboardingSession` é **atômica e única**. Ela não lê para depois
+ * decidir — ela escreve com a condição embutida, e quem não conseguir escrever
+ * não consumiu. Um `SELECT` seguido de `UPDATE` deixaria uma janela em que duas
+ * requisições simultâneas com o mesmo `state` passariam as duas, e o desfecho
+ * disso é dois vínculos criados para uma autorização só.
+ */
+import { uuidv7 } from '@baruk/shared';
+import { hashSignupState } from '../onboarding.js';
+function mapSession(r) {
+    return {
+        id: r.id,
+        tenantId: r.tenant_id,
+        product: r.product,
+        brand: r.brand,
+        channel: r.channel,
+        provider: r.provider,
+        status: r.status,
+        expiresAt: r.expires_at.toISOString(),
+        createdAt: r.created_at.toISOString(),
+        wabaRef: r.waba_ref,
+        phoneRef: r.phone_ref,
+        failureCode: r.failure_code,
+    };
+}
+const COLUMNS = `
+  id, tenant_id, product, brand, channel, provider, status,
+  expires_at, created_at, waba_ref, phone_ref, failure_code
+`;
+/**
+ * Janela de vida da sessão.
+ *
+ * Curta porque o fluxo do Embedded Signup leva minutos, não horas, e uma janela
+ * generosa só amplia o intervalo em que um `state` capturado ainda vale. Longa o
+ * bastante para o cliente terminar a verificação do número, que é o passo lento.
+ */
+export const ONBOARDING_SESSION_TTL_MS = 30 * 60 * 1000;
+/** Abre uma sessão `pending`. Roda dentro do contexto do tenant (RLS FORCE). */
+export async function openOnboardingSession(tx, input) {
+    const now = input.now ?? new Date();
+    const expiresAt = new Date(now.getTime() + (input.ttlMs ?? ONBOARDING_SESSION_TTL_MS));
+    const rows = await tx `
+    INSERT INTO channel_onboarding_session
+      (id, tenant_id, product, brand, channel, provider, state_hash, created_by, expires_at)
+    VALUES
+      (${uuidv7()}, ${input.tenantId}, ${input.product}, ${input.brand},
+       'whatsapp', 'meta_whatsapp', ${input.stateHash}, ${input.createdBy ?? null},
+       ${expiresAt.toISOString()})
+    RETURNING ${tx.unsafe(COLUMNS)}
+  `;
+    return mapSession(rows[0]);
+}
+/**
+ * Consome o `state` — uma vez, e só se ainda estiver na janela.
+ *
+ * O `UPDATE ... WHERE status = 'pending' AND expires_at > now()` é a garantia:
+ * duas requisições concorrentes disputam a mesma linha e apenas uma vê
+ * `count = 1`. A segunda recebe `not_pending`, que é a verdade.
+ *
+ * A distinção entre `unknown_state` e `not_pending` fica no servidor e **não vai
+ * para a resposta HTTP**: dizer ao cliente qual das duas foi transformaria a
+ * rota num oráculo de "este state existe neste tenant".
+ */
+export async function consumeOnboardingSession(tx, input) {
+    const state = input.state?.trim() ?? '';
+    if (!state)
+        return { ok: false, reason: 'unknown_state' };
+    const stateHash = hashSignupState(state);
+    const now = input.now ?? new Date();
+    const rows = await tx `
+    UPDATE channel_onboarding_session
+       SET status = 'consumed', consumed_at = ${now.toISOString()}, updated_at = now()
+     WHERE state_hash = ${stateHash}
+       AND status = 'pending'
+       AND expires_at > ${now.toISOString()}
+    RETURNING ${tx.unsafe(COLUMNS)}
+  `;
+    const row = rows[0];
+    if (row)
+        return { ok: true, session: mapSession(row) };
+    // Não conseguiu consumir. A linha existe (e não está mais elegível) ou nunca
+    // existiu neste tenant — a RLS já respondeu por essa segunda hipótese.
+    const existing = await tx `
+    SELECT id FROM channel_onboarding_session WHERE state_hash = ${stateHash} LIMIT 1
+  `;
+    return { ok: false, reason: existing[0] ? 'not_pending' : 'unknown_state' };
+}
+/**
+ * Marca uma sessão já consumida como falha, com a CLASSE do erro.
+ *
+ * Chamada depois de o `state` ter sido consumido e a troca com a Meta ter
+ * falhado. O status não volta para `pending`: o `code` pode ter sido gasto na
+ * tentativa, e reabrir a sessão convidaria a uma segunda troca que a Meta
+ * recusaria por motivo diferente do real.
+ */
+export async function failOnboardingSession(tx, id, failureCode) {
+    await tx `
+    UPDATE channel_onboarding_session
+       SET status = 'failed', failure_code = ${failureCode.slice(0, 60)}, updated_at = now()
+     WHERE id = ${id}
+  `;
+}
+/** Registra os identificadores devolvidos pelo fluxo. Não são segredo. */
+export async function recordOnboardingAssets(tx, id, refs) {
+    await tx `
+    UPDATE channel_onboarding_session
+       SET waba_ref = ${refs.wabaRef ?? null},
+           phone_ref = ${refs.phoneRef ?? null},
+           updated_at = now()
+     WHERE id = ${id}
+  `;
+}
+/** A última sessão do tenant neste canal — é o que a tela mostra. */
+export async function latestOnboardingSession(tx) {
+    const rows = await tx `
+    SELECT ${tx.unsafe(COLUMNS)}
+      FROM channel_onboarding_session
+     WHERE channel = 'whatsapp'
+     ORDER BY created_at DESC
+     LIMIT 1
+  `;
+    return rows[0] ? mapSession(rows[0]) : null;
+}
+//# sourceMappingURL=onboarding.js.map

package/dist/communication/stores/onboarding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding.js","sourceRoot":"","sources":["../../../src/communication/stores/onboarding.ts"],"names":[],"mappings":"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"}