@sinete/nfe 0.4.0 → 0.6.0

package/src/build/rejeicoes.ts

@@ -8,6 +8,7 @@
  */
 
 import type { Ocorrencia } from '@sinete/core';
+import { indicadoresCfop } from '@sinete/validators';
 import type { Issues } from '../issues.ts';
 import type { DadosNfe } from '../model.ts';
 import type { Instante } from '../time.ts';
@@ -140,3 +141,184 @@ export function conferirEmitenteDoCertificado(
   }
   return [];
 }
+
+/** A RV C17-42 (NFC-e sem IE) "não se aplica a partir de 2033". */
+const NFCE_SEM_IE_ATE = '2033-01-01';
+
+/**
+ * Contribuinte exclusivo do IBS/CBS: a nota sem `emitente.IE` (NT 2026.007 v1.10). Sai daqui o que a NT decide só com o
+ * documento:
+ *
+ * - NFC-e sem IE, rejeição 156 (RV C17-42), até o fim de 2032; a data é a da emissão e a do fato gerador, e a conferência
+ *   só recusa quando todas as leituras (local, Brasília e UTC) caem antes de 2033;
+ * - NF-e sem IE e sem CNPJ do emitente (emitente CPF), 157 (C17-43);
+ * - NF-e sem IE com a IE do substituto tributário, 158 (C18-50);
+ * - item com ICMS ou ICMS interestadual (`icmsUfDest`) na NF-e sem IE, 161 (N01-10), menos na devolução (finNFe 4) e na
+ *   nota de crédito de retorno por recusa ou não localização (tpNFCredito 03), as duas exceções da regra;
+ * - item sem `impostos.ibsCbs` (nem o grupo pronto nem a classificação para a calculadora) na NF-e sem IE, 162
+ *   (UB12-11). O item classificado cujo cálculo falhou já tem a ocorrência da calculadora, de montagem.
+ *
+ * Ficam para a SEFAZ as regras da mesma NT que dependem de tabela ou cadastro: a 159 (tabela de CFOP do Portal), a 163 e
+ * a 164 (CCC), as de local de retirada e entrega (CCC) e as da LCC-RFB (178 a 187). A 166 e a 188 são do roteamento.
+ */
+export function exclusivoIbsCbs(
+  input: DadosNfe,
+  contexto: { readonly nfce: boolean; readonly dhEmi: string; readonly instantes: readonly Instante[] },
+  issues: Issues,
+): void {
+  const e = input.emitente;
+  if (e.IE !== undefined) return;
+  if (contexto.nfce) {
+    const datas = [
+      contexto.dhEmi.slice(0, 10),
+      ...contexto.instantes.flatMap((i) => [dataNoFuso(i, OFFSET_BRASILIA), dataNoFuso(i, 0)]),
+    ];
+    if (datas.every((d) => d < NFCE_SEM_IE_ATE)) {
+      issues.add(
+        'emitente.IE',
+        'campo_obrigatorio',
+        'a NFC-e exige a IE do emitente: contribuinte exclusivo do IBS/CBS, sem IE, emite só NF-e (C17-42, rejeição 156)',
+      );
+    }
+    return;
+  }
+  if (e.CNPJ === undefined) {
+    issues.add(
+      'emitente.CNPJ',
+      'campo_obrigatorio',
+      'NF-e sem IE do emitente (contribuinte exclusivo do IBS/CBS) exige o CNPJ do emitente (C17-43, rejeição 157)',
+    );
+  }
+  if (e.IEST !== undefined) {
+    issues.add(
+      'emitente.IEST',
+      'combinacao_invalida',
+      'NF-e sem IE do emitente (contribuinte exclusivo do IBS/CBS) não leva a IE do substituto tributário (C18-50, rejeição 158)',
+    );
+  }
+  const icmsLiberado = (input.finNFe ?? '1') === '4' || input.tpNFCredito === '03';
+  input.itens.forEach((it, n) => {
+    if (!icmsLiberado) {
+      for (const [campo, grupo] of [
+        ['icms', it.impostos.icms],
+        ['icmsUfDest', it.impostos.icmsUfDest],
+      ] as const) {
+        if (grupo === undefined) continue;
+        issues.add(
+          `itens[${n}].impostos.${campo}`,
+          'grupo_vedado',
+          'NF-e sem IE do emitente (contribuinte exclusivo do IBS/CBS) não leva ICMS no item (N01-10, rejeição 161)',
+        );
+      }
+    }
+    if (it.impostos.ibsCbs === undefined) {
+      issues.add(
+        `itens[${n}].impostos.ibsCbs`,
+        'campo_obrigatorio',
+        'NF-e sem IE do emitente (contribuinte exclusivo do IBS/CBS) exige o grupo IBS/CBS em todo item (UB12-11, rejeição 162)',
+      );
+    }
+  });
+}
+
+/** Nota de crédito que aceita CFOP de devolução (NT 2025.002 v1.52, RV I08-144, exceção): 03, 04 e 06. */
+const CREDITO_COM_DEVOLUCAO: ReadonlySet<string> = new Set(['03', '04', '06']);
+
+/**
+ * CFOP de devolução (Tabela CFOP, `indDevol`) em NF-e que não é de devolução nem complementar: rejeição 328 (MOC 7.0
+ * Anexo I, RV I08-144, obrigatória no modelo 55; NT 2025.002 v1.52, que exclui a nota de crédito 03, 04 e 06). CFOP
+ * fora da tabela versionada não é recusado.
+ */
+export function cfopDeDevolucao(input: DadosNfe, issues: Issues): void {
+  const fin = input.finNFe ?? '1';
+  if (fin === '2' || fin === '4') return;
+  if (fin === '5' && input.tpNFCredito !== undefined && CREDITO_COM_DEVOLUCAO.has(input.tpNFCredito)) return;
+  input.itens.forEach((it, n) => {
+    if (indicadoresCfop(it.produto.CFOP.replace(/\D/g, ''))?.indDevol !== true) return;
+    issues.add(
+      `itens[${n}].produto.CFOP`,
+      'combinacao_invalida',
+      `CFOP ${it.produto.CFOP} é de devolução e a nota não é de devolução (finNFe ${fin}) (I08-144, rejeição 328)`,
+    );
+  });
+}
+
+/** CST aceitos com destinatário não contribuinte (RV N12-70; o 61 entrou pela NT 2023.001). */
+const CST_NAO_CONTRIBUINTE: ReadonlySet<string> = new Set(['00', '20', '40', '41', '60', '61']);
+
+/** Códigos ANP que a exceção 5 da N12-70 deixa de fora (não derivados de petróleo). */
+const ANP_FORA_DA_EXCECAO_5: ReadonlySet<string> = new Set([
+  '820101001',
+  '820101010',
+  '810102001',
+  '810102004',
+  '810102002',
+  '810102003',
+  '810101002',
+  '810101001',
+  '810101003',
+  '220101003',
+  '220101004',
+  '220101002',
+  '220101001',
+  '220101005',
+  '220101006',
+  '560101001',
+]);
+
+/** CFOP da exceção 7 da N12-70 (CST 51 em qualquer operação). */
+const CFOP_CST51: ReadonlySet<string> = new Set(['5123', '5922', '6123', '6922']);
+
+/**
+ * CST fora de 00, 20, 40, 41, 60 e 61 com destinatário não contribuinte (indIEDest 9): rejeição 508 (MOC 7.0 Anexo I,
+ * RV N12-70, obrigatória no modelo 55, no texto da NT 2023.001 v1.60 e da NT 2023.003 v1.40). Só o CST: a regra não
+ * fala do CSOSN. Ficam de fora todas as exceções:
+ *
+ * 1. NF-e de entrada; 3. nota com veículo novo (`veicProd`) em algum item; 6. CST 50 e 51 na devolução;
+ * 2. CST 50 com CFOP de retorno ou remessa (Tabela CFOP, `indRetor`, `indRemes`) ou 5949 e 6949, e com CFOP fora da
+ *    tabela versionada, que a conferência não sabe classificar;
+ * 5. CST 30 interestadual com combustível derivado de petróleo; 9. CST 30 interestadual com energia elétrica (NCM
+ *    27160000);
+ * 7. CST 51 com CFOP 5123, 5922, 6123 e 6922, e em qualquer operação interna: a NT 2023.001 diz "operações internas" e
+ *    a NT 2023.003 restringe ao retorno de depósito (5906 e 5907), e a conferência recusa só o que as duas recusam;
+ * 8. CST 10 e 02 em operação interna, a critério da UF; e o CST 90 com CFOP 5403 ou 5405 no CE (observação da NT
+ *    2023.003), também a critério da UF.
+ *
+ * A exceção 4 (emissão antes de 01/07/2016) não alcança nota montada agora.
+ */
+export function cstComNaoContribuinte(
+  input: DadosNfe,
+  contexto: { readonly idDest: string; readonly uf: string },
+  issues: Issues,
+): void {
+  if (input.destinatario?.indIEDest !== '9' || input.tpNF === '0') return;
+  if (input.itens.some((it) => it.produto.especifico !== undefined && 'veicProd' in it.produto.especifico)) return;
+  const fin = input.finNFe ?? '1';
+  const interna = contexto.idDest === '1';
+  const interestadual = contexto.idDest === '2';
+  input.itens.forEach((it, n) => {
+    const icms = it.impostos.icms;
+    if (icms === undefined || !('CST' in icms)) return;
+    const cst = icms.CST;
+    if (CST_NAO_CONTRIBUINTE.has(cst)) return;
+    const cfop = it.produto.CFOP.replace(/\D/g, '');
+    const esp = it.produto.especifico;
+    if ((cst === '50' || cst === '51') && fin === '4') return;
+    if (cst === '50') {
+      const ind = indicadoresCfop(cfop);
+      if (ind === undefined || ind.indRetor || ind.indRemes || cfop === '5949' || cfop === '6949') return;
+    }
+    if (cst === '51' && (CFOP_CST51.has(cfop) || interna)) return;
+    if ((cst === '10' || cst === '02') && interna) return;
+    if (cst === '30' && interestadual) {
+      if (esp !== undefined && 'comb' in esp && !ANP_FORA_DA_EXCECAO_5.has(esp.comb.cProdANP)) return;
+      if (it.produto.NCM.replace(/\D/g, '') === '27160000') return;
+    }
+    if (cst === '90' && contexto.uf === 'CE' && (cfop === '5403' || cfop === '5405')) return;
+    issues.add(
+      `itens[${n}].impostos.icms.CST`,
+      'combinacao_invalida',
+      `CST ${cst} não se usa com destinatário não contribuinte (indIEDest 9) (N12-70, rejeição 508)`,
+    );
+  });
+}

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

@@ -137,11 +137,13 @@ export type {
   Espera,
   EventoRegistrado,
   Inutilizacao,
+  InutilizacaoAnterior,
   InutilizacaoPedido,
   ManifestacaoPedido,
   ManifestacaoTipo,
   PoliticaRecibo,
   ProtocoloNfe,
+  RecusadoInutilizacao,
   ResultadoAutorizacao,
   ResultadoConsulta,
   ResultadoEvento,

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