@baruk/core 0.4.2 → 0.6.0

package/dist/fiscal/sync/retry.js

@@ -0,0 +1,176 @@
+import { FiscalTransportError } from '../transport/types.js';
+import { FiscalProviderError } from '../ingestion/provider.js';
+/**
+ * Perfil de recuo por categoria.
+ *
+ * `base` é a espera da PRIMEIRA tentativa falha; ela dobra a cada tentativa até
+ * `cap`. Os números não são arbitrários:
+ *
+ *   - `PROVIDER_RATE_LIMIT` começa em uma HORA porque é o que a NT 2014.002 §3.5
+ *     exige, e errar para menos custa o CNPJ de um terceiro.
+ *   - `AUTHENTICATION_FAILED` e as duas de certificado não têm recuo: elas não
+ *     retentam. O campo existe como zero explícito, para que ninguém leia a
+ *     ausência como "use o default".
+ *   - `NETWORK_TRANSIENT` começa em 30s: curto o bastante para um soluço de rede
+ *     caber dentro do mesmo ciclo, longo o bastante para não ser um laço.
+ */
+const PROFILE = {
+    NETWORK_TRANSIENT: { retryable: true, baseMs: 30_000, capMs: 900_000, provider: true },
+    PROVIDER_RATE_LIMIT: { retryable: true, baseMs: 3_600_000, capMs: 21_600_000, provider: true },
+    PROVIDER_TEMPORARILY_UNAVAILABLE: {
+        retryable: true,
+        baseMs: 300_000,
+        capMs: 3_600_000,
+        provider: true,
+    },
+    AUTHENTICATION_FAILED: { retryable: false, baseMs: 0, capMs: 0, provider: false },
+    CERTIFICATE_INVALID: { retryable: false, baseMs: 0, capMs: 0, provider: false },
+    CERTIFICATE_EXPIRED: { retryable: false, baseMs: 0, capMs: 0, provider: false },
+    PERMISSION_DENIED: { retryable: false, baseMs: 0, capMs: 0, provider: false },
+    // Resposta que não é o que o contrato promete pode ser um deploy ruim do
+    // provedor — volta sozinho — mas insistir rápido não ajuda em nada.
+    BAD_RESPONSE: { retryable: true, baseMs: 600_000, capMs: 3_600_000, provider: true },
+    // Documento ilegível é determinístico: o MESMO XML vai falhar de novo. Ele já
+    // ficou preservado na caixa de entrada pelo pipeline; retentar o lote não o
+    // conserta e ainda gasta a cota do cliente.
+    MALFORMED_DOCUMENT: { retryable: false, baseMs: 0, capMs: 0, provider: false },
+    // Outro processo mexeu no cursor. Volta sozinho, e rápido: o conflito é nosso.
+    CURSOR_CONFLICT: { retryable: true, baseMs: 60_000, capMs: 600_000, provider: false },
+    INTERNAL_ERROR: { retryable: true, baseMs: 300_000, capMs: 3_600_000, provider: false },
+};
+const INTERVENTION = {
+    AUTHENTICATION_FAILED: 'auth_required',
+    CERTIFICATE_EXPIRED: 'certificate_expired',
+    CERTIFICATE_INVALID: 'certificate_invalid',
+    PERMISSION_DENIED: 'provider_access_denied',
+};
+/** Classe do provedor → categoria de decisão. */
+export function categorizeProviderError(cls) {
+    switch (cls) {
+        case 'transient':
+            return 'PROVIDER_TEMPORARILY_UNAVAILABLE';
+        case 'throttled':
+            return 'PROVIDER_RATE_LIMIT';
+        case 'auth':
+            return 'AUTHENTICATION_FAILED';
+        case 'not_allowed':
+            return 'PERMISSION_DENIED';
+        case 'invalid':
+            return 'MALFORMED_DOCUMENT';
+        case 'unknown':
+            // Não classificado é tratado como transitório COM TETO — nunca como
+            // permanente (perderia recuperação) nem como retentável para sempre.
+            return 'NETWORK_TRANSIENT';
+    }
+}
+/** Classe do transporte → categoria de decisão. */
+export function categorizeTransportError(cls) {
+    switch (cls) {
+        case 'network':
+            return 'NETWORK_TRANSIENT';
+        case 'timeout':
+            // Timeout NÃO é "não aconteceu": o servidor pode ter processado. Retenta,
+            // e a idempotência da ingestão é quem absorve a repetição.
+            return 'NETWORK_TRANSIENT';
+        case 'tls':
+            return 'PROVIDER_TEMPORARILY_UNAVAILABLE';
+        case 'certificate':
+            return 'CERTIFICATE_INVALID';
+        case 'protocol':
+            return 'BAD_RESPONSE';
+    }
+}
+/** Status HTTP → categoria, para provedores REST (o ADN é um). */
+export function categorizeHttpStatus(status) {
+    if (status === 401)
+        return 'AUTHENTICATION_FAILED';
+    if (status === 403)
+        return 'PERMISSION_DENIED';
+    if (status === 429)
+        return 'PROVIDER_RATE_LIMIT';
+    if (status === 408 || status === 504)
+        return 'NETWORK_TRANSIENT';
+    if (status === 503 || status === 502)
+        return 'PROVIDER_TEMPORARILY_UNAVAILABLE';
+    if (status >= 500)
+        return 'PROVIDER_TEMPORARILY_UNAVAILABLE';
+    if (status >= 400)
+        return 'BAD_RESPONSE';
+    return 'INTERNAL_ERROR';
+}
+/**
+ * Decide o que fazer com uma falha.
+ *
+ * ## Jitter é obrigatório, não enfeite
+ *
+ * Sem ele, cem clientes que falharam no mesmo minuto voltam no mesmo minuto —
+ * o rebanho que derruba o provedor de novo assim que ele levanta. O jitter é
+ * "full jitter": um sorteio em `[0, espera]`, e não `espera ± 10%`. A variante
+ * completa é a que realmente espalha; a estreita só desloca o rebanho.
+ *
+ * ## `Retry-After` vence o nosso cálculo — com piso
+ *
+ * Quando o servidor diz quando voltar, ele sabe mais do que nós. Mas um
+ * `Retry-After: 0` num 429 é o servidor se contradizendo; o piso de 60s existe
+ * para que a obediência não vire laço.
+ */
+export function decideFiscalRetry(category, input, 
+/** Código curto do provedor/transporte. Sem ele, a categoria serve de rótulo. */
+code = category) {
+    const profile = PROFILE[category];
+    const escalateAfter = input.humanEscalationAfter ?? 5;
+    if (!profile.retryable) {
+        return {
+            category,
+            retryable: false,
+            nextAttemptAt: null,
+            countsAgainstProvider: profile.provider,
+            interventionKind: INTERVENTION[category] ?? null,
+            code,
+        };
+    }
+    let nextAttemptAt;
+    if (input.retryAfter && input.retryAfter > input.now) {
+        const floorMs = category === 'PROVIDER_RATE_LIMIT' ? 60_000 : 0;
+        const asked = input.retryAfter.getTime() - input.now.getTime();
+        nextAttemptAt = new Date(input.now.getTime() + Math.max(asked, floorMs));
+    }
+    else {
+        // Expoente limitado a 6 antes do teto: 2^6 já ultrapassa qualquer `capMs`
+        // desta tabela, e deixar o expoente crescer sem limite produz `Infinity`
+        // depois de mil falhas — uma data inválida em vez de uma espera longa.
+        const exponent = Math.min(input.previousFailures, 6);
+        const ceiling = Math.min(profile.baseMs * 2 ** exponent, profile.capMs);
+        const random = input.random ?? Math.random;
+        // Full jitter com piso na metade do teto seria o "equal jitter"; aqui o
+        // sorteio é em [0, ceiling] e o piso é a base, para que a primeira falha
+        // nunca produza uma retentativa imediata.
+        const jittered = Math.floor(random() * ceiling);
+        nextAttemptAt = new Date(input.now.getTime() + Math.max(jittered, profile.baseMs));
+    }
+    // Retentável não significa retentável para sempre. Depois de N falhas
+    // consecutivas, o caso deixa de ser "o provedor oscilou" e passa a ser algo
+    // que uma pessoa precisa olhar — sem parar de retentar, porque pode voltar.
+    const escalated = input.previousFailures + 1 >= escalateAfter;
+    return {
+        category,
+        retryable: true,
+        nextAttemptAt,
+        countsAgainstProvider: profile.provider,
+        interventionKind: escalated ? 'repeated_failure' : null,
+        code,
+    };
+}
+/** Atalho: recebe o erro e devolve a decisão, sem quem chama classificar antes. */
+export function decideFromError(err, input) {
+    if (err instanceof FiscalTransportError) {
+        return decideFiscalRetry(categorizeTransportError(err.errorClass), { ...input, retryAfter: input.retryAfter ?? err.retryAfter }, err.code);
+    }
+    if (err instanceof FiscalProviderError) {
+        return decideFiscalRetry(categorizeProviderError(err.errorClass), { ...input, retryAfter: input.retryAfter ?? err.retryAfter }, err.providerCode ?? err.errorClass);
+    }
+    // Erro não classificado é NOSSO até prova em contrário: tratá-lo como falha do
+    // provedor esconderia um defeito de código atrás de um recuo educado.
+    return decideFiscalRetry('INTERNAL_ERROR', input, 'UNCLASSIFIED');
+}
+//# sourceMappingURL=retry.js.map

