@baruk/core 0.3.1 → 0.4.2

package/dist/cjs/communication/audit.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Trilha de comunicação — o que o motor decidiu, e por quê.
+ *
+ * **Não é log.** Log é texto que alguém talvez leia; isto é registro estruturado
+ * e consultável, com um vocabulário fechado de eventos. A diferença aparece na
+ * pergunta que o escritório faz de verdade: "por que este cliente não recebeu?".
+ * Um `console.warn` responde isso para quem estiver com o terminal aberto no
+ * instante certo; uma trilha responde seis meses depois.
+ *
+ * A trilha financeira (`dunning_event`) continua sendo o estado da ETAPA da
+ * régua. Esta é o histórico da INTENÇÃO de comunicar — que é outra coisa: uma
+ * etapa pode ter uma intenção recusada por consentimento, outra por telefone
+ * inválido e uma terceira entregue, e `dunning_event` só guarda o desfecho final
+ * de uma delas.
+ *
+ * O que NUNCA entra aqui: valor de credencial, corpo de mensagem, telefone,
+ * e-mail. O destinatário aparece como referência lógica (`recipientRef`), que já
+ * é o vocabulário do consumidor.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNullAuditSink = createNullAuditSink;
+exports.createRecordingAuditSink = createRecordingAuditSink;
+exports.eventKindForSkip = eventKindForSkip;
+/**
+ * Sink que não grava nada.
+ *
+ * Existe para consumidores que ainda não têm armazenamento, e é EXPLÍCITO de
+ * propósito: um sink opcional viraria `deps.audit?.record(...)` espalhado pelo
+ * motor, e a diferença entre "não configurou trilha" e "esqueceu de chamar"
+ * deixaria de ser visível.
+ */
+function createNullAuditSink() {
+    return { async record() { } };
+}
+/** Coleta em memória — para teste e para o relatório de dry-run. */
+function createRecordingAuditSink() {
+    const events = [];
+    return {
+        events,
+        async record(event) {
+            events.push(event);
+        },
+    };
+}
+/**
+ * De qual evento de trilha um pulo é.
+ *
+ * Três motivos ganham nome próprio porque exigem ações operacionais opostas:
+ * opt-out é decisão do cliente (e ninguém no escritório deve "resolver"), falta
+ * de contato é cadastro, e o resto é ambiente. Colapsá-los em `dispatch_skipped`
+ * mandaria o escritório procurar no lugar errado nos dois primeiros casos.
+ */
+function eventKindForSkip(reason) {
+    if (reason === 'opted_out')
+        return 'consent_blocked';
+    if (reason === 'no_recipient' || reason === 'invalid_recipient')
+        return 'invalid_contact';
+    return 'dispatch_skipped';
+}
+//# sourceMappingURL=audit.js.map

package/dist/cjs/communication/audit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.js","sourceRoot":"","sources":["../../../src/communication/audit.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;AA6EH,kDAEC;AAGD,4DAUC;AAUD,4CAIC;AArCD;;;;;;;GAOG;AACH,SAAgB,mBAAmB;IACjC,OAAO,EAAE,KAAK,CAAC,MAAM,KAAmB,CAAC,EAAE,CAAC;AAC9C,CAAC;AAED,oEAAoE;AACpE,SAAgB,wBAAwB;IAGtC,MAAM,MAAM,GAAyB,EAAE,CAAC;IACxC,OAAO;QACL,MAAM;QACN,KAAK,CAAC,MAAM,CAAC,KAAyB;YACpC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,gBAAgB,CAAC,MAAkB;IACjD,IAAI,MAAM,KAAK,WAAW;QAAE,OAAO,iBAAiB,CAAC;IACrD,IAAI,MAAM,KAAK,cAAc,IAAI,MAAM,KAAK,mBAAmB;QAAE,OAAO,iBAAiB,CAAC;IAC1F,OAAO,kBAAkB,CAAC;AAC5B,CAAC"}

