@sinete/nfe 0.3.0 → 0.5.0

package/src/build/textos.ts

@@ -11,32 +11,18 @@
  * 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 { CampoDeTexto, ComplexType } from '@sinete/schemas';
+import { conferirTextos } 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;
-}
+export { textoXmlValido } from '@sinete/schemas';
 
 /**
  * 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])[] = [
+const CAMPOS: readonly CampoDeTexto[] = [
   ['natOp', 'ide.natOp'],
   ['emitente.xNome', 'emit.xNome'],
   ['emitente.xFant', 'emit.xFant'],
@@ -82,117 +68,6 @@ const CAMPOS: readonly (readonly [entrada: string, xml: string])[] = [
   ['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`,
@@ -206,23 +81,6 @@ export function conferirTextosDaEntrada(
   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);
-    }
-  }
+  const pular = new Set([...issues.list.map((i) => i.caminho), ...substituidos]);
+  for (const t of conferirTextos(entrada, infNFe, CAMPOS, pular)) issues.add(t.caminho, 'campo_invalido', t.mensagem);
 }

package/src/data/cstat.json

@@ -1,6 +1,6 @@
 {
   "descricao": "Códigos de status de sucesso e de processamento (MOC 7.0 Anexo I, tabela 4.4.1) e os códigos que o @sinete/nfe trata de forma própria. Rejeições e denegações com mensagem oficial estão no @sinete/rejeicoes; aqui fica só o desfecho de cada código por serviço.",
-  "fonte": "MOC 7.0 Anexo I, tabela 4.4.1 (códigos de sucesso) e 4.4.2 (denegação 301, 302, 303); NT 2014.002 (Distribuição DF-e, 137 e 138); NT 2011.004 (lote em processamento, 105); MOC 7.0 Anexo I, consulta protocolo J03 a J06 (561, 562 e 613: a numeração da chave consultada tem outra NF-e)",
+  "fonte": "MOC 7.0 Anexo I, tabela 4.4.1 (códigos de sucesso) e 4.4.2 (denegação 301, 302, 303); NT 2014.002 (Distribuição DF-e, 137 e 138); NT 2011.004 (lote em processamento, 105); MOC 7.0 Anexo I, consulta protocolo J03 a J06 (561, 562 e 613: a numeração da chave consultada tem outra NF-e); MOC 7.0 Visão Geral, tabela 5-12, regra I07 (563: a mesma faixa já inutilizada, com o nProt anterior)",
   "atualizadoEm": "2026-09-26",
   "autorizada": ["100", "150"],
   "denegada": ["110", "301", "302", "303"],
@@ -11,6 +11,7 @@
   "loteNaoLocalizado": ["106"],
   "servicoEmOperacao": ["107"],
   "inutilizacaoHomologada": ["102"],
+  "inutilizacaoJaHomologada": ["563"],
   "eventoRegistrado": ["135", "136", "155"],
   "loteEventoProcessado": ["128"],
   "cadastroEncontrado": ["111", "112"],

package/src/index.ts

@@ -107,7 +107,13 @@ export type {
   Volume,
 } from './model.ts';
 export { MotivoDesoneracaoIcms, TipoPagamento } from './model.ts';
-export type { CalculadoraIbsCbs, PedidoIbsCbsItem, PedidoIbsCbsNota, RespostaIbsCbs } from './ports.ts';
+export type {
+  AliquotaIbsCbsInformada,
+  CalculadoraIbsCbs,
+  PedidoIbsCbsItem,
+  PedidoIbsCbsNota,
+  RespostaIbsCbs,
+} from './ports.ts';
 export { rotuloDoCaminho } from './rotulo.ts';
 export type { CalculadoraIbsCbsOpcoes, GrupoIbsCbs } from './rtc.ts';
 export { calculadoraIbsCbs, carregarDatasetEmbarcado, localDaOperacao } from './rtc.ts';
@@ -131,11 +137,13 @@ export type {
   Espera,
   EventoRegistrado,
   Inutilizacao,
+  InutilizacaoAnterior,
   InutilizacaoPedido,
   ManifestacaoPedido,
   ManifestacaoTipo,
   PoliticaRecibo,
   ProtocoloNfe,
+  RecusadoInutilizacao,
   ResultadoAutorizacao,
   ResultadoConsulta,
   ResultadoEvento,

package/src/ports.ts

@@ -74,9 +74,28 @@ export interface PedidoIbsCbsNota {
   readonly compraGov?: { readonly tpEnteGov: string; readonly pRedutor: Decimal; readonly tpOperGov: string };
 }
 
+/**
+ * Alíquota do IBS/CBS que entrou no cálculo de um item vinda de quem integra (`comAliquotasInformadas`), e não da tabela
+ * oficial do pacote.
+ */
+export interface AliquotaIbsCbsInformada {
+  /** Número do item na nota (1 a 990). */
+  readonly nItem: number;
+  readonly tributo: 'CBS' | 'IBSUF' | 'IBSMun';
+  /** Percentual nominal informado (`'8.7'` = 8,7%). */
+  readonly valor: string;
+  /** O motivo declarado em `comAliquotasInformadas`. */
+  readonly motivo: string;
+}
+
 /** Resultado da calculadora: o grupo `IBSCBS` de cada item pedido, já na forma lexical do leiaute. */
 export interface RespostaIbsCbs {
   readonly itens: readonly { readonly nItem: number; readonly IBSCBS: TTribNFe }[];
+  /**
+   * As alíquotas que não vieram da tabela oficial: a montagem as repassa em `NfeMontada.aliquotasInformadas`. Ausente
+   * ou vazio quando todas foram oficiais; a calculadora de fora do sinete que não sabe dizer pode omitir.
+   */
+  readonly aliquotasInformadas?: readonly AliquotaIbsCbsInformada[];
   /**
    * Problemas de classificação ou de dado (`caminho` relativo ao item, como `itens[2].impostos.ibsCbs`). A ocorrência sem
    * `origem` entra como `montagem` (ADR 0011); marque `entrada` a que aponta um valor da nota.

package/src/rtc.ts

@@ -28,7 +28,13 @@ import { calcular, ErroClassificacao, ErroRegimeNaoSuportado } from '@sinete/ibs
 import type { Regra } from '@sinete/ibs-cbs/validar';
 import { documentoDoRoc, validar } from '@sinete/ibs-cbs/validar';
 import type { DatasetIbsCbs } from '@sinete/ibs-cbs-dados';
-import type { CalculadoraIbsCbs, PedidoIbsCbsItem, PedidoIbsCbsNota, RespostaIbsCbs } from './ports.ts';
+import type {
+  AliquotaIbsCbsInformada,
+  CalculadoraIbsCbs,
+  PedidoIbsCbsItem,
+  PedidoIbsCbsNota,
+  RespostaIbsCbs,
+} from './ports.ts';
 
 /** Grupo `IBSCBS` do item, como o `@sinete/nfe` o recebe. */
 export type GrupoIbsCbs = RespostaIbsCbs['itens'][number]['IBSCBS'];
@@ -109,15 +115,42 @@ function grupoDoLeiaute(g: IBSCBS, indDoacao: '1' | undefined): GrupoIbsCbs {
   } as GrupoIbsCbs;
 }
 
