@sinete/nfe 0.0.0 → 0.1.0

package/src/ports.ts

@@ -0,0 +1,96 @@
+/**
+ * Portas do `@sinete/nfe` para o que pode vir de fora. A montagem só conhece o contrato estreito declarado aqui; a
+ * implementação padrão do IBS/CBS é o `ibsCbsCalculator` (`rtc.ts`, sobre o `@sinete/ibs-cbs`), e quem calcula em outro
+ * lugar (ou testa com alíquotas fixas) injeta a sua em `BuildNfeOptions.ibsCbs`.
+ */
+
+import type { Ambiente, Uf, ValidationIssue } from '@sinete/core';
+import type { TTribNFe } from '@sinete/schemas/nfe/PL_010f';
+import type { Decimal } from './decimal.ts';
+import type { Instante } from './time.ts';
+
+/** Um item classificado, com os valores que a calculadora pode precisar para a base do IBS/CBS. */
+export interface IbsCbsItemRequest {
+  /** Número do item na nota (1 a 990). */
+  readonly nItem: number;
+  /** CST do IBS/CBS (3 dígitos). */
+  readonly CST: string;
+  /** Classificação tributária (6 dígitos). */
+  readonly cClassTrib: string;
+  readonly indDoacao?: '1';
+  readonly cCredPres?: string;
+  /**
+   * Tributação regular (`gTribRegular`, UB68): o CST e o cClassTrib que valeriam sem a suspensão, o diferimento ou a
+   * exportação do `cClassTrib` principal, quando ele exige ou permite o grupo (550001, por exemplo).
+   */
+  readonly gTribRegular?: { readonly CSTReg: string; readonly cClassTribReg: string };
+  /** Base informada por quem emite; ausente, a calculadora determina. */
+  readonly vBC?: Decimal;
+  readonly NCM: string;
+  readonly CFOP: string;
+  readonly uTrib: string;
+  readonly qTrib: Decimal;
+  readonly vProd: Decimal;
+  readonly vDesc: Decimal;
+  readonly vFrete: Decimal;
+  readonly vSeg: Decimal;
+  readonly vOutro: Decimal;
+  /** Tributos do item já calculados pelo builder (a base do IBS/CBS pode excluí-los, conforme a LC 214/2025). */
+  readonly vICMS: Decimal;
+  readonly vICMSST: Decimal;
+  readonly vFCP: Decimal;
+  readonly vFCPST: Decimal;
+  readonly vIPI: Decimal;
+  readonly vPIS: Decimal;
+  readonly vCOFINS: Decimal;
+  readonly vII: Decimal;
+  readonly vISSQN: Decimal;
+  /**
+   * ICMS e FCP de partilha do item para a UF de destino (grupo `ICMSUFDest`, DIFAL da EC 87/2015); zero sem o grupo.
+   * A base do IBS/CBS pode deduzi-los junto com o ICMS próprio.
+   */
+  readonly vICMSUFDest: Decimal;
+  readonly vFCPUFDest: Decimal;
+}
+
+/** Dados da nota que decidem a regra aplicável (local da operação, vigência, compra governamental). */
+export interface IbsCbsNotaRequest {
+  /** Instante do fato gerador (relógio `fatoGerador` do `TimeContext`): decide a vigência das alíquotas. */
+  readonly fatoGerador: Instante;
+  /** Instante da emissão (o do `dhEmi`): decide quais regras de validação da NT já estão implantadas no ambiente. */
+  readonly emissao: Instante;
+  readonly ambiente: Ambiente;
+  readonly mod: '55' | '65';
+  readonly tpNF: '0' | '1';
+  readonly finNFe: string;
+  readonly tpNFDebito?: string;
+  readonly tpNFCredito?: string;
+  readonly indFinal: '0' | '1';
+  readonly indPres: string;
+  readonly emitente: { readonly UF: Uf; readonly cMun: string; readonly CRT: string };
+  /** Local de destino da operação (entrega, destinatário ou `cMunFGIBS`, nessa ordem de precedência do leiaute). */
+  readonly destino?: { readonly UF: Uf | 'EX'; readonly cMun: string };
+  readonly cMunFGIBS?: string;
+  readonly compraGov?: { readonly tpEnteGov: string; readonly pRedutor: Decimal; readonly tpOperGov: string };
+}
+
+/** Resultado da calculadora: o grupo `IBSCBS` de cada item pedido, já na forma lexical do leiaute. */
+export interface IbsCbsResponse {
+  readonly itens: readonly { readonly nItem: number; readonly IBSCBS: TTribNFe }[];
+  /**
+   * Problemas de classificação ou de dado (`path` 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.
+   */
+  readonly issues?: readonly ValidationIssue[];
+}
+
+/**
+ * Calcula o IBS e a CBS dos itens classificados. O padrão é o `ibsCbsCalculator`, sobre o `@sinete/ibs-cbs/calcular`; nos
+ * testes, um dublê com alíquotas fixas. A calculadora não vê o XML nem o resto da nota além do que está no pedido.
+ */
+export interface IbsCbsCalculator {
+  calcular(request: {
+    readonly nota: IbsCbsNotaRequest;
+    readonly itens: readonly IbsCbsItemRequest[];
+  }): IbsCbsResponse | Promise<IbsCbsResponse>;
+}