package/dist/cjs/communication/capabilities.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * O que o PROVIDER por trás de um canal garante — declarado pelo adapter.
+ *
+ * Existe para que o motor possa tomar uma decisão que depende do provider sem
+ * nunca saber qual provider é. A alternativa é a que o certificador proibiu
+ * explicitamente:
+ *
+ *     if (provider === 'resend') { ...reenvia... } else { ...não reenvia... }
+ *
+ * Espalhado pelo núcleo, esse `if` transforma "trocar de provider" em mudança de
+ * regra de negócio, e faz o motor compartilhado carregar o catálogo de fornecedor
+ * de cada produto. Aqui o adapter DECLARA a garantia e o motor lê a declaração.
+ *
+ * **Toda capability nasce `false`.** O default não é conservadorismo estético: um
+ * campo opcional que o adapter esquece de declarar viraria uma garantia
+ * imaginária, e a consequência de imaginar idempotência que não existe é o
+ * cliente recebendo a mesma cobrança duas vezes. Quem tem a garantia declara; o
+ * silêncio significa ausência.
+ *
+ * **A declaração descreve o que ESTE ADAPTER exerce, não o que o provider anuncia
+ * no site.** O Resend publica webhooks de entrega; o adapter de e-mail daqui não
+ * consome nenhum, então `supportsDeliveryWebhook` é `false` para ele. Declarar a
+ * capacidade do fornecedor em vez da capacidade do código seria documentar uma
+ * integração que não existe — que é o defeito `DOCUMENTATION_MATCHES_RUNTIME`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESEND_IDEMPOTENCY_WINDOW_MS = exports.NO_PROVIDER_GUARANTEES = void 0;
+exports.providerIdempotencyCovers = providerIdempotencyCovers;
+/**
+ * Nenhuma garantia externa. É o que vale para todo canal que não declare o
+ * contrário — e é o que faz um adapter novo nascer seguro em vez de nascer
+ * otimista.
+ */
+exports.NO_PROVIDER_GUARANTEES = {
+    supportsProviderIdempotency: false,
+    supportsMessageLookup: false,
+    supportsDeliveryWebhook: false,
+    supportsReadReceipt: false,
+};
+/**
+ * Reenviar com a MESMA chave é seguro agora?
+ *
+ * Chamado quando o desfecho da tentativa anterior é desconhecido — o titular da
+ * reserva chamou o provider e morreu antes de assentar. A pergunta não é "o
+ * provider tem idempotência", é "a chave que eu usei ainda está viva lá".
+ *
+ * Fora da janela, a chave já não significa nada para o provider: a segunda
+ * chamada seria uma mensagem nova, e o cliente receberia duas. Por isso a
+ * expiração devolve `false` — e o motor, sem cobertura, não reenvia.
+ *
+ * **Recebe IDADE, não instante.** A diferença não é estética: o instante da
+ * primeira chamada é medido pelo relógio de quem guardou o dado (o `now()` do
+ * banco), e compará-lo com o `Date.now()` do processo mistura dois relógios que
+ * não têm obrigação de concordar. Numa deriva de poucos segundos isso passa
+ * despercebido; num processo com relógio adiantado, "dentro da janela" vira
+ * "fora" e o motor deixa de reenviar o que podia — ou o contrário. Quem guarda o
+ * dado calcula a idade, e a comparação acontece numa escala só.
+ *
+ * `ageMs` ausente significa que nenhuma chamada externa foi registrada, e aí não
+ * há o que cobrir: quem pergunta nesse estado está perguntando a coisa errada,
+ * então a resposta é `false`.
+ */
+function providerIdempotencyCovers(capabilities, ageMs) {
+    if (!capabilities.supportsProviderIdempotency)
+        return false;
+    const window = capabilities.providerIdempotencyWindowMs;
+    if (!window || window <= 0)
+        return false;
+    if (ageMs === null || ageMs < 0)
+        return false;
+    return ageMs < window;
+}
+/** Janela de idempotência do Resend: 24 horas. Ver `adapters/email.ts`. */
+exports.RESEND_IDEMPOTENCY_WINDOW_MS = 24 * 60 * 60 * 1000;
+//# sourceMappingURL=capabilities.js.map