package/dist/fiscal/sync/retry.js.map

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

package/dist/fiscal/sync/secret-boundary.d.ts

@@ -0,0 +1,169 @@
+import type { Tx } from '../../db/client.js';
+import type { FiscalCredentialKind, FiscalEnvironment } from '../eligibility.js';
+import type { FiscalDocumentAdapter, FiscalDocumentType, FiscalEnvironmentTag } from '../ingestion/provider.js';
+/**
+ * A fronteira entre "decidir se devemos sincronizar" e "abrir o cofre".
+ *
+ * ## O defeito que este módulo existe para tornar indizível
+ *
+ * A primeira escrita da Fase 2 tinha UM contrato para a fonte:
+ *
+ *   adapterFactory({ tx, tenantId, clientId, documentType, environment })
+ *     → { adapter, dispose } | null
+ *
+ * Ele devolvia o adapter JÁ com transporte e credencial. Quem o implementasse
+ * para homologação ou produção teria de decifrar o material do certificado ali
+ * dentro — não por descuido, mas porque era isso que o contrato pedia. E o
+ * orquestrador o chamava logo depois da cadência, ANTES da janela do cursor, do
+ * disjuntor, da prontidão da credencial, do CNPJ do ator e do lease.
+ *
+ * O resultado era estrutural, não hipotético: cinco portões que sabem dizer
+ * "não" sem tocar em segredo nenhum ficavam depois do acesso ao cofre. Um
+ * escritório com duzentos clientes cujo disjuntor estivesse aberto decifraria
+ * duzentos certificados para em seguida não fazer requisição alguma.
+ *
+ * ## A separação: descritor primeiro, material depois
+ *
+ * A fonte passa a ser resolvida em duas etapas com custos diferentes:
+ *
+ *   descritor    quem é o provedor, qual ambiente, qual slug de fonte, qual
+ *                teto de lote, qual credencial ele exige. Tudo isto é METADATA:
+ *                sai de configuração e de tabela, e nenhuma parte exige abrir
+ *                material criptográfico.
+ *
+ *   materialize  agora sim: cofre, chave privada, agente de TLS mútuo, adapter.
+ *
+ * O descritor é o que os portões precisam — a fonte (`source`) governa cursor,
+ * disjuntor e prontidão, e ela vem do descritor. `materialize` só é convidado
+ * quando não sobrou nenhum motivo para não sincronizar.
+ *
+ * ## Por que a autorização é um objeto, e não um booleano
+ *
+ * Uma convenção ("chame materialize só depois dos portões") volta a ser violada
+ * no primeiro refactor, em silêncio. Aqui a autorização é um valor que só o
+ * orquestrador consegue emitir, e `loadFiscalTlsMaterial` a exige.
+ *
+ * A marca não é um campo: é um `WeakSet` deste módulo. Um objeto com a forma
+ * certa não passa; uma cópia por spread do objeto certo também não passa. Só
+ * passa a instância que `grantFiscalSecretAccess` devolveu — e essa função não
+ * é reexportada pelo `index` do pacote, de modo que fora de `@baruk/core` não
+ * existe caminho para fabricá-la.
+ *
+ * Isso não é defesa contra um adversário com acesso ao processo: é a defesa
+ * contra a próxima pessoa apressada, que é quem de fato reintroduz este defeito.
+ */
+/** Violação da fronteira. Classe e contexto — nunca material, nunca ponteiro. */
+export declare class FiscalSecretBoundaryError extends Error {
+    readonly stage: string;
+    constructor(stage: string);
+}
+/**
+ * O passe para o cofre.
+ *
+ * Todo campo aqui é seguro para trilha: identificadores, slugs e uma impressão
+ * digital truncada. Nenhum deles é ou deriva de material criptográfico.
+ */
+export interface FiscalSecretAuthorization {
+    readonly tenantId: string;
+    readonly clientId: string;
+    readonly source: string;
+    readonly environment: FiscalEnvironment;
+    readonly documentType: FiscalDocumentType;
+    readonly credentialKind: FiscalCredentialKind;
+    /** A vez já está tomada quando o material é aberto. Ver `orchestrator.ts`. */
+    readonly leaseId: string;
+    /** sha256 truncado registrado no cadastro, quando existe. Seguro em tela. */
+    readonly credentialFingerprint: string | null;
+}
+/**
+ * Emite o passe. Chamada em UM lugar: o orquestrador, depois do último portão.
+ *
+ * Deliberadamente ausente do `index.ts` do pacote. Um `grep` por este nome
+ * responde "quem pode autorizar a abertura do cofre fiscal?" — e a resposta tem
+ * de caber em uma tela.
+ */
+export declare function grantFiscalSecretAccess(input: FiscalSecretAuthorization): FiscalSecretAuthorization;
+/**
+ * Recusa qualquer coisa que não tenha saído de `grantFiscalSecretAccess`.
+ *
+ * Lança em vez de devolver `false` porque não existe caminho de recuperação:
+ * chegar aqui sem passe significa que a ordem dos portões foi quebrada, e
+ * seguir adiante seria exatamente o dano que a fronteira existe para impedir.
+ */
+export declare function assertFiscalSecretAccess(auth: FiscalSecretAuthorization | null | undefined, stage: string): asserts auth is FiscalSecretAuthorization;
+/**
+ * O que se sabe de uma fonte SEM abrir nada.
+ *
+ * Espelha os campos do adapter que os portões consultam. Não é duplicação
+ * acidental: é o subconjunto que pode ser conhecido antes da credencial, e
+ * mantê-lo separado é o que impede alguém de "só espiar o adapter" para
+ * descobrir o `source`.
+ */
+export interface FiscalSourceDescriptor {
+    /** Slug estável. Governa `fiscal_document.source`, cursor, disjuntor. */
+    readonly source: string;
+    readonly documentTypes: readonly FiscalDocumentType[];
+    readonly environments: readonly FiscalEnvironmentTag[];
+    readonly batchLimit: number;
+    readonly exhaustedBackoffSeconds: number;
+    /**
+     * Qual credencial esta fonte exige. É o que a prontidão avalia — e é metadata:
+     * saber que o ADN pede A1 não exige ter um A1 aberto.
+     */
+    readonly credentialKind: FiscalCredentialKind;
+}
+/** O adapter já materializado, com o descarte do material que o sustenta. */
+export interface FiscalAdapterMaterialization {
+    adapter: FiscalDocumentAdapter;
+    /** Zera o material em memória. Chamado em TODO caminho de saída. */
+    dispose?: () => void;
+}
+/**
+ * Materializa o adapter. Só aqui o cofre pode ser aberto.
+ *
+ * `null` significa "o material não está disponível agora" — ponteiro que não
+ * resolve, envelope ilegível, cofre indisponível. Não é exceção porque não é
+ * anormal: é um estado do cadastro, e o orquestrador o transforma em desfecho
+ * nomeado mais tarefa humana.
+ */
+export type FiscalSourceMaterializer = (input: {
+    tx: Tx;
+    authorization: FiscalSecretAuthorization;
+}) => Promise<FiscalAdapterMaterialization | null>;
+/** Descritor mais a promessa de materialização. Uma resolução de fonte. */
+export interface FiscalSourceResolution {
+    descriptor: FiscalSourceDescriptor;
+    materialize: FiscalSourceMaterializer;
+}
+/**
+ * Resolve a fonte de um cliente a partir de METADATA.
+ *
+ * Recebe `tx` porque a resolução pode consultar cobertura, jurisdição ou
+ * configuração do tenant — todas leituras de tabela. O que ela não pode fazer é
+ * abrir o cofre: `loadFiscalTlsMaterial` exige um passe, e nesta etapa não
+ * existe passe nenhum.
+ *
+ * `null` não é falha: é a resposta correta para "NFS-e de um município que não
+ * aderiu ao ADN". O orquestrador a transforma em `no_adapter` mais tarefa.
+ */
+export type FiscalSourceResolver = (input: {
+    tx: Tx;
+    tenantId: string;
+    clientId: string;
+    documentType: FiscalDocumentType;
+    environment: FiscalEnvironment;
+}) => Promise<FiscalSourceResolution | null>;
+/**
+ * Descritor derivado de um adapter JÁ construído.
+ *
+ * Existe para as fontes que não têm segredo a materializar — hoje, o provedor
+ * sintético. Construir o adapter durante a resolução do descritor só é legítimo
+ * porque ali não há cofre a abrir: um adapter que exija material de certificado
+ * NÃO pode nascer nesta etapa, e é para esse caso que `materialize` existe.
+ *
+ * A alternativa seria repetir os cinco campos à mão em cada chamador, e a
+ * primeira divergência entre o descritor e o adapter que ele descreve
+ * apareceria como um teto de lote errado contra o ambiente nacional.
+ */
+export declare function describeAdapter(adapter: FiscalDocumentAdapter, credentialKind?: FiscalCredentialKind): FiscalSourceDescriptor;
+//# sourceMappingURL=secret-boundary.d.ts.map