package/src/rotulo.ts

@@ -0,0 +1,137 @@
+/**
+ * Rótulo em português do caminho de uma ocorrência da NF-e (ADR 0011), para mostrar a quem preencheu a nota: `Item 2,
+ * Descrição do produto` em vez de `itens[1].produto.xProd`. Aceita os caminhos da entrada (`NfeInput`) e os do
+ * documento montado, tanto os das conferências do montador (`infNFe.det[1].prod.xProd`) quanto os do validador de XSD
+ * (`/infNFe/det[2]/prod/xProd`).
+ */
+
+import type { GrupoDeCaminho } from '@sinete/core';
+import { criarRotuloDoCaminho } from '@sinete/core';
+
+const item =
+  (prefixo: string) =>
+  (n: number): string =>
+    `${prefixo} ${n}`;
+
+/** Do mais específico ao mais geral. Os índices chegam somados de um. */
+const GRUPOS: readonly GrupoDeCaminho[] = [
+  // Entrada (NfeInput)
+  { padrao: /^emitente\b/, rotulo: 'Emitente' },
+  { padrao: /^destinatario\b/, rotulo: 'Destinatário' },
+  { padrao: /^retirada\b/, rotulo: 'Local de retirada' },
+  { padrao: /^entrega\b/, rotulo: 'Local de entrega' },
+  { padrao: /^autXML\b/, rotulo: 'Autorizados a baixar o XML' },
+  { padrao: /^referenciadas\b/, rotulo: 'Nota referenciada' },
+  { padrao: /^itens\[(\d+)\]\.impostos\.icms\b/, rotulo: item('ICMS do item') },
+  { padrao: /^itens\[(\d+)\]\.impostos\.ibsCbs\b/, rotulo: item('IBS/CBS do item') },
+  { padrao: /^itens\[(\d+)\]\.impostos\b/, rotulo: item('Impostos do item') },
+  { padrao: /^itens\[(\d+)\]/, rotulo: item('Item') },
+  { padrao: /^itens\b/, rotulo: 'Itens' },
+  { padrao: /^transporte\b/, rotulo: 'Transporte' },
+  { padrao: /^cobranca\b/, rotulo: 'Cobrança' },
+  { padrao: /^pagamento\b/, rotulo: 'Pagamento' },
+  { padrao: /^informacoesAdicionais\b/, rotulo: 'Informações adicionais' },
+  { padrao: /^agropecuario\b/, rotulo: 'Produtos agropecuários' },
+  { padrao: /^respTec\b/, rotulo: 'Responsável técnico' },
+  { padrao: /^contingencia\b/, rotulo: 'Contingência' },
+  { padrao: /^gCompraGov\b/, rotulo: 'Compra governamental' },
+  { padrao: /^exporta\b/, rotulo: 'Exportação' },
+  // Opções da montagem da NFC-e (qrCode, urlQrCode, urlChave) e o infNFeSupl montado
+  { padrao: /^(?:qrCode|urlQrCode|urlChave)\b/, rotulo: 'QR Code da NFC-e' },
+  { padrao: /^(?:NFe\.)?infNFeSupl\b/, rotulo: 'QR Code da NFC-e' },
+  // Documento montado (infNFe)
+  { padrao: /^infNFe\.ide\.NFref\b/, rotulo: 'Nota referenciada' },
+  { padrao: /^infNFe\.ide\b/, rotulo: 'Identificação da nota' },
+  { padrao: /^infNFe\.emit\b/, rotulo: 'Emitente' },
+  { padrao: /^infNFe\.dest\b/, rotulo: 'Destinatário' },
+  { padrao: /^infNFe\.retirada\b/, rotulo: 'Local de retirada' },
+  { padrao: /^infNFe\.entrega\b/, rotulo: 'Local de entrega' },
+  { padrao: /^infNFe\.autXML\b/, rotulo: 'Autorizados a baixar o XML' },
+  { padrao: /^infNFe\.det(?:\[(\d+)\])?\.imposto\.ICMS\b/, rotulo: item('ICMS do item') },
+  { padrao: /^infNFe\.det(?:\[(\d+)\])?\.imposto\.IBSCBS\b/, rotulo: item('IBS/CBS do item') },
+  { padrao: /^infNFe\.det(?:\[(\d+)\])?\.imposto\b/, rotulo: item('Impostos do item') },
+  { padrao: /^infNFe\.det(?:\[(\d+)\])?/, rotulo: item('Item') },
+  { padrao: /^infNFe\.total\b/, rotulo: 'Totais da nota' },
+  { padrao: /^infNFe\.transp\b/, rotulo: 'Transporte' },
+  { padrao: /^infNFe\.cobr\b/, rotulo: 'Cobrança' },
+  { padrao: /^infNFe\.pag\b/, rotulo: 'Pagamento' },
+  { padrao: /^infNFe\.infAdic\b/, rotulo: 'Informações adicionais' },
+  { padrao: /^infNFe\.agropecuario\b/, rotulo: 'Produtos agropecuários' },
+  { padrao: /^infNFe\.infRespTec\b/, rotulo: 'Responsável técnico' },
+  { padrao: /^infNFe\.exporta\b/, rotulo: 'Exportação' },
+];
+
+/** Campos pelo nome do leiaute (os mesmos na entrada e no XML). */
+const CAMPOS: Readonly<Record<string, string>> = {
+  IE: 'Inscrição estadual',
+  IEST: 'Inscrição estadual do substituto tributário',
+  IM: 'Inscrição municipal',
+  CNPJ: 'CNPJ',
+  CPF: 'CPF',
+  idEstrangeiro: 'Identificação do estrangeiro',
+  xNome: 'Nome',
+  xFant: 'Nome fantasia',
+  xLgr: 'Logradouro',
+  nro: 'Número',
+  xCpl: 'Complemento',
+  xBairro: 'Bairro',
+  cMun: 'Município',
+  xMun: 'Município',
+  UF: 'UF',
+  CEP: 'CEP',
+  fone: 'Telefone',
+  email: 'E-mail',
+  natOp: 'Natureza da operação',
+  serie: 'Série',
+  nNF: 'Número da nota',
+  cProd: 'Código do produto',
+  cEAN: 'GTIN',
+  cEANTrib: 'GTIN da unidade tributável',
+  xProd: 'Descrição do produto',
+  NCM: 'NCM',
+  CEST: 'CEST',
+  cBenef: 'Código de benefício fiscal',
+  CFOP: 'CFOP',
+  uCom: 'Unidade comercial',
+  qCom: 'Quantidade comercial',
+  vUnCom: 'Valor unitário comercial',
+  uTrib: 'Unidade tributável',
+  qTrib: 'Quantidade tributável',
+  vUnTrib: 'Valor unitário tributável',
+  vProd: 'Valor do produto',
+  vDesc: 'Desconto',
+  vFrete: 'Frete',
+  vSeg: 'Seguro',
+  vOutro: 'Outras despesas',
+  CST: 'CST',
+  CSOSN: 'CSOSN',
+  cClassTrib: 'Classificação tributária (cClassTrib)',
+  vBC: 'Base de cálculo',
+  refNFe: 'Chave da NF-e referenciada',
+  refNFP: 'Nota de produtor referenciada',
+  AAMM: 'Mês de emissão da nota referenciada',
+  modFrete: 'Modalidade do frete',
+  placa: 'Placa',
+  RNTC: 'RNTC',
+  tPag: 'Meio de pagamento',
+  vPag: 'Valor do pagamento',
+  vTroco: 'Troco',
+  card: 'Cartão',
+  CSC: 'CSC',
+  idCSC: 'Identificador do CSC',
+  versao: 'Versão',
+  xJust: 'Justificativa',
+  dhCont: 'Entrada em contingência',
+  infCpl: 'Informações complementares',
+  infAdFisco: 'Informações de interesse do fisco',
+};
+
+const rotular = criarRotuloDoCaminho({ grupos: GRUPOS, campos: CAMPOS, padrao: 'Dados da NF-e' });
+
+/**
+ * Rótulo em português do caminho de uma ocorrência da NF-e: `Grupo, Campo` quando os dois são conhecidos (`Emitente,
+ * Inscrição estadual`), só um deles quando falta o outro, e `Dados da NF-e` quando nenhum é.
+ */
+export function rotuloDoCaminho(path: string): string {
+  return rotular(path);
+}