package/dist/cjs/communication/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../../../src/communication/capabilities.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;AAoEH,8DASC;AA5CD;;;;GAIG;AACU,QAAA,sBAAsB,GAAwB;IACzD,2BAA2B,EAAE,KAAK;IAClC,qBAAqB,EAAE,KAAK;IAC5B,uBAAuB,EAAE,KAAK;IAC9B,mBAAmB,EAAE,KAAK;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAgB,yBAAyB,CACvC,YAAiC,EACjC,KAAoB;IAEpB,IAAI,CAAC,YAAY,CAAC,2BAA2B;QAAE,OAAO,KAAK,CAAC;IAC5D,MAAM,MAAM,GAAG,YAAY,CAAC,2BAA2B,CAAC;IACxD,IAAI,CAAC,MAAM,IAAI,MAAM,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IACzC,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IAC9C,OAAO,KAAK,GAAG,MAAM,CAAC;AACxB,CAAC;AAED,2EAA2E;AAC9D,QAAA,4BAA4B,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/cjs/communication/channel.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Contrato canônico de canal do ecossistema — e-mail, WhatsApp, SMS e
+ * notificação interna sob a mesma interface.
+ *
+ * O ponto de desenho está no CONTEÚDO, não na interface. A abstração de canal
+ * que já existia na cobrança da SC (`collection/channel.ts`) carregava
+ * `subject` + `html` obrigatórios: um payload de e-mail com nome genérico. Um
+ * adapter de WhatsApp receberia HTML renderizado e teria de desmontá-lo de
+ * volta em texto, e um de SMS idem — o canal vazando para dentro do domínio
+ * pela porta do payload.
+ *
+ * Aqui o conteúdo é uma união discriminada, resolvida DEPOIS que o canal foi
+ * escolhido. Cada canal recebe o que sabe entregar, e o compilador recusa o
+ * resto.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHANNEL_ACCEPTS = exports.CHANNEL_KEYS = void 0;
+exports.channelAccepts = channelAccepts;
+exports.unavailableChannel = unavailableChannel;
+exports.resolveChannel = resolveChannel;
+const capabilities_js_1 = require("./capabilities.js");
+exports.CHANNEL_KEYS = ['email', 'whatsapp', 'sms', 'notification'];
+/** Quais conteúdos cada canal aceita. Consultado antes do envio, não dentro do adapter. */
+exports.CHANNEL_ACCEPTS = {
+    email: ['email'],
+    whatsapp: ['whatsapp_template', 'text'],
+    sms: ['text'],
+    notification: ['text'],
+};
+function channelAccepts(channel, content) {
+    return exports.CHANNEL_ACCEPTS[channel].includes(content.kind);
+}
+/**
+ * Canal indisponível.
+ *
+ * Deliberadamente NÃO simula entrega. Um adapter que responde `sent` sem enviar
+ * transforma a trilha em ficção: o escritório vê "cobrado" e o cliente nunca
+ * recebeu nada. Herdado da abstração da SC, que já acertou isso.
+ */
+function unavailableChannel(key, reason) {
+    return {
+        key,
+        providerName: 'none',
+        capabilities: capabilities_js_1.NO_PROVIDER_GUARANTEES,
+        isConfigured: () => false,
+        send: async () => ({ kind: 'unavailable', code: 'channel_not_configured', detail: reason }),
+    };
+}
+function resolveChannel(registry, key) {
+    return registry[key] ?? unavailableChannel(key, `canal ${key} não registrado`);
+}
+//# sourceMappingURL=channel.js.map

package/dist/cjs/communication/channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.js","sourceRoot":"","sources":["../../../src/communication/channel.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAsCH,wCAEC;AA0ED,gDAQC;AAID,wCAEC;AA7HD,uDAA2D;AAK9C,QAAA,YAAY,GAA0B,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC;AAsBhG,2FAA2F;AAC9E,QAAA,eAAe,GAA0D;IACpF,KAAK,EAAE,CAAC,OAAO,CAAC;IAChB,QAAQ,EAAE,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACvC,GAAG,EAAE,CAAC,MAAM,CAAC;IACb,YAAY,EAAE,CAAC,MAAM,CAAC;CACvB,CAAC;AAEF,SAAgB,cAAc,CAAC,OAAmB,EAAE,OAAuB;IACzE,OAAO,uBAAe,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AACzD,CAAC;AAmED;;;;;;GAMG;AACH,SAAgB,kBAAkB,CAAC,GAAe,EAAE,MAAc;IAChE,OAAO;QACL,GAAG;QACH,YAAY,EAAE,MAAM;QACpB,YAAY,EAAE,wCAAsB;QACpC,YAAY,EAAE,GAAG,EAAE,CAAC,KAAK;QACzB,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;KAC5F,CAAC;AACJ,CAAC;AAID,SAAgB,cAAc,CAAC,QAAyB,EAAE,GAAe;IACvE,OAAO,QAAQ,CAAC,GAAG,CAAC,IAAI,kBAAkB,CAAC,GAAG,EAAE,SAAS,GAAG,iBAAiB,CAAC,CAAC;AACjF,CAAC"}

