@baruk/core 0.4.2 → 0.5.0

package/dist/cjs/fiscal/transport/types.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * O transporte, separado do que trafega.
+ *
+ * ## Por que a fronteira fica exatamente aqui
+ *
+ * O adapter da NFS-e (`nfse-adn.ts`) recebia um `AdnTransport` cuja assinatura
+ * já falava de NSU e de lote — vocabulário FISCAL. Isso funcionou para provar a
+ * ingestão, mas amarra duas decisões que mudam por motivos diferentes: como se
+ * fala com o servidor (TLS mútuo, timeout, cabeçalho de espera) e o que se pede
+ * a ele (NSU, chave de acesso, evento).
+ *
+ * A prova de que são eixos independentes é o próprio Brasil fiscal: NF-e e CT-e
+ * usam SOAP; a NFS-e nacional usa REST; um provedor municipal usaria outra coisa
+ * ainda — e os TRÊS apresentam o mesmo certificado ICP-Brasil por TLS mútuo,
+ * respeitam a mesma classe de erro de rede e precisam do mesmo teto de espera.
+ * Um `if (provedor === 'x')` dentro de um cliente HTTP seria o sintoma da
+ * fronteira no lugar errado.
+ *
+ * Por isso esta camada não conhece NSU, não conhece documento e não conhece
+ * cliente. Ela conhece requisição, resposta, prazo e material de TLS.
+ *
+ * ## O que ela NÃO faz
+ *
+ * Não retenta. Não classifica erro fiscal. Não decide backoff. Essas decisões
+ * dependem do que estava sendo pedido — e um transporte que retentasse sozinho
+ * transformaria uma espera obrigatória de uma hora em três requisições, que é o
+ * caminho direto para o `cStat 656` e para o CNPJ do cliente bloqueado.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FiscalTransportError = void 0;
+exports.parseRetryAfter = parseRetryAfter;
+/**
+ * Falha de transporte.
+ *
+ * A mensagem é montada por NÓS a partir da classe e de um código curto. O erro
+ * original NÃO é encadeado, e isso é deliberado: `Error.message` de TLS cita o
+ * caminho do arquivo do certificado e o sujeito do titular, e `err.stack` de um
+ * cliente HTTP já carregou a URL inteira com credencial embutida neste
+ * ecossistema. Redigir o campo não bastaria — a defesa é não copiar o texto.
+ */
+class FiscalTransportError extends Error {
+    errorClass;
+    code;
+    retryAfter;
+    constructor(errorClass, 
+    /** Código curto e estável (`ETIMEDOUT`, `CERT_HAS_EXPIRED`). Nunca texto livre do sistema. */
+    code, 
+    /** Espera pedida pelo servidor (`Retry-After`), quando houver. */
+    retryAfter = null) {
+        super(`transporte ${errorClass} (${code})`);
+        this.errorClass = errorClass;
+        this.code = code;
+        this.retryAfter = retryAfter;
+        this.name = 'FiscalTransportError';
+    }
+}
+exports.FiscalTransportError = FiscalTransportError;
+/**
+ * Lê `Retry-After` como a RFC 9110 §10.2.3 o define: segundos OU data HTTP.
+ *
+ * Existe aqui, e não dentro do cliente HTTP, porque o cabeçalho é a única parte
+ * da resposta que o motor de retentativa consulta — e ela precisa ser lida
+ * igual venha de onde vier. Valor ausente, negativo ou ilegível devolve `null`:
+ * inventar uma espera a partir de lixo é pior do que não ter espera nenhuma,
+ * porque a inventada parece autorizada.
+ */
+function parseRetryAfter(raw, now = new Date()) {
+    if (!raw)
+        return null;
+    const trimmed = raw.trim();
+    if (trimmed === '')
+        return null;
+    if (/^\d+$/.test(trimmed)) {
+        const seconds = Number(trimmed);
+        // Um teto de 24h impede que um cabeçalho absurdo (ou hostil) congele um
+        // cliente por semanas. O valor continua sendo do servidor; o teto é nosso.
+        if (!Number.isFinite(seconds) || seconds < 0)
+            return null;
+        const capped = Math.min(seconds, 86_400);
+        return new Date(now.getTime() + capped * 1000);
+    }
+    const asDate = new Date(trimmed);
+    if (Number.isNaN(asDate.getTime()))
+        return null;
+    // Data no passado significa "pode agora". Devolver `null` diz exatamente isso
+    // sem obrigar quem chama a comparar de novo.
+    if (asDate.getTime() <= now.getTime())
+        return null;
+    const cap = new Date(now.getTime() + 86_400_000);
+    return asDate.getTime() > cap.getTime() ? cap : asDate;
+}
+//# sourceMappingURL=types.js.map

