@sinete/nfe 0.2.0 → 0.3.0

package/dist/services/recuperar.d.ts

@@ -8,7 +8,7 @@
  * função lê o evento de lá e só o dá como registrado quando o retorno dele diz 135, 136 ou 155 para a mesma chave e o
  * mesmo tipo.
  */
-import type { ClienteNfe, EventoRegistrado, ResultadoConsulta } from './client.js';
+import type { ClienteNfe, EnvioOpcoes, EventoRegistrado, ResultadoConsulta } from './client.js';
 /** Resultado da recuperação: o evento registrado, com a consulta que o prova, ou só a consulta. */
 export type RecuperacaoEvento = {
     readonly registrado: true;
@@ -23,6 +23,7 @@ export type RecuperacaoEvento = {
  * vários, como na CC-e; com `nSeqEvento`, só o dessa sequência). Serve depois de um pedido de evento sem resposta ou
  * respondido com 573 ou 580: nunca conclua que o evento existe só pelo `cStat` do pedido. `registrado: false` quer
  * dizer que a consulta não mostrou o evento (ou não decidiu: veja `consulta`); não quer dizer que o evento não existe.
+ * `opcoes.signal` cancela a consulta.
  */
-export declare function recuperarEventoRegistrado(cliente: ClienteNfe, chave: string, tpEvento: string, nSeqEvento?: number): Promise<RecuperacaoEvento>;
+export declare function recuperarEventoRegistrado(cliente: ClienteNfe, chave: string, tpEvento: string, nSeqEvento?: number, opcoes?: EnvioOpcoes): Promise<RecuperacaoEvento>;
 //# sourceMappingURL=recuperar.d.ts.map

package/dist/services/recuperar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recuperar.d.ts","sourceRoot":"","sources":["../../src/services/recuperar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAInF,mGAAmG;AACnG,MAAM,MAAM,iBAAiB,GACzB;IAAE,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE,GACtG;IAAE,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAkDzE;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,UAAU,EACnB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,iBAAiB,CAAC,CAW5B"}
+{"version":3,"file":"recuperar.d.ts","sourceRoot":"","sources":["../../src/services/recuperar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIhG,mGAAmG;AACnG,MAAM,MAAM,iBAAiB,GACzB;IAAE,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE,GACtG;IAAE,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAkDzE;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,UAAU,EACnB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,iBAAiB,CAAC,CAW5B"}

package/dist/services/resolver.d.ts

@@ -26,7 +26,7 @@
  * Acesso [chNFe: ...]") e serviço de consulta protocolo (cStat 217; 561, 562 e 613 quando a numeração tem outra NF-e).
  */
 import type { Recusado } from '@sinete/core';
-import type { ClienteNfe, ResultadoAutorizacao, ResultadoConsulta } from './client.js';
+import type { ClienteNfe, EnvioOpcoes, ResultadoAutorizacao, ResultadoConsulta } from './client.js';
 /**
  * O que o `digVal` do protocolo diz dos bytes assinados: `confere` (é o DigestValue deles), `sem-digval` (o protocolo
  * não o traz) ou `difere` (a SEFAZ registrou outro conteúdo com a mesma chave).
@@ -82,7 +82,8 @@ export type ResolucaoEnvio =
 export declare function chaveDaDuplicidade(xMotivo: string): string | undefined;
 /**
  * Resolve um envio de autorização sem resposta, ou cuja resposta foi 204 ou 539, consultando a chave da NF-e
- * assinada. `anterior` é o desfecho do envio, quando houve um.
+ * assinada. `anterior` é o desfecho do envio, quando houve um. `opcoes.signal` cancela a consulta (lança o
+ * `ErroTransporte` com `code: 'cancelado'`).
  */
-export declare function resolverEnvioSemResposta(cliente: ClienteNfe, nfeAssinada: string, anterior?: ResultadoAutorizacao): Promise<ResolucaoEnvio>;
+export declare function resolverEnvioSemResposta(cliente: ClienteNfe, nfeAssinada: string, anterior?: ResultadoAutorizacao, opcoes?: EnvioOpcoes): Promise<ResolucaoEnvio>;
 //# sourceMappingURL=resolver.d.ts.map

package/dist/services/resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/services/resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAgB,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrG;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,YAAY,GAAG,QAAQ,CAAC;AAEtE,yFAAyF;AACzF,MAAM,MAAM,cAAc;AACxB;;;;GAIG;AACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,WAAW,GAAG,UAAU,CAAC;IAC3D,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;CAC1C;AACH,gFAAgF;GAC9E;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAAE;AAC7D;;;GAGG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,iBAAiB,CAAC;CAC/C;AACH;;;;GAIG;GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,WAAW,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE;AACrH;;;GAGG;GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAK3E,mGAAmG;AACnG,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEtE;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,UAAU,EACnB,WAAW,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,oBAAoB,GAC9B,OAAO,CAAC,cAAc,CAAC,CAiCzB"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/services/resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAgB,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIlH;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,YAAY,GAAG,QAAQ,CAAC;AAEtE,yFAAyF;AACzF,MAAM,MAAM,cAAc;AACxB;;;;GAIG;AACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,WAAW,GAAG,UAAU,CAAC;IAC3D,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;CAC1C;AACH,gFAAgF;GAC9E;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAAE;AAC7D;;;GAGG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,iBAAiB,CAAC;CAC/C;AACH;;;;GAIG;GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,WAAW,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE;AACrH;;;GAGG;GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAK3E,mGAAmG;AACnG,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEtE;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,UAAU,EACnB,WAAW,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,oBAAoB,EAC/B,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,CAAC,CAiCzB"}

package/dist/versao-gerada.d.ts

@@ -1,3 +1,3 @@
 /** Versão de `@sinete/nfe`, para o padrão de `verProc`/`verAplic` (`formatarVerProc` do @sinete/core). */
-export declare const VERSAO_PACOTE = "0.2.0";
+export declare const VERSAO_PACOTE = "0.3.0";
 //# sourceMappingURL=versao-gerada.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinete/nfe",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "NF-e modelo 55: modelo de entrada tipado, montagem com totais em decimal exato, validação antes de assinar, autorização, consultas, eventos, inutilização, contingência SVC e Distribuição DF-e",
   "keywords": [
     "nfe",
@@ -44,16 +44,16 @@
     "build": "bun ../../scripts/build.ts ."
   },
   "dependencies": {
-    "@sinete/core": "^0.2.0",
-    "@sinete/ibs-cbs": "^0.2.0",
-    "@sinete/ibs-cbs-dados": "^2026.9.2",
-    "@sinete/rejeicoes": "^0.2.0",
-    "@sinete/schemas": "^0.2.0",
-    "@sinete/transport": "^0.2.0",
-    "@sinete/validators": "^0.2.0"
+    "@sinete/core": "^0.3.0",
+    "@sinete/ibs-cbs": "^0.2.1",
+    "@sinete/ibs-cbs-dados": ">=2026.9.3",
+    "@sinete/rejeicoes": "^0.3.0",
+    "@sinete/schemas": "^0.2.1",
+    "@sinete/transport": "^0.2.1",
+    "@sinete/validators": "^0.2.1"
   },
   "devDependencies": {
-    "@sinete/sefaz-sim": "^0.2.0"
+    "@sinete/sefaz-sim": "^0.2.1"
   },
   "publishConfig": {
     "access": "public"

package/src/build/build.ts

@@ -70,6 +70,7 @@ import {
 } from './nfce.ts';
 import { camposForaDoPl, escolherPl } from './pl.ts';
 import { cstComIsento, vencimentos } from './rejeicoes.ts';
+import { conferirTextosDaEntrada, textoXmlValido } from './textos.ts';
 import { buildIcmsUfDest, buildIi, buildIpi, buildIssqn, buildPisCofins, buildPisCofinsSt } from './tributos.ts';
 import type { Familia } from './values.ts';
 import { Ctx, clean, digits, TOLERANCIA } from './values.ts';
@@ -344,25 +345,10 @@ function referencia(ref: Referenciada, path: string, issues: Issues): TNFe_infNF
   } as TNFe_infNFe_ide_NFref;
 }
 