package/dist/cjs/communication/claim.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * Reserva atômica do direito de enviar.
+ *
+ * O desenho anterior era, em substância:
+ *
+ *     alreadySent(key)  →  adapter.send()  →  markSent(key)
+ *
+ * Três passos, e o intervalo entre o primeiro e o terceiro é uma janela aberta:
+ * dois workers que perguntam "já enviei?" ao mesmo tempo recebem "não" os dois,
+ * e os dois chamam o provider. O cliente recebe a mesma cobrança duas vezes. A
+ * marcação posterior não conserta nada — o dinheiro do envio já saiu, e a
+ * mensagem também.
+ *
+ * Aqui a ordem é outra:
+ *
+ *     claim(key)  →  markProviderAttempt  →  [só o vencedor] send()  →  settle
+ *
+ * `claim` é uma operação ÚNICA e atômica no armazenamento: ou ela devolve a
+ * reserva, ou devolve o motivo de não ter devolvido. Não existe estado
+ * intermediário observável entre "verifiquei" e "reservei", porque não há dois
+ * momentos. Quem não ganhou a reserva não chama o provider — nem para "tentar de
+ * novo mais rápido".
+ *
+ * **A reserva vem ANTES do efeito externo, e essa é a regra inteira.** Qualquer
+ * proteção que aconteça depois de `send` é contabilidade do que já foi feito,
+ * não controle.
+ *
+ * ## O que a H2 acrescentou, e por quê
+ *
+ * A reserva tem prazo, porque processo morre segurando reserva e uma etapa calada
+ * para sempre é pior que uma duplicata rara. Mas retomar por prazo vencido, do
+ * jeito que estava, era retomar **às cegas**: o motor não tinha como distinguir
+ *
+ *   (a) o titular anterior morreu ANTES de falar com o provider — nada saiu, e
+ *       reenviar é obviamente certo;
+ *   (b) o titular anterior morreu DEPOIS de falar com o provider — pode ter saído,
+ *       e reenviar duplica.
+ *
+ * Os dois casos chegavam aqui com a mesma cara. `markProviderAttempt` é o que os
+ * separa: uma marca durável, gravada IMEDIATAMENTE antes da chamada externa, em
+ * fronteira própria. Quem retoma uma reserva que já tinha essa marca sabe que o
+ * desfecho é **desconhecido**, não "não enviado" — e desconhecido não autoriza
+ * reenvio cego.
+ *
+ * A marca é conservadora de propósito: gravar antes de chamar significa que um
+ * processo que morre entre a marca e a chamada é classificado como "pode ter
+ * enviado" quando não enviou. Erra para o lado de calar uma mensagem, nunca para
+ * o lado de mandar duas.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CLAIM_TTL_MS = void 0;
+exports.createInMemoryDispatchClaimStore = createInMemoryDispatchClaimStore;
+/** Prazo da reserva. Ver `createInMemoryDispatchClaimStore` para o raciocínio. */
+exports.DEFAULT_CLAIM_TTL_MS = 10 * 60 * 1000;
+/**
+ * Reserva em memória — **um processo só**.
+ *
+ * Serve a testes e a consumidores que rodam em instância única. Não serve a
+ * produção com mais de um worker, e a limitação está aqui em vez de num
+ * comentário do consumidor porque é o consumidor que erra: "por enquanto é uma
+ * instância" é verdade até o dia do primeiro redeploy com sobreposição.
+ *
+ * É atômica dentro do processo porque a decisão inteira acontece sem `await` no
+ * meio — em JavaScript isso basta para que dois `dispatch` concorrentes não se
+ * intercalem no ponto de decisão. Essa propriedade é o que o teste de
+ * concorrência in-process exercita; a prova de múltiplos processos é do store
+ * SQL.
+ *
+ * O prazo (`ttlMs`) existe pela mesma razão do store SQL: processo que morre
+ * segurando reserva não pode calar a etapa para sempre. Dez minutos é muito
+ * maior que qualquer timeout de provider (o mais longo aqui é 10 s) e muito
+ * menor que o intervalo entre ciclos da régua (24 h).
+ */
+function createInMemoryDispatchClaimStore(options = {}) {
+    const ttl = options.ttlMs ?? exports.DEFAULT_CLAIM_TTL_MS;
+    const now = options.now ?? (() => Date.now());
+    const entries = new Map();
+    let seq = 0;
+    const write = async (entry, event) => {
+        if (!options.audit)
+            return;
+        await options.audit.record({
+            kind: event.kind,
+            ctx: entry.req.ctx,
+            channel: entry.req.channel,
+            eventType: entry.req.eventType,
+            subjectRef: entry.req.subjectRef,
+            recipientRef: entry.req.recipientRef,
+            idempotencyKey: entry.req.idempotencyKey,
+            providerRef: event.providerRef ?? null,
+            skipReason: event.skipReason ?? null,
+            status: event.status ?? null,
+            code: event.code ?? null,
+            detail: event.detail ?? null,
+            attempt: entry.attempt,
+        });
+    };
+    return {
+        async claim(req) {
+            // NENHUM `await` daqui até o `entries.set`. Um `await` aqui reabriria
+            // exatamente a janela que este módulo existe para fechar.
+            const current = entries.get(req.idempotencyKey);
+            const at = now();
+            if (current) {
+                if (current.state === 'sent')
+                    return { granted: false, reason: 'already_sent' };
+                if (current.state === 'failed_permanent') {
+                    return { granted: false, reason: 'permanently_failed' };
+                }
+                if (current.state === 'unknown_outcome') {
+                    return {
+                        granted: false,
+                        reason: 'unknown_outcome',
+                        detail: 'desfecho da tentativa anterior é desconhecido',
+                    };
+                }
+                if (current.state === 'in_flight' && current.expiresAt > at) {
+                    return { granted: false, reason: 'in_flight' };
+                }
+            }
+            const attempt = (current?.attempt ?? 0) + 1;
+            const recovered = current?.state === 'in_flight' && current.expiresAt <= at;
+            const providerAttempts = current?.providerAttempts ?? 0;
+            const claimId = current?.claimId ?? `mem-${++seq}`;
+            const claimToken = `tok-${++seq}`;
+            const entry = {
+                claimId,
+                claimToken,
+                state: 'in_flight',
+                attempt,
+                expiresAt: at + ttl,
+                providerAttempts,
+                providerFirstAttemptAt: current?.providerFirstAttemptAt ?? null,
+                req,
+            };
+            entries.set(req.idempotencyKey, entry);
+            const claim = {
+                claimId,
+                claimToken,
+                idempotencyKey: req.idempotencyKey,
+                attempt,
+                recoveredFromExpiredClaim: recovered,
+                // Retomada só é DESCONHECIDA se o titular anterior chegou a falar com o
+                // provider. Recuperar uma reserva que morreu antes disso é seguro, e
+                // tratá-la como desconhecida calaria a etapa sem motivo.
+                previousAttemptReachedProvider: recovered && providerAttempts > 0,
+                providerFirstAttemptAgeMs: entry.providerFirstAttemptAt === null ? null : at - entry.providerFirstAttemptAt,
+            };
+            await write(entry, {
+                kind: 'dispatch_claimed',
+                code: claim.previousAttemptReachedProvider
+                    ? 'recovered_unknown_outcome'
+                    : recovered
+                        ? 'recovered_from_expired_claim'
+                        : null,
+            });
+            return { granted: true, claim };
+        },
+        async markProviderAttempt(claim) {
+            const current = entries.get(claim.idempotencyKey);
+            // Linha sumiu, ou a geração é outra: quem chamou perdeu a reserva. A marca
+            // NÃO é gravada — gravá-la contaria uma tentativa externa do titular atual
+            // para o zumbi, e a próxima retomada leria o número errado.
+            if (!current || current.claimToken !== claim.claimToken) {
+                return { authority: 'lost', detail: 'reserva retomada por outra execução' };
+            }
+            if (current.state !== 'in_flight') {
+                return {
+                    authority: 'already_final',
+                    state: current.state,
+                    detail: `chave já assentada como ${current.state}`,
+                };
+            }
+            current.providerAttempts += 1;
+            current.providerFirstAttemptAt = current.providerFirstAttemptAt ?? now();
+            return { authority: 'held' };
+        },
+        async settle(claim, outcome, event) {
+            const current = entries.get(claim.idempotencyKey);
+            // Reserva já tomada por outro (prazo vencido): quem perdeu o direito não
+            // assenta o desfecho. A comparação é pelo TOKEN da geração, não pelo id da
+            // linha — o id sobrevive à retomada, o token não.
+            if (!current || current.claimToken !== claim.claimToken)
+                return;
+            if (outcome.kind === 'sent') {
+                current.state = 'sent';
+            }
+            else if (outcome.kind === 'failed') {
+                current.state = outcome.permanent ? 'failed_permanent' : 'failed_retryable';
+                current.expiresAt = 0;
+            }
+            else if (outcome.kind === 'unknown') {
+                current.state = 'unknown_outcome';
+                current.expiresAt = 0;
+            }
+            else {
+                // `released`: a chave volta a estar livre, sem contar como falha. O
+                // `attempt` permanece — é histórico, e serve para ver insistência.
+                current.state = 'failed_retryable';
+                current.expiresAt = 0;
+            }
+            await write(current, event);
+        },
+        async peek(idempotencyKey) {
+            const current = entries.get(idempotencyKey);
+            if (!current)
+                return 'none';
+            if (current.state === 'in_flight' && current.expiresAt <= now())
+                return 'failed_retryable';
+            return current.state;
+        },
+        async resolveUnknownOutcome(idempotencyKey, resolution, detail) {
+            const current = entries.get(idempotencyKey);
+            if (!current || current.state !== 'unknown_outcome')
+                return;
+            current.state = resolution === 'sent' ? 'sent' : 'failed_retryable';
+            current.expiresAt = 0;
+            await write(current, {
+                kind: resolution === 'sent' ? 'dispatch_sent' : 'dispatch_failed',
+                status: resolution === 'sent' ? 'sent' : null,
+                code: `unknown_resolved_${resolution}`,
+                detail: detail ?? null,
+            });
+        },
+    };
+}
+//# sourceMappingURL=claim.js.map