package/dist/fiscal/sync/secret-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-boundary.d.ts","sourceRoot":"","sources":["../../../src/fiscal/sync/secret-boundary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,KAAK,EACV,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,iFAAiF;AACjF,qBAAa,yBAA0B,SAAQ,KAAK;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM;CAInC;AAED;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAC;IAC1C,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC;IAC9C,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/C;AAYD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,yBAAyB,GAC/B,yBAAyB,CAI3B;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,yBAAyB,GAAG,IAAI,GAAG,SAAS,EAClD,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,IAAI,yBAAyB,CAI3C;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACrC,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACtD,QAAQ,CAAC,YAAY,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACvD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC;CAC/C;AAED,6EAA6E;AAC7E,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,qBAAqB,CAAC;IAC/B,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,KAAK,EAAE;IAC7C,EAAE,EAAE,EAAE,CAAC;IACP,aAAa,EAAE,yBAAyB,CAAC;CAC1C,KAAK,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CAAC;AAEnD,2EAA2E;AAC3E,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,sBAAsB,CAAC;IACnC,WAAW,EAAE,wBAAwB,CAAC;CACvC;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE;IACzC,EAAE,EAAE,EAAE,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,kBAAkB,CAAC;IACjC,WAAW,EAAE,iBAAiB,CAAC;CAChC,KAAK,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAAC;AAE7C;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,qBAAqB,EAC9B,cAAc,GAAE,oBAAuC,GACtD,sBAAsB,CASxB"}

