@baruk/core 0.4.2 → 0.6.0

package/dist/fiscal/conditions.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Condições de aplicabilidade — uma AST declarativa, tipada e interpretada.
+ *
+ * ## Por que não uma linguagem
+ *
+ * A tentação é guardar uma expressão e avaliá-la. Nada aqui é avaliado: não há
+ * `eval`, nem `Function`, nem SQL montado, nem código do usuário. A condição é
+ * um objeto JSON com formato fechado, validado na escrita e percorrido por um
+ * `switch` na leitura. O pior que uma condição malformada consegue fazer é ser
+ * recusada.
+ *
+ * ## Por que não uma floresta de `if`
+ *
+ * A alternativa seria `requires_employees`, `requires_icms`, `requires_iss`…
+ * uma coluna e um `if` por pergunta fiscal. Não escala: cada UF e cada segmento
+ * acrescenta perguntas, e o motor vira uma cascata que ninguém consegue ler nem
+ * testar. Aqui o motor sabe avaliar **operadores**; o catálogo declara **fatos**.
+ *
+ * ## O terceiro valor
+ *
+ * A avaliação não devolve booleano. Devolve `true`, `false` ou **`unknown`** —
+ * e `unknown` é o ponto inteiro desta fase. Um cliente sobre o qual ninguém
+ * disse se tem empregados não é "sem empregados": é desconhecido, e a decisão
+ * segura é não gerar nem declarar isento. Colapsar `unknown` em `false` é
+ * exatamente o defeito que a auditoria nacional encontrou.
+ */
+/** Lógica ternária de Kleene. `unknown` contamina, e é para isso que existe. */
+export type Truth = true | false | 'unknown';
+export type Condition = 
+/** Sempre aplicável — o padrão de uma regra sem restrição declarada. */
+{
+    op: 'always';
+} | {
+    op: 'eq';
+    attribute: string;
+    value: string | boolean;
+} | {
+    op: 'neq';
+    attribute: string;
+    value: string | boolean;
+} | {
+    op: 'in';
+    attribute: string;
+    values: readonly (string | boolean)[];
+} | {
+    op: 'not_in';
+    attribute: string;
+    values: readonly (string | boolean)[];
+}
+/** O atributo tem valor conhecido, qualquer que seja. */
+ | {
+    op: 'exists';
+    attribute: string;
+} | {
+    op: 'not_exists';
+    attribute: string;
+} | {
+    op: 'and';
+    of: readonly Condition[];
+} | {
+    op: 'or';
+    of: readonly Condition[];
+};
+/** O perfil como o motor o enxerga: nome do atributo → valor conhecido. */
+export type FiscalProfile = Readonly<Record<string, string | boolean>>;
+export declare class InvalidCondition extends Error {
+    constructor(message: string);
+}
+/**
+ * Valida a forma ANTES de gravar.
+ *
+ * Uma condição malformada gravada é uma regra que ninguém consegue avaliar, e
+ * o motor descobriria isso na madrugada do vencimento. Recusar na escrita é
+ * mais barato que descobrir na geração.
+ *
+ * `maxDepth` existe porque uma AST profunda o bastante estoura a pilha na
+ * avaliação, e a escrita é onde isso pode ser recusado com uma mensagem.
+ */
+export declare function parseCondition(raw: unknown, depth?: number): Condition;
+/** Atributos citados pela condição — o motor usa para explicar o que faltou. */
+export declare function referencedAttributes(c: Condition, into?: Set<string>): Set<string>;
+/**
+ * Avalia em lógica ternária.
+ *
+ * As regras de `and` e `or` são as de Kleene, e a escolha importa:
+ *
+ * - `and` com um `false` é `false` mesmo havendo desconhecidos — não adianta
+ *   saber o resto, a regra já não se aplica;
+ * - `or` com um `true` é `true` pelo mesmo motivo;
+ * - fora esses casos, qualquer desconhecido torna o todo desconhecido.
+ *
+ * Sem isso, uma regra "Simples E tem empregados" avaliada para um cliente do
+ * Lucro Real sem informação de folha devolveria `unknown` e viraria pendência
+ * na mesa de alguém — quando a resposta já era `false` pelo regime.
+ */
+export declare function evaluate(condition: Condition, profile: FiscalProfile): Truth;
+/** Atributos citados que o perfil não conhece — a explicação do `unknown`. */
+export declare function missingAttributes(condition: Condition, profile: FiscalProfile): string[];
+//# sourceMappingURL=conditions.d.ts.map