package/dist/cjs/communication/claim.js.map

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

package/dist/cjs/communication/consent.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Permissão de contato por canal.
+ *
+ * O motor implementa o MECANISMO (registrar, consultar, recusar). A POLÍTICA —
+ * o que fazer quando ninguém decidiu ainda — é do produto, porque a resposta
+ * depende da relação: um escritório cobrando honorário de cliente contratado
+ * não está na mesma posição de quem manda promoção para uma lista.
+ *
+ * O que o motor não faz, em nenhuma configuração: inventar consentimento.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateConsent = evaluateConsent;
+/**
+ * `denied` é absoluto.
+ *
+ * Nenhuma política do produto reverte um opt-out — não há parâmetro para isso, e
+ * é deliberado. Um `denied` vindo de `customer_reply` (o cliente respondeu SAIR
+ * no WhatsApp) é o registro mais forte que existe no sistema, e o dia em que
+ * alguém puder configurar "ignorar opt-out para cobrança" é o dia em que a
+ * configuração vai estar ligada em algum tenant.
+ */
+function evaluateConsent(channel, record, policy = {}) {
+    if (record?.state === 'denied') {
+        return {
+            allowed: false,
+            reason: 'opted_out',
+            detail: `destinatário recusou o canal ${channel}`,
+        };
+    }
+    if (record?.state === 'granted')
+        return { allowed: true };
+    // Sem registro, ou registro `unknown`: a política do produto decide.
+    const onUnknown = policy.onUnknown?.[channel] ?? 'fail_safe';
+    if (onUnknown === 'allow')
+        return { allowed: true };
+    return {
+        allowed: false,
+        reason: 'consent_unknown',
+        detail: `sem permissão registrada para ${channel}`,
+    };
+}
+//# sourceMappingURL=consent.js.map