package/dist/fiscal/sync/secret-boundary.js

@@ -0,0 +1,116 @@
+/**
+ * A fronteira entre "decidir se devemos sincronizar" e "abrir o cofre".
+ *
+ * ## O defeito que este módulo existe para tornar indizível
+ *
+ * A primeira escrita da Fase 2 tinha UM contrato para a fonte:
+ *
+ *   adapterFactory({ tx, tenantId, clientId, documentType, environment })
+ *     → { adapter, dispose } | null
+ *
+ * Ele devolvia o adapter JÁ com transporte e credencial. Quem o implementasse
+ * para homologação ou produção teria de decifrar o material do certificado ali
+ * dentro — não por descuido, mas porque era isso que o contrato pedia. E o
+ * orquestrador o chamava logo depois da cadência, ANTES da janela do cursor, do
+ * disjuntor, da prontidão da credencial, do CNPJ do ator e do lease.
+ *
+ * O resultado era estrutural, não hipotético: cinco portões que sabem dizer
+ * "não" sem tocar em segredo nenhum ficavam depois do acesso ao cofre. Um
+ * escritório com duzentos clientes cujo disjuntor estivesse aberto decifraria
+ * duzentos certificados para em seguida não fazer requisição alguma.
+ *
+ * ## A separação: descritor primeiro, material depois
+ *
+ * A fonte passa a ser resolvida em duas etapas com custos diferentes:
+ *
+ *   descritor    quem é o provedor, qual ambiente, qual slug de fonte, qual
+ *                teto de lote, qual credencial ele exige. Tudo isto é METADATA:
+ *                sai de configuração e de tabela, e nenhuma parte exige abrir
+ *                material criptográfico.
+ *
+ *   materialize  agora sim: cofre, chave privada, agente de TLS mútuo, adapter.
+ *
+ * O descritor é o que os portões precisam — a fonte (`source`) governa cursor,
+ * disjuntor e prontidão, e ela vem do descritor. `materialize` só é convidado
+ * quando não sobrou nenhum motivo para não sincronizar.
+ *
+ * ## Por que a autorização é um objeto, e não um booleano
+ *
+ * Uma convenção ("chame materialize só depois dos portões") volta a ser violada
+ * no primeiro refactor, em silêncio. Aqui a autorização é um valor que só o
+ * orquestrador consegue emitir, e `loadFiscalTlsMaterial` a exige.
+ *
+ * A marca não é um campo: é um `WeakSet` deste módulo. Um objeto com a forma
+ * certa não passa; uma cópia por spread do objeto certo também não passa. Só
+ * passa a instância que `grantFiscalSecretAccess` devolveu — e essa função não
+ * é reexportada pelo `index` do pacote, de modo que fora de `@baruk/core` não
+ * existe caminho para fabricá-la.
+ *
+ * Isso não é defesa contra um adversário com acesso ao processo: é a defesa
+ * contra a próxima pessoa apressada, que é quem de fato reintroduz este defeito.
+ */
+/** Violação da fronteira. Classe e contexto — nunca material, nunca ponteiro. */
+export class FiscalSecretBoundaryError extends Error {
+    stage;
+    constructor(stage) {
+        super(`SECRET_BOUNDARY_VIOLATION: ${stage}`);
+        this.stage = stage;
+        this.name = 'FiscalSecretBoundaryError';
+    }
+}
+/**
+ * As autorizações realmente emitidas.
+ *
+ * `WeakSet` e não um campo `Symbol`: um campo sobrevive a `{...auth}`, a
+ * `structuredClone` e a `JSON.parse(JSON.stringify(auth))`, e qualquer uma
+ * dessas três é como a checagem passaria a aceitar um objeto que os portões
+ * nunca aprovaram.
+ */
+const emitidas = new WeakSet();
+/**
+ * Emite o passe. Chamada em UM lugar: o orquestrador, depois do último portão.
+ *
+ * Deliberadamente ausente do `index.ts` do pacote. Um `grep` por este nome
+ * responde "quem pode autorizar a abertura do cofre fiscal?" — e a resposta tem
+ * de caber em uma tela.
+ */
+export function grantFiscalSecretAccess(input) {
+    const auth = Object.freeze({ ...input });
+    emitidas.add(auth);
+    return auth;
+}
+/**
+ * Recusa qualquer coisa que não tenha saído de `grantFiscalSecretAccess`.
+ *
+ * Lança em vez de devolver `false` porque não existe caminho de recuperação:
+ * chegar aqui sem passe significa que a ordem dos portões foi quebrada, e
+ * seguir adiante seria exatamente o dano que a fronteira existe para impedir.
+ */
+export function assertFiscalSecretAccess(auth, stage) {
+    if (!auth || typeof auth !== 'object' || !emitidas.has(auth)) {
+        throw new FiscalSecretBoundaryError(stage);
+    }
+}
+/**
+ * Descritor derivado de um adapter JÁ construído.
+ *
+ * Existe para as fontes que não têm segredo a materializar — hoje, o provedor
+ * sintético. Construir o adapter durante a resolução do descritor só é legítimo
+ * porque ali não há cofre a abrir: um adapter que exija material de certificado
+ * NÃO pode nascer nesta etapa, e é para esse caso que `materialize` existe.
+ *
+ * A alternativa seria repetir os cinco campos à mão em cada chamador, e a
+ * primeira divergência entre o descritor e o adapter que ele descreve
+ * apareceria como um teto de lote errado contra o ambiente nacional.
+ */
+export function describeAdapter(adapter, credentialKind = 'certificate_a1') {
+    return {
+        source: adapter.source,
+        documentTypes: adapter.documentTypes,
+        environments: adapter.environments,
+        batchLimit: adapter.batchLimit,
+        exhaustedBackoffSeconds: adapter.exhaustedBackoffSeconds,
+        credentialKind,
+    };
+}
+//# sourceMappingURL=secret-boundary.js.map