package/dist/cjs/fiscal/transport/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/fiscal/transport/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;;;AAiHH,0CAwBC;AA9FD;;;;;;;;GAQG;AACH,MAAa,oBAAqB,SAAQ,KAAK;IAElC;IAEA;IAEA;IALX,YACW,UAAqC;IAC9C,8FAA8F;IACrF,IAAY;IACrB,kEAAkE;IACzD,aAA0B,IAAI;QAEvC,KAAK,CAAC,cAAc,UAAU,KAAK,IAAI,GAAG,CAAC,CAAC;QANnC,eAAU,GAAV,UAAU,CAA2B;QAErC,SAAI,GAAJ,IAAI,CAAQ;QAEZ,eAAU,GAAV,UAAU,CAAoB;QAGvC,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF;AAXD,oDAWC;AAyCD;;;;;;;;GAQG;AACH,SAAgB,eAAe,CAC7B,GAA8B,EAC9B,MAAY,IAAI,IAAI,EAAE;IAEtB,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,CAAC;IACtB,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IAC3B,IAAI,OAAO,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAEhC,IAAI,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QAC1B,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;QAChC,wEAAwE;QACxE,2EAA2E;QAC3E,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC;YAAE,OAAO,IAAI,CAAC;QAC1D,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACzC,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,MAAM,GAAG,IAAI,CAAC,CAAC;IACjD,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;IACjC,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QAAE,OAAO,IAAI,CAAC;IAChD,8EAA8E;IAC9E,6CAA6C;IAC7C,IAAI,MAAM,CAAC,OAAO,EAAE,IAAI,GAAG,CAAC,OAAO,EAAE;QAAE,OAAO,IAAI,CAAC;IACnD,MAAM,GAAG,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,UAAU,CAAC,CAAC;IACjD,OAAO,MAAM,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;AACzD,CAAC"}

package/dist/cjs/import/br-documents.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * CPF e CNPJ — validação por dígito verificador.
+ *
+ * Contar dígitos não valida documento. `00000000000` tem onze dígitos e não é
+ * CPF de ninguém; `11222333000182` tem catorze e não fecha o DV. Num importador
+ * de carteira, aceitar por comprimento significa que um erro de digitação vira
+ * cliente, e o erro só aparece na primeira cobrança devolvida — quando já há
+ * honorário, obrigação e um e-mail enviado ao titular errado.
+ *
+ * Os dois algoritmos são o módulo 11 oficial da Receita. Ficam no CORE, e não na
+ * vertical contábil, pela mesma razão que `client.document_number` está no core:
+ * CPF e CNPJ identificam pessoa no Brasil inteiro, não no segmento contábil.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onlyDigits = void 0;
+exports.isValidCpf = isValidCpf;
+exports.isValidCnpj = isValidCnpj;
+exports.classifyDocument = classifyDocument;
+/** Remove tudo que não é dígito. Aceita máscara, ponto, barra e traço. */
+const onlyDigits = (v) => v.replace(/\D/g, '');
+exports.onlyDigits = onlyDigits;
+function dv(base, pesoInicial) {
+    let soma = 0;
+    let peso = pesoInicial;
+    for (const c of base) {
+        soma += Number(c) * peso;
+        peso--;
+        if (peso < 2)
+            peso = 9;
+    }
+    const resto = soma % 11;
+    return resto < 2 ? 0 : 11 - resto;
+}
+function isValidCpf(value) {
+    const d = (0, exports.onlyDigits)(value);
+    if (d.length !== 11)
+        return false;
+    // Repetidos passam no módulo 11 por construção — são recusados por regra.
+    if (/^(\d)\1{10}$/.test(d))
+        return false;
+    const base = d.slice(0, 9);
+    let soma = 0;
+    for (let i = 0; i < 9; i++)
+        soma += Number(base[i]) * (10 - i);
+    let r = (soma * 10) % 11;
+    if (r === 10)
+        r = 0;
+    if (r !== Number(d[9]))
+        return false;
+    soma = 0;
+    for (let i = 0; i < 10; i++)
+        soma += Number(d[i]) * (11 - i);
+    r = (soma * 10) % 11;
+    if (r === 10)
+        r = 0;
+    return r === Number(d[10]);
+}
+function isValidCnpj(value) {
+    const d = (0, exports.onlyDigits)(value);
+    if (d.length !== 14)
+        return false;
+    if (/^(\d)\1{13}$/.test(d))
+        return false;
+    const d1 = dv(d.slice(0, 12), 5);
+    if (d1 !== Number(d[12]))
+        return false;
+    const d2 = dv(d.slice(0, 13), 6);
+    return d2 === Number(d[13]);
+}
+/**
+ * Classifica pelo próprio documento.
+ *
+ * O comprimento já diz se a linha é pessoa física ou jurídica; uma coluna
+ * `tipo` que discorde disso é conflito de dado, não preferência do usuário.
+ */
+function classifyDocument(value) {
+    const d = (0, exports.onlyDigits)(value);
+    if (d.length === 11)
+        return isValidCpf(d) ? 'cpf' : 'invalid';
+    if (d.length === 14)
+        return isValidCnpj(d) ? 'cnpj' : 'invalid';
+    return 'invalid';
+}
+//# sourceMappingURL=br-documents.js.map