-/** 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. */
-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;
-}
-
 /**
- * Texto com caractere que o XML não representa (vindo, por exemplo, de uma descrição importada) vira ocorrência com o
- * caminho do campo, em vez de falhar no parse do documento montado.
+ * Texto com caractere que o XML não representa vira ocorrência com o caminho do campo, em vez de falhar no parse do
+ * documento montado. Os textos da entrada já foram conferidos com o caminho dela (`conferirTextosDaEntrada`): aqui só
+ * sobra o que veio das opções da montagem.
  */
 function textosForaDoXml(value: unknown, path: string, issues: Issues): void {
   if (typeof value === 'string') {
@@ -971,6 +957,13 @@ export async function montarNfe(entrada: DadosNfe, opcoes: MontarNfeOpcoes): Pro
       grupoInvalido(TISCt as ComplexType, 'IS', imp.IS, is, issues);
     }
   });
+  // Texto e tamanho dos campos de texto pelo tipo do PL, com o caminho da entrada (ADR 0011); o campo que outra
+  // conferência já recusou fica só com a ocorrência dela.
+  // Em homologação, o nome do destinatário e, na NFC-e, a descrição do primeiro item são as literais da E04-20 e da I04-10:
+  // o texto informado não vai ao XML.
+  const substituidos =
+    opcoes.ambiente === 'homologacao' ? ['destinatario.xNome', ...(nfce ? ['itens[0].produto.xProd'] : [])] : [];
+  conferirTextosDaEntrada(entrada, pl.infNFe as ComplexType, issues, new Set(substituidos));
   if (!issues.empty) return { ok: false, ocorrencias: issues.classificadas };
 
   // Totais (grupo W)

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);
+    }
+  }
+}

package/src/ibs-cbs.ts

@@ -7,6 +7,11 @@
  * embarcado não entra aqui, para não ir para o bundle de quem não o usa: `carregarDatasetEmbarcado()`, na raiz do
  * `@sinete/nfe`, o importa sob demanda. `Dec`, `DataIso` e `Vigencia` vêm do motor (os de `Dec` e `DataIso` são os
  * mesmos; a `Vigencia` dos dados, com os campos do dataset, fica acessível pelos tipos que a usam).