package/dist/cjs/communication/consent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent.js","sourceRoot":"","sources":["../../../src/communication/consent.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;AA+CH,0CAwBC;AAjCD;;;;;;;;GAQG;AACH,SAAgB,eAAe,CAC7B,OAAmB,EACnB,MAA4B,EAC5B,SAAwB,EAAE;IAE1B,IAAI,MAAM,EAAE,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO;YACL,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,WAAW;YACnB,MAAM,EAAE,gCAAgC,OAAO,EAAE;SAClD,CAAC;IACJ,CAAC;IAED,IAAI,MAAM,EAAE,KAAK,KAAK,SAAS;QAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAE1D,qEAAqE;IACrE,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,IAAI,WAAW,CAAC;IAC7D,IAAI,SAAS,KAAK,OAAO;QAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAEpD,OAAO;QACL,OAAO,EAAE,KAAK;QACd,MAAM,EAAE,iBAAiB;QACzB,MAAM,EAAE,iCAAiC,OAAO,EAAE;KACnD,CAAC;AACJ,CAAC"}

package/dist/cjs/communication/context.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Contexto de toda operação de comunicação do ecossistema.
+ *
+ * Existe porque o motor é UM e os consumidores são vários. Sem contexto
+ * explícito, "envie esta mensagem" é ambíguo em três dimensões que só aparecem
+ * quando já é tarde: de qual escritório, sob qual marca, com qual número.
+ *
+ * Nenhum campo tem valor padrão, e nenhum é inferido do ambiente. Um default
+ * aqui seria a porta pela qual um produto envia com a identidade de outro — e
+ * seria justamente no caso que ninguém testou, porque o caminho feliz sempre
+ * passa o contexto certo.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateContext = validateContext;
+exports.contextRef = contextRef;
+const SLUG = /^[a-z][a-z0-9-]{1,62}[a-z0-9]$/;
+/**
+ * Valida o contexto na BORDA do motor.
+ *
+ * Rejeitar aqui, e não no adapter, é o que garante que nenhum caminho de envio
+ * exista sem contexto: o adapter recebe um contexto já validado ou não é
+ * chamado. Um adapter que valida por conta própria é um adapter que pode
+ * esquecer.
+ */
+function validateContext(ctx) {
+    if (!ctx.tenantId || !ctx.tenantId.trim())
+        return 'tenant';
+    if (!SLUG.test(ctx.product))
+        return 'product';
+    if (!SLUG.test(ctx.brand))
+        return 'brand';
+    return null;
+}
+/**
+ * Forma canônica do contexto para chave e trilha: `tenant/product/brand`.
+ *
+ * Não é PII e não é segredo — é o que aparece em log e em métrica, e é o que
+ * permite atribuir custo por tenant, produto e marca depois, sem que nada
+ * precise ser reinstrumentado.
+ */
+function contextRef(ctx) {
+    return `${ctx.tenantId}/${ctx.product}/${ctx.brand}`;
+}
+//# sourceMappingURL=context.js.map