package/dist/cjs/import/br-documents.js.map

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

package/dist/cjs/import/clients-import.js

@@ -1,23 +1,66 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportDigestMismatch = exports.ImportWaveLimitExceeded = exports.CANONICAL_HEADER = void 0;
+exports.canonicalTemplateCsv = canonicalTemplateCsv;
+exports.digestOf = digestOf;
 exports.parseClientsCsv = parseClientsCsv;
 exports.planImport = planImport;
 exports.commitImport = commitImport;
+exports.rollbackImportBatch = rollbackImportBatch;
+exports.listImportBatches = listImportBatches;
+const node_crypto_1 = require("node:crypto");
 const repository_js_1 = require("../clients/repository.js");
+const phone_js_1 = require("../contacts/phone.js");
+const br_documents_js_1 = require("./br-documents.js");
+const shared_1 = require("@baruk/shared");
 const HEADER_ALIASES = {
     nome: 'displayName',
     display_name: 'displayName',
-    razao_social: 'displayName',
+    nome_fantasia: 'displayName',
+    razao_social: 'legalName',
+    legal_name: 'legalName',
     documento: 'documentNumber',
     document_number: 'documentNumber',
     cnpj: 'documentNumber',
     cpf: 'documentNumber',
-    tipo: 'clientType',
-    client_type: 'clientType',
+    cpf_cnpj: 'documentNumber',
+    tipo: 'clientTypeHint',
+    client_type: 'clientTypeHint',
     email: 'email',
+    'e-mail': 'email',
     telefone: 'phone',
     phone: 'phone',
+    celular: 'phone',
+    municipio: 'municipality',
+    município: 'municipality',
+    cidade: 'municipality',
+    uf: 'stateUf',
+    estado: 'stateUf',
+    endereco: 'addressLine',
+    endereço: 'addressLine',
+    cep: 'postalCode',
+    observacoes: 'notes',
+    observações: 'notes',
 };
+/** Cabeçalho canônico do template distribuído ao escritório. */
+exports.CANONICAL_HEADER = [
+    'nome',
+    'razao_social',
+    'documento',
+    'email',
+    'telefone',
+    'municipio',
+    'uf',
+    'endereco',
+    'cep',
+    'observacoes',
+];
+function canonicalTemplateCsv() {
+    return [
+        exports.CANONICAL_HEADER.join(','),
+        'Padaria Central Ltda,PADARIA CENTRAL LTDA,11.222.333/0001-81,contato@exemplo.com.br,(62) 99988-7766,Goiânia,GO,Rua das Flores 100,74000-000,',
+    ].join('\n');
+}
 function parseCsvRaw(text) {
     const rows = [];
     let field = '';
@@ -59,89 +102,353 @@ function parseCsvRaw(text) {
     }
     return rows.filter((r) => r.some((cell) => cell.trim() !== ''));
 }