+ *
+ * Experimental (ADR 0016, seção 5) até o `@sinete/ibs-cbs` sair 1.0: a calculadora espera a norma da base de cálculo
+ * (NT 2025.002, UB16-10), e este subpath pode mudar em minor, sempre com changeset.
+ *
+ * @experimental
  */
 
 // biome-ignore lint/performance/noReExportAll: o subpath existe para reexportar o motor inteiro, e as duas pontas são do mesmo repo.

package/src/services/recuperar.ts

@@ -11,7 +11,7 @@
 
 import type { DocumentoXml, ElementoXml } from '@sinete/core/xml';
 import { lerXml, primeiroFilho, textoDe } from '@sinete/core/xml';
-import type { ClienteNfe, EventoRegistrado, ResultadoConsulta } from './client.ts';
+import type { ClienteNfe, EnvioOpcoes, EventoRegistrado, ResultadoConsulta } from './client.ts';
 import { cstatEm } from './outcome.ts';
 import { NFE_NS, recortarElemento } from './proc.ts';
 
@@ -73,14 +73,16 @@ function lerProcEvento(xml: string): EventoRegistrado | undefined {
  * vários, como na CC-e; com `nSeqEvento`, só o dessa sequência). Serve depois de um pedido de evento sem resposta ou
  * respondido com 573 ou 580: nunca conclua que o evento existe só pelo `cStat` do pedido. `registrado: false` quer
  * dizer que a consulta não mostrou o evento (ou não decidiu: veja `consulta`); não quer dizer que o evento não existe.
+ * `opcoes.signal` cancela a consulta.
  */
 export async function recuperarEventoRegistrado(
   cliente: ClienteNfe,
   chave: string,
   tpEvento: string,
   nSeqEvento?: number,
+  opcoes?: EnvioOpcoes,
 ): Promise<RecuperacaoEvento> {
-  const consulta = await cliente.consultar(chave);
+  const consulta = await cliente.consultar(chave, undefined, opcoes);
   if (consulta.tipo !== 'autorizado' && consulta.tipo !== 'denegado') return { registrado: false, consulta };
   let achado: EventoRegistrado | undefined;
   for (const xml of consulta.valor.eventos) {

package/src/services/resolver.ts

@@ -28,7 +28,7 @@
 
 import type { Recusado } from '@sinete/core';
 import { criarAutorizado, criarDenegado } from '@sinete/core';
-import type { ClienteNfe, ProtocoloNfe, ResultadoAutorizacao, ResultadoConsulta } from './client.ts';
+import type { ClienteNfe, EnvioOpcoes, ProtocoloNfe, ResultadoAutorizacao, ResultadoConsulta } from './client.ts';
 import { cstatEm } from './outcome.ts';
 import { documentoAssinado } from './proc.ts';
 
@@ -85,12 +85,14 @@ export function chaveDaDuplicidade(xMotivo: string): string | undefined {
 
 /**
  * Resolve um envio de autorização sem resposta, ou cuja resposta foi 204 ou 539, consultando a chave da NF-e
- * assinada. `anterior` é o desfecho do envio, quando houve um.
+ * assinada. `anterior` é o desfecho do envio, quando houve um. `opcoes.signal` cancela a consulta (lança o
+ * `ErroTransporte` com `code: 'cancelado'`).
  */
 export async function resolverEnvioSemResposta(
   cliente: ClienteNfe,
   nfeAssinada: string,
   anterior?: ResultadoAutorizacao,
+  opcoes?: EnvioOpcoes,
 ): Promise<ResolucaoEnvio> {
   const a = documentoAssinado(nfeAssinada, 'NFe', 'infNFe');
   const chave = a.id.slice(3);
@@ -98,7 +100,7 @@ export async function resolverEnvioSemResposta(
     const outra = chaveDaDuplicidade(anterior.xMotivo);
     return { acao: 'divergente', motivo: anterior, ...(outra === undefined ? {} : { chNFe: outra }) };
   }
-  const consulta = await cliente.consultar(chave, nfeAssinada);
+  const consulta = await cliente.consultar(chave, nfeAssinada, opcoes);
   if (consulta.tipo === 'recusado') {
     if (cstatEm(consulta.cStat, 'naoConsta')) return { acao: 'reenviar', nfeAssinada: a.xml };
     // 561, 562 e 613 na consulta: a chave local não consta, mas a numeração dela tem outra NF-e (outro mês, outro cNF

package/src/versao-gerada.ts

@@ -1,3 +1,3 @@
 // GERADO por scripts/versao-gerada.ts a partir do package.json. Não edite: rode `bun scripts/versao-gerada.ts`.
 /** Versão de `@sinete/nfe`, para o padrão de `verProc`/`verAplic` (`formatarVerProc` do @sinete/core). */
-export const VERSAO_PACOTE = '0.2.0';
+export const VERSAO_PACOTE = '0.3.0';