package/src/rtc.ts

@@ -0,0 +1,305 @@
+/**
+ * A calculadora padrão de IBS/CBS do `buildNfe`: a porta `IbsCbsCalculator` implementada sobre o motor do sinete.
+ *
+ * Para cada item classificado, monta a operação do `@sinete/ibs-cbs/calcular` (CST, cClassTrib, base, local da operação,
+ * compra governamental), calcula com o dataset do `@sinete/ibs-cbs-dados` e as alíquotas do `@sinete/ibs-cbs/aliquotas`, confere o
+ * resultado pelas regras da NT 2025.002 do `@sinete/ibs-cbs/validar` e devolve o grupo `IBSCBS` de cada item na forma
+ * lexical do leiaute. Erro de classificação, regime não suportado, alíquota desconhecida e violação de regra voltam
+ * como ocorrências (`ValidationIssue`) no caminho do item: a nota não é montada, e nunca sai valor zerado no lugar.
+ *
+ * O dataset embarcado (~2 MB de JSON) só é importado na primeira nota com item classificado, por `import()` dinâmico:
+ * quem usa o pacote para ler XML, eventos ou Distribuição DF-e não o carrega, e um bundler com code splitting o põe num
+ * chunk à parte.
+ */
+
+import type { ValidationIssue } from '@sinete/core';
+import { fixedClock, isUf, timeContext, ufByCUf } from '@sinete/core';
+import type { RateProvider } from '@sinete/ibs-cbs/aliquotas';
+import { officialRates, RateUnknownError } from '@sinete/ibs-cbs/aliquotas';
+import type {
+  ClassifiedItem,
+  ClassifiedOperation,
+  IBSCBS,
+  OperationPlace,
+  Roc,
+  TpEnteGov,
+} from '@sinete/ibs-cbs/calcular';
+import { ClassificationError, calculate, UnsupportedRegimeError } from '@sinete/ibs-cbs/calcular';
+import type { Rule } from '@sinete/ibs-cbs/validar';
+import { documentFromRoc, validate } from '@sinete/ibs-cbs/validar';
+import type { IbsCbsDataset } from '@sinete/ibs-cbs-dados';
+import type { IbsCbsCalculator, IbsCbsItemRequest, IbsCbsNotaRequest, IbsCbsResponse } from './ports.ts';
+
+/** Grupo `IBSCBS` do item, como o `@sinete/nfe` o recebe. */
+export type GrupoIbsCbs = IbsCbsResponse['itens'][number]['IBSCBS'];
+
+export interface IbsCbsCalculatorOptions {
+  /**
+   * Dataset do IBS/CBS. Padrão: o embarcado no `@sinete/ibs-cbs-dados`, importado sob demanda na primeira nota
+   * (`carregarDatasetEmbarcado`). Informe um bundle verificado em runtime (`verifyDataset`) para usar dados de outra
+   * origem, ou o `bundledDataset()` já carregado para o cálculo ser síncrono.
+   */
+  readonly dataset?: IbsCbsDataset;
+  /** Alíquotas. Padrão: `officialRates()` do `@sinete/ibs-cbs/aliquotas`; troque por um provedor com alíquotas informadas. */
+  readonly rates?: RateProvider;
+  /**
+   * Base do IBS/CBS do item que não trouxe `vBC`, em texto com até 2 casas. A composição da base (NT 2025.002, UB16-10)
+   * ainda é "implementação futura, aguardando orientação normativa": sem esta função, item sem `vBC` vira ocorrência
+   * `ibscbs_base_ausente` em vez de uma base presumida.
+   */
+  readonly base?: (item: IbsCbsItemRequest, nota: IbsCbsNotaRequest) => string;
+  /**
+   * Regras da NT 2025.002 conferidas sobre os grupos produzidos (`@sinete/ibs-cbs/validar`). Padrão: as implantadas na data
+   * de emissão e no ambiente. `false` desliga; `{ rules }` troca a lista.
+   */
+  readonly regras?: false | { readonly rules?: readonly Rule[]; readonly ignoreActivation?: boolean };
+  /** Fuso do local da operação para a data civil do fato gerador, em minutos. Padrão: Brasília (-180). */
+  readonly utcOffsetMinutes?: number;
+}
+
+const BASE = /^\d{1,13}(\.\d{1,2})?$/;
+
+/** Texto decimal sem zeros à direita, para comparar valores com escalas diferentes (`'0.00'` e `'0'`). */
+function normalizado(v: string): string {
+  const [int = '0', frac = ''] = v.split('.');
+  const f = frac.replace(/0+$/, '');
+  const i = int.replace(/^0+(?=\d)/, '');
+  return f === '' ? i : `${i}.${f}`;
+}
+
+const caminho = (nItem: number): string => `itens[${nItem - 1}].impostos.ibsCbs`;
+
+/** UF do município pelo código IBGE (os dois primeiros dígitos são o cUF). */
+function ufDoMunicipio(cMun: string): string | undefined {
+  return ufByCUf(cMun.slice(0, 2))?.sigla;
+}
+
+/**
+ * Local da operação para as alíquotas próprias de UF e município: o `cMunFGIBS` informado (campo B12a da NT
+ * 2025.002, município de ocorrência do fato gerador do IBS/CBS), senão o destino da mercadoria (entrega ou
+ * destinatário, pela LC 214/2025, art. 11, o local da entrega), senão o emitente. Destino no exterior cai no emitente.
+ */
+export function localDaOperacao(nota: IbsCbsNotaRequest): OperationPlace {
+  if (nota.cMunFGIBS !== undefined) {
+    const uf = ufDoMunicipio(nota.cMunFGIBS);
+    if (uf !== undefined) return { uf, cMun: nota.cMunFGIBS };
+  }
+  const d = nota.destino;
+  if (d !== undefined && d.UF !== 'EX' && isUf(d.UF)) return { uf: d.UF, cMun: d.cMun };
+  return { uf: nota.emitente.UF, cMun: nota.emitente.cMun };
+}
+
+/** Converte o grupo do motor para o do leiaute: os códigos numéricos do motor viram texto. */
+function grupoDoLeiaute(g: IBSCBS, indDoacao: '1' | undefined): GrupoIbsCbs {
+  const { gCredPresOper, gCredPresIBSZFM, ...resto } = g;
+  return {
+    ...resto,
+    ...(indDoacao === undefined ? {} : { indDoacao }),
+    ...(gCredPresOper === undefined
+      ? {}
+      : { gCredPresOper: { ...gCredPresOper, cCredPres: String(gCredPresOper.cCredPres).padStart(2, '0') } }),
+    ...(gCredPresIBSZFM === undefined
+      ? {}
+      : {
+          gCredPresIBSZFM: {
+            ...gCredPresIBSZFM,
+            tpCredPresIBSZFM: String(gCredPresIBSZFM.tpCredPresIBSZFM),
+          },
+        }),
+  } 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 IbsCbsItemRequest[]): ValidationIssue | undefined {
+  if (e instanceof ClassificationError || e instanceof UnsupportedRegimeError) {
+    const path = e.item !== undefined ? caminho(e.item) : caminho(itens[0]?.nItem ?? 1);
+    return { path, code: e.code, message: 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 RateUnknownError)
+    return { path: 'impostos.ibsCbs', code: e.code, message: e.message, origem: 'montagem' };
+  return undefined;
+}
+
+let embarcado: Promise<IbsCbsDataset> | undefined;
+
+/**
+ * O dataset embarcado no `@sinete/ibs-cbs-dados`, importado sob demanda (`import()` dinâmico) e carregado uma vez por
+ * processo. É o que a calculadora padrão usa quando `dataset` não é informado; chamar antes só adianta a carga. Se o
+ * import falhar, a próxima chamada tenta de novo.
+ */
+export function carregarDatasetEmbarcado(): Promise<IbsCbsDataset> {
+  embarcado ??= import('@sinete/ibs-cbs-dados/bundled').then(
+    (m) => m.bundledDataset(),
+    (e: unknown) => {
+      embarcado = undefined;
+      throw e;
+    },
+  );
+  return embarcado;
+}
+
+/**
+ * Cria a calculadora de IBS/CBS sobre o motor do sinete. O `buildNfe` usa uma com as opções padrão quando
+ * `options.ibsCbs` não é informado; crie a sua para trocar dataset, alíquotas, base ou regras. Com `dataset` informado
+ * o cálculo é síncrono; sem ele, a primeira chamada espera o import do dataset embarcado.
+ */
+export function ibsCbsCalculator(options: IbsCbsCalculatorOptions = {}): IbsCbsCalculator {
+  const rates = options.rates ?? officialRates();
+  const dataset = options.dataset;
+  return {
+    calcular(request: {
+      readonly nota: IbsCbsNotaRequest;
+      readonly itens: readonly IbsCbsItemRequest[];
+    }): IbsCbsResponse | Promise<IbsCbsResponse> {
+      if (dataset !== undefined) return calcularCom(dataset, rates, options, request);
+      return carregarDatasetEmbarcado().then((ds) => calcularCom(ds, rates, options, request));
+    },
+  };
+}
+
+function calcularCom(
+  dataset: IbsCbsDataset,
+  rates: RateProvider,
+  options: IbsCbsCalculatorOptions,
+  {
+    nota,
+    itens,
+  }: {
+    readonly nota: IbsCbsNotaRequest;
+    readonly itens: readonly IbsCbsItemRequest[];
+  },
+): IbsCbsResponse {
+  const issues: ValidationIssue[] = [];
+  const classificados: ClassifiedItem[] = [];
+  for (const it of itens) {
+    if (it.cCredPres !== undefined) {
+      // O crédito presumido pede os percentuais por tributo (pCredPres), que a porta não traz.
+      issues.push({
+        path: caminho(it.nItem),
+        code: 'ibscbs_nao_suportado',
+        message: 'crédito presumido (cCredPres) precisa do grupo gCredPresOper pronto (ibsCbs.grupo)',
+        origem: 'entrada',
+      });
+      continue;
+    }
+    const base = it.vBC !== undefined ? it.vBC.toFixed(2) : options.base?.(it, nota);
+    if (base === undefined) {
+      issues.push({
+        path: `${caminho(it.nItem)}.classificacao.vBC`,
+        code: 'ibscbs_base_ausente',
+        message:
+          'informe vBC do IBS/CBS ou IbsCbsCalculatorOptions.base: a composição da base (UB16-10) ainda não tem regra publicada',
+        origem: 'entrada',
+      });
+      continue;
+    }
+    if (!BASE.test(base)) {
+      // Da entrada quando é o vBC do item; da montagem quando veio da função `base` das opções.
+      issues.push({
+        path: `${caminho(it.nItem)}.classificacao.vBC`,
+        code: 'decimal_invalido',
+        message: base,
+        origem: it.vBC !== undefined ? 'entrada' : 'montagem',
+      });
+      continue;
+    }
+    classificados.push({
+      n: it.nItem,
+      cst: it.CST,
+      cClassTrib: it.cClassTrib,
+      base,
+      quantity: it.qTrib.toString(),
+      unit: it.uTrib,
+      ...(it.gTribRegular === undefined
+        ? {}
+        : { regular: { cst: it.gTribRegular.CSTReg, cClassTrib: it.gTribRegular.cClassTribReg } }),
+    });
+  }
+  if (issues.length > 0) return { itens: [], issues };
+
+  const op: ClassifiedOperation = {
+    modelo: Number(nota.mod),
+    place: localDaOperacao(nota),
+    ...(nota.compraGov === undefined
+      ? {}
+      : {
+          governmentPurchase: {
+            tpEnteGov: Number(nota.compraGov.tpEnteGov) as TpEnteGov,
+            ...(nota.compraGov.tpOperGov === '1' || nota.compraGov.tpOperGov === '2'
+              ? { tpOperGov: Number(nota.compraGov.tpOperGov) as 1 | 2 }
+              : {}),
+          },
+        }),
+    items: classificados,
+  };
+  const time = timeContext({ emissao: fixedClock(nota.emissao), fatoGerador: fixedClock(nota.fatoGerador) });
+  let roc: Roc;
+  try {
+    roc = calculate(op, {
+      dataset,
+      rates,
+      time,
+      ...(options.utcOffsetMinutes === undefined ? {} : { utcOffsetMinutes: options.utcOffsetMinutes }),
+    });
+  } catch (e) {
+    const issue = ocorrenciaDoMotor(e, itens);
+    if (issue === undefined) throw e;
+    return { itens: [], issues: [issue] };
+  }
+
+  // O redutor da compra governamental vai no ide.gCompraGov como a nota informou, mas o motor calcula com o do
+  // dataset: se diferirem, os valores do item não fechariam com o cabeçalho emitido.
+  const redutor = roc.oper?.gCompraGov.pRedutor;
+  if (
+    nota.compraGov !== undefined &&
+    redutor !== undefined &&
+    normalizado(nota.compraGov.pRedutor.toString()) !== normalizado(redutor)
+  ) {
+    issues.push({
+      path: 'gCompraGov.pRedutor',
+      code: 'ibscbs_redutor_divergente',
+      message: `pRedutor informado (${nota.compraGov.pRedutor.toString()}) difere do vigente no fato gerador (${redutor})`,
+      origem: 'entrada',
+    });
+  }
+
+  if (options.regras !== false) {
+    const doc = documentFromRoc(roc, {
+      modelo: op.modelo as 55 | 65,
+      crt: Number(nota.emitente.CRT) as 1 | 2 | 3 | 4,
+      finNFe: Number(nota.finNFe) as 1 | 2 | 3 | 4 | 5 | 6,
+      ...(nota.tpNFDebito === undefined ? {} : { tpNFDebito: nota.tpNFDebito }),
+      ...(nota.tpNFCredito === undefined ? {} : { tpNFCredito: nota.tpNFCredito }),
+      emitMun: nota.emitente.cMun,
+      ...(nota.destino === undefined ? {} : { destMun: nota.destino.cMun }),
+      items: itens.map((it) => ({ nItem: it.nItem, ncm: it.NCM, vProd: it.vProd.toFixed(2) })),
+    });
+    const report = validate(doc, {
+      dataset,
+      time,
+      ambiente: nota.ambiente,
+      rates,
+      ...(options.utcOffsetMinutes === undefined ? {} : { utcOffsetMinutes: options.utcOffsetMinutes }),
+      ...(options.regras?.rules === undefined ? {} : { rules: options.regras.rules }),
+      ...(options.regras?.ignoreActivation === undefined ? {} : { ignoreActivation: options.regras.ignoreActivation }),
+    });
+    for (const v of report.violations) {
+      issues.push({
+        path: v.item === undefined ? 'total.IBSCBSTot' : caminho(v.item),
+        code: 'ibscbs_regra_nt',
+        message: `${v.rule} (rejeição ${v.cStat}): ${v.message} [${v.source}]`,
+        origem: 'montagem',
+      });
+    }
+  }
+
+  const porItem = new Map(itens.map((it) => [it.nItem, it]));
+  return {
+    itens: roc.items.map((r) => ({
+      nItem: r.nItem,
+      IBSCBS: grupoDoLeiaute(r.IBSCBS, porItem.get(r.nItem)?.indDoacao),
+    })),
+    ...(issues.length === 0 ? {} : { issues }),
+  };
+}