-const onlyDigits = (v) => v.replace(/\D/g, '');
+/**
+ * Aceita o que um e-mail precisa ter para ser endereçável, e nada além.
+ *
+ * Não é a gramática da RFC 5322 — ela aceita coisas que nenhum provedor entrega
+ * e recusá-las cedo é melhor que descobrir no bounce.
+ */
+const EMAIL_RE = /^[^\s@,;]+@[^\s@.,;]+(\.[^\s@.,;]+)+$/;
+function digestOf(text) {
+    return (0, node_crypto_1.createHash)('sha256').update(text, 'utf8').digest('hex');
+}
 function parseClientsCsv(text) {
     const raw = parseCsvRaw(text);
     const errors = [];
+    const warnings = [];
     if (raw.length === 0)
-        return { rows: [], errors: [{ line: 0, message: 'CSV vazio' }] };
-    const header = raw[0].map((h) => h.trim().toLowerCase());
+        return { rows: [], errors: [{ line: 0, message: 'CSV vazio' }], warnings };
+    // `\uFEFF` escrito como escape, e não como o caractere: um BOM literal no
+    // código-fonte é invisível em revisão. Ele aparece de verdade no CSV — todo
+    // Excel em português salva com BOM, e sem removê-lo a primeira coluna do
+    // cabeçalho nunca casa com nenhum alias.
+    const header = raw[0].map((h) => h
+        .trim()
+        .toLowerCase()
+        .replace(/^\uFEFF/, ''));
     const colMap = header.map((h) => HEADER_ALIASES[h]);
     if (!colMap.includes('displayName')) {
-        return { rows: [], errors: [{ line: 1, message: 'Cabeçalho sem coluna de nome (nome/display_name)' }] };
+        return {
+            rows: [],
+            errors: [
+                {
+                    line: 1,
+                    message: `Cabeçalho sem coluna de nome. Esperado um destes: nome, display_name, nome_fantasia. Recebido: ${header.join(', ')}`,
+                    field: 'cabecalho',
+                },
+            ],
+            warnings,
+        };
+    }
+    for (const [idx, h] of header.entries()) {
+        if (!colMap[idx] && h) {
+            warnings.push({ line: 1, message: `Coluna "${h}" não reconhecida e ignorada`, field: h });
+        }
     }
     const rows = [];
     for (let i = 1; i < raw.length; i++) {
         const cells = raw[i];
-        const rec = { line: i + 1, clientType: 'pj' };
-        colMap.forEach((key, idx) => {
-            if (!key)
-                return;
-            const value = (cells[idx] ?? '').trim();
-            if (key === 'documentNumber')
-                rec.documentNumber = value ? onlyDigits(value) : null;
-            else if (key === 'clientType')
-                rec.clientType = value.toLowerCase() === 'pf' ? 'pf' : 'pj';
-            else if (key === 'email')
-                rec.email = value || null;
-            else if (key === 'phone')
-                rec.phone = value || null;
-            else if (key === 'displayName')
-                rec.displayName = value;
-        });
-        if (!rec.displayName) {
-            errors.push({ line: i + 1, message: 'Nome obrigatório ausente' });
+        const line = i + 1;
+        const get = (key) => {
+            const idx = colMap.indexOf(key);
+            return idx >= 0 ? (cells[idx] ?? '').trim() : '';
+        };
+        const displayName = get('displayName');
+        if (!displayName) {
+            errors.push({ line, message: 'Nome obrigatório ausente', field: 'nome' });
             continue;
         }
-        if (rec.documentNumber && ![11, 14].includes(rec.documentNumber.length)) {
-            errors.push({ line: i + 1, message: `Documento inválido (${rec.documentNumber.length} dígitos)` });
+        const docRaw = get('documentNumber');
+        let documentNumber = null;
+        let clientType = null;
+        if (docRaw) {
+            const kind = (0, br_documents_js_1.classifyDocument)(docRaw);
+            if (kind === 'invalid') {
+                const d = (0, br_documents_js_1.onlyDigits)(docRaw);
+                errors.push({
+                    line,
+                    message: d.length === 11 || d.length === 14
+                        ? `Documento com dígito verificador inválido (${docRaw})`
+                        : `Documento não é CPF nem CNPJ: ${d.length} dígitos`,
+                    field: 'documento',
+                });
+                continue;
+            }
+            documentNumber = (0, br_documents_js_1.onlyDigits)(docRaw);
+            clientType = kind === 'cpf' ? 'pf' : 'pj';
+        }
+        // A coluna `tipo` só é consultada quando o documento não decidiu. Quando
+        // ambos falam e discordam, isso é conflito de dado: recusar é mais seguro
+        // que eleger um vencedor, porque escolher errado grava a pessoa errada.
+        const hint = get('clientTypeHint').toLowerCase();
+        if (hint === 'pf' || hint === 'pj') {
+            if (clientType && clientType !== hint) {
+                errors.push({
+                    line,
+                    message: `Coluna tipo diz "${hint}" mas o documento é ${clientType === 'pf' ? 'CPF' : 'CNPJ'}`,
+                    field: 'tipo',
+                });
+                continue;
+            }
+            clientType ??= hint;
+        }
+        if (!clientType) {
+            clientType = 'pj';
+            warnings.push({
+                line,
+                message: 'Sem documento e sem tipo — assumido PJ',
+                field: 'tipo',
+            });
+        }
+        const email = get('email') || null;
+        if (email && !EMAIL_RE.test(email)) {
+            errors.push({ line, message: `E-mail malformado: ${email}`, field: 'email' });
             continue;
         }
+        if (!email) {
+            warnings.push({
+                line,
+                message: 'Sem e-mail — a automação de cobrança e de pedido de documento não alcança este cliente',
+                field: 'email',
+            });
+        }
+        const phoneRaw = get('phone') || null;
+        if (phoneRaw) {
+            const p = (0, phone_js_1.parseBrazilPhone)(phoneRaw);
+            if (!p.ok) {
+                warnings.push({
+                    line,
+                    message: `Telefone não discável (${p.reason}) — guardado como texto, sem uso automático`,
+                    field: 'telefone',
+                });
+            }
+        }
+        const ufRaw = get('stateUf') || null;
+        const stateUf = (0, repository_js_1.normalizeUf)(ufRaw);
+        if (ufRaw && !stateUf) {
+            warnings.push({
+                line,
+                message: `UF "${ufRaw}" fora do formato de duas letras — não gravada`,
+                field: 'uf',
+            });
+        }
         rows.push({
-            line: i + 1,
-            displayName: rec.displayName,
-            documentNumber: rec.documentNumber ?? null,
-            clientType: rec.clientType ?? 'pj',
-            email: rec.email ?? null,
-            phone: rec.phone ?? null,
+            line,
+            displayName,
+            legalName: get('legalName') || null,
+            documentNumber,
+            clientType,
+            email,
+            phone: phoneRaw,
+            municipality: get('municipality') || null,
+            stateUf,
+            addressLine: get('addressLine') || null,
+            postalCode: get('postalCode') || null,
+            notes: get('notes') || null,
         });
     }
-    return { rows, errors };
+    return { rows, errors, warnings };
 }
 async function planImport(tx, text) {
-    const { rows, errors } = parseClientsCsv(text);
+    const { rows, errors, warnings } = parseClientsCsv(text);
     const toCreate = [];
     const duplicates = [];
     const seen = new Set();
     for (const row of rows) {
         if (row.documentNumber) {
             if (seen.has(row.documentNumber)) {
-                duplicates.push({ line: row.line, documentNumber: row.documentNumber });
+                duplicates.push({
+                    line: row.line,
+                    documentNumber: row.documentNumber,
+                    reason: 'no_arquivo',
+                });
                 continue;
             }
             seen.add(row.documentNumber);
             const existing = await (0, repository_js_1.findClientIdByDocument)(tx, row.documentNumber);
             if (existing) {
-                duplicates.push({ line: row.line, documentNumber: row.documentNumber });
+                duplicates.push({
+                    line: row.line,
+                    documentNumber: row.documentNumber,
+                    reason: 'ja_cadastrado',
+                });
                 continue;
             }
         }
         toCreate.push(row);
     }
-    return { total: rows.length, toCreate, duplicates, errors };
+    return {
+        total: rows.length,
+        toCreate,
+        duplicates,
+        errors,
+        warnings,
+        digest: digestOf(text),
+        summary: {
+            comEmail: toCreate.filter((r) => r.email).length,
+            semEmail: toCreate.filter((r) => !r.email).length,
+            comTelefone: toCreate.filter((r) => r.phone).length,
+            pf: toCreate.filter((r) => r.clientType === 'pf').length,
+            pj: toCreate.filter((r) => r.clientType === 'pj').length,
+            comLocalidade: toCreate.filter((r) => r.stateUf && r.municipality).length,
+        },
+    };
+}
+class ImportWaveLimitExceeded extends Error {
+    planned;
+    limit;
+    constructor(planned, limit) {
+        super(`O plano cria ${planned} cliente(s) e o limite declarado é ${limit}. ` +
+            'Nada foi importado. Confira se o arquivo é o esperado ou declare o limite correto.');
+        this.planned = planned;
+        this.limit = limit;
+        this.name = 'ImportWaveLimitExceeded';
+    }
+}
+exports.ImportWaveLimitExceeded = ImportWaveLimitExceeded;
+class ImportDigestMismatch extends Error {
+    constructor() {
+        super('O conteúdo enviado não confere com o que foi planejado. Refaça a conferência antes de aplicar.');
+        this.name = 'ImportDigestMismatch';
+    }
 }
-async function commitImport(tx, text, createdBy) {
+exports.ImportDigestMismatch = ImportDigestMismatch;
+/**
+ * Aplica o plano.
+ *
+ * `expectedDigest` é obrigatório por desenho: sem ele, o commit poderia aplicar
+ * um arquivo que ninguém conferiu. Quem realmente quer pular a conferência passa
+ * o digest do próprio conteúdo — e isso fica explícito na chamada, em vez de
+ * acontecer por omissão.
+ */
+async function commitImport(tx, text, createdBy, expectedDigest, 
+/**
+ * Quantos clientes o operador ESPERA criar. Obrigatório, e sem valor padrão.
+ *
+ * Não existe "sem limite" por omissão, e a ausência de default é a decisão:
+ * um teto opcional é um teto que ninguém passa no dia em que importa o
+ * arquivo errado. Aqui o compilador obriga a declarar a expectativa antes de
+ * escrever, e o importador recusa quando o plano não bate.
+ *
+ * Isso vale além da Onda 1. O erro que ele pega é o mais banal e o mais caro
+ * da importação: apontar para o arquivo da carteira inteira quando se queria
+ * uma amostra. Sem o teto, a diferença entre cinco clientes e trezentos é um
+ * clique — e o desfazer, embora exista, não recolhe o que a régua de cobrança
+ * já tiver alcançado.
+ */
+expectedMax) {
+    const digest = digestOf(text);
+    if (digest !== expectedDigest)
+        throw new ImportDigestMismatch();
     const plan = await planImport(tx, text);
+    // ANTES de qualquer escrita: nem o lote é criado se o plano estourar o teto.
+    if (plan.toCreate.length > expectedMax) {
+        throw new ImportWaveLimitExceeded(plan.toCreate.length, expectedMax);
+    }
+    const batchId = (0, shared_1.uuidv7)();
+    await tx `
+    INSERT INTO client_import_batch
+      (id, tenant_id, source_digest, row_total, created_count, skipped_count, error_count, created_by)
+    VALUES (
+      ${batchId}, current_setting('app.current_tenant')::uuid, ${digest},
+      ${plan.total}, 0, ${plan.duplicates.length}, ${plan.errors.length}, ${createdBy ?? null}
+    )
+  `;
     let created = 0;
     for (const row of plan.toCreate) {
         await (0, repository_js_1.createClient)(tx, {
             displayName: row.displayName,
+            legalName: row.legalName,
             clientType: row.clientType,
             documentNumber: row.documentNumber,
+            email: row.email,
+            phone: row.phone,
+            municipality: row.municipality,
+            stateUf: row.stateUf,
+            addressLine: row.addressLine,
+            postalCode: row.postalCode,
+            notes: row.notes,
+            importBatchId: batchId,
             createdBy: createdBy ?? null,
         });
         created++;
     }
-    return { created, skipped: plan.duplicates.length, errors: plan.errors };
+    await tx `UPDATE client_import_batch SET created_count = ${created} WHERE id = ${batchId}`;
+    return {
+        batchId,
+        created,
+        skipped: plan.duplicates.length,
+        errors: plan.errors,
+        warnings: plan.warnings,
+    };
+}
+/**
+ * Desfaz uma importação — logicamente, e só o que ainda é seguro desfazer.
+ *
+ * Soft-delete, nunca `DELETE`. E não é "desfaz o lote": é "desfaz as linhas do
+ * lote que ninguém usou desde então". Um cliente que já recebeu honorário,
+ * obrigação, documento ou cobrança deixou de ser uma linha importada — apagá-lo
+ * levaria junto trabalho real. Esses ficam, e o relatório diz quais e por quê,
+ * em vez de o desfazer falhar inteiro ou apagar demais.
+ */
+async function rollbackImportBatch(tx, batchId, actorId) {
+    const [batch] = await tx `
+    SELECT id, status FROM client_import_batch WHERE id = ${batchId}
+  `;
+    if (!batch)
+        throw new Error('Lote de importação não encontrado neste escritório.');
+    if (batch.status === 'rolled_back')
+        return { batchId, reverted: 0, retained: [] };
+    const candidatos = await tx `
+    SELECT id FROM client WHERE import_batch_id = ${batchId} AND deleted_at IS NULL
+  `;
+    const retained = [];
+    let reverted = 0;
+    for (const c of candidatos) {
+        const [uso] = await tx `
+      SELECT
+        (SELECT count(*)::int FROM fee_agreement      WHERE client_id = ${c.id} AND deleted_at IS NULL) AS fees,
+        (SELECT count(*)::int FROM recurring_instance WHERE client_id = ${c.id} AND deleted_at IS NULL) AS obligations,
+        (SELECT count(*)::int FROM document           WHERE client_id = ${c.id} AND deleted_at IS NULL) AS docs,
+        (SELECT count(*)::int FROM charge             WHERE client_id = ${c.id} AND deleted_at IS NULL) AS charges
+    `;
+        const motivos = [
+            (uso?.fees ?? 0) > 0 ? 'honorário' : null,
+            (uso?.obligations ?? 0) > 0 ? 'obrigação' : null,
+            (uso?.docs ?? 0) > 0 ? 'documento' : null,
+            (uso?.charges ?? 0) > 0 ? 'cobrança' : null,
+        ].filter((m) => m !== null);
+        if (motivos.length > 0) {
+            retained.push({ clientId: c.id, reason: motivos.join(', ') });
+            continue;
+        }
+        await tx `
+      UPDATE client SET deleted_at = now(), deleted_by = ${actorId ?? null}, updated_at = now()
+       WHERE id = ${c.id} AND deleted_at IS NULL
+    `;
+        reverted++;
+    }
+    await tx `
+    UPDATE client_import_batch
+       SET status = 'rolled_back', rolled_back_at = now(), rolled_back_by = ${actorId ?? null}
+     WHERE id = ${batchId}
+  `;
+    return { batchId, reverted, retained };
+}
+async function listImportBatches(tx) {
+    const rows = await tx `
+    SELECT id, source_digest, row_total, created_count, skipped_count, error_count, status, created_at
+      FROM client_import_batch ORDER BY created_at DESC LIMIT 50
+  `;
+    return rows.map((r) => ({
+        id: r.id,
+        sourceDigest: r.source_digest,
+        rowTotal: r.row_total,
+        createdCount: r.created_count,
+        skippedCount: r.skipped_count,
+        errorCount: r.error_count,
+        status: r.status,
+        createdAt: r.created_at.toISOString(),
+    }));
 }
 //# sourceMappingURL=clients-import.js.map