package/dist/fiscal/sync/secret-boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-boundary.js","sourceRoot":"","sources":["../../../src/fiscal/sync/secret-boundary.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,iFAAiF;AACjF,MAAM,OAAO,yBAA0B,SAAQ,KAAK;IAC7B;IAArB,YAAqB,KAAa;QAChC,KAAK,CAAC,8BAA8B,KAAK,EAAE,CAAC,CAAC;QAD1B,UAAK,GAAL,KAAK,CAAQ;QAEhC,IAAI,CAAC,IAAI,GAAG,2BAA2B,CAAC;IAC1C,CAAC;CACF;AAqBD;;;;;;;GAOG;AACH,MAAM,QAAQ,GAAG,IAAI,OAAO,EAAU,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAAgC;IAEhC,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;IACzC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACnB,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CACtC,IAAkD,EAClD,KAAa;IAEb,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7D,MAAM,IAAI,yBAAyB,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;AACH,CAAC;AAqED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAC7B,OAA8B,EAC9B,iBAAuC,gBAAgB;IAEvD,OAAO;QACL,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,aAAa,EAAE,OAAO,CAAC,aAAa;QACpC,YAAY,EAAE,OAAO,CAAC,YAAY;QAClC,UAAU,EAAE,OAAO,CAAC,UAAU;QAC9B,uBAAuB,EAAE,OAAO,CAAC,uBAAuB;QACxD,cAAc;KACf,CAAC;AACJ,CAAC"}