-/** Erro do motor ou das alíquotas como ocorrência no item (ou na nota, quando o erro não diz o item). */
-function ocorrenciaDoMotor(e: unknown, itens: readonly PedidoIbsCbsItem[]): Ocorrencia | undefined {
+/**
+ * Erro do motor ou das alíquotas como uma ocorrência no caminho do item (o primeiro, quando o erro não diz o item).
+ * `semAliquota` acha o item que pediu a alíquota desconhecida: o erro do provedor diz o tributo e a data, não o item.
+ */
+function ocorrenciaDoMotor(
+  e: unknown,
+  itens: readonly PedidoIbsCbsItem[],
+  semAliquota: () => number | undefined,
+): Ocorrencia | undefined {
   if (e instanceof ErroClassificacao || e instanceof ErroRegimeNaoSuportado) {
     const path = e.item !== undefined ? caminho(e.item) : caminho(itens[0]?.nItem ?? 1);
     return { caminho: path, code: e.code, mensagem: e.message, origem: 'entrada' };
   }
   // Alíquota que o sinete não conhece para a data: falta de dado do pacote, não da nota.
-  if (e instanceof ErroAliquotaDesconhecida)
-    return { caminho: 'impostos.ibsCbs', code: e.code, mensagem: e.message, origem: 'montagem' };
+  if (e instanceof ErroAliquotaDesconhecida) {
+    const n = semAliquota() ?? itens[0]?.nItem ?? 1;
+    return { caminho: caminho(n), code: e.code, mensagem: e.message, origem: 'montagem' };
+  }
+  return undefined;
+}
+
+/**
+ * O primeiro item (pela ordem de `nItem`, a do motor) cujo cálculo sozinho pede uma alíquota desconhecida. Só roda na
+ * recusa, para pôr a ocorrência no item em vez de na nota.
+ */
+function primeiroItemSemAliquota(
+  op: OperacaoClassificada,
+  calc: (op: OperacaoClassificada) => unknown,
+): number | undefined {
+  for (const it of [...op.itens].sort((a, b) => a.n - b.n)) {
+    try {
+      calc({ ...op, itens: [it] });
+    } catch (e) {
+      if (e instanceof ErroAliquotaDesconhecida) return it.n;
+    }
+  }
   return undefined;
 }
 
@@ -234,16 +267,18 @@ function calcularCom(
     itens: classificados,
   };
   const time = contextoDeTempo({ emissao: relogioFixo(nota.emissao), fatoGerador: relogioFixo(nota.fatoGerador) });
-  let roc: Roc;
-  try {
-    roc = calcular(op, {
+  const calc = (o: OperacaoClassificada): Roc =>
+    calcular(o, {
       dataset,
       aliquotas: rates,
       tempo: time,
       ...(options.deslocamentoMin === undefined ? {} : { deslocamentoMin: options.deslocamentoMin }),
     });
+  let roc: Roc;
+  try {
+    roc = calc(op);
   } catch (e) {
-    const issue = ocorrenciaDoMotor(e, itens);
+    const issue = ocorrenciaDoMotor(e, itens, () => primeiroItemSemAliquota(op, calc));
     if (issue === undefined) throw e;
     return { itens: [], ocorrencias: [issue] };
   }
@@ -295,11 +330,17 @@ function calcularCom(
   }
 
   const porItem = new Map(itens.map((it) => [it.nItem, it]));
+  const informadas: AliquotaIbsCbsInformada[] = roc.itens.flatMap((r) =>
+    r.aliquotas
+      .filter((a) => a.situacao === 'informada')
+      .map((a) => ({ nItem: r.nItem, tributo: a.tributo, valor: a.valor, motivo: a.motivo ?? '' })),
+  );
   return {
     itens: roc.itens.map((r) => ({
       nItem: r.nItem,
       IBSCBS: grupoDoLeiaute(r.IBSCBS, porItem.get(r.nItem)?.indDoacao),
     })),
+    ...(informadas.length === 0 ? {} : { aliquotasInformadas: informadas }),
     ...(issues.length === 0 ? {} : { ocorrencias: issues }),
   };
 }

package/src/services/client.ts

@@ -13,7 +13,7 @@
  * número. Consulte a chave (`resolverEnvioSemResposta`) e, se ela não constar, reenvie exatamente os mesmos bytes.
  */
 
-import type { Ambiente, Assinador, CUf, Logger, Relogio, ResultadoSefaz, Uf } from '@sinete/core';
+import type { Ambiente, Assinador, CUf, Logger, Recusado, Relogio, ResultadoSefaz, Uf } from '@sinete/core';
 import {
   criarAutorizado,
   criarDenegado,
@@ -112,6 +112,16 @@ export interface ClienteNfeOpcoes {
   readonly endpointNfce?: (servico: NfeServico, uf: Uf) => EndpointResolvido;
   /** Gerador de `idLote` (até 15 dígitos); padrão: os milissegundos do relógio. */
   readonly idLote?: () => string;
+  /**
+   * O titular emite NF-e sem inscrição estadual, como contribuinte exclusivo do IBS/CBS (NT 2026.007 v1.10). A
+   * autorização dessa NF-e é só na SVRS (RV C17-11, rejeição 166), e os eventos de autoria do emitente dela também
+   * (RV 1P10-40, rejeição 188), menos na série 890 a 919. Com a NF-e assinada na mão (`autorizar`, `consultar` e
+   * `consultarRecibo` com ela) o cliente vê a falta de `emit/IE` sozinho; esta opção é para o que parte só da chave:
+   * cancelamento, carta de correção, consulta e recibo sem a nota (o recibo sem a nota vai à SVRS no modelo 55). A série 890 a
+   * 919 é exceção só dos eventos. Não vale para a NFC-e, que não admite emitente sem
+   * IE (RV C17-42, rejeição 156).
+   */
+  readonly contribuinteExclusivoIbsCbs?: boolean;
 }
 
 /** Opções de toda chamada que vai à rede. */
@@ -213,7 +223,24 @@ export interface Inutilizacao {
   readonly procInutNFe: string;
 }
 
-export type ResultadoInutilizacao = ResultadoSefaz<Inutilizacao, never>;
+/**
+ * Protocolo da inutilização que já valia para a mesma faixa, trazido pelo 563 (MOC 7.0 Visão Geral, tabela 5-12,
+ * regra I07). Não existe consulta de inutilização na NF-e 4.00: depois de um pedido sem resposta, reenviar a mesma
+ * faixa e ler este campo é o único caminho para guardar o `nProt` que valeu. O `procInutNFe` não se monta com ele,
+ * porque a resposta 563 não é a homologação.
+ */
+export interface InutilizacaoAnterior {
+  readonly nProt: string;
+  /** `retInutNFe` do 563 como veio na resposta. */
+  readonly retInutNFe: string;
+}
+
+/** Recusa da inutilização; no 563 com protocolo, `anterior` traz o protocolo da faixa já inutilizada. */
+export interface RecusadoInutilizacao extends Recusado {
+  readonly anterior?: InutilizacaoAnterior;
+}
+
+export type ResultadoInutilizacao = Exclude<ResultadoSefaz<Inutilizacao, never>, Recusado> | RecusadoInutilizacao;
 
 export interface Cadastro {
   readonly UF: string;
@@ -430,6 +457,13 @@ function autorDoEmitente(a: AutorDocumento | undefined, c: ChaveAcesso): { CNPJ:
  */
 const SVC_DO_TPEMIS: Readonly<Record<string, 'SVC-AN' | 'SVC-RS'>> = { '6': 'SVC-AN', '7': 'SVC-RS' };
 
+/** A NF-e tem o grupo `emit` e ele não traz `IE`: contribuinte exclusivo do IBS/CBS (NT 2026.007). */
+function emitenteSemIe(a: DocumentoAssinado): boolean {
+  const inf = primeiroFilho(a.documento.raiz, 'infNFe', NFE_NS);
+  const emit = inf === undefined ? undefined : primeiroFilho(inf, 'emit', NFE_NS);
+  return emit !== undefined && primeiroFilho(emit, 'IE', NFE_NS) === undefined;
+}
+
 /** Chave do documento assinado, lida para rotear: o emitente é conferido pela SEFAZ, não aqui. */
 function chaveDoDocumento(a: DocumentoAssinado): ChaveAcesso {
   const r = lerChaveAcesso(a.id.slice(3), { caminho: 'infNFe.Id', conferirEmitente: false });
@@ -592,8 +626,18 @@ export function criarClienteNfe(opcoesDoCliente: ClienteNfeOpcoes): ClienteNfe {
    * autorizou a nota. `naUf` força o autorizador da UF (a CC-e não existe no SVC). A NFC-e vai sempre ao autorizador
    * normal da NFC-e.
    */
-  const endpointDaChave = (servico: NfeServico, c: ChaveAcesso, naUf = false): EndpointResolvido => {
+  const endpointDaChave = (
+    servico: NfeServico,
+    c: ChaveAcesso,
+    naUf = false,
+    semIe = opcoesDoCliente.contribuinteExclusivoIbsCbs === true,
+  ): EndpointResolvido => {
     if (c.mod === '65') return endpointNfce(servico, c.uf);
+    // Contribuinte exclusivo do IBS/CBS (NT 2026.007): autorização, consulta e eventos do emitente só na SVRS (RV
+    // C17-11 e 1P10-40). A série 890 a 919 é exceção só dos eventos (exceção 1 da RV 1P10-40).
+    const serie = Number(c.serie);
+    if (semIe && !(servico === 'RecepcaoEvento' && serie >= 890 && serie <= 919))
+      return nfeEndpoint({ ambiente: opcoesDoCliente.ambiente, servico, autorizador: 'SVRS' });
     const svc = naUf || c.tpEmis === undefined ? undefined : SVC_DO_TPEMIS[c.tpEmis];
     return nfeEndpoint({
       ambiente: opcoesDoCliente.ambiente,
@@ -602,6 +646,10 @@ export function criarClienteNfe(opcoesDoCliente: ClienteNfeOpcoes): ClienteNfe {
     });
   };
 
+  /** A NF-e assinada diz se o emitente tem IE; sem ela, vale a opção `contribuinteExclusivoIbsCbs`. */
+  const semIeOuOpcao = (a: DocumentoAssinado | undefined): boolean =>
+    a === undefined ? opcoesDoCliente.contribuinteExclusivoIbsCbs === true : emitenteSemIe(a);
+
   const call = (
     ep: EndpointResolvido,
     servico: NfeServico,
@@ -640,7 +688,11 @@ export function criarClienteNfe(opcoesDoCliente: ClienteNfeOpcoes): ClienteNfe {
     const msg = envelope('consReciNFe', '4.00', [`<tpAmb>${tpAmb}</tpAmb><nRec>${nRec}</nRec>`]);
     // O recibo é do autorizador que recebeu o lote: com a NF-e, o da chave; sem ela, o das opções.
     const ep =
-      c === undefined ? endpoint('NFeRetAutorizacao', opcoes.mod ?? '55') : endpointDaChave('NFeRetAutorizacao', c);
+      c === undefined
+        ? (opcoes.mod ?? '55') === '55' && opcoesDoCliente.contribuinteExclusivoIbsCbs === true
+          ? nfeEndpoint({ ambiente: opcoesDoCliente.ambiente, servico: 'NFeRetAutorizacao', autorizador: 'SVRS' })
+          : endpoint('NFeRetAutorizacao', opcoes.mod ?? '55')
+        : endpointDaChave('NFeRetAutorizacao', c, false, semIeOuOpcao(a));
     const r = await call(ep, 'NFeRetAutorizacao', msg, 'retConsReciNFe', opcoes.signal);
     const v = decodificar(TRetConsReciNFe, r.ret, r.doc.texto).valor;
     if (v.nRec !== undefined && v.nRec !== nRec) {
@@ -663,7 +715,7 @@ export function criarClienteNfe(opcoesDoCliente: ClienteNfeOpcoes): ClienteNfe {
     const a = nfeAssinada === undefined ? undefined : documentoAssinado(nfeAssinada, 'NFe', 'infNFe');
     if (a && a.id !== `NFe${c.chave}`) throw new ErroDeConfiguracao('a NF-e assinada não é a da chave consultada');
     const msg = serializarRaiz(consSitNFeElement, { versao: '4.00', tpAmb, xServ: 'CONSULTAR', chNFe: c.chave });
-    const ep = endpointDaChave('NfeConsultaProtocolo', c);
+    const ep = endpointDaChave('NfeConsultaProtocolo', c, false, semIeOuOpcao(a));
     const r = await call(ep, 'NfeConsultaProtocolo', msg, 'retConsSitNFe', opcoes?.signal);
     const v = decodificar(TRetConsSitNFe, r.ret, r.doc.texto).valor;
     const status = { cStat: v.cStat, xMotivo: v.xMotivo };
@@ -797,7 +849,7 @@ export function criarClienteNfe(opcoesDoCliente: ClienteNfeOpcoes): ClienteNfe {
         a.xml,
       ]);
       // O autorizador é o do documento: a UF do cUF e, assinada em SVC (tpEmis 6 ou 7), o SVC da chave.
-      const ep = endpointDaChave('NFeAutorizacao', chaveDoDocumento(a));
+      const ep = endpointDaChave('NFeAutorizacao', chaveDoDocumento(a), false, semIeOuOpcao(a));
       const r = await call(ep, 'NFeAutorizacao', msg, 'retEnviNFe', opcoes.signal);
       const v = decodificar(TRetEnviNFe, r.ret, r.doc.texto).valor;
       const status = { cStat: v.cStat, xMotivo: v.xMotivo };
@@ -1015,8 +1067,11 @@ export function criarClienteNfe(opcoesDoCliente: ClienteNfeOpcoes): ClienteNfe {
       const v = decodificar(TRetInutNFe, r.ret, r.doc.texto).valor;
       const status = { cStat: v.infInut.cStat, xMotivo: v.infInut.xMotivo };
       logger.info('nfe.inutilizacao', { id, cStat: status.cStat });
-      if (!cstatEm(status.cStat, 'inutilizacaoHomologada')) return rejeitado(status);
-      // A homologação tem de ser desta faixa: os campos que o retorno trouxer, iguais aos do pedido.
+      const homologada = cstatEm(status.cStat, 'inutilizacaoHomologada');
+      // `<nProt></nProt>` vazio não é protocolo: sem ele, o 563 fica como a recusa simples.
+      const anterior = cstatEm(status.cStat, 'inutilizacaoJaHomologada') ? v.infInut.nProt || undefined : undefined;
+      if (!homologada && anterior === undefined) return rejeitado(status);
+      // A homologação (ou a anterior, no 563) tem de ser desta faixa: os campos que o retorno trouxer, iguais aos do pedido.
       const r0 = v.infInut;
       const n = (x: string | undefined): string | undefined => (x === undefined ? undefined : String(Number(x)));
       const confere: readonly (readonly [string, string | undefined, string])[] = [
@@ -1033,6 +1088,9 @@ export function criarClienteNfe(opcoesDoCliente: ClienteNfeOpcoes): ClienteNfe {
           detalhes: Object.fromEntries(fora.map(([k, v]) => [k, v])),
         });
       }
+      if (anterior !== undefined) {
+        return { ...rejeitado(status), anterior: { nProt: anterior, retInutNFe: avulso(r.doc, r.ret) } };
+      }
       return criarAutorizado(status, {
         dhRecbto: v.infInut.dhRecbto,
         retInutNFe: avulso(r.doc, r.ret),

package/src/services/outcome.ts

@@ -19,6 +19,7 @@ export type CStatClasse =
   | 'loteNaoLocalizado'
   | 'servicoEmOperacao'
   | 'inutilizacaoHomologada'
+  | 'inutilizacaoJaHomologada'
   | 'eventoRegistrado'
   | 'loteEventoProcessado'
   | 'cadastroEncontrado'

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.3.0';
+export const VERSAO_PACOTE = '0.5.0';