package/dist/fiscal/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../src/fiscal/conditions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,gFAAgF;AAChF,MAAM,MAAM,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,SAAS,CAAC;AAE7C,MAAM,MAAM,SAAS;AACnB,wEAAwE;AACtE;IAAE,EAAE,EAAE,QAAQ,CAAA;CAAE,GAChB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GACxD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GACzD;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,EAAE,CAAA;CAAE,GACtE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,EAAE,CAAA;CAAE;AAC5E,yDAAyD;GACvD;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,EAAE,EAAE,YAAY,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,SAAS,SAAS,EAAE,CAAA;CAAE,GACvC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,SAAS,SAAS,EAAE,CAAA;CAAE,CAAC;AAE3C,2EAA2E;AAC3E,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;AAIvE,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,SAAS,CAiEjE;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,cAAoB,GAAG,GAAG,CAAC,MAAM,CAAC,CAYxF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,GAAG,KAAK,CA+C5E;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,GAAG,MAAM,EAAE,CAExF"}

package/dist/fiscal/conditions.js

@@ -0,0 +1,190 @@
+/**
+ * Condições de aplicabilidade — uma AST declarativa, tipada e interpretada.
+ *
+ * ## Por que não uma linguagem
+ *
+ * A tentação é guardar uma expressão e avaliá-la. Nada aqui é avaliado: não há
+ * `eval`, nem `Function`, nem SQL montado, nem código do usuário. A condição é
+ * um objeto JSON com formato fechado, validado na escrita e percorrido por um
+ * `switch` na leitura. O pior que uma condição malformada consegue fazer é ser
+ * recusada.
+ *
+ * ## Por que não uma floresta de `if`
+ *
+ * A alternativa seria `requires_employees`, `requires_icms`, `requires_iss`…
+ * uma coluna e um `if` por pergunta fiscal. Não escala: cada UF e cada segmento
+ * acrescenta perguntas, e o motor vira uma cascata que ninguém consegue ler nem
+ * testar. Aqui o motor sabe avaliar **operadores**; o catálogo declara **fatos**.
+ *
+ * ## O terceiro valor
+ *
+ * A avaliação não devolve booleano. Devolve `true`, `false` ou **`unknown`** —
+ * e `unknown` é o ponto inteiro desta fase. Um cliente sobre o qual ninguém
+ * disse se tem empregados não é "sem empregados": é desconhecido, e a decisão
+ * segura é não gerar nem declarar isento. Colapsar `unknown` em `false` é
+ * exatamente o defeito que a auditoria nacional encontrou.
+ */
+const OPS = new Set(['always', 'eq', 'neq', 'in', 'not_in', 'exists', 'not_exists', 'and', 'or']);
+export class InvalidCondition extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidCondition';
+    }
+}
+/**
+ * Valida a forma ANTES de gravar.
+ *
+ * Uma condição malformada gravada é uma regra que ninguém consegue avaliar, e
+ * o motor descobriria isso na madrugada do vencimento. Recusar na escrita é
+ * mais barato que descobrir na geração.
+ *
+ * `maxDepth` existe porque uma AST profunda o bastante estoura a pilha na
+ * avaliação, e a escrita é onde isso pode ser recusado com uma mensagem.
+ */
+export function parseCondition(raw, depth = 0) {
+    if (depth > 12)
+        throw new InvalidCondition('condição aninhada demais (limite 12)');
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw new InvalidCondition('condição precisa ser um objeto');
+    }
+    const o = raw;
+    const op = o['op'];
+    if (typeof op !== 'string' || !OPS.has(op)) {
+        throw new InvalidCondition(`operador desconhecido: ${String(op)}`);
+    }
+    const attr = () => {
+        const a = o['attribute'];
+        if (typeof a !== 'string' || a.length === 0) {
+            throw new InvalidCondition(`${op} exige "attribute"`);
+        }
+        return a;
+    };
+    const scalar = () => {
+        const v = o['value'];
+        if (typeof v !== 'string' && typeof v !== 'boolean') {
+            throw new InvalidCondition(`${op} exige "value" texto ou booleano`);
+        }
+        return v;
+    };
+    const list = () => {
+        const v = o['values'];
+        if (!Array.isArray(v) || v.length === 0) {
+            throw new InvalidCondition(`${op} exige "values" não vazio`);
+        }
+        return v.map((x) => {
+            if (typeof x !== 'string' && typeof x !== 'boolean') {
+                throw new InvalidCondition(`${op} aceita apenas texto ou booleano em "values"`);
+            }
+            return x;
+        });
+    };
+    const children = () => {
+        const v = o['of'];
+        if (!Array.isArray(v) || v.length === 0) {
+            throw new InvalidCondition(`${op} exige "of" não vazio`);
+        }
+        return v.map((c) => parseCondition(c, depth + 1));
+    };
+    switch (op) {
+        case 'always':
+            return { op: 'always' };
+        case 'eq':
+            return { op: 'eq', attribute: attr(), value: scalar() };
+        case 'neq':
+            return { op: 'neq', attribute: attr(), value: scalar() };
+        case 'in':
+            return { op: 'in', attribute: attr(), values: list() };
+        case 'not_in':
+            return { op: 'not_in', attribute: attr(), values: list() };
+        case 'exists':
+            return { op: 'exists', attribute: attr() };
+        case 'not_exists':
+            return { op: 'not_exists', attribute: attr() };
+        case 'and':
+            return { op: 'and', of: children() };
+        default:
+            return { op: 'or', of: children() };
+    }
+}
+/** Atributos citados pela condição — o motor usa para explicar o que faltou. */
+export function referencedAttributes(c, into = new Set()) {
+    switch (c.op) {
+        case 'always':
+            break;
+        case 'and':
+        case 'or':
+            for (const child of c.of)
+                referencedAttributes(child, into);
+            break;
+        default:
+            into.add(c.attribute);
+    }
+    return into;
+}
+/**
+ * Avalia em lógica ternária.
+ *
+ * As regras de `and` e `or` são as de Kleene, e a escolha importa:
+ *
+ * - `and` com um `false` é `false` mesmo havendo desconhecidos — não adianta
+ *   saber o resto, a regra já não se aplica;
+ * - `or` com um `true` é `true` pelo mesmo motivo;
+ * - fora esses casos, qualquer desconhecido torna o todo desconhecido.
+ *
+ * Sem isso, uma regra "Simples E tem empregados" avaliada para um cliente do
+ * Lucro Real sem informação de folha devolveria `unknown` e viraria pendência
+ * na mesa de alguém — quando a resposta já era `false` pelo regime.
+ */
+export function evaluate(condition, profile) {
+    switch (condition.op) {
+        case 'always':
+            return true;
+        case 'exists':
+            return profile[condition.attribute] !== undefined;
+        case 'not_exists':
+            return profile[condition.attribute] === undefined;
+        case 'eq':
+        case 'neq': {
+            const v = profile[condition.attribute];
+            if (v === undefined)
+                return 'unknown';
+            const igual = v === condition.value;
+            return condition.op === 'eq' ? igual : !igual;
+        }
+        case 'in':
+        case 'not_in': {
+            const v = profile[condition.attribute];
+            if (v === undefined)
+                return 'unknown';
+            const dentro = condition.values.includes(v);
+            return condition.op === 'in' ? dentro : !dentro;
+        }
+        case 'and': {
+            let desconhecido = false;
+            for (const c of condition.of) {
+                const r = evaluate(c, profile);
+                if (r === false)
+                    return false;
+                if (r === 'unknown')
+                    desconhecido = true;
+            }
+            return desconhecido ? 'unknown' : true;
+        }
+        default: {
+            let desconhecido = false;
+            for (const c of condition.of) {
+                const r = evaluate(c, profile);
+                if (r === true)
+                    return true;
+                if (r === 'unknown')
+                    desconhecido = true;
+            }
+            return desconhecido ? 'unknown' : false;
+        }
+    }
+}
+/** Atributos citados que o perfil não conhece — a explicação do `unknown`. */
+export function missingAttributes(condition, profile) {
+    return [...referencedAttributes(condition)].filter((a) => profile[a] === undefined).sort();
+}
+//# sourceMappingURL=conditions.js.map