package/dist/fiscal/transport/https.d.ts

@@ -0,0 +1,86 @@
+import { type ClientTlsMaterial, type FiscalTransport, type FiscalTransportRequest, type FiscalTransportResponse } from './types.js';
+/**
+ * O transporte HTTPS, com TLS mútuo quando há material de cliente.
+ *
+ * ═══ A opção que este arquivo não tem ══════════════════════════════════════
+ *
+ * Não existe aqui nenhuma forma de desligar a verificação do certificado do
+ * servidor. Não é uma opção com default seguro — é uma opção que não existe,
+ * e a diferença é o ponto inteiro. Um default seguro é contornável por quem
+ * estiver com pressa às 23h de uma sexta; um caminho ausente não é.
+ *
+ * A tentação é concreta e tem nome: a cadeia ICP-Brasil não vem no bundle de CAs
+ * do sistema em várias imagens Docker, e a primeira tentativa contra o ambiente
+ * nacional falha com `UNABLE_TO_VERIFY_LEAF_SIGNATURE`. A correção correta é
+ * ACRESCENTAR a cadeia em `ca`; a correção de dois caracteres é desligar a
+ * verificação — e ela transforma TLS mútuo, cujo propósito inteiro é provar com
+ * quem se está falando, em criptografia contra ninguém. O certificado que
+ * viajaria por esse canal é o do CLIENTE, contra a Receita.
+ *
+ * `assertNoTlsBypass` confere as opções montadas ANTES de abrir o socket. É
+ * redundante com a ausência da opção, e essa redundância é o desenho: um dia
+ * alguém acrescentará um `...opcoesExtras` aqui, e o portão precisa estar no
+ * caminho do socket, não na revisão de código.
+ *
+ * ═══ Erro nunca copia texto do sistema ═════════════════════════════════════
+ *
+ * Só `err.code` atravessa. `err.message` de TLS cita o sujeito do certificado e
+ * o caminho do arquivo; `err.stack` de um cliente HTTP já carregou URL com
+ * credencial embutida neste ecossistema. Redigir o campo depois não resolve —
+ * a defesa é não copiar.
+ */
+export interface HttpsFiscalTransportOptions {
+    /** Material do cliente. Ausente = TLS simples (só o servidor se identifica). */
+    tls?: ClientTlsMaterial | null;
+    /** Nome para SNI e para a validação de identidade, quando difere do host. */
+    servername?: string;
+    /** Teto de conexões simultâneas. Um por cliente é o suficiente e o educado. */
+    maxSockets?: number;
+    /**
+     * Teto de bytes do CORPO da resposta. Ausente = sem teto.
+     *
+     * Sem ele, o acúmulo em `chunks` é ilimitado: um servidor comprometido, um
+     * proxy hostil ou um defeito do lado de lá derrubam o worker por memória sem
+     * jamais precisar de uma resposta válida. O teto é conferido enquanto os
+     * pedaços chegam — e não no fim —, porque conferir no fim significa já ter
+     * alocado o que se queria recusar.
+     */
+    maxResponseBytes?: number;
+}
+/**
+ * As opções que serão entregues ao socket, conferidas.
+ *
+ * Exportada porque o teste de regressão precisa exercitar a rejeição — um portão
+ * que só é conferido pela leitura do código não é um portão.
+ */
+export declare function assertNoTlsBypass(options: Record<string, unknown>): void;
+export declare class HttpsFiscalTransport implements FiscalTransport {
+    readonly kind = "https";
+    private readonly agent;
+    private readonly servername;
+    /** Apresentamos certificado de cliente? Decide a leitura do reset abaixo. */
+    private readonly presentsClientCert;
+    private readonly maxResponseBytes;
+    constructor(options?: HttpsFiscalTransportOptions);
+    send(req: FiscalTransportRequest): Promise<FiscalTransportResponse>;
+}
+/**
+ * Contexto do socket, para separar recusa de credencial de queda de rede.
+ *
+ * Ver o comentário longo em `send`: no TLS 1.3 os dois chegam como
+ * `ECONNRESET`, e sem estes três fatos não há como distingui-los.
+ */
+export interface TlsAttemptContext {
+    presentsClientCert: boolean;
+    handshakeCompleted: boolean;
+    bytesReceived: number;
+}
+/**
+ * Espera pedida por uma RESPOSTA (e não por um erro).
+ *
+ * Um `429` ou `503` com `Retry-After` é o servidor dizendo exatamente quando
+ * voltar. Ignorá-lo e aplicar o nosso backoff seria substituir a informação de
+ * quem sabe pela estimativa de quem não sabe.
+ */
+export declare function retryAfterOf(res: FiscalTransportResponse, now?: Date): Date | null;
+//# sourceMappingURL=https.d.ts.map

package/dist/fiscal/transport/https.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"https.d.ts","sourceRoot":"","sources":["../../../src/fiscal/transport/https.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC7B,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,MAAM,WAAW,2BAA2B;IAC1C,gFAAgF;IAChF,GAAG,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC/B,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+EAA+E;IAC/E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAyDD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAWxE;AAED,qBAAa,oBAAqB,YAAW,eAAe;IAC1D,QAAQ,CAAC,IAAI,WAAW;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;IAChD,6EAA6E;IAC7E,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAU;IAC7C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;gBAE9B,OAAO,GAAE,2BAAgC;IAuC/C,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAgI1E;AA0BD;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,kBAAkB,EAAE,OAAO,CAAC;IAC5B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;CACvB;AAwCD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,uBAAuB,EAAE,GAAG,GAAE,IAAiB,GAAG,IAAI,GAAG,IAAI,CAE9F"}