@sinete/nfe 0.1.0 → 0.3.0

package/src/build/destinatario.ts

@@ -5,11 +5,11 @@
  * critério da UF (E16a-30 e E16a-35, E14-10 e E14-20, facultativas). As regras só da NFC-e estão em `nfce.ts`.
  */
 
-import { ufBySigla } from '@sinete/core';
-import { parseCnpj } from '@sinete/validators';
+import { ufPorSigla } from '@sinete/core';
+import { lerCnpj } from '@sinete/validators';
 import suframa from '../data/suframa.json' with { type: 'json' };
 import type { Issues } from '../issues.ts';
-import type { NfeInput } from '../model.ts';
+import type { DadosNfe } from '../model.ts';
 
 /** Identificação já resolvida pelo montador (com os padrões aplicados). */
 export interface IdeDestinatario {
@@ -26,7 +26,7 @@ const ID_ESTRANGEIRO = /^[0-9A-Za-z:.+\-/()]*$/;
 
 const digitos = (s: string): string => s.replace(/\D/g, '');
 
-export function conferirDestinatario(input: NfeInput, ide: IdeDestinatario, issues: Issues): void {
+export function conferirDestinatario(input: DadosNfe, ide: IdeDestinatario, issues: Issues): void {
   const d = input.destinatario;
   if (d === undefined) return;
   const nfe = ide.mod === '55';
@@ -85,7 +85,7 @@ export function conferirDestinatario(input: NfeInput, ide: IdeDestinatario, issu
   // E10-20: o município do destinatário é da UF dele (as duas primeiras posições do código são o código da UF).
   if (end !== undefined && !exterior) {
     const e = end as { UF: string; cMun: string };
-    const cUF = ufBySigla(e.UF)?.cUF;
+    const cUF = ufPorSigla(e.UF)?.cUF;
     if (cUF !== undefined && digitos(e.cMun).slice(0, 2) !== cUF) {
       issues.add(
         'destinatario.endereco.cMun',
@@ -108,11 +108,11 @@ export function conferirDestinatario(input: NfeInput, ide: IdeDestinatario, issu
     // Na saída a entrega vale contra o emitente e a retirada contra o destinatário; na entrada, ao contrário.
     const [ufEntrega, ufRetirada] = saida ? [emitUf, destUf] : [destUf, emitUf];
     if (ide.idDest === '2' && destUf === emitUf) {
-      // CNPJ alfanumérico: as letras contam; só a máscara sai (a mesma normalização do parseCnpj).
+      // CNPJ alfanumérico: as letras contam; só a máscara sai (a mesma normalização do lerCnpj).
       const cnpj = (v: string | undefined): string | undefined => {
         if (v === undefined) return undefined;
-        const r = parseCnpj(v);
-        return r.ok ? r.value : undefined;
+        const r = lerCnpj(v);
+        return r.ok ? r.valor : undefined;
       };
       const cnpjDest = 'CNPJ' in d ? cnpj(d.CNPJ) : undefined;
       const mesmoCnpj = cnpjDest !== undefined && cnpjDest === cnpj(input.emitente.CNPJ);

package/src/build/ibscbs.ts

@@ -3,9 +3,9 @@
  * `IBSCBSTot` (W34 a W59g) somando exatamente os valores dos itens.
  */
 
-import { firstChild, parseXml } from '@sinete/core/xml';
+import { lerXml, primeiroFilho } from '@sinete/core/xml';
 import type { ComplexType } from '@sinete/schemas';
-import { serialize, validate } from '@sinete/schemas';
+import { serializar, validar } from '@sinete/schemas';
 import type { TIBSCBSMonoTot, TTribNFe } from '@sinete/schemas/nfe/PL_010f';
 import { Decimal } from '../decimal.ts';
 import type { Issues } from '../issues.ts';
@@ -19,12 +19,16 @@ const NFE_NS = 'http://www.portalfiscal.inf.br/nfe';
 export function grupoInvalido(ct: ComplexType, nome: string, value: unknown, path: string, issues: Issues): boolean {
   if (value === undefined) return false;
   try {
-    const doc = parseXml(`<w xmlns="${NFE_NS}">${serialize(ct, nome, value as never, NFE_NS)}</w>`);
-    const el = firstChild(doc.root, nome, NFE_NS);
+    const doc = lerXml(`<w xmlns="${NFE_NS}">${serializar(ct, nome, value as never, NFE_NS)}</w>`);
+    const el = primeiroFilho(doc.raiz, nome, NFE_NS);
     const erros =
-      el === undefined ? [{ path: '', code: 'modelo_de_conteudo', message: 'grupo vazio' }] : validate(ct, el);
+      el === undefined ? [{ caminho: '', code: 'modelo_de_conteudo', mensagem: 'grupo vazio' }] : validar(ct, el);
     for (const e of erros)
-      issues.add(`${path}${e.path.replace(/^\/[^/]+/, '').replace(/\//g, '.')}`, 'schema', `${e.code}: ${e.message}`);
+      issues.add(
+        `${path}${e.caminho.replace(/^\/[^/]+/, '').replace(/\//g, '.')}`,
+        'schema',
+        `${e.code}: ${e.mensagem}`,
+      );
     return erros.length > 0;
   } catch (e) {
     issues.add(path, 'schema', `grupo malformado: ${(e as Error).message}`);

package/src/build/icms.ts

@@ -6,7 +6,7 @@
 import type { TNFe_infNFe_det_imposto_ICMS } from '@sinete/schemas/nfe/PL_010f';
 import type { DecimalInput } from '../decimal.ts';
 import { Decimal } from '../decimal.ts';
-import type { DecimalFormat } from '../format.ts';
+import type { FormatoDecimal } from '../format.ts';
 import { D0302A04, D0302A04_OPC, D1104V, D1302 } from '../format.ts';
 import type {
   Desoneracao,
@@ -74,9 +74,9 @@ export interface IcmsItemBase {
 
 type Out = Record<string, string | undefined>;
 
-const M: DecimalFormat = D1302;
-const P: DecimalFormat = D0302A04;
-const PO: DecimalFormat = D0302A04_OPC;
+const M: FormatoDecimal = D1302;
+const P: FormatoDecimal = D0302A04;
+const PO: FormatoDecimal = D0302A04_OPC;
 
 function nonNeg(d: Decimal): Decimal {
   return d.isNegative() ? Decimal.ZERO : d;
@@ -221,7 +221,7 @@ export function buildIcms(
 
   /** Retido anteriormente (N26 a N26b, N27a a N27c, N34 a N37): informativo, só o FCP retido entra no total. */
   const retido = (i: IcmsStRetido): Out => {
-    const o = (k: keyof IcmsStRetido, f: DecimalFormat): string | undefined =>
+    const o = (k: keyof IcmsStRetido, f: FormatoDecimal): string | undefined =>
       ctx.so(ctx.opt(i[k], `${path}.${k}`, f), f);
     const vFCPSTRet = ctx.opt(i.vFCPSTRet, `${path}.vFCPSTRet`, M);
     if (vFCPSTRet !== undefined) t.vFCPSTRet = t.vFCPSTRet.plus(vFCPSTRet);
@@ -259,7 +259,7 @@ export function buildIcms(
       vFCPDif?: DecimalInput;
       vFCPEfet?: DecimalInput;
     },
-    redFormat: DecimalFormat,
+    redFormat: FormatoDecimal,
     triade: boolean,
   ): Out => {
     const pRedBC = ctx.opt(i.pRedBC, `${path}.pRedBC`, redFormat);

package/src/build/nfce.ts

@@ -7,14 +7,14 @@
  * UF decide, e recusar localmente bloquearia a venda onde a regra não vale.
  */
 
-import type { Ambiente, Signer, Uf } from '@sinete/core';
-import { tpAmbOf } from '@sinete/core';
-import { base64Encode, c14n, firstChild, parseXml, SHA1_DIGEST_INFO_PREFIX } from '@sinete/core/xml';
-import { parseCnpj } from '@sinete/validators';
+import type { Ambiente, Assinador, Uf } from '@sinete/core';
+import { tpAmbDoAmbiente } from '@sinete/core';
+import { c14n, codificarBase64, lerXml, PREFIXO_DIGEST_INFO_SHA1, primeiroFilho } from '@sinete/core/xml';
+import { lerCnpj } from '@sinete/validators';
 import urls from '../data/nfce-urls.json' with { type: 'json' };
 import { Decimal } from '../decimal.ts';
 import type { Issues } from '../issues.ts';
-import type { NfeInput } from '../model.ts';
+import type { DadosNfe } from '../model.ts';
 
 /**
  * Versão do QR Code da NFC-e. A 3 (padrão) dispensa o CSC: na emissão normal leva só chave, versão e ambiente, e na
@@ -60,7 +60,7 @@ function vigente(lista: readonly Entrada[] | undefined, dia: string): Entrada |
 /**
  * Endereços da NFC-e da UF no ambiente e no dia (`data/nfce-urls.json`, das tabelas do Portal Nacional da NFC-e). O
  * `qrCode` é `undefined` onde a tabela não traz o endereço completo (AM e MA publicam sem o protocolo): informe
- * `BuildNfeOptions.urlQrCode`.
+ * `MontarNfeOpcoes.urlQrCode`.
  */
 export function urlsNfce(
   uf: Uf,
@@ -87,10 +87,10 @@ const hex = (b: Uint8Array): string => Array.from(b, (x) => x.toString(16).padSt
  * `797a4759...`).
  */
 async function digValHex(xml: string): Promise<string> {
-  const doc = parseXml(xml);
-  const inf = firstChild(doc.root, 'infNFe', NFE_NS);
+  const doc = lerXml(xml);
+  const inf = primeiroFilho(doc.raiz, 'infNFe', NFE_NS);
   if (inf === undefined) throw new Error('NF-e montada sem infNFe');
-  return hexDoDigestValue(base64Encode(await sha1(te.encode(c14n(inf)))));
+  return hexDoDigestValue(codificarBase64(await sha1(te.encode(c14n(inf)))));
 }
 
 /** O DigestValue em Base64 convertido para hexadecimal, caractere a caractere (Manual 6.0, 4.3.5, passo 1). */
@@ -128,7 +128,7 @@ export async function parametrosQrCode(
   d: DadosQrCode,
   qr: QrCodeNfceOpcoes,
 ): Promise<{ readonly parametros: string; readonly assinar: boolean }> {
-  const tpAmb = tpAmbOf(d.ambiente);
+  const tpAmb = tpAmbDoAmbiente(d.ambiente);
   const offline = d.tpEmis === '9';
   const dia = d.dhEmi.slice(8, 10);
   if (qr.versao === '3') {
@@ -155,14 +155,14 @@ export async function parametrosQrCode(
  * Assinatura dos parâmetros 1 a 7 do QR Code versão 3 off-line: RSA com SHA-1 (PKCS#1 v1.5), em Base64, com o mesmo
  * certificado que assina a NFC-e (Manual 6.0, 4.4.2, parâmetro 8).
  */
-export async function assinarParametros(parametros: string, signer: Signer): Promise<string> {
+export async function assinarParametros(parametros: string, signer: Assinador): Promise<string> {
   const bytes = te.encode(parametros);
-  if (signer.kind === 'data') return base64Encode(await signer.sign(bytes, 'SHA-1'));
+  if (signer.tipo === 'dados') return codificarBase64(await signer.assinar(bytes, 'SHA-1'));
   const h = await sha1(bytes);
-  const di = new Uint8Array(SHA1_DIGEST_INFO_PREFIX.length + h.length);
-  di.set(SHA1_DIGEST_INFO_PREFIX);
-  di.set(h, SHA1_DIGEST_INFO_PREFIX.length);
-  return base64Encode(await signer.signDigestInfo(di));
+  const di = new Uint8Array(PREFIXO_DIGEST_INFO_SHA1.length + h.length);
+  di.set(PREFIXO_DIGEST_INFO_SHA1);
+  di.set(h, PREFIXO_DIGEST_INFO_SHA1.length);
+  return codificarBase64(await signer.assinarDigestInfo(di));
 }
 
 /** CFOP da prestação de serviço tributada pelo ISSQN na NFC-e (MOC 7.0 Anexo I, RV I08-150 a I08-170). */
@@ -192,7 +192,7 @@ export interface IdeNfce {
  * Regras da NFC-e sobre a entrada (origem `entrada`, ADR 0011), todas de aplicação obrigatória. Grupos que a NFC-e
  * não tem saem como `grupo_vedado` no caminho da entrada.
  */
-export function conferirNfce(input: NfeInput, ide: IdeNfce, issues: Issues): void {
+export function conferirNfce(input: DadosNfe, ide: IdeNfce, issues: Issues): void {
   const vedado = (path: string, msg: string): void => issues.add(path, 'grupo_vedado', `NFC-e ${msg}`);
   const invalido = (path: string, msg: string): void => issues.add(path, 'campo_invalido', `NFC-e ${msg}`);
 
@@ -416,8 +416,8 @@ export function pagamentoNfce(pag: PagMontado, vNF: Decimal, issues: Issues): vo
       );
     }
     if (c.CNPJ !== undefined) {
-      const r = parseCnpj(c.CNPJ, { path: `${path}.CNPJ` });
-      if (!r.ok) issues.list.push(r.error);
+      const r = lerCnpj(c.CNPJ, { caminho: `${path}.CNPJ` });
+      if (!r.ok) issues.list.push(r.erro);
     }
   });
 }

package/src/build/pl.ts

@@ -6,10 +6,10 @@
  * `camposForaDoPl` aponta cada campo que sumiria em silêncio.
  */
 
-import type { Ambiente, Clock } from '@sinete/core';
-import { UnsupportedError } from '@sinete/core';
-import type { ComplexType, Particle, VigenciaEntry } from '@sinete/schemas';
-import { isComplexType, isElementParticle, isWildcard, selecionarPl } from '@sinete/schemas';
+import type { Ambiente, Relogio } from '@sinete/core';
+import { ErroNaoSuportado } from '@sinete/core';
+import type { ComplexType, EntradaDeVigencia, Particle } from '@sinete/schemas';
+import { ehComplexType, ehElementParticle, ehWildcard, selecionarPl } from '@sinete/schemas';
 import { TNFe_infNFe as Inf010e } from '@sinete/schemas/nfe/PL_010e';
 import { TNFe_infNFe as Inf010f } from '@sinete/schemas/nfe/PL_010f';
 import type { Issues } from '../issues.ts';
@@ -21,32 +21,32 @@ const INF_NFE: Readonly<Record<string, ComplexType>> = {
 };
 
 export interface PlEscolhido {
-  readonly vigencia: VigenciaEntry;
+  readonly vigencia: EntradaDeVigencia;
   readonly infNFe: ComplexType;
 }
 
 /** PL da NF-e vigente para o ambiente no relógio de emissão (ADR 0002, decisão 6). */
-export function escolherPl(ambiente: Ambiente, emissao: Clock): PlEscolhido {
+export function escolherPl(ambiente: Ambiente, emissao: Relogio): PlEscolhido {
   const vigencia = selecionarPl('nfe', ambiente, emissao);
   const infNFe = INF_NFE[vigencia.modulo];
   if (infNFe === undefined) {
     // A tabela de vigências ganhou um PL que este pacote ainda não conhece: falha explícita, nunca tentativa.
-    throw new UnsupportedError(`@sinete/nfe não conhece o módulo ${vigencia.modulo}; atualize o pacote`);
+    throw new ErroNaoSuportado(`@sinete/nfe não conhece o módulo ${vigencia.modulo}; atualize o pacote`);
   }
   return { vigencia, infNFe };
 }
 
 function memberNames(p: Particle, acc: Set<string>): Set<string> {
-  if (isWildcard(p)) acc.add('$any');
-  else if (isElementParticle(p)) acc.add(p.e);
+  if (ehWildcard(p)) acc.add('$any');
+  else if (ehElementParticle(p)) acc.add(p.e);
   else for (const i of p.i) memberNames(i, acc);
   return acc;
 }
 
 function elementTypes(p: Particle, acc: Map<string, ComplexType>): Map<string, ComplexType> {
-  if (isWildcard(p)) return acc;
-  if (isElementParticle(p)) {
-    if (isComplexType(p.t)) acc.set(p.e, p.t);
+  if (ehWildcard(p)) return acc;
+  if (ehElementParticle(p)) {
+    if (ehComplexType(p.t)) acc.set(p.e, p.t);
   } else for (const i of p.i) elementTypes(i, acc);
   return acc;
 }

package/src/build/rejeicoes.ts

@@ -7,11 +7,11 @@
  * dúvida, a nota vai e a SEFAZ decide, porque recusar localmente uma nota que a SEFAZ aceitaria é pior que a rejeição.
  */
 
-import type { ValidationIssue } from '@sinete/core';
+import type { Ocorrencia } from '@sinete/core';
 import type { Issues } from '../issues.ts';
-import type { NfeInput } from '../model.ts';
+import type { DadosNfe } from '../model.ts';
 import type { Instante } from '../time.ts';
-import { formatDh } from '../time.ts';
+import { formatarDh } from '../time.ts';
 
 /**
  * CFOP em que o CST 50 (suspensão) é aceito com destinatário contribuinte isento: conserto ou reparo e remessa para
@@ -40,7 +40,7 @@ const CFOP_CST50_ISENTO: ReadonlySet<string> = new Set([
  * recusado aqui, seja qual for o documento do destinatário. A exceção 2 (emissão antes de 01/07/2016) não alcança nota
  * montada agora.
  */
-export function cstComIsento(input: NfeInput, idDest: string, issues: Issues): void {
+export function cstComIsento(input: DadosNfe, idDest: string, issues: Issues): void {
   const d = input.destinatario;
   if (d?.indIEDest !== '2') return;
   input.itens.forEach((it, n) => {
@@ -60,7 +60,7 @@ export function cstComIsento(input: NfeInput, idDest: string, issues: Issues): v
 
 /** Data (`AAAA-MM-DD`) do instante no deslocamento dado, em minutos. */
 const dataNoFuso = (instante: Instante, offsetMinutes: number): string =>
-  formatDh(instante, offsetMinutes).slice(0, 10);
+  formatarDh(instante, offsetMinutes).slice(0, 10);
 
 /** Brasília (UTC-3), o fuso das SEFAZ, para a comparação de datas que o MOC faz "desconsiderando a hora". */
 const OFFSET_BRASILIA = -180;
@@ -78,7 +78,7 @@ const OFFSET_BRASILIA = -180;
  * "na data da emissão" só vale quando a data local do `dhEmi`, a de Brasília e a de UTC coincidem.
  */
 export function vencimentos(
-  input: NfeInput,
+  input: DadosNfe,
   emissao: { readonly dhEmi: string; readonly instante: Instante },
   issues: Issues,
 ): void {
@@ -107,22 +107,22 @@ const soDocumento = (s: string): string => s.replace(/[^0-9A-Za-z]/g, '').toUppe
  * - e-CPF: o CPF do emitente é o do certificado, senão rejeição 227 (RV F03A).
  *
  * Só compara documento com documento do mesmo tipo: e-CNPJ assinando nota de emitente CPF (ou o contrário) fica para a
- * SEFAZ. O certificado da SEFAZ que a F03 dispensa só assina a nota avulsa, que o `buildNfe` não monta (procEmi 0).
+ * SEFAZ. O certificado da SEFAZ que a F03 dispensa só assina a nota avulsa, que o `montarNfe` não monta (procEmi 0).
  * Devolve as ocorrências (vazio quando confere), com o caminho da entrada.
  */
 export function conferirEmitenteDoCertificado(
-  nfe: NfeInput,
+  nfe: DadosNfe,
   titular: { readonly cnpj?: string | undefined; readonly cpf?: string | undefined },
-): readonly ValidationIssue[] {
+): readonly Ocorrencia[] {
   const e = nfe.emitente;
   if (e.CNPJ !== undefined && titular.cnpj !== undefined) {
     const base = soDocumento(e.CNPJ).slice(0, 8);
     if (base !== soDocumento(titular.cnpj).slice(0, 8)) {
       return [
         {
-          path: 'emitente.CNPJ',
+          caminho: 'emitente.CNPJ',
           code: 'emitente_difere_do_certificado',
-          message: `CNPJ-base ${base} do emitente difere do CNPJ-base do certificado (F03, rejeição 213)`,
+          mensagem: `CNPJ-base ${base} do emitente difere do CNPJ-base do certificado (F03, rejeição 213)`,
           origem: 'entrada',
         },
       ];
@@ -131,9 +131,9 @@ export function conferirEmitenteDoCertificado(
   if (e.CPF !== undefined && titular.cpf !== undefined && soDocumento(e.CPF) !== soDocumento(titular.cpf)) {
     return [
       {
-        path: 'emitente.CPF',
+        caminho: 'emitente.CPF',
         code: 'emitente_difere_do_certificado',
-        message: 'CPF do emitente difere do CPF do certificado (F03A, rejeição 227)',
+        mensagem: 'CPF do emitente difere do CPF do certificado (F03A, rejeição 227)',
         origem: 'entrada',
       },
     ];

package/src/build/textos.ts

@@ -0,0 +1,228 @@
+/**
+ * Texto e tamanho dos campos de texto da NF-e conferidos na entrada (ADR 0011, revisão de 01/10/2026).
+ *
+ * Antes, o caractere que o XML não representa e o texto fora do tipo do leiaute (tamanho, espaço nas pontas,
+ * caractere fora do `TString`) só apareciam na montagem, com o caminho do XML (`infNFe.det[0].prod.xProd` ou
+ * `/infNFe/det[1]/prod/xProd`). Conferidos aqui, saem como `campo_invalido`, com `origem: 'entrada'`, o caminho da
+ * entrada (`itens[0].produto.xProd`) e uma mensagem para quem preenche o campo (`no máximo 60 caracteres`), sem nome
+ * de validador nem de tipo do XSD.
+ *
+ * O tipo de cada campo vem do schema do PL da montagem (o `TString` com o `maxLength` do elemento), nunca de um número
+ * escrito aqui: a tabela abaixo só diz qual elemento do `infNFe` recebe cada campo da entrada.
+ */
+
+import type { ComplexType, OcorrenciaSchema, Particle, SimpleType } from '@sinete/schemas';
+import { conferirTipoSimples, ehComplexType, ehElementParticle, ehWildcard } from '@sinete/schemas';
+import type { Issues } from '../issues.ts';
+import type { DadosNfe } from '../model.ts';
+
+/** Produção `Char` do XML 1.0: tab, LF, CR, U+0020 a U+D7FF, U+E000 a U+FFFD e U+10000 a U+10FFFF. */
+export function textoXmlValido(texto: string): boolean {
+  for (const ch of texto) {
+    const c = ch.codePointAt(0) ?? 0;
+    const ok =
+      c === 0x9 ||
+      c === 0xa ||
+      c === 0xd ||
+      (c >= 0x20 && c <= 0xd7ff) ||
+      (c >= 0xe000 && c <= 0xfffd) ||
+      (c >= 0x10000 && c <= 0x10ffff);
+    if (!ok) return false;
+  }
+  return true;
+}
+
+/**
+ * Campo de texto da entrada (com `[]` onde a entrada é uma lista) e o elemento do `infNFe` que o recebe como veio. Só
+ * os campos copiados sem transformação: o que a montagem calcula ou formata é conferido por ela.
+ */
+const CAMPOS: readonly (readonly [entrada: string, xml: string])[] = [
+  ['natOp', 'ide.natOp'],
+  ['emitente.xNome', 'emit.xNome'],
+  ['emitente.xFant', 'emit.xFant'],
+  ['emitente.endereco.xLgr', 'emit.enderEmit.xLgr'],
+  ['emitente.endereco.nro', 'emit.enderEmit.nro'],
+  ['emitente.endereco.xCpl', 'emit.enderEmit.xCpl'],
+  ['emitente.endereco.xBairro', 'emit.enderEmit.xBairro'],
+  ['emitente.endereco.xMun', 'emit.enderEmit.xMun'],
+  ['destinatario.xNome', 'dest.xNome'],
+  ['destinatario.email', 'dest.email'],
+  ['destinatario.endereco.xLgr', 'dest.enderDest.xLgr'],
+  ['destinatario.endereco.nro', 'dest.enderDest.nro'],
+  ['destinatario.endereco.xCpl', 'dest.enderDest.xCpl'],
+  ['destinatario.endereco.xBairro', 'dest.enderDest.xBairro'],
+  ['destinatario.endereco.xMun', 'dest.enderDest.xMun'],
+  ['destinatario.endereco.xPais', 'dest.enderDest.xPais'],
+  ...(['retirada', 'entrega'] as const).flatMap((g) =>
+    (['xNome', 'xLgr', 'nro', 'xCpl', 'xBairro', 'xMun', 'email'] as const).map(
+      (c) => [`${g}.${c}`, `${g}.${c}`] as const,
+    ),
+  ),
+  ['itens[].produto.cProd', 'det.prod.cProd'],
+  ['itens[].produto.xProd', 'det.prod.xProd'],
+  ['itens[].produto.uCom', 'det.prod.uCom'],
+  ['itens[].produto.uTrib', 'det.prod.uTrib'],
+  ['itens[].produto.xPed', 'det.prod.xPed'],
+  ['itens[].infAdProd', 'det.infAdProd'],
+  ['transporte.transportador.xNome', 'transp.transporta.xNome'],
+  ['transporte.transportador.xEnder', 'transp.transporta.xEnder'],
+  ['transporte.transportador.xMun', 'transp.transporta.xMun'],
+  ['transporte.volumes[].esp', 'transp.vol.esp'],
+  ['transporte.volumes[].marca', 'transp.vol.marca'],
+  ['transporte.volumes[].nVol', 'transp.vol.nVol'],
+  ['cobranca.fatura.nFat', 'cobr.fat.nFat'],
+  ['cobranca.duplicatas[].nDup', 'cobr.dup.nDup'],
+  ['pagamento.detPag[].xPag', 'pag.detPag.xPag'],
+  ['informacoesAdicionais.infAdFisco', 'infAdic.infAdFisco'],
+  ['informacoesAdicionais.infCpl', 'infAdic.infCpl'],
+  ['informacoesAdicionais.obsCont[].xTexto', 'infAdic.obsCont.xTexto'],
+  ['informacoesAdicionais.obsFisco[].xTexto', 'infAdic.obsFisco.xTexto'],
+  ['compra.xNEmp', 'compra.xNEmp'],
+  ['compra.xPed', 'compra.xPed'],
+  ['compra.xCont', 'compra.xCont'],
+];
+
+/** O tipo do elemento `nome` entre as partículas (sequências e escolhas aninhadas). */
+function elemento(p: Particle | undefined, nome: string): ComplexType | SimpleType | undefined {
+  if (p === undefined || ehWildcard(p)) return undefined;
+  if (ehElementParticle(p)) return p.e === nome ? p.t : undefined;
+  for (const i of p.i) {
+    const t = elemento(i, nome);
+    if (t !== undefined) return t;
+  }
+  return undefined;
+}
+
+/** O tipo simples do elemento em `caminho` (pontos) a partir do `infNFe`; `undefined` se o PL não o tem. */
+function tipoEm(infNFe: ComplexType, caminho: string): SimpleType | undefined {
+  let t: ComplexType | SimpleType | undefined = infNFe;
+  for (const nome of caminho.split('.')) {
+    if (t === undefined || !ehComplexType(t)) return undefined;
+    t = elemento(t.c, nome);
+  }
+  return t === undefined || ehComplexType(t) ? undefined : t;
+}
+
+const tiposPorPl = new WeakMap<ComplexType, ReadonlyMap<string, SimpleType>>();
+
+/** Tipo de cada campo da tabela no PL, calculado uma vez por PL. */
+function tiposDoPl(infNFe: ComplexType): ReadonlyMap<string, SimpleType> {
+  let m = tiposPorPl.get(infNFe);
+  if (m === undefined) {
+    const novo = new Map<string, SimpleType>();
+    for (const [entrada, xml] of CAMPOS) {
+      const t = tipoEm(infNFe, xml);
+      if (t !== undefined) novo.set(entrada, t);
+    }
+    m = novo;
+    tiposPorPl.set(infNFe, m);
+  }
+  return m;
+}
+
+/** Os valores de `caminho` (com `[]` nas listas) na entrada, com o caminho concreto de cada um. */
+function valoresEm(raiz: unknown, caminho: string): [string, unknown][] {
+  let atuais: [string, unknown][] = [['', raiz]];
+  for (const parte of caminho.split('.')) {
+    const lista = parte.endsWith('[]');
+    const chave = lista ? parte.slice(0, -2) : parte;
+    const proximos: [string, unknown][] = [];
+    for (const [c, v] of atuais) {
+      if (typeof v !== 'object' || v === null) continue;
+      const filho = (v as Record<string, unknown>)[chave];
+      const base = c === '' ? chave : `${c}.${chave}`;
+      if (!lista) proximos.push([base, filho]);
+      else if (Array.isArray(filho)) for (const [n, f] of filho.entries()) proximos.push([`${base}[${n}]`, f]);
+    }
+    atuais = proximos;
+  }
+  return atuais;
+}
+
+/** Caminhos de todos os textos da entrada com caractere que o XML não representa. */
+function textosForaDoXml(valor: unknown, caminho: string, saida: string[]): void {
+  if (typeof valor === 'string') {
+    if (!textoXmlValido(valor)) saida.push(caminho);
+  } else if (Array.isArray(valor)) {
+    for (const [n, v] of valor.entries()) textosForaDoXml(v, `${caminho}[${n}]`, saida);
+  } else if (typeof valor === 'object' && valor !== null) {
+    for (const [k, v] of Object.entries(valor)) textosForaDoXml(v, caminho === '' ? k : `${caminho}.${k}`, saida);
+  }
+}
+
+/** Mensagem do caractere que não vai ao documento e que a pessoa não consegue ver (controle, invisível). */
+const CARACTERE_INVISIVEL = 'caractere não aceito (símbolo ou caractere de controle)';
+
+/** Caractere que a pessoa enxerga: letra, marca, número, pontuação ou símbolo. */
+const VISIVEL = /^[\p{L}\p{M}\p{N}\p{P}\p{S}]$/u;
+
+/** O primeiro caractere de `valor` que o tipo não aceita no meio de um texto, ou `undefined` se todos passam. */
+function caractereRecusado(tipo: SimpleType, valor: string): string | undefined {
+  for (const ch of new Set(valor)) {
+    const saida: OcorrenciaSchema[] = [];
+    conferirTipoSimples(tipo, `A${ch}A`, '', saida);
+    if (saida.some((o) => o.code === 'padrao')) return ch;
+  }
+  return undefined;
+}
+
+/**
+ * As regras do tipo que `valor` viola, em texto para quem preenche o campo. O código do validador decide a regra; a
+ * mensagem diz o limite (do próprio tipo) e, no `padrao`, se o problema é o espaço nas pontas ou um caractere.
+ */
+function mensagensDoTexto(tipo: SimpleType, valor: string, violadas: readonly OcorrenciaSchema[]): string[] {
+  if (violadas.length === 0) return [];
+  if (valor.trim() === '') return ['não pode ficar em branco'];
+  const tamanho = [...valor].length;
+  const mensagens = new Set<string>();
+  for (const o of violadas) {
+    if (o.code === 'tamanho_maximo' && tipo.mx !== undefined)
+      mensagens.add(`no máximo ${tipo.mx} caracteres (tem ${tamanho})`);
+    else if (o.code === 'tamanho_minimo' && tipo.mn !== undefined)
+      mensagens.add(`no mínimo ${tipo.mn} caracteres (tem ${tamanho})`);
+    else if (o.code === 'tamanho' && tipo.l !== undefined)
+      mensagens.add(`exatamente ${tipo.l} caracteres (tem ${tamanho})`);
+    else if (o.code === 'padrao') {
+      const espaco = valor !== valor.trim();
+      const ch = caractereRecusado(tipo, valor);
+      if (espaco) mensagens.add('sem espaço no começo nem no fim');
+      if (ch !== undefined) mensagens.add(VISIVEL.test(ch) ? `caractere não aceito: “${ch}”` : CARACTERE_INVISIVEL);
+      if (!espaco && ch === undefined) mensagens.add('formato não aceito');
+    } else mensagens.add('valor não aceito neste campo');
+  }
+  return [...mensagens];
+}
+
+/**
+ * Confere os textos da entrada: em qualquer campo, o caractere que o XML não representa; nos campos da tabela, o tipo
+ * do elemento no PL (tamanho, espaço nas pontas, caractere fora do conjunto aceito). Tudo sai como `campo_invalido`,
+ * com o caminho da entrada, `origem: 'entrada'` e uma ocorrência por regra violada. O campo que já tem ocorrência (de
+ * outra conferência da entrada) não ganha outra. `substituidos` são os campos que a montagem troca por um texto fixo
+ * (o nome do destinatário em homologação): o tipo deles não é conferido, porque o texto informado não vai ao XML.
+ */
+export function conferirTextosDaEntrada(
+  entrada: DadosNfe,
+  infNFe: ComplexType,
+  issues: Issues,
+  substituidos: ReadonlySet<string> = new Set(),
+): void {
+  const jaRecusados = new Set(issues.list.map((i) => i.caminho));
+  const foraDoXml: string[] = [];
+  textosForaDoXml(entrada, '', foraDoXml);
+  for (const c of foraDoXml) {
+    if (jaRecusados.has(c) || substituidos.has(c)) continue;
+    issues.add(c, 'campo_invalido', CARACTERE_INVISIVEL);
+    jaRecusados.add(c);
+  }
+  const tipos = tiposDoPl(infNFe);
+  for (const [campo] of CAMPOS) {
+    const tipo = tipos.get(campo);
+    if (tipo === undefined) continue;
+    for (const [caminho, valor] of valoresEm(entrada, campo)) {
+      if (typeof valor !== 'string' || jaRecusados.has(caminho) || substituidos.has(caminho)) continue;
+      const saida: OcorrenciaSchema[] = [];
+      conferirTipoSimples(tipo, valor, caminho, saida);
+      for (const m of mensagensDoTexto(tipo, valor, saida)) issues.add(caminho, 'campo_invalido', m);
+    }
+  }
+}