package/dist/fiscal/conditions.js.map

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

package/dist/fiscal/contracts/nfse-adn-contract.d.ts

@@ -0,0 +1,315 @@
+/**
+ * O contrato oficial da NFS-e Nacional — ADN — como artefato versionado.
+ *
+ * ## Por que um módulo, e não comentários espalhados
+ *
+ * Até a Fase 2 o que sabíamos do ADN estava disperso em comentários de
+ * `nfse-adn.ts` e `adn-transport.ts`, misturado com o que apenas SUPÚNHAMOS. Um
+ * leitor não tinha como separar "o manual diz" de "assumimos por simetria com a
+ * NF-e" — e a segunda categoria é exatamente a que produz um parser que devolve
+ * lote vazio com sucesso aparente.
+ *
+ * Aqui cada afirmação carrega a fonte que a sustenta e, quando não há fonte, diz
+ * que não há. `evidence: 'official'` significa que existe um documento oficial
+ * publicado, com versão, data e sha256 registrados abaixo; `evidence:
+ * 'unverified'` significa que a afirmação é a melhor leitura disponível e NÃO
+ * foi conferida contra o serviço.
+ *
+ * A distinção não é documental: ela é executável. Um perfil de envelope com
+ * `verified: false` fecha o transporte real (`adn-transport.ts`), e é por isso
+ * que a Fase 3 termina com o motor pronto e parado em vez de pronto e chutando.
+ *
+ * ## O que foi medido nesta onda, e como
+ *
+ * Todo host do ADN — `adn.nfse.gov.br` e `adn.producaorestrita.nfse.gov.br` —
+ * exige TLS mútuo com certificado ICP-Brasil para TODOS os seus módulos,
+ * documentação inclusive. Medido em 2026-09-08 percorrendo as dezesseis URLs de
+ * Swagger publicadas em gov.br (oito módulos × dois ambientes): o handshake
+ * completa, o servidor envia `CertificateRequest` — 170 CAs aceitas em produção
+ * restrita, 5 em produção — e então encerra a conexão sem UM byte de HTTP.
+ * Não há caminho público para ler o envelope de resposta.
+ *
+ * Por isso o envelope permanece `unverified`, e por isso a Fase 3 não é a
+ * primeira conexão real: é a transformação do que ESTÁ publicado num contrato
+ * executável que se recusa a adivinhar o que não está.
+ */
+import type { FiscalProviderErrorClass } from '../ingestion/provider.js';
+/**
+ * A versão do contrato que este código implementa.
+ *
+ * Vai gravada em `fiscal_sync_run.contract_version`. O motivo é operacional e
+ * concreto: quando o governo alterar o leiaute — e ele já alterou duas vezes
+ * entre dez/2025 e fev/2026 —, a pergunta "qual parser processou este lote?"
+ * precisa ter resposta no dado, não na arqueologia do `git log`.
+ */
+export declare const NFSE_ADN_CONTRACT_VERSION: "nfse-adn:v1";
+/** Uma afirmação do contrato tem, ou não tem, documento oficial por trás. */
+export type ContractEvidence = 'official' | 'unverified';
+export interface OfficialSource {
+    readonly id: string;
+    readonly title: string;
+    readonly url: string;
+    /** Versão declarada PELO documento. `null` quando ele não declara uma. */
+    readonly version: string | null;
+    /** Data declarada pelo documento ou pelo portal, em ISO. */
+    readonly publishedAt: string | null;
+    /** sha256 do arquivo baixado em `retrievedAt`. É o detector de troca silenciosa. */
+    readonly sha256: string;
+    readonly retrievedAt: string;
+    readonly scope: string;
+}
+/**
+ * As fontes primárias. Somente gov.br / Portal Nacional NFS-e.
+ *
+ * Blog, fórum, artigo de fornecedor e repositório de terceiro ficaram de fora
+ * por decisão de fase, e não por desdém: nenhum deles é responsável pelo
+ * protocolo, e um deles CONTRADIZ o manual quanto ao papel do certificado.
+ * Pista serve para saber onde procurar; certificação, não.
+ */
+export declare const NFSE_ADN_OFFICIAL_SOURCES: readonly OfficialSource[];
+/**
+ * ═══ A distinção que a Fase 3 existe para tornar precisa ═══════════════════
+ *
+ * `payloadShapeVerified` — o CONTEÚDO (o XML da NFS-e e do evento). Conferido
+ * contra o XSD oficial v1.01, cujo hash está acima. É `true`.
+ *
+ * `envelopeShapeVerified` — o ENVELOPE de transporte que embrulha esse conteúdo
+ * na resposta HTTP do ADN. NÃO existe em nenhum artefato alcançável sem
+ * certificado ICP-Brasil: o Swagger é servido pelo próprio host que exige TLS
+ * mútuo. É `false`.
+ *
+ * Uma constante só para os dois esconderia justamente a diferença que importa.
+ * O antigo `ADN_RESPONSE_SHAPE_VERIFIED` era essa constante única, e ela dizia
+ * `false` por causa do envelope — deixando o leitor concluir que também não
+ * sabíamos ler o documento, o que era falso e desnecessariamente pessimista.
+ */
+export declare const NFSE_ADN_PAYLOAD_SHAPE_VERIFIED = true;
+export declare const NFSE_ADN_ENVELOPE_SHAPE_VERIFIED = false;
+/**
+ * mTLS é exigência do PROTOCOLO neste endpoint — medido e documentado.
+ *
+ * Duas evidências independentes, e nenhuma delas é dedução:
+ *
+ *   1. O manual do contribuinte (v1.0, §1.1) fala do "CNPJ do certificado
+ *      utilizado para ESTABELECER A CONEXÃO" e valida o CNPJ Raiz entre o
+ *      parâmetro informado e esse certificado. Certificado que estabelece a
+ *      conexão é certificado de cliente em TLS.
+ *   2. As dezesseis URLs oficiais de Swagger do ADN, nos dois ambientes, não
+ *      devolvem um byte de HTTP sem certificado de cliente (medido 2026-09-08).
+ *
+ * O escopo desta afirmação é o HOST do ADN, e para nada além dele. A NFS-e
+ * nacional tem outros serviços — emissão pela Sefin, sistemas municipais
+ * próprios, Emissor Público Web com login gov.br — e generalizar um endpoint
+ * para todo o ecossistema seria o mesmo erro de método que a Fase 1 cometeu ao
+ * adivinhar código de evento por prefixo.
+ */
+export declare const NFSE_ADN_MTLS_REQUIREMENT: "required";
+/**
+ * A1 continua REFUTADO como exigência de protocolo.
+ *
+ * O que as fontes oficiais exigem do certificado é: raiz ICP-Brasil (E1208),
+ * `KeyUsage` com Autenticação Cliente (E1200), extensão de CNPJ no `OtherName`
+ * OID 2.16.76.1.3.3 (E1209), cadeia e LCR válidas (E1205/E1206/E1207). Nada
+ * disso distingue A1 de A3 — um A3 em token satisfaz os cinco.
+ *
+ * A1 é PREFERÊNCIA DE AUTOMAÇÃO nossa: um worker sem pessoa presente não digita
+ * PIN de token. Registrar isso como preferência, e não como obrigação legal, é o
+ * que impede o produto de exigir do cliente um certificado que a norma não pede.
+ */
+export declare const NFSE_ADN_A1_REQUIREMENT: "refuted";
+export declare const NFSE_ADN_A1_RATIONALE: "server_side_automation_preference";
+/** Hosts oficiais, por ambiente. Nunca substituíveis um pelo outro. */
+export declare const NFSE_ADN_HOSTS: Readonly<Record<'homologation' | 'production', string>>;
+/**
+ * Limites. Os oficiais vêm da norma; os defensivos são nossos e dizem que são.
+ *
+ * A separação existe porque um limite oficial ultrapassado é violação de norma —
+ * e o CNPJ bloqueado é o do CLIENTE —, enquanto um limite defensivo ultrapassado
+ * é só a nossa proteção agindo. Confundi-los faria alguém "afrouxar o limite"
+ * numa madrugada sem saber qual dos dois estava afrouxando.
+ */
+export declare const NFSE_ADN_LIMITS: Readonly<{
+    /** Manual dos Municípios §1.4.2.b: "Quantidade máxima de documentos no lote: 50". */
+    readonly maxDocumentsPerBatch: {
+        readonly value: 50;
+        readonly evidence: ContractEvidence;
+    };
+    /**
+     * Manual dos Municípios §1.4.2.b: espera mínima de UMA HORA depois de receber
+     * a indicação de que não há mais documentos.
+     *
+     * Isto corrige o comentário da Fase 1, que dizia que a NFS-e "não publica a
+     * regra de uma hora que a NF-e publica" e que adotávamos 3600s por simetria.
+     * Ela publica. A regra é dela, não emprestada.
+     */
+    readonly exhaustedWaitSeconds: {
+        readonly value: 3600;
+        readonly evidence: ContractEvidence;
+    };
+    /**
+     * Teto de bytes da resposta HTTP. DEFENSIVO — a norma não fixa um.
+     *
+     * 16 MiB acomoda com folga 50 documentos comprimidos (uma NFS-e tem alguns KB)
+     * e impede que um servidor comprometido, um proxy hostil ou um defeito do lado
+     * de lá transformem uma sincronização em consumo ilimitado de memória.
+     */
+    readonly maxResponseBytes: {
+        readonly value: number;
+        readonly evidence: ContractEvidence;
+    };
+    /**
+     * Teto de bytes DESCOMPACTADOS por documento. DEFENSIVO.
+     *
+     * É o mesmo 8 MiB que `decodeFiscalXml` já impõe ao XML. Repeti-lo aqui não é
+     * duplicação: sem ele, uma bomba de descompressão estoura a memória ANTES de
+     * o leitor de XML ter a chance de recusar o tamanho.
+     */
+    readonly maxDecompressedBytesPerDocument: {
+        readonly value: number;
+        readonly evidence: ContractEvidence;
+    };
+    /**
+     * Teto de bytes descompactados do lote inteiro. DEFENSIVO.
+     *
+     * 50 × 8 MiB seriam 400 MiB — o produto dos dois tetos anteriores não é um
+     * teto útil. 64 MiB é generoso para o caso real e finito para o hostil.
+     */
+    readonly maxDecompressedBytesPerBatch: {
+        readonly value: number;
+        readonly evidence: ContractEvidence;
+    };
+    /** Teto de espera de uma requisição. DEFENSIVO — ver `FiscalTransportRequest`. */
+    readonly requestTimeoutMs: {
+        readonly value: 30000;
+        readonly evidence: ContractEvidence;
+    };
+}>;
+/**
+ * As quatro séries de NSU do ADN — Manual dos Municípios §1.3.4.
+ *
+ * Confundi-las é o erro caro: cada uma numera um conjunto diferente de fatos, e
+ * usar o cursor de uma para consultar outra pularia documentos em silêncio.
+ * A nossa é a QUARTA, e apenas ela.
+ */
+export declare const NFSE_ADN_NSU_SERIES: Readonly<{
+    readonly general: "NSU Geral do ADN (por DF-e) — controle interno do ADN; NÃO é distribuição.";
+    readonly municipalReception: "NSU de Recepção/Backup (por Código de Município) — do município emissor.";
+    readonly municipalDistribution: "NSU de Distribuição (por Código de Município) — do município interessado.";
+    readonly actorDistribution: "NSU de Distribuição para os atores da NFS-e (por CPF/CNPJ) — Prestador, Tomador e Intermediário. É ESTA que o Office consome.";
+}>;
+/** A série que este adapter consome. Explícito para que nunca seja "a outra". */
+export declare const NFSE_ADN_NSU_SERIES_IN_USE: "actorDistribution";
+export interface AdnOperation {
+    readonly id: string;
+    readonly method: 'GET';
+    readonly path: string;
+    readonly environments: readonly ('homologation' | 'production')[];
+    readonly authentication: string;
+    readonly identityScope: string;
+    readonly requestFormat: string;
+    readonly responseFormat: string;
+    readonly cursorSemantics: string;
+    readonly emptySemantics: string;
+    readonly errorShape: string;
+    readonly rateLimitSemantics: string;
+    readonly sourceId: string;
+    /** Implementado por este adapter nesta fase? */
+    readonly implemented: boolean;
+    /** O que dentro desta operação NÃO está conferido. Vazio = tudo conferido. */
+    readonly unverified: readonly string[];
+}
+/**
+ * A matriz de contrato. Nada aqui é inferido em silêncio.
+ *
+ * Onde a fonte oficial não diz, o campo diz "não publicado" e o item entra em
+ * `unverified`. Um campo preenchido com a melhor suposição e sem marca seria
+ * indistinguível de um campo conferido — e essa indistinção é precisamente o
+ * defeito que a Fase 3 fecha.
+ */
+export declare const NFSE_ADN_OPERATIONS: readonly AdnOperation[];
+/**
+ * Códigos oficiais do ADN → como o motor deve tratá-los.
+ *
+ * `outcome` separa o que a classe de erro sozinha não separa: E2215 é uma
+ * REJEIÇÃO no vocabulário do ADN e um DIA NORMAL no nosso. Tratá-lo como erro
+ * encheria a caixa de intervenções de escritórios cujos clientes simplesmente
+ * não receberam nota nenhuma na semana; tratá-lo como sucesso genérico o tornaria
+ * indistinguível de um envelope que mudou. Ele é um terceiro estado, nomeado.
+ */
+export interface AdnOfficialCode {
+    readonly code: string;
+    readonly meaning: string;
+    readonly outcome: 'no_documents' | 'error';
+    readonly errorClass: FiscalProviderErrorClass | null;
+}
+export declare const NFSE_ADN_OFFICIAL_CODES: Readonly<Record<string, AdnOfficialCode>>;
+/**
+ * O perfil de um envelope: os nomes EXATOS que o parser aceita.
+ *
+ * ## Por que os nomes viram dado, e não `if`
+ *
+ * A versão anterior aceitava `LoteDFe ?? loteDFe` e `ArquivoXml ?? arquivoXml`.
+ * Cada `??` desses é uma hipótese silenciosa: se o campo real for um terceiro
+ * nome, o `??` devolve `undefined`, o array não existe, e — na melhor das
+ * hipóteses — o parser lança. Na pior, um envelope com `LoteDFe: []` de um
+ * serviço que na verdade usa outro nome para o lote NÃO lança: devolve zero
+ * documentos com sucesso aparente.
+ *
+ * Com o perfil, o parser aceita exatamente UM conjunto de nomes. Se a resposta
+ * não os tiver, ela não é reconhecida — e não ser reconhecida é um desfecho
+ * nomeado, nunca um lote vazio.
+ *
+ * ## `verified` é o portão, e não um rótulo
+ *
+ * `verified: false` fecha o transporte real. É a única forma honesta de embarcar
+ * um parser escrito contra um formato suposto: ele existe, é testado contra o
+ * que supomos, e não pode falar com o serviço até alguém ter visto a resposta.
+ */
+export interface AdnEnvelopeProfile {
+    readonly id: string;
+    readonly contractVersion: string;
+    /** O envelope foi conferido contra o serviço oficial? */
+    readonly verified: boolean;
+    /** Ambientes em que este perfil pode ser usado. */
+    readonly environments: readonly ('synthetic' | 'homologation' | 'production')[];
+    readonly batchField: string;
+    readonly itemNsuField: string;
+    readonly itemContentField: string;
+    readonly lastNsuField: string;
+    readonly maxNsuField: string;
+    /** Códigos do ADN chegam neste campo, quando a resposta é uma rejeição. */
+    readonly codeField: string;
+    readonly contentEncoding: 'gzip+base64' | 'base64';
+}
+/**
+ * O perfil OFICIAL — a melhor leitura disponível, e declaradamente não conferida.
+ *
+ * Os nomes vêm da descrição pública da API e da simetria com o `docZip` da
+ * NF-e. Estão aqui para que exista UM lugar onde corrigi-los no dia em que
+ * alguém vir a resposta — e para que o `verified: false` mantenha o transporte
+ * real fechado até esse dia.
+ */
+export declare const ADN_OFFICIAL_ENVELOPE_PROFILE: AdnEnvelopeProfile;
+/**
+ * O perfil SINTÉTICO — conferido, porque somos nós quem o define.
+ *
+ * Não há circularidade: ele não afirma nada sobre o ADN. Ele descreve o servidor
+ * de mentira que a suíte levanta, e `verified: true` aqui significa apenas "o
+ * parser e o servidor sintético concordam", que é uma afirmação verificável e
+ * verificada. `environments: ['synthetic']` impede que ele seja usado como
+ * atalho para abrir o transporte real.
+ */
+export declare const ADN_SYNTHETIC_ENVELOPE_PROFILE: AdnEnvelopeProfile;
+/**
+ * O transporte real está ligado?
+ *
+ * Constante, e não variável de ambiente, por decisão de fase: uma variável de
+ * ambiente é ligável sem revisão, e a primeira conexão fiscal real do produto
+ * não deve poder acontecer por causa de uma linha num painel. Quando o portão
+ * humano da Fase 4 for aberto, isto vira um commit — revisável, revertível, e
+ * com o nome de quem o abriu.
+ */
+export declare const ADN_REAL_TRANSPORT_ENABLED = false;
+/** Motivos pelos quais o transporte real está fechado, para tela e trilha. */
+export declare function adnRealTransportBlockers(profile?: AdnEnvelopeProfile): readonly string[];
+//# sourceMappingURL=nfse-adn-contract.d.ts.map

package/dist/fiscal/contracts/nfse-adn-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nfse-adn-contract.d.ts","sourceRoot":"","sources":["../../../src/fiscal/contracts/nfse-adn-contract.ts"],"names":[],"mappings":"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"}