package/dist/cjs/communication/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/communication/context.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;AAkCH,0CAKC;AASD,gCAEC;AAnCD,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAW9C;;;;;;;GAOG;AACH,SAAgB,eAAe,CAAC,GAAyB;IACvD,IAAI,CAAC,GAAG,CAAC,QAAQ,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;QAAE,OAAO,QAAQ,CAAC;IAC3D,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC;QAAE,OAAO,SAAS,CAAC;IAC9C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO,OAAO,CAAC;IAC1C,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,UAAU,CAAC,GAAyB;IAClD,OAAO,GAAG,GAAG,CAAC,QAAQ,IAAI,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC,KAAK,EAAE,CAAC;AACvD,CAAC"}

package/dist/cjs/communication/credentials.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Resolução de credencial de canal — do NOME lógico ao segredo.
+ *
+ * **O motor nunca vê o segredo antes da borda do adapter.** O que atravessa o
+ * domínio é `credentialRef`, um nome; o valor só é materializado no último
+ * passo, e a trava por conta (`credentialResolverFor`) garante que o adapter só
+ * consiga abrir a referência DAQUELA conta.
+ *
+ * O que muda nesta fase é de onde o valor vem.
+ *
+ * O resolvedor anterior traduzia um punhado de nomes fixos de variável de
+ * ambiente. Isso funciona para um tenant e falha de duas maneiras para dois:
+ * ou os dois apontam para o mesmo nome e COMPARTILHAM o token — a WABA de uma
+ * marca respondendo pelo comportamento de outra —, ou apontam para nomes
+ * distintos e nenhum resolve. Nenhuma das duas é aceitável num canal em que o
+ * bloqueio se propaga.
+ *
+ * A saída não é uma tabela nova de segredos: o ecossistema já tem o Vault
+ * Engine (migração 0012) — AES-256-GCM, chave-mestra fora do banco, tenant como
+ * dado autenticado adicional da cifra, RLS FORCE, vencimento e rotação. Um
+ * segundo cofre seria um segundo lugar para errar.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChannelCredentialResolver = createChannelCredentialResolver;
+exports.isVaultRef = isVaultRef;
+exports.isAcceptableForNewBinding = isAcceptableForNewBinding;
+exports.noCredentialResolver = noCredentialResolver;
+/** Esquema das referências que apontam para o cofre. */
+const VAULT_SCHEME = 'vault://';
+/**
+ * Nomes de variável de ambiente ainda aceitos — **legado, em remoção**.
+ *
+ * `RESEND_API_KEY` continua porque a SC entrega e-mail em produção por ela
+ * hoje, e desligá-la para exigir configuração por escritório pararia a régua de
+ * quem está cobrando agora. Removê-la não é hardening, é interrupção de serviço.
+ *
+ * `WHATSAPP_ACCESS_TOKEN` e `SMS_API_KEY` **saíram**. Nenhum tenant os usa —
+ * não há canal de telefone configurado em lugar nenhum —, então a remoção não
+ * quebra nada e fecha a porta antes de o primeiro tenant entrar por ela. Um
+ * token global de WhatsApp que "ainda ninguém usa" é exatamente o tipo de
+ * conveniência que vira padrão no dia em que alguém tem pressa.
+ *
+ * @deprecated Novos tenants devem usar `vault://`. Plano de remoção: quando a
+ * credencial de e-mail da plataforma migrar para o cofre, esta lista some junto
+ * com esta função.
+ */
+const LEGACY_ENV_NAMES = new Set(['RESEND_API_KEY']);
+/** Canais para os quais uma referência de ambiente nunca é aceitável. */
+const ENV_FORBIDDEN_PREFIXES = ['WHATSAPP_', 'SMS_', 'META_'];
+/**
+ * Resolvedor composto: cofre primeiro, ambiente só para o legado declarado.
+ *
+ * A ordem importa e é fixa. Se o ambiente viesse primeiro, uma variável com o
+ * nome certo passaria na frente do cofre do tenant sem que ninguém percebesse —
+ * e o sintoma seria o pior possível: envio bem-sucedido, pela conta errada.
+ */
+function createChannelCredentialResolver(tenantId, secrets, env = process.env) {
+    return async (ref) => {
+        const trimmed = ref?.trim() ?? '';
+        if (!trimmed)
+            return undefined;
+        if (trimmed.startsWith(VAULT_SCHEME)) {
+            if (!secrets)
+                return undefined;
+            const name = trimmed.slice(VAULT_SCHEME.length).trim();
+            // Um nome vazio depois do esquema resolveria para "qualquer coisa" na
+            // implementação errada do store. Recusa antes de chegar lá.
+            if (!name)
+                return undefined;
+            return secrets.reveal(tenantId, name);
+        }
+        // A partir daqui é o caminho legado, e ele é fechado por allowlist de NOME.
+        // Filtrar por "o que parece segredo" deixaria `DATABASE_URL` passar inteiro,
+        // e `credentialRef` é editável por quem administra o escritório.
+        const name = trimmed.split('/').pop() ?? '';
+        if (ENV_FORBIDDEN_PREFIXES.some((p) => name.startsWith(p)))
+            return undefined;
+        if (!LEGACY_ENV_NAMES.has(name))
+            return undefined;
+        return env[name];
+    };
+}
+/**
+ * A referência aponta para o cofre?
+ *
+ * Usado por guard e por tela: um vínculo novo com referência de ambiente é
+ * dívida sendo criada, e deve ser visível no momento do cadastro, não seis meses
+ * depois.
+ */
+function isVaultRef(ref) {
+    return typeof ref === 'string' && ref.trim().startsWith(VAULT_SCHEME);
+}
+/**
+ * Referência aceitável para um vínculo NOVO?
+ *
+ * `NO_GLOBAL_WHATSAPP_CREDENTIAL_FOR_NEW_TENANTS` deixa de ser promessa de
+ * documento e vira predicado que um teste consegue exercer.
+ */
+function isAcceptableForNewBinding(channel, ref) {
+    if (channel === 'whatsapp' || channel === 'sms')
+        return isVaultRef(ref);
+    return isVaultRef(ref) || LEGACY_ENV_NAMES.has((ref ?? '').split('/').pop() ?? '');
+}
+/**
+ * Resolvedor que não abre NADA — nem cofre, nem ambiente.
+ *
+ * Existe para as composições que montam o motor só para LER configuração
+ * (quais canais estão registrados, qual o remetente, qual o `credentialRef`) e
+ * nunca despacham. `GET /v1/communication/channels` é exatamente esse caso.
+ *
+ * Passar o resolvedor de envio ali seria dar à rota de leitura a capacidade de
+ * decifrar, ainda que ela não a exerça hoje. Capacidade que não é exercida é
+ * capacidade que alguém exerce depois, na primeira mudança que parecer
+ * inofensiva — e a diferença entre "não usa" e "não pode" é a única que sobrevive
+ * a essa mudança.
+ */
+function noCredentialResolver() {
+    return async () => undefined;
+}
+//# sourceMappingURL=credentials.js.map