@sinete/nfe 0.0.0 → 0.2.0

package/dist/index.js

@@ -0,0 +1,4399 @@
+// packages/nfe/src/build/build.ts
+import {
+  ErroDeConfiguracao as ErroDeConfiguracao2,
+  ErroDeValidacao,
+  ehUf as ehUf2,
+  formatarVerProc,
+  relogioFixo as relogioFixo2,
+  tpAmbDoAmbiente as tpAmbDoAmbiente2,
+  ufPorSigla as ufPorSigla2
+} from "@sinete/core";
+import { assinarXml, codificarBase64 as codificarBase642, lerXml as lerXml3, primeiroFilho as primeiroFilho3 } from "@sinete/core/xml";
+import { ErroSerializacao, serializar as serializar2, validar as validar3 } from "@sinete/schemas";
+import { TIS as TISCt, TNFe_infNFeSupl, TTribNFe as TTribNFeCt } from "@sinete/schemas/nfe/PL_010f";
+import { lerChaveAcesso, lerCnpj as lerCnpj3, lerCpf, lerIe, montarChaveAcesso } from "@sinete/validators";
+// packages/nfe/src/data/arredondamento.json
+var arredondamento_default = {
+  descricao: "Modo de arredondamento dos valores calculados pelo builder, por família de campo. HALF_UP é o arredondamento comercial; HALF_EVEN é o bancário (NBR 5891). Quem emite pode sobrepor por família em MontarNfeOpcoes.arredondamento.",
+  atualizadoEm: "2026-09-26",
+  familias: {
+    produto: {
+      modo: "HALF_UP",
+      fonte: "MOC 7.0 Anexo I, nota (*4): o produto de multiplicações arredonda em 2 casas, com tolerância de R$ 0,01; o modo não é fixado. vProd = qCom x vUnCom (I11)."
+    },
+    icms: {
+      modo: "HALF_UP",
+      fonte: "MOC 7.0 Anexo I, nota (*4) das regras N17, N16a, N16c, N23d: 2 casas, tolerância de R$ 0,01, modo não fixado."
+    },
+    ipi: {
+      modo: "HALF_UP",
+      fonte: "MOC 7.0 Anexo I, nota (*4): 2 casas, tolerância de R$ 0,01."
+    },
+    pisCofins: {
+      modo: "HALF_UP",
+      fonte: "MOC 7.0 Anexo I, nota (*4): 2 casas, tolerância de R$ 0,01."
+    },
+    issqn: {
+      modo: "HALF_UP",
+      fonte: "MOC 7.0 Anexo I, nota (*4): 2 casas, tolerância de R$ 0,01."
+    },
+    ibsCbs: {
+      modo: "HALF_EVEN",
+      fonte: "NT 2025.002 v1.51, RV UB35-10 e seguintes (tolerância de 0,01) e ADR 0007 (a Calculadora da RFB arredonda em HALF_EVEN)."
+    }
+  }
+};
+// packages/nfe/src/data/produtor-rural.json
+var produtor_rural_default = {
+  descricao: "Regras do produtor rural que variam no tempo ou por UF. refNFP: a nota fiscal de produtor em papel (modelo 04) foi extinta; uma NF-e ainda pode referenciar uma nota modelo 04 emitida antes do fim da vigência na UF da nota referenciada. vedadaDesde é o primeiro AAMM em que a UF não aceita mais nota modelo 04 emitida; a referência a nota com AAMM igual ou posterior é recusada pelo builder. series: faixas de série por tipo de emitente na emissão pelo contribuinte (procEmi 0, a única que o montarNfe monta).",
+  atualizadoEm: "2026-09-28",
+  refNFP: {
+    modelo04: {
+      vedadaDesde: "2601",
+      fonte: "Ajuste SINIEF 10/2022 (extinção da nota fiscal de produtor modelo 4, com prazos prorrogados até 05/01/2026) e avisos das SEFAZ (RS e SP: fim do talão em 05/01/2026)."
+    },
+    ufs: {}
+  },
+  series: {
+    cpf: [920, 969],
+    fonte: "MOC 7.0 Anexo I, RV B07 e BA02-30: séries 920 a 969 reservadas à NF-e emitida por pessoa física (CPF).",
+    cnpj: [0, 889],
+    fonteCnpj: "MOC 7.0 Anexo I, RV C02-30 (emitente CNPJ: séries 0 a 909, rejeição 503) e B26-10 (emissão pelo contribuinte, procEmi 0: séries 0 a 889 ou 920 a 969, rejeição 244): as duas juntas deixam 0 a 889. A NT 2026.001 v1.02b (PAA, produção em 05/10/2026) abre 980 a 989 na C02-30 e mantém a B26-10, então a faixa continua 0 a 889."
+  }
+};
+// packages/nfe/src/data/reforma.json
+var reforma_default = {
+  descricao: "Parâmetros da reforma tributária no total do item e da nota. vItemSomaTributosDesde: a partir desta data do fato gerador (Brasília), vItem soma vIBS, vCBS, vIS e os totais monofásicos; antes dela, não soma (exceção de 2025 e 2026).",
+  atualizadoEm: "2026-09-26",
+  vItemSomaTributosDesde: "2027-01-01",
+  fonte: "NT 2025.002 v1.51, RV VB01-10 e VB01-20, Exceção 1: em 2025 e 2026 não somar vIBS, vCBS, vIS, vTotIBSMonoItem e vTotCBSMonoItem."
+};
+// packages/nfe/src/data/resp-tec.json
+var resp_tec_default = {
+  descricao: "Exigência do grupo infRespTec e do CSRT por UF do emitente, com vigência por ambiente. infRespTec: 'obrigatorio' faz o builder recusar a nota sem responsável técnico; 'opcional' só o inclui quando informado. csrt: 'obrigatorio' exige idCSRT e hashCSRT (rejeição 975). Datas no formato AAAA-MM-DD, a partir de 00:00 de Brasília. UF ausente usa o padrão. A adesão é de cada UF (NT 2018.005); quem emite pode sobrepor em MontarNfeOpcoes.",
+  atualizadoEm: "2026-09-26",
+  fonte: "NT 2018.005 v1.50 (responsável técnico e CSRT, adesão a critério da UF)",
+  padrao: { infRespTec: "opcional", csrt: "opcional" },
+  ufs: {
+    PR: {
+      csrt: { homologacao: "2025-03-02", producao: "2025-09-15" },
+      infRespTec: { homologacao: "2025-03-02", producao: "2025-09-15" },
+      fonte: "SEFAZ-PR, NT 2018.005 v1.50: CSRT obrigatório na NF-e em homologação desde 02/03/2025 e em produção desde 15/09/2025 (aviso da SEFAZ-PR, reproduzido em https://inventti.com.br/nf-e-nfc-e-nt-2018-005-versao-1-50-prorroga-regras-de-validacao-para-uf-do-parana/)."
+    }
+  }
+};
+
+// packages/nfe/src/decimal.ts
+import { ErroDeConfiguracao } from "@sinete/core";
+var DECIMAL_TEXT = /^([+-])?(\d+)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$|^([+-])?\.(\d+)(?:[eE]([+-]?\d+))?$/;
+var MAX_SCALE = 64;
+function pow10(n) {
+  return 10n ** BigInt(n);
+}
+
+class Decimal {
+  coef;
+  scale;
+  constructor(coef, scale) {
+    this.coef = coef;
+    this.scale = scale;
+  }
+  static ZERO = new Decimal(0n, 0);
+  static ONE = new Decimal(1n, 0);
+  static HUNDRED = new Decimal(100n, 0);
+  static fromParts(coef, scale) {
+    if (!Number.isInteger(scale) || scale < 0 || scale > MAX_SCALE)
+      throw new ErroDeConfiguracao(`escala inválida: ${scale}`);
+    return new Decimal(coef, scale);
+  }
+  static of(input) {
+    const d = Decimal.tryOf(input);
+    if (d === undefined)
+      throw new ErroDeConfiguracao(`número decimal inválido: ${JSON.stringify(String(input))}`);
+    return d;
+  }
+  static tryOf(input) {
+    if (input instanceof Decimal)
+      return input;
+    if (typeof input === "bigint")
+      return new Decimal(input, 0);
+    if (typeof input === "number") {
+      if (!Number.isFinite(input))
+        return;
+      return Decimal.tryOf(String(input));
+    }
+    if (typeof input !== "string")
+      return;
+    const m = DECIMAL_TEXT.exec(input);
+    if (!m)
+      return;
+    const sign = (m[1] ?? m[5]) === "-" ? -1n : 1n;
+    const intPart = m[2] ?? "";
+    const frac = m[3] ?? m[6] ?? "";
+    const exp = Number(m[4] ?? m[7] ?? "0");
+    if (!Number.isSafeInteger(exp) || Math.abs(exp) > MAX_SCALE)
+      return;
+    let coef = BigInt(`${intPart}${frac}` || "0") * sign;
+    let scale = frac.length - exp;
+    if (scale < 0) {
+      coef *= pow10(-scale);
+      scale = 0;
+    }
+    if (scale > MAX_SCALE)
+      return;
+    return new Decimal(coef, scale);
+  }
+  aligned(other) {
+    if (this.scale === other.scale)
+      return [this.coef, other.coef, this.scale];
+    if (this.scale > other.scale)
+      return [this.coef, other.coef * pow10(this.scale - other.scale), this.scale];
+    return [this.coef * pow10(other.scale - this.scale), other.coef, other.scale];
+  }
+  plus(other) {
+    const [a, b, s] = this.aligned(Decimal.of(other));
+    return new Decimal(a + b, s);
+  }
+  minus(other) {
+    const [a, b, s] = this.aligned(Decimal.of(other));
+    return new Decimal(a - b, s);
+  }
+  times(other) {
+    const o = Decimal.of(other);
+    const scale = this.scale + o.scale;
+    if (scale > MAX_SCALE) {
+      return new Decimal(this.coef * o.coef, scale).round(MAX_SCALE, "HALF_EVEN");
+    }
+    return new Decimal(this.coef * o.coef, scale);
+  }
+  dividedBy(other, scale, mode) {
+    const o = Decimal.of(other);
+    if (o.coef === 0n)
+      throw new ErroDeConfiguracao("divisão por zero");
+    const shift = o.scale + scale + 1 - this.scale;
+    const num = shift >= 0 ? this.coef * pow10(shift) : this.coef;
+    const den = shift >= 0 ? o.coef : o.coef * pow10(-shift);
+    const q = num / den;
+    const exact = q * den === num;
+    return roundCoef(q, scale + 1, scale, mode, !exact);
+  }
+  percent(rate) {
+    const product = this.times(rate);
+    return new Decimal(product.coef, product.scale + 2);
+  }
+  negate() {
+    return new Decimal(-this.coef, this.scale);
+  }
+  abs() {
+    return this.coef < 0n ? this.negate() : this;
+  }
+  round(scale, mode) {
+    if (!Number.isInteger(scale) || scale < 0)
+      throw new ErroDeConfiguracao(`casas decimais inválidas: ${scale}`);
+    if (scale >= this.scale)
+      return new Decimal(this.coef * pow10(scale - this.scale), scale);
+    return roundCoef(this.coef, this.scale, scale, mode, false);
+  }
+  compare(other) {
+    const [a, b] = this.aligned(Decimal.of(other));
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  eq(other) {
+    return this.compare(other) === 0;
+  }
+  lt(other) {
+    return this.compare(other) < 0;
+  }
+  gt(other) {
+    return this.compare(other) > 0;
+  }
+  isZero() {
+    return this.coef === 0n;
+  }
+  isNegative() {
+    return this.coef < 0n;
+  }
+  significantScale() {
+    if (this.coef === 0n)
+      return 0;
+    let c = this.coef;
+    let s = this.scale;
+    while (s > 0 && c % 10n === 0n) {
+      c /= 10n;
+      s--;
+    }
+    return s;
+  }
+  toFixed(scale, mode = "HALF_UP") {
+    const r = this.round(scale, mode);
+    const neg = r.coef < 0n;
+    const digits = (neg ? -r.coef : r.coef).toString().padStart(scale + 1, "0");
+    const int = digits.slice(0, digits.length - scale);
+    const frac = digits.slice(digits.length - scale);
+    return `${neg ? "-" : ""}${int}${scale > 0 ? `.${frac}` : ""}`;
+  }
+  toString() {
+    return this.toFixed(this.significantScale());
+  }
+  toJSON() {
+    return this.toString();
+  }
+}
+function roundCoef(coef, from, to, mode, sticky) {
+  const div = pow10(from - to);
+  const neg = coef < 0n;
+  const abs = neg ? -coef : coef;
+  let q = abs / div;
+  const r = abs % div;
+  if (mode !== "DOWN" && (r !== 0n || sticky)) {
+    const twice = r * 2n;
+    const above = twice > div || twice === div && sticky;
+    const tie = twice === div && !sticky;
+    if (above || tie && (mode === "HALF_UP" || mode === "HALF_EVEN" && q % 2n === 1n))
+      q += 1n;
+  }
+  return Decimal.fromParts(neg ? -q : q, to);
+}
+function dec(valor) {
+  return Decimal.of(valor);
+}
+function sum(valores) {
+  let acc = Decimal.ZERO;
+  for (const v of valores)
+    acc = acc.plus(v);
+  return acc;
+}
+
+// packages/nfe/src/format.ts
+var D1302 = { nome: "TDec_1302", min: 2, max: 2, digitosInteiros: 13 };
+var D1302_OPC = { nome: "TDec_1302Opc", min: 2, max: 2, digitosInteiros: 13, naoNulo: true };
+var D0302A04 = { nome: "TDec_0302a04", min: 2, max: 4, digitosInteiros: 3 };
+var D0302A04_OPC = { nome: "TDec_0302a04Opc", min: 2, max: 4, digitosInteiros: 3 };
+var D0302 = { nome: "TDec_0302Max100", min: 2, max: 2, digitosInteiros: 3 };
+var D1104V = { nome: "TDec_1104v", min: 0, max: 4, digitosInteiros: 11 };
+var D1104 = { nome: "TDec_1104", min: 4, max: 4, digitosInteiros: 11 };
+var D1110V = { nome: "TDec_1110v", min: 0, max: 10, digitosInteiros: 11 };
+var D1204V = { nome: "TDec_1204v", min: 0, max: 4, digitosInteiros: 12 };
+var D1204 = { nome: "TDec_1204", min: 4, max: 4, digitosInteiros: 12 };
+var D1203 = { nome: "TDec_1203", min: 3, max: 3, digitosInteiros: 12 };
+function formatarDecimal(valor, formato, modo = "HALF_UP") {
+  const r = valor.round(formato.max, modo);
+  let places = Math.max(formato.min, Math.min(formato.max, r.significantScale()));
+  if (formato.minimoAbaixoDeUm !== undefined && !r.isZero() && r.abs().lt(1))
+    places = Math.max(places, formato.minimoAbaixoDeUm);
+  return r.toFixed(places, modo);
+}
+function problemaDeFormato(valor, formato) {
+  if (valor.isNegative())
+    return "valor negativo";
+  if (formato.naoNulo && valor.isZero())
+    return "valor zero não é aceito neste campo";
+  if (valor.significantScale() > formato.max)
+    return `mais de ${formato.max} casas decimais`;
+  const intDigits = valor.round(0, "DOWN").abs().toString().replace(/^0$/, "").length;
+  if (intDigits > formato.digitosInteiros)
+    return `mais de ${formato.digitosInteiros} dígitos inteiros`;
+  return;
+}
+
+// packages/nfe/src/issues.ts
+var CODIGOS_OCORRENCIA_NFE = [
+  "campo_obrigatorio",
+  "campo_invalido",
+  "campo_fora_do_pl",
+  "decimal_invalido",
+  "valor_divergente",
+  "combinacao_invalida",
+  "modelo_nao_suportado",
+  "serie_invalida",
+  "documento_invalido",
+  "ie_invalida",
+  "chave_invalida",
+  "referencia_vedada",
+  "resp_tec_obrigatorio",
+  "csrt_obrigatorio",
+  "ibscbs_calculo",
+  "ibscbs_base_ausente",
+  "ibscbs_nao_suportado",
+  "ibscbs_redutor_divergente",
+  "ibscbs_regra_nt",
+  "totais_divergentes",
+  "itens_limite",
+  "contingencia_invalida",
+  "pagamento_igual_total",
+  "emitente_difere_do_certificado",
+  "grupo_vedado",
+  "pagamento_invalido",
+  "qrcode_invalido",
+  "schema"
+];
+
+class Issues {
+  list;
+  constructor() {
+    this.list = [];
+  }
+  add(path, code, message, origem = "entrada") {
+    this.list.push({ caminho: path, code, mensagem: message, origem });
+  }
+  montagem(path, code, message) {
+    this.add(path, code, message, "montagem");
+  }
+  get classificadas() {
+    return this.list.map((i) => i.origem === undefined ? { ...i, origem: "entrada" } : i);
+  }
+  addAll(issues, origem = "entrada") {
+    this.list.push(...issues.map((i) => i.origem === undefined ? { ...i, origem } : i));
+  }
+  reclassificarDesde(inicio, origem) {
+    for (let k = inicio;k < this.list.length; k++) {
+      const i = this.list[k];
+      if (i !== undefined)
+        this.list[k] = { ...i, origem };
+    }
+  }
+  get empty() {
+    return this.list.length === 0;
+  }
+}
+
+// packages/nfe/src/rtc.ts
+import { contextoDeTempo, ehUf, relogioFixo, ufPorCUf } from "@sinete/core";
+import { aliquotasOficiais, ErroAliquotaDesconhecida } from "@sinete/ibs-cbs/aliquotas";
+import { calcular, ErroClassificacao, ErroRegimeNaoSuportado } from "@sinete/ibs-cbs/calcular";
+import { documentoDoRoc, validar } from "@sinete/ibs-cbs/validar";
+var BASE = /^\d{1,13}(\.\d{1,2})?$/;
+function normalizado(v) {
+  const [int = "0", frac = ""] = v.split(".");
+  const f = frac.replace(/0+$/, "");
+  const i = int.replace(/^0+(?=\d)/, "");
+  return f === "" ? i : `${i}.${f}`;
+}
+var caminho = (nItem) => `itens[${nItem - 1}].impostos.ibsCbs`;
+function ufDoMunicipio(cMun) {
+  return ufPorCUf(cMun.slice(0, 2))?.sigla;
+}
+function localDaOperacao(nota) {
+  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" && ehUf(d.UF))
+    return { uf: d.UF, cMun: d.cMun };
+  return { uf: nota.emitente.UF, cMun: nota.emitente.cMun };
+}
+function grupoDoLeiaute(g, indDoacao) {
+  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)
+      }
+    }
+  };
+}
+function ocorrenciaDoMotor(e, itens) {
+  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" };
+  }
+  if (e instanceof ErroAliquotaDesconhecida)
+    return { caminho: "impostos.ibsCbs", code: e.code, mensagem: e.message, origem: "montagem" };
+  return;
+}
+var embarcado;
+function carregarDatasetEmbarcado() {
+  embarcado ??= import("@sinete/ibs-cbs-dados/embarcado").then((m) => m.datasetEmbarcado(), (e) => {
+    embarcado = undefined;
+    throw e;
+  });
+  return embarcado;
+}
+function calculadoraIbsCbs(opcoes = {}) {
+  const rates = opcoes.aliquotas ?? aliquotasOficiais();
+  const dataset = opcoes.dataset;
+  return {
+    calcular(request) {
+      if (dataset !== undefined)
+        return calcularCom(dataset, rates, opcoes, request);
+      return carregarDatasetEmbarcado().then((ds) => calcularCom(ds, rates, opcoes, request));
+    }
+  };
+}
+function calcularCom(dataset, rates, options, {
+  nota,
+  itens
+}) {
+  const issues = [];
+  const classificados = [];
+  for (const it of itens) {
+    if (it.cCredPres !== undefined) {
+      issues.push({
+        caminho: caminho(it.nItem),
+        code: "ibscbs_nao_suportado",
+        mensagem: "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({
+        caminho: `${caminho(it.nItem)}.classificacao.vBC`,
+        code: "ibscbs_base_ausente",
+        mensagem: "informe vBC do IBS/CBS ou CalculadoraIbsCbsOpcoes.base: a composição da base (UB16-10) ainda não tem regra publicada",
+        origem: "entrada"
+      });
+      continue;
+    }
+    if (!BASE.test(base)) {
+      issues.push({
+        caminho: `${caminho(it.nItem)}.classificacao.vBC`,
+        code: "decimal_invalido",
+        mensagem: base,
+        origem: it.vBC !== undefined ? "entrada" : "montagem"
+      });
+      continue;
+    }
+    classificados.push({
+      n: it.nItem,
+      cst: it.CST,
+      cClassTrib: it.cClassTrib,
+      base,
+      quantidade: it.qTrib.toString(),
+      unidade: it.uTrib,
+      ...it.gTribRegular === undefined ? {} : { regular: { cst: it.gTribRegular.CSTReg, cClassTrib: it.gTribRegular.cClassTribReg } }
+    });
+  }
+  if (issues.length > 0)
+    return { itens: [], ocorrencias: issues };
+  const op = {
+    modelo: Number(nota.mod),
+    local: localDaOperacao(nota),
+    ...nota.compraGov === undefined ? {} : {
+      compraGovernamental: {
+        tpEnteGov: Number(nota.compraGov.tpEnteGov),
+        ...nota.compraGov.tpOperGov === "1" || nota.compraGov.tpOperGov === "2" ? { tpOperGov: Number(nota.compraGov.tpOperGov) } : {}
+      }
+    },
+    itens: classificados
+  };
+  const time = contextoDeTempo({ emissao: relogioFixo(nota.emissao), fatoGerador: relogioFixo(nota.fatoGerador) });
+  let roc;
+  try {
+    roc = calcular(op, {
+      dataset,
+      aliquotas: rates,
+      tempo: time,
+      ...options.deslocamentoMin === undefined ? {} : { deslocamentoMin: options.deslocamentoMin }
+    });
+  } catch (e) {
+    const issue = ocorrenciaDoMotor(e, itens);
+    if (issue === undefined)
+      throw e;
+    return { itens: [], ocorrencias: [issue] };
+  }
+  const redutor = roc.oper?.gCompraGov.pRedutor;
+  if (nota.compraGov !== undefined && redutor !== undefined && normalizado(nota.compraGov.pRedutor.toString()) !== normalizado(redutor)) {
+    issues.push({
+      caminho: "gCompraGov.pRedutor",
+      code: "ibscbs_redutor_divergente",
+      mensagem: `pRedutor informado (${nota.compraGov.pRedutor.toString()}) difere do vigente no fato gerador (${redutor})`,
+      origem: "entrada"
+    });
+  }
+  if (options.regras !== false) {
+    const doc = documentoDoRoc(roc, {
+      modelo: op.modelo,
+      crt: Number(nota.emitente.CRT),
+      finNFe: Number(nota.finNFe),
+      ...nota.tpNFDebito === undefined ? {} : { tpNFDebito: nota.tpNFDebito },
+      ...nota.tpNFCredito === undefined ? {} : { tpNFCredito: nota.tpNFCredito },
+      munEmitente: nota.emitente.cMun,
+      ...nota.destino === undefined ? {} : { munDestinatario: nota.destino.cMun },
+      itens: itens.map((it) => ({ nItem: it.nItem, ncm: it.NCM, vProd: it.vProd.toFixed(2) }))
+    });
+    const report = validar(doc, {
+      dataset,
+      tempo: time,
+      ambiente: nota.ambiente,
+      aliquotas: rates,
+      ...options.deslocamentoMin === undefined ? {} : { deslocamentoMin: options.deslocamentoMin },
+      ...options.regras?.regras === undefined ? {} : { regras: options.regras.regras },
+      ...options.regras?.ignorarAtivacao === undefined ? {} : { ignorarAtivacao: options.regras.ignorarAtivacao }
+    });
+    for (const v of report.violacoes) {
+      issues.push({
+        caminho: v.item === undefined ? "total.IBSCBSTot" : caminho(v.item),
+        code: "ibscbs_regra_nt",
+        mensagem: `${v.regra} (rejeição ${v.cStat}): ${v.message} [${v.fonte}]`,
+        origem: "montagem"
+      });
+    }
+  }
+  const porItem = new Map(itens.map((it) => [it.nItem, it]));
+  return {
+    itens: roc.itens.map((r) => ({
+      nItem: r.nItem,
+      IBSCBS: grupoDoLeiaute(r.IBSCBS, porItem.get(r.nItem)?.indDoacao)
+    })),
+    ...issues.length === 0 ? {} : { ocorrencias: issues }
+  };
+}
+
+// packages/nfe/src/time.ts
+import { formatarDataHoraComFuso } from "@sinete/core";
+// packages/nfe/src/data/fusos.json
+var fusos_default = {
+  descricao: "Deslocamento do horário legal de cada UF em relação a UTC, em minutos, usado para formatar dhEmi, dhSaiEnt, dhCont e dhEvento quando quem emite não informa o fuso. Sem horário de verão desde 2019. UFs com mais de um fuso usam o da capital; o emitente de outro fuso informa deslocamentoMin.",
+  atualizadoEm: "2026-09-26",
+  fontes: [
+    "Lei 11.662/2008 e Lei 12.876/2013 (fusos horários do Brasil; Acre em UTC-5)",
+    "Decreto 9.772/2019 (fim do horário de verão)"
+  ],
+  padrao: -180,
+  ufs: {
+    AC: -300,
+    AM: -240,
+    MS: -240,
+    MT: -240,
+    RO: -240,
+    RR: -240
+  }
+};
+
+// packages/nfe/src/time.ts
+var UF_OFFSETS = fusos_default.ufs;
+function deslocamentoDaUf(uf) {
+  return Object.hasOwn(UF_OFFSETS, uf) ? UF_OFFSETS[uf] : fusos_default.padrao;
+}
+function formatarDh(data, deslocamentoMin) {
+  return formatarDataHoraComFuso(data, deslocamentoMin);
+}
+
+// packages/nfe/src/versao-gerada.ts
+var VERSAO_PACOTE = "0.2.0";
+
+// packages/nfe/src/build/destinatario.ts
+import { ufPorSigla } from "@sinete/core";
+import { lerCnpj } from "@sinete/validators";
+// packages/nfe/src/data/suframa.json
+var suframa_default = {
+  descricao: "Onde a inscrição na Suframa do destinatário (ISUF) é aceita na NF-e: UFs inteiras e, no Amapá, só os municípios listados. Fora delas, rejeição 251.",
+  atualizadoEm: "2026-09-28",
+  fonte: "MOC 7.0 Anexo I, RV E18-30 (rejeição 251, modelo 55, obrigatória)",
+  ufs: ["AC", "AM", "RO", "RR"],
+  municipios: { AP: ["1600303", "1600600"] }
+};
+
+// packages/nfe/src/build/destinatario.ts
+var ID_ESTRANGEIRO = /^[0-9A-Za-z:.+\-/()]*$/;
+var digitos = (s) => s.replace(/\D/g, "");
+function conferirDestinatario(input, ide, issues) {
+  const d = input.destinatario;
+  if (d === undefined)
+    return;
+  const nfe = ide.mod === "55";
+  const emitUf = input.emitente.endereco.UF;
+  const end = d.endereco;
+  const exterior = end !== undefined && "exterior" in end && end.exterior === true;
+  const destUf = end === undefined ? undefined : exterior ? "EX" : end.UF;
+  const idEstrangeiro = "idEstrangeiro" in d ? d.idEstrangeiro : undefined;
+  if (nfe && ide.idDest === "3" && idEstrangeiro === undefined) {
+    issues.add("destinatario", "campo_obrigatorio", "na operação com o exterior (idDest 3) o destinatário é identificado por idEstrangeiro, mesmo vazio (E03a-10, rejeição 720)");
+  }
+  if (nfe && idEstrangeiro !== undefined && ide.idDest !== "3" && ide.indFinal !== "1") {
+    issues.add("destinatario.idEstrangeiro", "combinacao_invalida", "idEstrangeiro fora da operação com o exterior só com consumidor final, indFinal 1 (E03a-20, rejeição 721)");
+  }
+  if (idEstrangeiro !== undefined && d.IE !== undefined) {
+    issues.add("destinatario.IE", "combinacao_invalida", "destinatário estrangeiro (idEstrangeiro) não informa IE (E03a-30, rejeição 925)");
+  }
+  if (idEstrangeiro !== undefined && !ID_ESTRANGEIRO.test(idEstrangeiro)) {
+    issues.add("destinatario.idEstrangeiro", "campo_invalido", "idEstrangeiro só com algarismos, letras e os caracteres : . + - / ( ) (E03a-60, rejeição 372)");
+  }
+  if (nfe && ide.producao && (d.xNome === undefined || d.xNome.trim() === "")) {
+    issues.add("destinatario.xNome", "campo_obrigatorio", "a NF-e informa o nome do destinatário (E04-10, rejeição 724)");
+  }
+  if (nfe && end === undefined) {
+    issues.add("destinatario.endereco", "campo_obrigatorio", "a NF-e informa o endereço do destinatário (E05-10, rejeição 726)");
+  }
+  if (end !== undefined && !exterior) {
+    const e = end;
+    const cUF = ufPorSigla(e.UF)?.cUF;
+    if (cUF !== undefined && digitos(e.cMun).slice(0, 2) !== cUF) {
+      issues.add("destinatario.endereco.cMun", "combinacao_invalida", `município ${e.cMun} não é da UF ${e.UF} do destinatário (E10-20, rejeição 275)`);
+    }
+  }
+  if (nfe && destUf !== undefined && destUf !== "EX") {
+    const caminho = ide.idDestInformado ? "idDest" : "destinatario.endereco.UF";
+    const ufsCons = input.itens.flatMap((it) => {
+      const esp = it.produto.especifico;
+      return esp !== undefined && "comb" in esp ? [String(esp.comb.UFCons)] : [];
+    });
+    const entrega = input.entrega?.UF;
+    const retirada = input.retirada?.UF;
+    const saida = ide.tpNF === "1";
+    const [ufEntrega, ufRetirada] = saida ? [emitUf, destUf] : [destUf, emitUf];
+    if (ide.idDest === "2" && destUf === emitUf) {
+      const cnpj = (v) => {
+        if (v === undefined)
+          return;
+        const r = lerCnpj(v);
+        return r.ok ? r.valor : undefined;
+      };
+      const cnpjDest = "CNPJ" in d ? cnpj(d.CNPJ) : undefined;
+      const mesmoCnpj = cnpjDest !== undefined && cnpjDest === cnpj(input.emitente.CNPJ);
+      const excecao = ufsCons.some((u) => u !== emitUf) || entrega !== undefined && retirada === undefined && entrega !== ufEntrega || retirada !== undefined && entrega === undefined && retirada !== ufRetirada || entrega !== undefined && retirada !== undefined && entrega !== retirada;
+      if (!mesmoCnpj && !excecao) {
+        issues.add(caminho, "combinacao_invalida", `operação interestadual (idDest 2) com o destinatário na UF do emitente (${emitUf}) (${saida ? "E12-30" : "E12-50"}, rejeição 772)`);
+      }
+    }
+    if (ide.idDest === "1" && destUf !== emitUf && ide.indFinal !== "1") {
+      const excecao = ufsCons.some((u) => u === emitUf) || entrega !== undefined && retirada === undefined && entrega === ufEntrega || retirada !== undefined && entrega === undefined && retirada === ufRetirada || entrega !== undefined && retirada !== undefined && entrega === retirada;
+      if (!excecao) {
+        issues.add(caminho, "combinacao_invalida", `operação interna (idDest 1) com o destinatário em ${destUf}, fora da UF do emitente (${emitUf}) (${saida ? "E12-40" : "E12-60"}, rejeição 773)`);
+      }
+    }
+  }
+  if (exterior && Number(digitos(end.cPais)) === 1058) {
+    issues.add("destinatario.endereco.cPais", "campo_invalido", "destinatário no exterior com o país Brasil, 1058 (E14-30, rejeição 926)");
+  }
+  if (!nfe)
+    return;
+  if (ide.idDest === "3" && d.indIEDest !== "9") {
+    issues.add("destinatario.indIEDest", "combinacao_invalida", "na operação com o exterior o destinatário é não contribuinte, indIEDest 9 (E16a-20, rejeição 790)");
+  }
+  if (d.indIEDest === "9" && ide.indFinal !== "1" && ide.tpNF === "1" && ide.idDest !== "3") {
+    issues.add("indFinal", "combinacao_invalida", "saída para não contribuinte (indIEDest 9) é operação com consumidor final, indFinal 1 (E16a-40, rejeição 696)");
+  }
+  if (d.indIEDest === "1" && d.IE === undefined) {
+    issues.add("destinatario.IE", "campo_obrigatorio", "destinatário contribuinte (indIEDest 1) informa a IE (E17-20, rejeição 728)");
+  }
+  if (d.indIEDest === "2" && d.IE !== undefined) {
+    issues.add("destinatario.IE", "combinacao_invalida", "destinatário contribuinte isento (indIEDest 2) não informa a IE (E17-30, rejeição 791)");
+  }
+  if (exterior && d.IE !== undefined) {
+    issues.add("destinatario.IE", "combinacao_invalida", "destinatário no exterior não informa a IE (E17-40, rejeição 792)");
+  }
+  if (d.ISUF !== undefined && destUf !== undefined) {
+    const cMun = exterior ? "" : digitos(end.cMun);
+    const municipios = suframa_default.municipios[destUf];
+    const aceita = suframa_default.ufs.includes(destUf) || (municipios?.includes(cMun) ?? false);
+    if (!aceita) {
+      const onde = exterior ? "no exterior" : `${destUf}, município ${end.cMun}`;
+      issues.add("destinatario.ISUF", "combinacao_invalida", `inscrição na Suframa com o destinatário fora da área incentivada (${onde}) (E18-30, rejeição 251)`);
+    }
+  }
+}
+
+// packages/nfe/src/build/ibscbs.ts
+import { lerXml, primeiroFilho } from "@sinete/core/xml";
+import { serializar, validar as validar2 } from "@sinete/schemas";
+var NFE_NS = "http://www.portalfiscal.inf.br/nfe";
+function grupoInvalido(ct, nome, value, path, issues) {
+  if (value === undefined)
+    return false;
+  try {
+    const doc = lerXml(`<w xmlns="${NFE_NS}">${serializar(ct, nome, value, NFE_NS)}</w>`);
+    const el = primeiroFilho(doc.raiz, nome, NFE_NS);
+    const erros = el === undefined ? [{ caminho: "", code: "modelo_de_conteudo", mensagem: "grupo vazio" }] : validar2(ct, el);
+    for (const e of erros)
+      issues.add(`${path}${e.caminho.replace(/^\/[^/]+/, "").replace(/\//g, ".")}`, "schema", `${e.code}: ${e.mensagem}`);
+    return erros.length > 0;
+  } catch (e) {
+    issues.add(path, "schema", `grupo malformado: ${e.message}`);
+    return true;
+  }
+}
+var NUMERICO = /^(v|p|q|adRem)[A-Z]/;
+function decimaisInvalidos(value, path, issues) {
+  if (typeof value !== "object" || value === null)
+    return;
+  for (const [k, v] of Object.entries(value)) {
+    const p = `${path}.${k}`;
+    if (typeof v === "string" && NUMERICO.test(k) && Decimal.tryOf(v) === undefined) {
+      issues.add(p, "decimal_invalido", "número decimal inválido");
+    } else if (typeof v === "object")
+      decimaisInvalidos(v, p, issues);
+  }
+}
+function somaCampo(value, name) {
+  if (typeof value !== "object" || value === null)
+    return Decimal.ZERO;
+  let acc = Decimal.ZERO;
+  for (const [k, v] of Object.entries(value)) {
+    if (k === name && typeof v === "string")
+      acc = acc.plus(Decimal.of(v));
+    else if (typeof v === "object")
+      acc = acc.plus(somaCampo(v, name));
+  }
+  return acc;
+}
+function ibsCbsDoItem(g) {
+  const s = (x) => x === undefined ? Decimal.ZERO : Decimal.of(x);
+  return {
+    vIBS: s(g.gIBSCBS?.vIBS),
+    vCBS: s(g.gIBSCBS?.gCBS.vCBS),
+    vTotIBSMonoItem: s(g.gIBSCBSMono?.vTotIBSMonoItem),
+    vTotCBSMonoItem: s(g.gIBSCBSMono?.vTotCBSMonoItem)
+  };
+}
+function totalIbsCbs(grupos) {
+  const f = (d) => d.toFixed(2);
+  const sum = (pick, name) => grupos.reduce((acc, g) => acc.plus(somaCampo(pick(g), name)), Decimal.ZERO);
+  const regulares = grupos.filter((g) => g.gIBSCBS !== undefined || g.gCredPresOper !== undefined);
+  const total = {
+    vBCIBSCBS: f(sum((g) => g.gIBSCBS && { vBC: g.gIBSCBS.vBC }, "vBC"))
+  };
+  if (regulares.length > 0) {
+    const credIbs = (g) => g.gCredPresOper?.gIBSCredPres;
+    const credCbs = (g) => g.gCredPresOper?.gCBSCredPres;
+    total.gIBS = {
+      gIBSUF: {
+        vDif: f(sum((g) => g.gIBSCBS?.gIBSUF.gDif, "vDif")),
+        vDevTrib: f(sum((g) => g.gIBSCBS?.gIBSUF.gDevTrib, "vDevTrib")),
+        vIBSUF: f(sum((g) => g.gIBSCBS && { v: g.gIBSCBS.gIBSUF.vIBSUF }, "v"))
+      },
+      gIBSMun: {
+        vDif: f(sum((g) => g.gIBSCBS?.gIBSMun.gDif, "vDif")),
+        vDevTrib: f(sum((g) => g.gIBSCBS?.gIBSMun.gDevTrib, "vDevTrib")),
+        vIBSMun: f(sum((g) => g.gIBSCBS && { v: g.gIBSCBS.gIBSMun.vIBSMun }, "v"))
+      },
+      vIBS: f(sum((g) => g.gIBSCBS && { v: g.gIBSCBS.vIBS }, "v")),
+      vCredPres: f(sum(credIbs, "vCredPres")),
+      vCredPresCondSus: f(sum(credIbs, "vCredPresCondSus"))
+    };
+    total.gCBS = {
+      vDif: f(sum((g) => g.gIBSCBS?.gCBS.gDif, "vDif")),
+      vDevTrib: f(sum((g) => g.gIBSCBS?.gCBS.gDevTrib, "vDevTrib")),
+      vCBS: f(sum((g) => g.gIBSCBS && { v: g.gIBSCBS.gCBS.vCBS }, "v")),
+      vCredPres: f(sum(credCbs, "vCredPres")),
+      vCredPresCondSus: f(sum(credCbs, "vCredPresCondSus"))
+    };
+  }
+  if (grupos.some((g) => g.gIBSCBSMono !== undefined)) {
+    const mono = (n) => f(sum((g) => g.gIBSCBSMono, n));
+    total.gMono = {
+      vIBSMono: mono("vIBSMono"),
+      vCBSMono: mono("vCBSMono"),
+      vIBSMonoReten: mono("vIBSMonoReten"),
+      vCBSMonoReten: mono("vCBSMonoReten"),
+      vIBSMonoRet: mono("vIBSMonoRet"),
+      vCBSMonoRet: mono("vCBSMonoRet")
+    };
+  }
+  if (grupos.some((g) => g.gEstornoCred !== undefined)) {
+    total.gEstornoCred = {
+      vIBSEstCred: f(sum((g) => g.gEstornoCred, "vIBSEstCred")),
+      vCBSEstCred: f(sum((g) => g.gEstornoCred, "vCBSEstCred"))
+    };
+  }
+  return total;
+}
+
+// packages/nfe/src/build/values.ts
+var TOLERANCIA = Decimal.of("0.01");
+
+class Ctx {
+  issues;
+  modes;
+  conferir;
+  constructor(issues, modes, conferir = true) {
+    this.issues = issues;
+    this.modes = modes;
+    this.conferir = conferir;
+  }
+  opt(value, path, format) {
+    if (value === undefined)
+      return;
+    const d = Decimal.tryOf(value);
+    if (d === undefined) {
+      this.issues.add(path, "decimal_invalido", "número decimal inválido (use ponto como separador, sem milhar)");
+      return;
+    }
+    const problem = problemaDeFormato(d, format);
+    if (problem !== undefined) {
+      this.issues.add(path, "decimal_invalido", `${problem} (${format.nome})`);
+      return;
+    }
+    return d;
+  }
+  req(value, path, format) {
+    if (value === undefined) {
+      this.issues.add(path, "campo_obrigatorio", "campo obrigatório");
+      return Decimal.ZERO;
+    }
+    return this.opt(value, path, format) ?? Decimal.ZERO;
+  }
+  round(value, format, familia) {
+    return value.round(format.max, this.modes[familia]);
+  }
+  base(given, padrao, path, format, familia) {
+    return this.opt(given, path, format) ?? this.round(padrao, format, familia);
+  }
+  calc(given, computed, path, format, familia) {
+    const r = this.round(computed, format, familia);
+    if (given === undefined)
+      return r;
+    const g = this.opt(given, path, format);
+    if (g === undefined)
+      return r;
+    if (this.conferir && g.minus(r).abs().gt(TOLERANCIA)) {
+      this.issues.add(path, "valor_divergente", `valor informado difere do calculado (${r.toFixed(format.max)}) em mais de ${TOLERANCIA.toString()}`);
+    }
+    return g;
+  }
+  s(value, format) {
+    return formatarDecimal(value, format);
+  }
+  so(value, format) {
+    if (value === undefined)
+      return;
+    if (format.naoNulo && value.isZero())
+      return;
+    return formatarDecimal(value, format);
+  }
+}
+function clean(o) {
+  const out = {};
+  for (const [k, v] of Object.entries(o))
+    if (v !== undefined)
+      out[k] = v;
+  return out;
+}
+function digits(s) {
+  return s.replace(/\D/g, "");
+}
+
+// packages/nfe/src/build/icms.ts
+function zeroIcmsTotais() {
+  const z = Decimal.ZERO;
+  return {
+    vBC: z,
+    vICMS: z,
+    vICMSDeson: z,
+    vICMSDesonDeduz: z,
+    vFCP: z,
+    vBCST: z,
+    vST: z,
+    vFCPST: z,
+    vFCPSTRet: z,
+    qBCMono: z,
+    vICMSMono: z,
+    qBCMonoReten: z,
+    vICMSMonoReten: z,
+    qBCMonoRet: z,
+    vICMSMonoRet: z,
+    mono: false
+  };
+}
+var M = D1302;
+var P = D0302A04;
+var PO = D0302A04_OPC;
+function nonNeg(d) {
+  return d.isNegative() ? Decimal.ZERO : d;
+}
+function buildIcms(ctx, input, base, path) {
+  const t = zeroIcmsTotais();
+  const S = (d) => ctx.s(d, M);
+  const proprio = (i, pRedBC, required) => {
+    const pICMS = required ? ctx.req(i.pICMS, `${path}.pICMS`, P) : ctx.opt(i.pICMS, `${path}.pICMS`, P);
+    if (pICMS === undefined && i.vBC === undefined && i.vICMS === undefined)
+      return;
+    const reduzida = pRedBC === undefined ? base.vOp : base.vOp.times(Decimal.HUNDRED.minus(pRedBC)).dividedBy(100, 10, "HALF_EVEN");
+    const vBC = ctx.base(i.vBC, reduzida, `${path}.vBC`, M, "icms");
+    const aliq = pICMS ?? Decimal.ZERO;
+    const vICMS = ctx.calc(i.vICMS, vBC.percent(aliq), `${path}.vICMS`, M, "icms");
+    t.vBC = t.vBC.plus(vBC);
+    t.vICMS = t.vICMS.plus(vICMS);
+    return {
+      out: { modBC: i.modBC ?? "3", vBC: S(vBC), pICMS: ctx.s(aliq, P), vICMS: S(vICMS) },
+      vBC,
+      vICMS
+    };
+  };
+  const orfao = (valor, presente, campo, exige, base = path) => {
+    if (valor !== undefined && !presente) {
+      ctx.issues.add(`${base}.${exige}`, "campo_obrigatorio", `${campo} informado exige ${exige}`);
+    }
+  };
+  const fcp = (i, vBC, withBase) => {
+    const pFCP = ctx.opt(i.pFCP, `${path}.pFCP`, PO);
+    orfao(i.vBCFCP, i.pFCP !== undefined || i.vFCP !== undefined, "vBCFCP", "pFCP");
+    if (pFCP === undefined && i.vFCP === undefined)
+      return {};
+    const vBCFCP = ctx.base(i.vBCFCP, vBC, `${path}.vBCFCP`, M, "icms");
+    const vFCP = ctx.calc(i.vFCP, vBCFCP.percent(pFCP ?? Decimal.ZERO), `${path}.vFCP`, M, "icms");
+    t.vFCP = t.vFCP.plus(vFCP);
+    return { ...withBase ? { vBCFCP: S(vBCFCP) } : {}, pFCP: ctx.so(pFCP, PO), vFCP: S(vFCP) };
+  };
+  const st = (i, vICMSProprio, vFCPProprio) => {
+    const sp = `${path}.st`;
+    const pMVAST = ctx.opt(i.pMVAST, `${sp}.pMVAST`, PO);
+    const pRedBCST = ctx.opt(i.pRedBCST, `${sp}.pRedBCST`, PO);
+    const pICMSST = ctx.req(i.pICMSST, `${sp}.pICMSST`, P);
+    if (i.modBCST === "4" && pMVAST === undefined) {
+      ctx.issues.add(`${sp}.pMVAST`, "campo_obrigatorio", "modBCST 4 (MVA) exige pMVAST");
+    }
+    if (i.modBCST !== "4" && pMVAST !== undefined) {
+      ctx.issues.add(`${sp}.pMVAST`, "combinacao_invalida", "pMVAST só pode ser informado com modBCST 4 (MVA)");
+    }
+    let vBCST;
+    if (i.vBCST === undefined && i.modBCST === "4") {
+      const bruta = base.vOp.plus(base.vIPI).times(Decimal.HUNDRED.plus(pMVAST ?? Decimal.ZERO)).dividedBy(100, 12, "HALF_EVEN");
+      const reduzida = pRedBCST === undefined ? bruta : bruta.times(Decimal.HUNDRED.minus(pRedBCST)).dividedBy(100, 12, "HALF_EVEN");
+      vBCST = ctx.round(reduzida, M, "icms");
+    } else {
+      vBCST = ctx.req(i.vBCST, `${sp}.vBCST`, M);
+    }
+    const deducao = ctx.opt(i.vICMSDeducaoST, `${sp}.vICMSDeducaoST`, M) ?? vICMSProprio;
+    const vICMSST = ctx.calc(i.vICMSST, nonNeg(ctx.round(vBCST.percent(pICMSST), M, "icms").minus(deducao)), `${sp}.vICMSST`, M, "icms");
+    t.vBCST = t.vBCST.plus(vBCST);
+    t.vST = t.vST.plus(vICMSST);
+    const out = {
+      modBCST: i.modBCST,
+      pMVAST: ctx.so(pMVAST, PO),
+      pRedBCST: ctx.so(pRedBCST, PO),
+      vBCST: S(vBCST),
+      pICMSST: ctx.s(pICMSST, P),
+      vICMSST: S(vICMSST)
+    };
+    const pFCPST = ctx.opt(i.pFCPST, `${sp}.pFCPST`, PO);
+    orfao(i.vBCFCPST, i.pFCPST !== undefined || i.vFCPST !== undefined, "vBCFCPST", "pFCPST", sp);
+    if (pFCPST !== undefined || i.vFCPST !== undefined) {
+      const vBCFCPST = ctx.base(i.vBCFCPST, vBCST, `${sp}.vBCFCPST`, M, "icms");
+      const vFCPST = ctx.calc(i.vFCPST, nonNeg(ctx.round(vBCFCPST.percent(pFCPST ?? Decimal.ZERO), M, "icms").minus(vFCPProprio)), `${sp}.vFCPST`, M, "icms");
+      t.vFCPST = t.vFCPST.plus(vFCPST);
+      Object.assign(out, { vBCFCPST: S(vBCFCPST), pFCPST: ctx.so(pFCPST, PO), vFCPST: S(vFCPST) });
+    }
+    return out;
+  };
+  const deson = (d) => {
+    if (d === undefined)
+      return {};
+    const v = ctx.req(d.vICMSDeson, `${path}.desoneracao.vICMSDeson`, M);
+    t.vICMSDeson = t.vICMSDeson.plus(v);
+    if (d.indDeduzDeson === "1")
+      t.vICMSDesonDeduz = t.vICMSDesonDeduz.plus(v);
+    return { vICMSDeson: S(v), motDesICMS: d.motDesICMS, indDeduzDeson: d.indDeduzDeson };
+  };
+  const desonSt = (d) => {
+    if (d === undefined)
+      return {};
+    const v = ctx.req(d.vICMSSTDeson, `${path}.desoneracaoSt.vICMSSTDeson`, M);
+    return { vICMSSTDeson: S(v), motDesICMSST: d.motDesICMSST };
+  };
+  const retido = (i) => {
+    const o = (k, f) => ctx.so(ctx.opt(i[k], `${path}.${k}`, f), f);
+    const vFCPSTRet = ctx.opt(i.vFCPSTRet, `${path}.vFCPSTRet`, M);
+    if (vFCPSTRet !== undefined)
+      t.vFCPSTRet = t.vFCPSTRet.plus(vFCPSTRet);
+    return {
+      vBCSTRet: o("vBCSTRet", M),
+      pST: o("pST", PO),
+      vICMSSubstituto: o("vICMSSubstituto", M),
+      vICMSSTRet: o("vICMSSTRet", M),
+      vBCFCPSTRet: o("vBCFCPSTRet", M),
+      pFCPSTRet: o("pFCPSTRet", PO),
+      vFCPSTRet: ctx.so(vFCPSTRet, M),
+      pRedBCEfet: o("pRedBCEfet", PO),
+      vBCEfet: o("vBCEfet", M),
+      pICMSEfet: o("pICMSEfet", PO),
+      vICMSEfet: o("vICMSEfet", M)
+    };
+  };
+  const diferimento = (i, redFormat, triade) => {
+    const pRedBC = ctx.opt(i.pRedBC, `${path}.pRedBC`, redFormat);
+    const pICMS = ctx.opt(i.pICMS, `${path}.pICMS`, P);
+    const out = {};
+    let vBC;
+    if (pICMS !== undefined || i.vBC !== undefined) {
+      const reduzida = pRedBC === undefined ? base.vOp : base.vOp.times(Decimal.HUNDRED.minus(pRedBC)).dividedBy(100, 10, "HALF_EVEN");
+      vBC = ctx.base(i.vBC, reduzida, `${path}.vBC`, M, "icms");
+      out.modBC = i.modBC ?? "3";
+      out.vBC = S(vBC);
+    }
+    out.pRedBC = ctx.so(pRedBC, redFormat);
+    out.cBenefRBC = i.cBenefRBC;
+    if (pICMS !== undefined && vBC !== undefined) {
+      out.pICMS = ctx.s(pICMS, P);
+      const vICMSOp = ctx.calc(i.vICMSOp, vBC.percent(pICMS), `${path}.vICMSOp`, M, "icms");
+      const pDif = ctx.opt(i.pDif, `${path}.pDif`, P);
+      const vICMSDif = ctx.calc(i.vICMSDif, vICMSOp.percent(pDif ?? Decimal.ZERO), `${path}.vICMSDif`, M, "icms");
+      const vICMS = ctx.calc(i.vICMS, vICMSOp.minus(vICMSDif), `${path}.vICMS`, M, "icms");
+      const temDif = pDif !== undefined || i.vICMSDif !== undefined || i.vICMSOp !== undefined;
+      if (triade) {
+        if (temDif)
+          Object.assign(out, { vICMSOp: S(vICMSOp), pDif: ctx.s(pDif ?? Decimal.ZERO, P), vICMSDif: S(vICMSDif) });
+      } else {
+        Object.assign(out, {
+          vICMSOp: S(vICMSOp),
+          pDif: ctx.so(pDif, P),
+          vICMSDif: pDif === undefined && i.vICMSDif === undefined ? undefined : S(vICMSDif)
+        });
+      }
+      Object.assign(out, {
+        vICMS: S(vICMS)
+      });
+      t.vBC = t.vBC.plus(vBC);
+      t.vICMS = t.vICMS.plus(vICMS);
+    } else {
+      const informados = [i.vBC, i.vICMS, i.vICMSOp, i.pDif, i.vICMSDif, i.pRedBC].some((x) => x !== undefined);
+      if (triade && informados) {
+        ctx.issues.add(`${path}.pICMS`, "campo_obrigatorio", "o ICMS próprio do CST 90 (vBC, vICMS, diferimento) exige pICMS");
+      }
+      if (!triade) {
+        Object.assign(out, {
+          modBC: out.modBC ?? i.modBC,
+          vICMSOp: ctx.so(ctx.opt(i.vICMSOp, `${path}.vICMSOp`, M), M),
+          pDif: ctx.so(ctx.opt(i.pDif, `${path}.pDif`, P), P),
+          vICMSDif: ctx.so(ctx.opt(i.vICMSDif, `${path}.vICMSDif`, M), M)
+        });
+      }
+      const vICMS = ctx.opt(i.vICMS, `${path}.vICMS`, M);
+      if (vICMS !== undefined) {
+        out.vICMS = S(vICMS);
+        t.vICMS = t.vICMS.plus(vICMS);
+      }
+      if (vBC !== undefined)
+        t.vBC = t.vBC.plus(vBC);
+    }
+    const pFCP = ctx.opt(i.pFCP, `${path}.pFCP`, PO);
+    const temFcp = i.pFCP !== undefined || i.vFCP !== undefined;
+    for (const k of ["vBCFCP", "pFCPDif", "vFCPDif", "vFCPEfet"])
+      orfao(i[k], temFcp, k, "pFCP");
+    orfao(i.vFCPEfet, !temFcp || i.pFCPDif !== undefined || i.vFCPDif !== undefined, "vFCPEfet", "pFCPDif");
+    if (pFCP !== undefined || i.vFCP !== undefined) {
+      const vBCFCP = ctx.base(i.vBCFCP, vBC ?? Decimal.ZERO, `${path}.vBCFCP`, M, "icms");
+      const vFCP = ctx.calc(i.vFCP, vBCFCP.percent(pFCP ?? Decimal.ZERO), `${path}.vFCP`, M, "icms");
+      const pFCPDif = ctx.opt(i.pFCPDif, `${path}.pFCPDif`, PO);
+      const vFCPDif = ctx.calc(i.vFCPDif, vFCP.percent(pFCPDif ?? Decimal.ZERO), `${path}.vFCPDif`, M, "icms");
+      const vFCPEfet = ctx.calc(i.vFCPEfet, vFCP.minus(vFCPDif), `${path}.vFCPEfet`, M, "icms");
+      t.vFCP = t.vFCP.plus(vFCP);
+      const temDif = pFCPDif !== undefined || i.vFCPDif !== undefined;
+      Object.assign(out, {
+        vBCFCP: S(vBCFCP),
+        pFCP: ctx.so(pFCP, PO),
+        vFCP: S(vFCP),
+        pFCPDif: ctx.so(pFCPDif, PO),
+        vFCPDif: temDif ? S(vFCPDif) : undefined,
+        vFCPEfet: temDif ? S(vFCPEfet) : undefined
+      });
+    }
+    return out;
+  };
+  const q = (v, k) => ctx.opt(v, `${path}.${k}`, D1104V);
+  const mono = (qtd, adRem, given, k) => ctx.base(given, (qtd ?? Decimal.ZERO).times(adRem ?? Decimal.ZERO), `${path}.${k}`, M, "icms");
+  let grupo;
+  if ("CSOSN" in input) {
+    const orig = input.orig;
+    switch (input.CSOSN) {
+      case "101": {
+        const pCredSN = ctx.req(input.pCredSN, `${path}.pCredSN`, P);
+        const v = ctx.calc(input.vCredICMSSN, base.vOp.percent(pCredSN), `${path}.vCredICMSSN`, M, "icms");
+        grupo = { ICMSSN101: { orig, CSOSN: "101", pCredSN: ctx.s(pCredSN, P), vCredICMSSN: S(v) } };
+        break;
+      }
+      case "102":
+      case "103":
+      case "300":
+      case "400":
+        grupo = { ICMSSN102: { orig, CSOSN: input.CSOSN } };
+        break;
+      case "201": {
+        const stOut = st(input.st, Decimal.ZERO, Decimal.ZERO);
+        const pCredSN = ctx.req(input.pCredSN, `${path}.pCredSN`, P);
+        const v = ctx.calc(input.vCredICMSSN, base.vOp.percent(pCredSN), `${path}.vCredICMSSN`, M, "icms");
+        grupo = { ICMSSN201: { orig, CSOSN: "201", ...stOut, pCredSN: ctx.s(pCredSN, P), vCredICMSSN: S(v) } };
+        break;
+      }
+      case "202":
+      case "203":
+        grupo = { ICMSSN202: { orig, CSOSN: input.CSOSN, ...st(input.st, Decimal.ZERO, Decimal.ZERO) } };
+        break;
+      case "500":
+        grupo = { ICMSSN500: { orig, CSOSN: "500", ...retido(input) } };
+        break;
+      case "900": {
+        const pRedBC = ctx.opt(input.pRedBC, `${path}.pRedBC`, PO);
+        const p = proprio(input, pRedBC, false);
+        const out = { orig, CSOSN: "900" };
+        if (p)
+          Object.assign(out, {
+            modBC: p.out.modBC,
+            vBC: p.out.vBC,
+            pRedBC: ctx.so(pRedBC, PO),
+            pICMS: p.out.pICMS,
+            vICMS: p.out.vICMS
+          });
+        if (input.st)
+          Object.assign(out, st(input.st, p?.vICMS ?? Decimal.ZERO, Decimal.ZERO));
+        const pCredSN = ctx.opt(input.pCredSN, `${path}.pCredSN`, P);
+        orfao(input.vCredICMSSN, input.pCredSN !== undefined, "vCredICMSSN", "pCredSN");
+        if (pCredSN !== undefined) {
+          const v = ctx.calc(input.vCredICMSSN, base.vOp.percent(pCredSN), `${path}.vCredICMSSN`, M, "icms");
+          Object.assign(out, { pCredSN: ctx.s(pCredSN, P), vCredICMSSN: S(v) });
+        }
+        grupo = { ICMSSN900: out };
+        break;
+      }
+    }
+  } else if (input.grupo === "Part") {
+    const pRedBC = ctx.opt(input.pRedBC, `${path}.pRedBC`, PO);
+    const p = proprio(input, pRedBC, true);
+    const pBCOp = ctx.req(input.pBCOp, `${path}.pBCOp`, PO);
+    grupo = {
+      ICMSPart: {
+        orig: input.orig,
+        CST: input.CST,
+        modBC: input.modBC,
+        vBC: p.out.vBC,
+        pRedBC: ctx.so(pRedBC, PO),
+        pICMS: p.out.pICMS,
+        vICMS: p.out.vICMS,
+        ...st(input.st, p.vICMS, Decimal.ZERO),
+        pBCOp: ctx.s(pBCOp, PO),
+        UFST: input.UFST,
+        ...deson(input.desoneracao)
+      }
+    };
+  } else if (input.grupo === "ST") {
+    grupo = {
+      ICMSST: {
+        orig: input.orig,
+        CST: input.CST,
+        ...retido(input),
+        vBCSTRet: S(ctx.req(input.vBCSTRet, `${path}.vBCSTRet`, M)),
+        vICMSSTRet: S(ctx.req(input.vICMSSTRet, `${path}.vICMSSTRet`, M)),
+        vBCSTDest: S(ctx.req(input.vBCSTDest, `${path}.vBCSTDest`, M)),
+        vICMSSTDest: S(ctx.req(input.vICMSSTDest, `${path}.vICMSSTDest`, M))
+      }
+    };
+  } else {
+    const orig = input.orig;
+    switch (input.CST) {
+      case "00": {
+        const p = proprio(input, undefined, true);
+        grupo = { ICMS00: { orig, CST: "00", ...p.out, ...fcp(input, p.vBC, false) } };
+        break;
+      }
+      case "02": {
+        const qBCMono = q(input.qBCMono, "qBCMono");
+        const adRem = ctx.req(input.adRemICMS, `${path}.adRemICMS`, P);
+        const v = mono(qBCMono, adRem, input.vICMSMono, "vICMSMono");
+        t.mono = true;
+        t.qBCMono = t.qBCMono.plus(qBCMono ?? Decimal.ZERO);
+        t.vICMSMono = t.vICMSMono.plus(v);
+        grupo = {
+          ICMS02: {
+            orig,
+            CST: "02",
+            qBCMono: ctx.so(qBCMono, D1104V),
+            adRemICMS: ctx.s(adRem, P),
+            vICMSMono: S(v)
+          }
+        };
+        break;
+      }
+      case "10": {
+        const p = proprio(input, undefined, true);
+        const f = fcp(input, p.vBC, true);
+        const vFCP = f.vFCP === undefined ? Decimal.ZERO : Decimal.of(f.vFCP);
+        grupo = {
+          ICMS10: { orig, CST: "10", ...p.out, ...f, ...st(input.st, p.vICMS, vFCP), ...desonSt(input.desoneracaoSt) }
+        };
+        break;
+      }
+      case "15": {
+        const qBCMono = q(input.qBCMono, "qBCMono");
+        const adRem = ctx.req(input.adRemICMS, `${path}.adRemICMS`, P);
+        const v = mono(qBCMono, adRem, input.vICMSMono, "vICMSMono");
+        const qReten = q(input.qBCMonoReten, "qBCMonoReten");
+        const adRemReten = ctx.req(input.adRemICMSReten, `${path}.adRemICMSReten`, P);
+        if (input.pRedAdRem !== undefined) {
+          if (input.vICMSMono === undefined)
+            ctx.issues.add(`${path}.vICMSMono`, "campo_obrigatorio", "com pRedAdRem, informe vICMSMono");
+          if (input.vICMSMonoReten === undefined) {
+            ctx.issues.add(`${path}.vICMSMonoReten`, "campo_obrigatorio", "com pRedAdRem, informe vICMSMonoReten");
+          }
+        }
+        const vReten = mono(qReten, adRemReten, input.vICMSMonoReten, "vICMSMonoReten");
+        t.mono = true;
+        t.qBCMono = t.qBCMono.plus(qBCMono ?? Decimal.ZERO);
+        t.vICMSMono = t.vICMSMono.plus(v);
+        t.qBCMonoReten = t.qBCMonoReten.plus(qReten ?? Decimal.ZERO);
+        t.vICMSMonoReten = t.vICMSMonoReten.plus(vReten);
+        grupo = {
+          ICMS15: {
+            orig,
+            CST: "15",
+            qBCMono: ctx.so(qBCMono, D1104V),
+            adRemICMS: ctx.s(adRem, P),
+            vICMSMono: S(v),
+            qBCMonoReten: ctx.so(qReten, D1104V),
+            adRemICMSReten: ctx.s(adRemReten, P),
+            vICMSMonoReten: S(vReten),
+            pRedAdRem: ctx.so(ctx.opt(input.pRedAdRem, `${path}.pRedAdRem`, D0302A04), D0302A04),
+            motRedAdRem: input.motRedAdRem
+          }
+        };
+        break;
+      }
+      case "20": {
+        const pRedBC = ctx.req(input.pRedBC, `${path}.pRedBC`, P);
+        const p = proprio(input, pRedBC, true);
+        grupo = {
+          ICMS20: {
+            orig,
+            CST: "20",
+            modBC: p.out.modBC,
+            pRedBC: ctx.s(pRedBC, P),
+            vBC: p.out.vBC,
+            pICMS: p.out.pICMS,
+            vICMS: p.out.vICMS,
+            ...fcp(input, p.vBC, true),
+            ...deson(input.desoneracao)
+          }
+        };
+        break;
+      }
+      case "30":
+        grupo = {
+          ICMS30: { orig, CST: "30", ...st(input.st, Decimal.ZERO, Decimal.ZERO), ...deson(input.desoneracao) }
+        };
+        break;
+      case "40":
+      case "41":
+      case "50":
+        grupo = { ICMS40: { orig, CST: input.CST, ...deson(input.desoneracao) } };
+        break;
+      case "51":
+        grupo = { ICMS51: { orig, CST: "51", ...diferimento(input, P, false) } };
+        break;
+      case "53": {
+        const qBCMono = q(input.qBCMono, "qBCMono");
+        const adRem = ctx.opt(input.adRemICMS, `${path}.adRemICMS`, P);
+        const vOp = mono(qBCMono, adRem, input.vICMSMonoOp, "vICMSMonoOp");
+        const pDif = ctx.opt(input.pDif, `${path}.pDif`, P);
+        const vDif = ctx.calc(input.vICMSMonoDif, vOp.percent(pDif ?? Decimal.ZERO), `${path}.vICMSMonoDif`, M, "icms");
+        const v = ctx.calc(input.vICMSMono, vOp.minus(vDif), `${path}.vICMSMono`, M, "icms");
+        const qDif = q(input.qBCMonoDif, "qBCMonoDif");
+        const adRemDif = ctx.opt(input.adRemICMSDif, `${path}.adRemICMSDif`, P);
+        t.mono = true;
+        t.qBCMono = t.qBCMono.plus(qBCMono ?? Decimal.ZERO);
+        t.vICMSMono = t.vICMSMono.plus(v);
+        grupo = {
+          ICMS53: {
+            orig,
+            CST: "53",
+            qBCMono: ctx.so(qBCMono, D1104V),
+            adRemICMS: ctx.so(adRem, P),
+            vICMSMonoOp: adRem === undefined && input.vICMSMonoOp === undefined ? undefined : S(vOp),
+            pDif: ctx.so(pDif, P),
+            vICMSMonoDif: pDif === undefined && input.vICMSMonoDif === undefined ? undefined : S(vDif),
+            vICMSMono: adRem === undefined && input.vICMSMono === undefined ? undefined : S(v),
+            qBCMonoDif: ctx.so(qDif, D1104V),
+            adRemICMSDif: ctx.so(adRemDif, P)
+          }
+        };
+        break;
+      }
+      case "60":
+        grupo = { ICMS60: { orig, CST: "60", ...retido(input) } };
+        break;
+      case "61": {
+        const qRet = q(input.qBCMonoRet, "qBCMonoRet");
+        const adRem = ctx.req(input.adRemICMSRet, `${path}.adRemICMSRet`, P);
+        const v = mono(qRet, adRem, input.vICMSMonoRet, "vICMSMonoRet");
+        t.mono = true;
+        t.qBCMonoRet = t.qBCMonoRet.plus(qRet ?? Decimal.ZERO);
+        t.vICMSMonoRet = t.vICMSMonoRet.plus(v);
+        grupo = {
+          ICMS61: {
+            orig,
+            CST: "61",
+            qBCMonoRet: ctx.so(qRet, D1104V),
+            adRemICMSRet: ctx.s(adRem, P),
+            vICMSMonoRet: S(v)
+          }
+        };
+        break;
+      }
+      case "70": {
+        const pRedBC = ctx.req(input.pRedBC, `${path}.pRedBC`, P);
+        const p = proprio(input, pRedBC, true);
+        const f = fcp(input, p.vBC, true);
+        const vFCP = f.vFCP === undefined ? Decimal.ZERO : Decimal.of(f.vFCP);
+        grupo = {
+          ICMS70: {
+            orig,
+            CST: "70",
+            modBC: p.out.modBC,
+            pRedBC: ctx.s(pRedBC, P),
+            vBC: p.out.vBC,
+            pICMS: p.out.pICMS,
+            vICMS: p.out.vICMS,
+            ...f,
+            ...st(input.st, p.vICMS, vFCP),
+            ...deson(input.desoneracao),
+            ...desonSt(input.desoneracaoSt)
+          }
+        };
+        break;
+      }
+      case "90": {
+        const d = diferimento(input, PO, true);
+        const vICMS = d.vICMS === undefined ? Decimal.ZERO : Decimal.of(d.vICMS);
+        const vFCP = d.vFCP;
+        grupo = {
+          ICMS90: {
+            orig,
+            CST: "90",
+            ...d,
+            ...input.st ? st(input.st, vICMS, vFCP === undefined ? Decimal.ZERO : Decimal.of(vFCP)) : {},
+            ...deson(input.desoneracao),
+            ...desonSt(input.desoneracaoSt)
+          }
+        };
+        break;
+      }
+    }
+  }
+  const [name, body] = Object.entries(grupo)[0];
+  return { grupo: { [name]: clean(body) }, totais: t };
+}
+
+// packages/nfe/src/build/nfce.ts
+import { tpAmbDoAmbiente } from "@sinete/core";
+import { c14n, codificarBase64, lerXml as lerXml2, PREFIXO_DIGEST_INFO_SHA1, primeiroFilho as primeiroFilho2 } from "@sinete/core/xml";
+import { lerCnpj as lerCnpj2 } from "@sinete/validators";
+// packages/nfe/src/data/nfce-urls.json
+var nfce_urls_default = {
+  descricao: "Endereços da NFC-e (modelo 65) por UF e ambiente: a consulta via QR Code (1ª parte da URL do infNFeSupl/qrCode, sem o '?p=' que o builder acrescenta) e a consulta por chave de acesso (infNFeSupl/urlChave, impressa no DANFC-e). Cada UF tem uma lista de endereços com a data de início ('desde', AAAA-MM-DD, 00:00 de Brasília); vale o mais recente cujo início não passou da data de emissão. As tabelas do ENCAT foram transcritas como publicadas, com três ajustes: o '?' final e o exemplo de parâmetros (AM: '?chNFe=1315....') foram retirados, porque o builder monta a query; o espaço dentro do endereço de homologação do MA ('homolog acao') foi juntado; e o endereço de MG por chave de acesso vem da página de web services da própria SEFAZ-MG, mais nova que a do ENCAT. Onde a tabela não dá o protocolo ('http://' ou 'https://'), a URL do QR Code fica null: o schema exige o protocolo e não há fonte para escolher um; informe MontarNfeOpcoes.urlQrCode. A regra ZX02-20 (rejeição 395) compara o endereço sem diferenciar maiúsculas e minúsculas; ZX03-20 (rejeição 878) é opcional por UF.",
+  atualizadoEm: "2026-09-26",
+  fontes: [
+    "Portal Nacional da NFC-e (ENCAT), URL por UF utilizada QR code: https://nfce.encat.org/desenvolvedor/qrcode/ (coletada em 26/09/2026)",
+    "Portal Nacional da NFC-e (ENCAT), URL por UF utilizada para consulta chave, QR Code versão 2.0: https://nfce.encat.org/desenvolvedor/httpnfce-encat-orgconsulte-sua-nota-qr-code-versao-2-0/ (coletada em 26/09/2026)",
+    "SEFAZ-MG, web services da NFC-e: https://portalsped.fazenda.mg.gov.br/spedmg/nfce/web-services/ (a mesma fonte do urlsConsultaNfce do @sinete/transport) (coletada em 26/09/2026)",
+    "MOC 7.0 Anexo I, regras ZX02-20 e ZX03-20; NT 2025.001 v1.03, grupo ZX (campos ZX02 qrCode e ZX03 urlChave)"
+  ],
+  qrCode: {
+    producao: {
+      AC: [{ url: "http://www.sefaznet.ac.gov.br/nfce/qrcode" }],
+      AL: [{ url: "http://nfce.sefaz.al.gov.br/QRCode/consultarNFCe.jsp" }],
+      AP: [{ url: "https://www.sefaz.ap.gov.br/nfce/nfcep.php" }],
+      AM: [
+        { url: null, nota: "tabela do ENCAT sem protocolo: sistemas.sefaz.am.gov.br/nfceweb/consultarNFCe.jsp" }
+      ],
+      BA: [{ url: "http://nfe.sefaz.ba.gov.br/servicos/nfce/qrcode.aspx" }],
+      CE: [{ url: "http://nfce.sefaz.ce.gov.br/pages/ShowNFCe.html" }],
+      DF: [{ url: "http://www.fazenda.df.gov.br/nfce/qrcode" }],
+      ES: [{ url: "http://app.sefaz.es.gov.br/ConsultaNFCe/" }],
+      GO: [
+        { url: "http://nfe.sefaz.go.gov.br/nfeweb/sites/nfce/danfeNFCe" },
+        { url: "https://nfeweb.sefaz.go.gov.br/nfeweb/sites/nfce/danfeNFCe", desde: "2025-06-16" }
+      ],
+      MA: [{ url: null, nota: "tabela do ENCAT sem protocolo: nfce.sefaz.ma.gov.br/portal/consultarNFCe.jsp" }],
+      MT: [{ url: "http://www.sefaz.mt.gov.br/nfce/consultanfce" }],
+      MS: [{ url: "http://www.dfe.ms.gov.br/nfce/qrcode" }],
+      MG: [
+        { url: "https://nfce.fazenda.mg.gov.br/portalnfce/sistema/qrcode.xhtml" },
+        { url: "https://portalsped.fazenda.mg.gov.br/portalnfce/sistema/qrcode.xhtml", desde: "2022-03-21" }
+      ],
+      PA: [{ url: "https://appnfc.sefa.pa.gov.br/portal/view/consultas/nfce/nfceForm.seam" }],
+      PB: [{ url: "http://www.sefaz.pb.gov.br/nfce" }],
+      PR: [{ url: "http://www.fazenda.pr.gov.br/nfce/qrcode" }],
+      PE: [{ url: "http://nfce.sefaz.pe.gov.br/nfce/consulta" }],
+      PI: [{ url: "http://www.sefaz.pi.gov.br/nfce/qrcode" }],
+      RJ: [
+        { url: "http://www4.fazenda.rj.gov.br/consultaNFCe/QRCode" },
+        { url: "https://consultadfe.fazenda.rj.gov.br/consultaNFCe/QRCode", desde: "2023-12-19" }
+      ],
+      RN: [
+        { url: "http://nfce.set.rn.gov.br/consultarNFCe.aspx" },
+        { url: "https://nfce.sefaz.rn.gov.br/consultarNFCe.aspx", desde: "2026-05-25" }
+      ],
+      RS: [{ url: "https://www.sefaz.rs.gov.br/NFCE/NFCE-COM.aspx" }],
+      RO: [{ url: "http://www.nfce.sefin.ro.gov.br/consultanfce/consulta.jsp" }],
+      RR: [{ url: "https://www.sefaz.rr.gov.br/nfce/servlet/qrcode" }],
+      SC: [{ url: "https://sat.sef.sc.gov.br/nfce/consulta" }],
+      SP: [
+        {
+          url: "https://www.nfce.fazenda.sp.gov.br/NFCeConsultaPublica/Paginas/ConsultaQRCode.aspx",
+          nota: "a tabela do ENCAT lista também https://www.nfce.fazenda.sp.gov.br/qrcode"
+        }
+      ],
+      SE: [{ url: "http://www.nfce.se.gov.br/nfce/qrcode" }],
+      TO: [{ url: "http://www.sefaz.to.gov.br/nfce/qrcode" }]
+    },
+    homologacao: {
+      AC: [{ url: "http://www.hml.sefaznet.ac.gov.br/nfce/qrcode" }],
+      AL: [{ url: "http://nfce.sefaz.al.gov.br/QRCode/consultarNFCe.jsp" }],
+      AP: [{ url: "https://www.sefaz.ap.gov.br/nfcehml/nfce.php" }],
+      AM: [
+        { url: null, nota: "tabela do ENCAT sem protocolo: homnfce.sefaz.am.gov.br/nfceweb/consultarNFCe.jsp" }
+      ],
+      BA: [{ url: "http://hnfe.sefaz.ba.gov.br/servicos/nfce/qrcode.aspx" }],
+      CE: [{ url: "http://nfceh.sefaz.ce.gov.br/pages/ShowNFCe.html" }],
+      DF: [{ url: "http://www.fazenda.df.gov.br/nfce/qrcode" }],
+      ES: [{ url: "http://homologacao.sefaz.es.gov.br/ConsultaNFCe/" }],
+      GO: [
+        { url: "http://homolog.sefaz.go.gov.br/nfeweb/sites/nfce/danfeNFCe" },
+        { url: "https://nfewebhomolog.sefaz.go.gov.br/nfeweb/sites/nfce/danfeNFCe", desde: "2025-06-16" }
+      ],
+      MA: [
+        { url: null, nota: "tabela do ENCAT sem protocolo: homologacao.sefaz.ma.gov.br/portal/consultarNFCe.jsp" }
+      ],
+      MT: [{ url: "http://homologacao.sefaz.mt.gov.br/nfce/consultanfce" }],
+      MS: [{ url: "http://www.dfe.ms.gov.br/nfce/qrcode" }],
+      MG: [
+        { url: "https://nfce.fazenda.mg.gov.br/portalnfce/sistema/qrcode.xhtml" },
+        { url: "https://portalsped.fazenda.mg.gov.br/portalnfce/sistema/qrcode.xhtml", desde: "2022-03-21" }
+      ],
+      PA: [{ url: "https://appnfc.sefa.pa.gov.br/portal-homologacao/view/consultas/nfce/nfceForm.seam" }],
+      PB: [{ url: "http://www.sefaz.pb.gov.br/nfcehom" }],
+      PR: [{ url: "http://www.fazenda.pr.gov.br/nfce/qrcode" }],
+      PE: [{ url: "http://nfcehomolog.sefaz.pe.gov.br/nfce/consulta" }],
+      PI: [{ url: "http://www.sefaz.pi.gov.br/nfce/qrcode" }],
+      RJ: [
+        { url: "http://www4.fazenda.rj.gov.br/consultaNFCe/QRCode" },
+        { url: "https://consultadfe.fazenda.rj.gov.br/consultaNFCe/QRCode", desde: "2023-12-19" }
+      ],
+      RN: [
+        { url: "http://hom.nfce.set.rn.gov.br/consultarNFCe.aspx" },
+        { url: "https://hom.nfce.sefaz.rn.gov.br/consultarNFCe.aspx", desde: "2026-05-25" }
+      ],
+      RS: [{ url: "https://www.sefaz.rs.gov.br/NFCE/NFCE-COM.aspx" }],
+      RO: [{ url: "http://www.nfce.sefin.ro.gov.br/consultanfce/consulta.jsp" }],
+      RR: [{ url: "http://200.174.88.103:8080/nfce/servlet/qrcode" }],
+      SC: [{ url: "https://hom.sat.sef.sc.gov.br/nfce/consulta" }],
+      SP: [
+        {
+          url: "https://www.homologacao.nfce.fazenda.sp.gov.br/NFCeConsultaPublica/Paginas/ConsultaQRCode.aspx",
+          nota: "a tabela do ENCAT lista também https://www.homologacao.nfce.fazenda.sp.gov.br/qrcode"
+        }
+      ],
+      SE: [{ url: "http://www.hom.nfe.se.gov.br/nfce/qrcode" }],
+      TO: [{ url: "http://homologacao.sefaz.to.gov.br/nfce/qrcode" }]
+    }
+  },
+  urlChave: {
+    producao: {
+      AC: [{ url: "www.sefaznet.ac.gov.br/nfce/consulta" }],
+      AL: [{ url: "www.sefaz.al.gov.br/nfce/consulta" }],
+      AP: [{ url: "www.sefaz.ap.gov.br/nfce/consulta" }],
+      AM: [{ url: "www.sefaz.am.gov.br/nfce/consulta" }],
+      BA: [{ url: "www.sefaz.ba.gov.br/nfce/consulta" }],
+      CE: [{ url: "www.sefaz.ce.gov.br/nfce/consulta" }],
+      DF: [{ url: "www.fazenda.df.gov.br/nfce/consulta" }],
+      ES: [{ url: "www.sefaz.es.gov.br/nfce/consulta" }],
+      GO: [{ url: "www.sefaz.go.gov.br/nfce/consulta" }],
+      MA: [{ url: "www.sefaz.ma.gov.br/nfce/consulta" }],
+      MT: [{ url: "http://www.sefaz.mt.gov.br/nfce/consultanfce" }],
+      MS: [{ url: "www.dfe.ms.gov.br/nfce/consulta" }],
+      MG: [{ url: "https://portalsped.fazenda.mg.gov.br/portalnfce" }],
+      PA: [{ url: "www.sefa.pa.gov.br/nfce/consulta" }],
+      PB: [{ url: "www.receita.pb.gov.br/nfce/consulta" }],
+      PR: [{ url: "http://www.fazenda.pr.gov.br/nfce/consulta" }],
+      PE: [{ url: "nfce.sefaz.pe.gov.br/nfce/consulta" }],
+      PI: [{ url: "www.sefaz.pi.gov.br/nfce/consulta" }],
+      RJ: [{ url: "www.fazenda.rj.gov.br/nfce/consulta" }],
+      RN: [{ url: "www.set.rn.gov.br/nfce/consulta" }],
+      RS: [{ url: "www.sefaz.rs.gov.br/nfce/consulta" }],
+      RO: [{ url: "www.sefin.ro.gov.br/nfce/consulta" }],
+      RR: [{ url: "www.sefaz.rr.gov.br/nfce/consulta" }],
+      SC: [{ url: "https://sat.sef.sc.gov.br/nfce/consulta" }],
+      SP: [{ url: "https://www.nfce.fazenda.sp.gov.br/consulta" }],
+      SE: [{ url: "http://www.nfce.se.gov.br/nfce/consulta" }],
+      TO: [{ url: "www.sefaz.to.gov.br/nfce/consulta" }]
+    },
+    homologacao: {
+      AC: [{ url: "www.sefaznet.ac.gov.br/nfce/consulta" }],
+      AL: [{ url: "www.sefaz.al.gov.br/nfce/consulta" }],
+      AP: [{ url: "www.sefaz.ap.gov.br/nfce/consulta" }],
+      AM: [{ url: "www.sefaz.am.gov.br/nfce/consulta" }],
+      BA: [{ url: "http://hinternet.sefaz.ba.gov.br/nfce/consulta" }],
+      CE: [{ url: "www.sefaz.ce.gov.br/nfce/consulta" }],
+      DF: [{ url: "www.fazenda.df.gov.br/nfce/consulta" }],
+      ES: [{ url: "www.sefaz.es.gov.br/nfce/consulta" }],
+      GO: [{ url: "www.sefaz.go.gov.br/nfce/consulta" }],
+      MA: [{ url: "www.sefaz.ma.gov.br/nfce/consulta" }],
+      MT: [{ url: "http://homologacao.sefaz.mt.gov.br/nfce/consultanfce" }],
+      MS: [{ url: "www.dfe.ms.gov.br/nfce/consulta" }],
+      MG: [{ url: "https://hportalsped.fazenda.mg.gov.br/portalnfce" }],
+      PA: [{ url: "www.sefa.pa.gov.br/nfce/consulta" }],
+      PB: [{ url: "www.receita.pb.gov.br/nfcehom" }],
+      PR: [{ url: "http://www.fazenda.pr.gov.br/nfce/consulta" }],
+      PE: [{ url: "nfce.sefaz.pe.gov.br/nfce/consulta" }],
+      PI: [{ url: "www.sefaz.pi.gov.br/nfce/consulta" }],
+      RJ: [{ url: "www.fazenda.rj.gov.br/nfce/consulta" }],
+      RN: [{ url: "www.set.rn.gov.br/nfce/consulta" }],
+      RS: [{ url: "www.sefaz.rs.gov.br/nfce/consulta" }],
+      RO: [{ url: "www.sefin.ro.gov.br/nfce/consulta" }],
+      RR: [{ url: "www.sefaz.rr.gov.br/nfce/consulta" }],
+      SC: [{ url: "https://hom.sat.sef.sc.gov.br/nfce/consulta" }],
+      SP: [{ url: "https://www.homologacao.nfce.fazenda.sp.gov.br/consulta" }],
+      SE: [{ url: "http://www.hom.nfe.se.gov.br/nfce/consulta" }],
+      TO: [{ url: "http://homologacao.sefaz.to.gov.br/nfce/consulta.jsf" }]
+    }
+  }
+};
+
+// packages/nfe/src/build/nfce.ts
+function vigente(lista, dia) {
+  let achado;
+  for (const e of lista ?? []) {
+    if ((e.desde ?? "") <= dia && (achado === undefined || (e.desde ?? "") >= (achado.desde ?? "")))
+      achado = e;
+  }
+  return achado;
+}
+function urlsNfce(uf, ambiente, dia) {
+  const q = vigente(nfce_urls_default.qrCode[ambiente][uf], dia);
+  const c = vigente(nfce_urls_default.urlChave[ambiente][uf], dia);
+  return { qrCode: q?.url ?? undefined, urlChave: c?.url ?? undefined };
+}
+var te = new TextEncoder;
+var NFE_NS2 = "http://www.portalfiscal.inf.br/nfe";
+async function sha1(bytes) {
+  return new Uint8Array(await globalThis.crypto.subtle.digest("SHA-1", bytes));
+}
+var hex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+async function digValHex(xml) {
+  const doc = lerXml2(xml);
+  const inf = primeiroFilho2(doc.raiz, "infNFe", NFE_NS2);
+  if (inf === undefined)
+    throw new Error("NF-e montada sem infNFe");
+  return hexDoDigestValue(codificarBase64(await sha1(te.encode(c14n(inf)))));
+}
+function hexDoDigestValue(digestValue) {
+  return hex(te.encode(digestValue));
+}
+async function hashQrCodeV2(parametros, csc) {
+  return hex(await sha1(te.encode(parametros + csc))).toUpperCase();
+}
+async function parametrosQrCode(d, qr) {
+  const tpAmb = tpAmbDoAmbiente(d.ambiente);
+  const offline = d.tpEmis === "9";
+  const dia = d.dhEmi.slice(8, 10);
+  if (qr.versao === "3") {
+    if (!offline)
+      return { parametros: `${d.chave}|3|${tpAmb}`, assinar: false };
+    const dest = d.dest;
+    const [tp, id] = dest?.CNPJ !== undefined ? ["1", dest.CNPJ] : dest?.CPF !== undefined ? ["2", dest.CPF] : dest?.idEstrangeiro !== undefined ? ["3", ""] : ["", ""];
+    return { parametros: `${d.chave}|3|${tpAmb}|${dia}|${d.vNF}|${tp}|${id}`, assinar: true };
+  }
+  const idCSC = String(Number(qr.idCSC));
+  const antes = offline ? `${d.chave}|2|${tpAmb}|${dia}|${d.vNF}|${await digValHex(d.xml)}|${idCSC}` : `${d.chave}|2|${tpAmb}|${idCSC}`;
+  return { parametros: `${antes}|${await hashQrCodeV2(antes, qr.CSC)}`, assinar: false };
+}
+async function assinarParametros(parametros, signer) {
+  const bytes = te.encode(parametros);
+  if (signer.tipo === "dados")
+    return codificarBase64(await signer.assinar(bytes, "SHA-1"));
+  const h = await sha1(bytes);
+  const di = new Uint8Array(PREFIXO_DIGEST_INFO_SHA1.length + h.length);
+  di.set(PREFIXO_DIGEST_INFO_SHA1);
+  di.set(h, PREFIXO_DIGEST_INFO_SHA1.length);
+  return codificarBase64(await signer.assinarDigestInfo(di));
+}
+var CFOP_ISSQN = "5933";
+var NFCE_LIMITE_SEM_DESTINATARIO = "10000.00";
+var TPAG_VEDADOS = {
+  "14": "duplicata mercantil não é meio de pagamento da NFC-e (YA02-10, rejeição 857)",
+  "90": "a NFC-e sempre tem pagamento: tPag 90 (sem pagamento) é recusado (YA02-40, rejeição 899)",
+  "99": "tPag 99 (outros) não é aceito na NFC-e (YA02-50, rejeição 436, NT 2020.006)"
+};
+function conferirNfce(input, ide, issues) {
+  const vedado = (path, msg) => issues.add(path, "grupo_vedado", `NFC-e ${msg}`);
+  const invalido = (path, msg) => issues.add(path, "campo_invalido", `NFC-e ${msg}`);
+  if (input.dhSaiEnt !== undefined)
+    vedado("dhSaiEnt", "sem data de entrada ou saída (B10-10, rejeição 705)");
+  if (input.dPrevEntrega !== undefined) {
+    vedado("dPrevEntrega", "sem data de previsão de entrega (NT 2025.002, B10a-10, rejeição 1153)");
+  }
+  if (ide.tpNF !== "1")
+    invalido("tpNF", "só de saída, tpNF 1 (B11-10, rejeição 706)");
+  if (ide.idDest !== "1") {
+    invalido("idDest", "só em operação interna, idDest 1 (B11a-10, rejeição 707)");
+  }
+  if (ide.tpImp !== "4" && ide.tpImp !== "5") {
+    invalido("tpImp", "com DANFC-e: tpImp 4 (impresso) ou 5 (mensagem eletrônica) (B21-10, rejeição 709)");
+  }
+  if (ide.finNFe !== "1")
+    invalido("finNFe", "só com finalidade normal, finNFe 1 (B25-20, rejeição 715)");
+  if (ide.indFinal !== "1")
+    invalido("indFinal", "só com consumidor final, indFinal 1 (B25a-10, rejeição 716)");
+  if (!["1", "4", "5"].includes(ide.indPres)) {
+    invalido("indPres", "só presencial: indPres 1, 4 (entrega a domicílio) ou 5 (NT 2025.002, B25b-20, rejeição 717)");
+  }
+  if (input.cMunFGIBS !== undefined && ide.indPres !== "5") {
+    invalido("cMunFGIBS", "com cMunFGIBS só em operação presencial fora do estabelecimento, indPres 5 (NT 2025.002, B25b-60, rejeição 1000)");
+  }
+  if (input.cMunFGIBS === undefined && ide.indPres === "5") {
+    issues.add("cMunFGIBS", "campo_obrigatorio", "NFC-e presencial fora do estabelecimento (indPres 5) informa cMunFGIBS (NT 2025.002, B25b-70, rejeição 1005)");
+  }
+  if (input.referenciadas !== undefined && input.referenciadas.length > 0) {
+    vedado("referenciadas", "não referencia documento fiscal (BA01-10, rejeição 708)");
+  }
+  if (input.gCompraGov !== undefined)
+    vedado("gCompraGov", "sem compra governamental (NT 2025.002, BB01-10, rejeição 1006)");
+  if (input.emitente.IEST !== undefined)
+    vedado("emitente.IEST", "sem IE de substituto tributário (C18-10, rejeição 718)");
+  const d = input.destinatario;
+  if (ide.indPres === "4" && d === undefined) {
+    issues.add("destinatario", "campo_obrigatorio", "NFC-e com entrega a domicílio identifica o destinatário (E01-20, rejeição 787)");
+  }
+  if (ide.indPres === "4" && d !== undefined && d.endereco === undefined) {
+    issues.add("destinatario.endereco", "campo_obrigatorio", "NFC-e com entrega a domicílio informa o endereço do destinatário (E05-20, rejeição 788)");
+  }
+  if (d !== undefined) {
+    if (d.CNPJ !== undefined && input.emitente.CNPJ !== undefined && digitos2(d.CNPJ) === digitos2(input.emitente.CNPJ)) {
+      invalido("destinatario.CNPJ", "com destinatário igual ao emitente (E02-20, rejeição 220)");
+    }
+    if (d.indIEDest !== "9") {
+      invalido("destinatario.indIEDest", "só para não contribuinte, indIEDest 9 (E16a-10, rejeição 789)");
+    }
+    if (d.ISUF !== undefined)
+      vedado("destinatario.ISUF", "sem inscrição na Suframa (E18-10, rejeição 730)");
+  }
+  input.itens.forEach((it, n) => {
+    const p = `itens[${n}]`;
+    const esp = it.produto.especifico ?? {};
+    if (esp.veicProd !== undefined)
+      vedado(`${p}.produto.especifico.veicProd`, "sem veículo novo (J01-10, rejeição 736)");
+    if (esp.arma !== undefined)
+      vedado(`${p}.produto.especifico.arma`, "sem armamento (L01-10, rejeição 738)");
+    if (esp.nRECOPI !== undefined)
+      vedado(`${p}.produto.especifico.nRECOPI`, "sem papel imune RECOPI (LB01-10, rejeição 348)");
+    if (it.produto.tpCredPresIBSZFM !== undefined) {
+      vedado(`${p}.produto.tpCredPresIBSZFM`, "sem classificação para subapuração do IBS na ZFM (NT 2025.002, I05k-10, rejeição 1165)");
+    }
+    const cfop = it.produto.CFOP.replace(/\D/g, "");
+    const imp = it.impostos;
+    if (cfop === CFOP_ISSQN && imp.issqn === undefined) {
+      issues.add(`${p}.impostos.issqn`, "combinacao_invalida", "NFC-e com CFOP 5.933 tem o grupo do ISSQN (I08-160, rejeição 374)");
+    }
+    if (cfop !== CFOP_ISSQN && imp.issqn !== undefined) {
+      issues.add(`${p}.produto.CFOP`, "combinacao_invalida", "NFC-e com ISSQN usa o CFOP 5.933 (I08-170, rejeição 374)");
+    }
+    const icms = imp.icms;
+    if (icms?.grupo === "Part")
+      vedado(`${p}.impostos.icms`, "sem partilha do ICMS entre UF (N12-50, rejeição 741)");
+    if (icms?.grupo === "ST")
+      vedado(`${p}.impostos.icms`, "sem repasse do ICMS-ST retido (N12-60, rejeição 740)");
+    if (icms?.grupo === undefined && icms?.CST === "90" && icms.st !== undefined) {
+      vedado(`${p}.impostos.icms.st`, "com CST 90 sem os dados do ICMS-ST (N12-34, rejeição 381)");
+    }
+    if (imp.icmsUfDest !== undefined)
+      vedado(`${p}.impostos.icmsUfDest`, "sem ICMS da UF de destino (NA01-10, rejeição 807)");
+    if (imp.ipi !== undefined)
+      vedado(`${p}.impostos.ipi`, "sem IPI (O01-10, rejeição 742)");
+    if (imp.ii !== undefined)
+      vedado(`${p}.impostos.ii`, "sem imposto de importação (P01-10, rejeição 743)");
+    if (imp.pisSt !== undefined)
+      vedado(`${p}.impostos.pisSt`, "sem PIS-ST (R01-10, rejeição 746)");
+    if (imp.cofinsSt !== undefined)
+      vedado(`${p}.impostos.cofinsSt`, "sem COFINS-ST (T01-10, rejeição 749)");
+    if (it.impostoDevol !== undefined)
+      vedado(`${p}.impostoDevol`, "sem devolução de tributos (UA01-20, rejeição 390)");
+  });
+  const tr = input.transporte;
+  const entrega = ide.indPres === "4";
+  if (tr !== undefined && tr.modFrete !== "9" && !entrega) {
+    invalido("transporte.modFrete", "sem frete fora da entrega a domicílio: modFrete 9 (X02-10, rejeição 753)");
+  }
+  if (tr?.transportador !== undefined && !entrega) {
+    vedado("transporte.transportador", "só tem transportador na entrega a domicílio (X03-10, rejeição 754)");
+  }
+  if (entrega && tr?.transportador === undefined) {
+    issues.add("transporte.transportador", "campo_obrigatorio", "NFC-e com entrega a domicílio identifica o transportador (X03-20, rejeição 786)");
+  }
+  if (tr?.retTransp !== undefined)
+    vedado("transporte.retTransp", "sem retenção do ICMS no transporte (X11-10, rejeição 755)");
+  if (tr?.veicTransp !== undefined)
+    vedado("transporte.veicTransp", "sem veículo de transporte (X18-10, rejeição 756)");
+  if (tr?.reboque !== undefined)
+    vedado("transporte.reboque", "sem reboque (X22-10, rejeição 757)");
+  if (input.cobranca !== undefined)
+    vedado("cobranca", "sem fatura nem duplicata (Y01-10, rejeição 760)");
+  if (input.pagamento === undefined || input.pagamento.detPag.length === 0) {
+    issues.add("pagamento", "campo_obrigatorio", "a NFC-e informa o pagamento: tPag 90 (sem pagamento) é recusado (YA02-40, rejeição 899)");
+  } else {
+    input.pagamento.detPag.forEach((p, n) => {
+      const motivo = TPAG_VEDADOS[p.tPag];
+      if (motivo !== undefined)
+        issues.add(`pagamento.detPag[${n}].tPag`, "pagamento_invalido", motivo);
+      if (["03", "04", "17"].includes(p.tPag) && p.card === undefined) {
+        issues.add(`pagamento.detPag[${n}].card`, "campo_obrigatorio", "pagamento com cartão (tPag 03 ou 04) ou PIX (17) informa o grupo card (NT 2025.001, YA04-10, rejeição 391)");
+      }
+    });
+  }
+  if (input.exporta !== undefined)
+    vedado("exporta", "sem comércio exterior (ZA01-30, rejeição 814)");
+  if (input.compra !== undefined)
+    vedado("compra", "sem dados de compra (ZB01-10, rejeição 762)");
+  if (input.cana !== undefined)
+    vedado("cana", "sem aquisição de cana (ZC01-10, rejeição 763)");
+}
+function pagamentoNfce(pag, vNF, issues) {
+  const total = pag.detPag.reduce((a, p) => a.plus(Decimal.of(p.vPag)), Decimal.ZERO);
+  const troco = total.minus(vNF);
+  const posterior = pag.detPag.some((p) => p.tPag === "91");
+  pag.detPag.forEach((p, n) => {
+    if (p.tPag === "91" && !Decimal.of(p.vPag).isZero()) {
+      issues.add(`pagamento.detPag[${n}].vPag`, "pagamento_invalido", "pagamento posterior (tPag 91) tem vPag zero (NT 2025.001 v1.03, YA03-30, rejeição 904)");
+    }
+  });
+  if (troco.isNegative() && !posterior) {
+    issues.add("pagamento.detPag", "pagamento_invalido", `pagamentos (${total.toFixed(2)}) abaixo do total da NFC-e (${vNF.toFixed(2)}) (NT 2025.001 v1.03, YA03-10, rejeição 865)`);
+  }
+  if (pag.vTroco === undefined) {
+    if (!troco.isNegative() && !troco.isZero())
+      pag.vTroco = troco.toFixed(2);
+  } else if (!Decimal.of(pag.vTroco).eq(troco)) {
+    issues.add("pagamento.vTroco", "valor_divergente", `troco ${pag.vTroco} difere de pagamentos menos o total (${troco.toFixed(2)}) (YA09-10, rejeição 869)`);
+  }
+  pag.detPag.forEach((p, n) => {
+    const c = p.card;
+    if (c === undefined)
+      return;
+    const path = `pagamento.detPag[${n}].card`;
+    if (c.tpIntegra === "1" && (c.CNPJ === undefined || c.cAut === undefined)) {
+      issues.add(path, "campo_obrigatorio", "cartão integrado à automação (tpIntegra 1) informa o CNPJ da credenciadora e o cAut (NT 2025.001, YA05-10, rejeição 392)");
+    }
+    if (c.CNPJ !== undefined) {
+      const r = lerCnpj2(c.CNPJ, { caminho: `${path}.CNPJ` });
+      if (!r.ok)
+        issues.list.push(r.erro);
+    }
+  });
+}
+var digitos2 = (s) => s.replace(/[^0-9A-Za-z]/g, "").toUpperCase();
+
+// packages/nfe/src/build/pl.ts
+import { ErroNaoSuportado } from "@sinete/core";
+import { ehComplexType, ehElementParticle, ehWildcard, selecionarPl } from "@sinete/schemas";
+import { TNFe_infNFe as Inf010e } from "@sinete/schemas/nfe/PL_010e";
+import { TNFe_infNFe as Inf010f } from "@sinete/schemas/nfe/PL_010f";
+var INF_NFE = {
+  "nfe/PL_010e": Inf010e,
+  "nfe/PL_010f": Inf010f
+};
+function escolherPl(ambiente, emissao) {
+  const vigencia = selecionarPl("nfe", ambiente, emissao);
+  const infNFe = INF_NFE[vigencia.modulo];
+  if (infNFe === undefined) {
+    throw new ErroNaoSuportado(`@sinete/nfe não conhece o módulo ${vigencia.modulo}; atualize o pacote`);
+  }
+  return { vigencia, infNFe };
+}
+function memberNames(p, acc) {
+  if (ehWildcard(p))
+    acc.add("$any");
+  else if (ehElementParticle(p))
+    acc.add(p.e);
+  else
+    for (const i of p.i)
+      memberNames(i, acc);
+  return acc;
+}
+function elementTypes(p, acc) {
+  if (ehWildcard(p))
+    return acc;
+  if (ehElementParticle(p)) {
+    if (ehComplexType(p.t))
+      acc.set(p.e, p.t);
+  } else
+    for (const i of p.i)
+      elementTypes(i, acc);
+  return acc;
+}
+function camposForaDoPl(ct, value, path, pl, issues) {
+  if (typeof value !== "object" || value === null)
+    return;
+  const allowed = new Set(["$attrs", "$text"]);
+  for (const a of ct.a ?? [])
+    allowed.add(a.a);
+  if (ct.c)
+    memberNames(ct.c, allowed);
+  const children = ct.c ? elementTypes(ct.c, new Map) : new Map;
+  for (const [k, v] of Object.entries(value)) {
+    if (v === undefined)
+      continue;
+    if (!allowed.has(k)) {
+      issues.montagem(`${path}.${k}`, "campo_fora_do_pl", `o campo não existe no ${pl} vigente para esta emissão`);
+      continue;
+    }
+    const child = children.get(k);
+    if (!child)
+      continue;
+    if (Array.isArray(v)) {
+      for (const [n, x] of v.entries())
+        camposForaDoPl(child, x, `${path}.${k}[${n}]`, pl, issues);
+    } else
+      camposForaDoPl(child, v, `${path}.${k}`, pl, issues);
+  }
+}
+
+// packages/nfe/src/build/rejeicoes.ts
+var CFOP_CST50_ISENTO = new Set([
+  "1915",
+  "1916",
+  "2915",
+  "2916",
+  "5915",
+  "5916",
+  "6915",
+  "6916",
+  "1912",
+  "1913",
+  "5912",
+  "5913"
+]);
+function cstComIsento(input, idDest, issues) {
+  const d = input.destinatario;
+  if (d?.indIEDest !== "2")
+    return;
+  input.itens.forEach((it, n) => {
+    const icms = it.impostos.icms;
+    if (icms === undefined || !("CST" in icms))
+      return;
+    const cst = icms.CST;
+    if (cst === "50" && CFOP_CST50_ISENTO.has(it.produto.CFOP.replace(/\D/g, "")))
+      return;
+    if (cst === "51" && idDest === "1")
+      return;
+    if (cst !== "50" && cst !== "51")
+      return;
+    issues.add(`itens[${n}].impostos.icms.CST`, "combinacao_invalida", `CST ${cst} não se usa com destinatário contribuinte isento de IE (indIEDest 2) (N12-80, rejeição 529)`);
+  });
+}
+var dataNoFuso = (instante, offsetMinutes) => formatarDh(instante, offsetMinutes).slice(0, 10);
+var OFFSET_BRASILIA = -180;
+function vencimentos(input, emissao, issues) {
+  const dups = input.cobranca?.duplicatas;
+  if (dups === undefined || dups.length !== 1)
+    return;
+  const unica = dups[0]?.dVenc;
+  if (unica === undefined)
+    return;
+  const local = emissao.dhEmi.slice(0, 10);
+  const datas = new Set([local, dataNoFuso(emissao.instante, OFFSET_BRASILIA), dataNoFuso(emissao.instante, 0)]);
+  if (datas.size === 1 && datas.has(unica)) {
+    issues.add("cobranca.duplicatas", "combinacao_invalida", "uma parcela só, vencendo na data de emissão, é pagamento à vista: não informe a cobrança (Y09-40, rejeição 853)");
+  }
+}
+var soDocumento = (s) => s.replace(/[^0-9A-Za-z]/g, "").toUpperCase();
+function conferirEmitenteDoCertificado(nfe, titular) {
+  const e = nfe.emitente;
+  if (e.CNPJ !== undefined && titular.cnpj !== undefined) {
+    const base = soDocumento(e.CNPJ).slice(0, 8);
+    if (base !== soDocumento(titular.cnpj).slice(0, 8)) {
+      return [
+        {
+          caminho: "emitente.CNPJ",
+          code: "emitente_difere_do_certificado",
+          mensagem: `CNPJ-base ${base} do emitente difere do CNPJ-base do certificado (F03, rejeição 213)`,
+          origem: "entrada"
+        }
+      ];
+    }
+  }
+  if (e.CPF !== undefined && titular.cpf !== undefined && soDocumento(e.CPF) !== soDocumento(titular.cpf)) {
+    return [
+      {
+        caminho: "emitente.CPF",
+        code: "emitente_difere_do_certificado",
+        mensagem: "CPF do emitente difere do CPF do certificado (F03A, rejeição 227)",
+        origem: "entrada"
+      }
+    ];
+  }
+  return [];
+}
+
+// packages/nfe/src/build/tributos.ts
+function buildIpi(ctx, input, vOp, path) {
+  const head = {
+    CNPJProd: input.CNPJProd === undefined ? undefined : input.CNPJProd.replace(/[./-]/g, "").toUpperCase(),
+    cSelo: input.cSelo,
+    qSelo: input.qSelo,
+    cEnq: input.cEnq
+  };
+  if (!["00", "49", "50", "99"].includes(input.CST)) {
+    return { grupo: { ...clean(head), IPINT: { CST: input.CST } }, vIPI: Decimal.ZERO };
+  }
+  const i = input;
+  let trib;
+  let vIPI;
+  if (i.qUnid !== undefined || i.vUnid !== undefined) {
+    const qUnid = ctx.req(i.qUnid, `${path}.qUnid`, D1204V);
+    const vUnid = ctx.req(i.vUnid, `${path}.vUnid`, D1104);
+    vIPI = ctx.calc(i.vIPI, qUnid.times(vUnid), `${path}.vIPI`, D1302, "ipi");
+    trib = { CST: i.CST, qUnid: ctx.s(qUnid, D1204V), vUnid: ctx.s(vUnid, D1104), vIPI: ctx.s(vIPI, D1302) };
+  } else {
+    const pIPI = ctx.req(i.pIPI, `${path}.pIPI`, D0302A04);
+    const vBC = ctx.base(i.vBC, vOp, `${path}.vBC`, D1302, "ipi");
+    vIPI = ctx.calc(i.vIPI, vBC.percent(pIPI), `${path}.vIPI`, D1302, "ipi");
+    trib = { CST: i.CST, vBC: ctx.s(vBC, D1302), pIPI: ctx.s(pIPI, D0302A04), vIPI: ctx.s(vIPI, D1302) };
+  }
+  return { grupo: { ...clean(head), IPITrib: clean(trib) }, vIPI };
+}
+function buildIi(ctx, input, path) {
+  const vII = ctx.req(input.vII, `${path}.vII`, D1302);
+  return {
+    grupo: {
+      vBC: ctx.s(ctx.req(input.vBC, `${path}.vBC`, D1302), D1302),
+      vDespAdu: ctx.s(ctx.req(input.vDespAdu, `${path}.vDespAdu`, D1302), D1302),
+      vII: ctx.s(vII, D1302),
+      vIOF: ctx.s(ctx.req(input.vIOF, `${path}.vIOF`, D1302), D1302)
+    },
+    vII
+  };
+}
+function buildPisCofins(ctx, input, tag, path) {
+  const p = `p${tag}`;
+  const v = `v${tag}`;
+  const cst = input.CST;
+  if (!("vBC" in input) && !("qBCProd" in input)) {
+    return { grupo: { [`${tag}NT`]: { CST: cst } }, valor: Decimal.ZERO };
+  }
+  const i = input;
+  let body;
+  let valor;
+  if (i.qBCProd !== undefined) {
+    const q = ctx.req(i.qBCProd, `${path}.qBCProd`, D1204V);
+    const a = ctx.req(i.vAliqProd, `${path}.vAliqProd`, D1104V);
+    valor = ctx.calc(i.valor, q.times(a), `${path}.valor`, D1302, "pisCofins");
+    body = { CST: cst, qBCProd: ctx.s(q, D1204V), vAliqProd: ctx.s(a, D1104V), [v]: ctx.s(valor, D1302) };
+  } else {
+    const vBC = ctx.req(i.vBC, `${path}.vBC`, D1302);
+    const a = ctx.req(i.aliquota, `${path}.aliquota`, D0302A04);
+    valor = ctx.calc(i.valor, vBC.percent(a), `${path}.valor`, D1302, "pisCofins");
+    body = { CST: cst, vBC: ctx.s(vBC, D1302), [p]: ctx.s(a, D0302A04), [v]: ctx.s(valor, D1302) };
+  }
+  const nome = cst === "01" || cst === "02" ? "Aliq" : cst === "03" ? "Qtde" : "Outr";
+  return { grupo: { [`${tag}${nome}`]: body }, valor };
+}
+function buildPisCofinsSt(ctx, input, tag, path) {
+  let body;
+  let valor;
+  if (input.qBCProd !== undefined) {
+    const q = ctx.req(input.qBCProd, `${path}.qBCProd`, D1204);
+    const a = ctx.req(input.vAliqProd, `${path}.vAliqProd`, D1104);
+    valor = ctx.calc(input.valor, q.times(a), `${path}.valor`, D1302, "pisCofins");
+    body = { qBCProd: ctx.s(q, D1204), vAliqProd: ctx.s(a, D1104) };
+  } else {
+    const fBC = tag === "PIS" ? D1302_OPC : D1302;
+    const vBC = ctx.req(input.vBC, `${path}.vBC`, fBC);
+    const a = ctx.req(input.aliquota, `${path}.aliquota`, D0302A04);
+    valor = ctx.calc(input.valor, vBC.percent(a), `${path}.valor`, D1302, "pisCofins");
+    body = { vBC: ctx.s(vBC, fBC), [`p${tag}`]: ctx.s(a, D0302A04) };
+  }
+  body[`v${tag}`] = ctx.s(valor, D1302);
+  body[`indSoma${tag}ST`] = input.indSoma;
+  return { grupo: clean(body), valor, soma: input.indSoma === "1" };
+}
+function buildIssqn(ctx, input, path) {
+  const vBC = ctx.req(input.vBC, `${path}.vBC`, D1302);
+  const vAliq = ctx.req(input.vAliq, `${path}.vAliq`, D0302A04);
+  const vISSQN = ctx.calc(input.vISSQN, vBC.percent(vAliq), `${path}.vISSQN`, D1302, "issqn");
+  const opcionais = {};
+  const opt = (k) => {
+    const d = ctx.opt(input[k], `${path}.${k}`, D1302);
+    if (d !== undefined)
+      opcionais[k] = d;
+    return ctx.so(d, D1302_OPC);
+  };
+  return {
+    grupo: clean({
+      vBC: ctx.s(vBC, D1302),
+      vAliq: ctx.s(vAliq, D0302A04),
+      vISSQN: ctx.s(vISSQN, D1302),
+      cMunFG: input.cMunFG,
+      cListServ: input.cListServ,
+      vDeducao: opt("vDeducao"),
+      vOutro: opt("vOutro"),
+      vDescIncond: opt("vDescIncond"),
+      vDescCond: opt("vDescCond"),
+      vISSRet: opt("vISSRet"),
+      indISS: input.indISS,
+      cServico: input.cServico,
+      cMun: input.cMun,
+      cPais: input.cPais === undefined ? undefined : digits(input.cPais),
+      nProcesso: input.nProcesso,
+      indIncentivo: input.indIncentivo
+    }),
+    vBC,
+    vISSQN,
+    opcionais
+  };
+}
+function buildIcmsUfDest(ctx, input, path) {
+  const pFCPUFDest = ctx.opt(input.pFCPUFDest, `${path}.pFCPUFDest`, D0302A04);
+  const vFCPUFDest = ctx.opt(input.vFCPUFDest, `${path}.vFCPUFDest`, D1302);
+  if (pFCPUFDest !== undefined && vFCPUFDest === undefined) {
+    ctx.issues.add(`${path}.vFCPUFDest`, "campo_obrigatorio", "pFCPUFDest informado exige vFCPUFDest");
+  }
+  const vICMSUFDest = ctx.req(input.vICMSUFDest, `${path}.vICMSUFDest`, D1302);
+  const vICMSUFRemet = ctx.opt(input.vICMSUFRemet, `${path}.vICMSUFRemet`, D1302) ?? Decimal.ZERO;
+  const vBCFCPUFDest = ctx.opt(input.vBCFCPUFDest, `${path}.vBCFCPUFDest`, D1302);
+  return {
+    grupo: clean({
+      vBCUFDest: ctx.s(ctx.req(input.vBCUFDest, `${path}.vBCUFDest`, D1302), D1302),
+      vBCFCPUFDest: ctx.so(vBCFCPUFDest, D1302),
+      pFCPUFDest: ctx.so(pFCPUFDest, D0302A04),
+      pICMSUFDest: ctx.s(ctx.req(input.pICMSUFDest, `${path}.pICMSUFDest`, D0302A04), D0302A04),
+      pICMSInter: input.pICMSInter,
+      pICMSInterPart: ctx.s(ctx.opt(input.pICMSInterPart, `${path}.pICMSInterPart`, D0302A04) ?? Decimal.HUNDRED, D0302A04),
+      vFCPUFDest: ctx.so(vFCPUFDest, D1302),
+      vICMSUFDest: ctx.s(vICMSUFDest, D1302),
+      vICMSUFRemet: ctx.s(vICMSUFRemet, D1302)
+    }),
+    vFCPUFDest: vFCPUFDest ?? Decimal.ZERO,
+    vICMSUFDest,
+    vICMSUFRemet
+  };
+}
+
+// packages/nfe/src/build/build.ts
+var padrao;
+function calculadoraPadrao() {
+  padrao ??= calculadoraIbsCbs();
+  return padrao;
+}
+var NFE_NS3 = "http://www.portalfiscal.inf.br/nfe";
+var XNOME_HOMOLOGACAO = "NF-E EMITIDA EM AMBIENTE DE HOMOLOGACAO - SEM VALOR FISCAL";
+var XPROD_HOMOLOGACAO_NFCE = "NOTA FISCAL EMITIDA EM AMBIENTE DE HOMOLOGACAO - SEM VALOR FISCAL";
+var MODES = Object.fromEntries(Object.entries(arredondamento_default.familias).map(([k, v]) => [k, v.modo]));
+var SEM_GTIN = "SEM GTIN";
+var BRASILIA = -180;
+function diaBrasilia(d) {
+  return formatarDh(d, BRASILIA).slice(0, 10);
+}
+function exigenciaRespTec(uf, ambiente, data) {
+  const dia = diaBrasilia(data);
+  const ufs = resp_tec_default.ufs;
+  const regra = Object.hasOwn(ufs, uf) ? ufs[uf] : undefined;
+  const vale = (r, padrao) => {
+    const desde = r?.[ambiente];
+    if (desde !== undefined)
+      return dia >= desde ? "obrigatorio" : padrao;
+    return padrao;
+  };
+  return {
+    infRespTec: vale(regra?.infRespTec, resp_tec_default.padrao.infRespTec),
+    csrt: vale(regra?.csrt, resp_tec_default.padrao.csrt)
+  };
+}
+async function hashCsrt(csrt, chave) {
+  const d = await globalThis.crypto.subtle.digest("SHA-1", new TextEncoder().encode(csrt + chave));
+  return codificarBase642(new Uint8Array(d));
+}
+function documento(doc, path, issues) {
+  if (doc.CNPJ !== undefined) {
+    const r = lerCnpj3(doc.CNPJ, { caminho: `${path}.CNPJ` });
+    if (!r.ok)
+      issues.list.push(r.erro);
+    return { CNPJ: r.ok ? r.valor : doc.CNPJ };
+  }
+  const r = lerCpf(doc.CPF ?? "", { caminho: `${path}.CPF` });
+  if (!r.ok)
+    issues.list.push(r.erro);
+  return { CPF: r.ok ? r.valor : doc.CPF ?? "" };
+}
+function ie(value, uf, path, issues, allowIsento) {
+  if (value === undefined)
+    return;
+  const r = lerIe(value, uf, { caminho: path, aceitarIsento: allowIsento });
+  if (!r.ok) {
+    issues.list.push(r.erro);
+    return value;
+  }
+  return r.valor.valor;
+}
+function endereco(e) {
+  return {
+    xLgr: e.xLgr,
+    nro: e.nro,
+    xCpl: e.xCpl,
+    xBairro: e.xBairro,
+    cMun: e.cMun,
+    xMun: e.xMun,
+    UF: e.UF,
+    CEP: e.CEP === undefined ? undefined : digits(e.CEP),
+    fone: e.fone === undefined ? undefined : digits(e.fone)
+  };
+}
+function isExterior(e) {
+  return e !== undefined && "exterior" in e && e.exterior === true;
+}
+function gerarChave(parts, cNFInformado, random, issues) {
+  const tentar = (cNF) => {
+    const chave = montarChaveAcesso({ ...parts, cNF });
+    const r = lerChaveAcesso(chave, { emissao: true, caminho: "chave" });
+    return r.ok ? { chave, ok: true } : { chave, ok: false, issue: r.erro };
+  };
+  if (cNFInformado !== undefined) {
+    if (!/^\d{8}$/.test(cNFInformado)) {
+      issues.add("cNF", "campo_invalido", "cNF tem 8 algarismos");
+      return;
+    }
+    const r = tentar(cNFInformado);
+    if (!r.ok && r.issue) {
+      const doCnf = r.issue.code === "chave_cnf_invalido";
+      issues.list.push({
+        ...r.issue,
+        caminho: doCnf ? "cNF" : r.issue.caminho,
+        code: "chave_invalida",
+        mensagem: `${r.issue.mensagem} (${r.issue.code})`,
+        origem: doCnf ? "entrada" : "montagem"
+      });
+    }
+    return r.ok ? { chave: r.chave, cNF: cNFInformado } : undefined;
+  }
+  for (let n = 0;n < 32; n++) {
+    const b = random(new Uint8Array(4));
+    const v = ((b[0] ?? 0) * 2 ** 24 + (b[1] ?? 0) * 2 ** 16 + (b[2] ?? 0) * 2 ** 8 + (b[3] ?? 0)) % 1e8;
+    const cNF = String(v).padStart(8, "0");
+    const r = tentar(cNF);
+    if (r.ok)
+      return { chave: r.chave, cNF };
+    if (r.issue && r.issue.code !== "chave_cnf_invalido") {
+      issues.list.push({
+        ...r.issue,
+        code: "chave_invalida",
+        mensagem: `${r.issue.mensagem} (${r.issue.code})`,
+        origem: "montagem"
+      });
+      return;
+    }
+  }
+  issues.montagem("cNF", "chave_invalida", "não foi possível gerar um cNF válido");
+  return;
+}
+function referencia(ref, path, issues) {
+  const chave = (c, p) => {
+    const r = lerChaveAcesso(c, { caminho: p });
+    if (!r.ok)
+      issues.list.push(r.erro);
+    return r.ok ? r.valor.chave : c;
+  };
+  if ("refNFe" in ref)
+    return { refNFe: chave(ref.refNFe, `${path}.refNFe`) };
+  if ("refNFeSig" in ref) {
+    const c = ref.refNFeSig.replace(/\s/g, "").toUpperCase();
+    if (!/^[0-9]{6}[0-9A-Z]{12}[0-9]{2}55[0-9]{22}$/.test(c) || c.slice(35, 43) !== "00000000") {
+      issues.add(`${path}.refNFeSig`, "chave_invalida", "chave de NF-e (modelo 55) com o código numérico (cNF) zerado");
+    }
+    return { refNFeSig: c };
+  }
+  if ("refCTe" in ref)
+    return { refCTe: chave(ref.refCTe, `${path}.refCTe`) };
+  if ("refNF" in ref)
+    return { refNF: ref.refNF };
+  if ("refECF" in ref)
+    return { refECF: ref.refECF };
+  const nfp = ref.refNFP;
+  if (nfp.mod === "04") {
+    const porUf = produtor_rural_default.refNFP.ufs;
+    const cUfSigla = Object.keys(porUf).find((k) => ufPorSigla2(k)?.cUF === nfp.cUF);
+    const vedadaDesde = cUfSigla ? porUf[cUfSigla]?.vedadaDesde ?? "" : produtor_rural_default.refNFP.modelo04.vedadaDesde;
+    if (nfp.AAMM >= vedadaDesde) {
+      issues.add(`${path}.refNFP.AAMM`, "referencia_vedada", `nota de produtor modelo 04 emitida em ${nfp.AAMM}, depois do fim do modelo (${vedadaDesde}; ${produtor_rural_default.refNFP.modelo04.fonte})`);
+    }
+  }
+  const doc = documento(nfp, `${path}.refNFP`, issues);
+  return {
+    refNFP: {
+      cUF: nfp.cUF,
+      AAMM: nfp.AAMM,
+      ...doc,
+      IE: nfp.IE,
+      mod: nfp.mod,
+      serie: String(Number(nfp.serie)),
+      nNF: String(Number(nfp.nNF))
+    }
+  };
+}
+function textoXmlValido(texto) {
+  for (const ch of texto) {
+    const c = ch.codePointAt(0) ?? 0;
+    const ok = c === 9 || c === 10 || c === 13 || c >= 32 && c <= 55295 || c >= 57344 && c <= 65533 || c >= 65536 && c <= 1114111;
+    if (!ok)
+      return false;
+  }
+  return true;
+}
+function textosForaDoXml(value, path, issues) {
+  if (typeof value === "string") {
+    if (!textoXmlValido(value))
+      issues.montagem(path, "campo_invalido", "texto com caractere não permitido em XML");
+  } else if (Array.isArray(value)) {
+    for (const [n, v] of value.entries())
+      textosForaDoXml(v, `${path}[${n}]`, issues);
+  } else if (typeof value === "object" && value !== null) {
+    for (const [k, v] of Object.entries(value))
+      textosForaDoXml(v, `${path}.${k}`, issues);
+  }
+}
+function montarItem(ctx, item, n, normal) {
+  const path = `itens[${n}]`;
+  const p = item.produto;
+  const pp = `${path}.produto`;
+  const qCom = ctx.req(p.qCom, `${pp}.qCom`, D1104V);
+  const vUnCom = ctx.req(p.vUnCom, `${pp}.vUnCom`, D1110V);
+  const vProd = (normal ? ctx.calc : ctx.base).call(ctx, p.vProd, qCom.times(vUnCom), `${pp}.vProd`, D1302, "produto");
+  const uTrib = p.uTrib ?? p.uCom;
+  const qTrib = p.qTrib === undefined ? qCom : ctx.req(p.qTrib, `${pp}.qTrib`, D1104V);
+  let vUnTrib;
+  if (p.vUnTrib !== undefined)
+    vUnTrib = ctx.req(p.vUnTrib, `${pp}.vUnTrib`, D1110V);
+  else if (uTrib === p.uCom && qTrib.eq(qCom))
+    vUnTrib = vUnCom;
+  else if (qTrib.isZero())
+    vUnTrib = Decimal.ZERO;
+  else
+    vUnTrib = vProd.dividedBy(qTrib, 10, ctx.modes.produto);
+  if (normal) {
+    const trib = ctx.round(qTrib.times(vUnTrib), D1302, "produto");
+    if (trib.minus(vProd).abs().gt(TOLERANCIA)) {
+      ctx.issues.add(`${pp}.vUnTrib`, "valor_divergente", `qTrib × vUnTrib (${trib.toFixed(2)}) difere de vProd (${vProd.toFixed(2)}) em mais de ${TOLERANCIA.toString()}`);
+    }
+  }
+  const opt = (v, k) => ctx.opt(v, `${pp}.${k}`, D1302) ?? Decimal.ZERO;
+  const vFrete = opt(p.vFrete, "vFrete");
+  const vSeg = opt(p.vSeg, "vSeg");
+  const vDesc = opt(p.vDesc, "vDesc");
+  const vOutro = opt(p.vOutro, "vOutro");
+  const vOp = vProd.plus(vFrete).plus(vSeg).plus(vOutro).minus(vDesc);
+  const cEAN = p.cEAN ?? SEM_GTIN;
+  const especifico = p.especifico ?? {};
+  const prod = clean({
+    cProd: p.cProd,
+    cEAN,
+    cBarra: p.cBarra,
+    xProd: p.xProd,
+    NCM: digits(p.NCM),
+    NVE: p.NVE,
+    CEST: p.CEST === undefined ? undefined : digits(p.CEST),
+    indEscala: p.indEscala,
+    CNPJFab: p.CNPJFab,
+    cBenef: p.cBenef,
+    gCred: p.gCred,
+    tpCredPresIBSZFM: p.tpCredPresIBSZFM,
+    EXTIPI: p.EXTIPI,
+    CFOP: digits(p.CFOP),
+    uCom: p.uCom,
+    qCom: ctx.s(qCom, D1104V),
+    vUnCom: ctx.s(vUnCom, D1110V),
+    vProd: ctx.s(vProd, D1302),
+    cEANTrib: p.cEANTrib ?? cEAN,
+    cBarraTrib: p.cBarraTrib,
+    uTrib,
+    qTrib: ctx.s(qTrib, D1104V),
+    vUnTrib: ctx.s(vUnTrib, D1110V),
+    vFrete: ctx.so(vFrete, D1302_OPC),
+    vSeg: ctx.so(vSeg, D1302_OPC),
+    vDesc: ctx.so(vDesc, D1302_OPC),
+    vOutro: ctx.so(vOutro, D1302_OPC),
+    indTot: p.indTot ?? "1",
+    indBemMovelUsado: p.indBemMovelUsado,
+    DI: p.DI,
+    detExport: p.detExport,
+    xPed: p.xPed,
+    nItemPed: p.nItemPed,
+    nFCI: p.nFCI,
+    rastro: p.rastro,
+    infProdNFF: p.infProdNFF,
+    infProdEmb: p.infProdEmb,
+    ...especifico
+  });
+  const imp = item.impostos;
+  const ip = `${path}.impostos`;
+  const imposto = {};
+  const z = Decimal.ZERO;
+  const v = {
+    vProd,
+    vFrete,
+    vSeg,
+    vDesc,
+    vOutro,
+    vII: z,
+    vIPI: z,
+    vIPIDevol: z,
+    vPIS: z,
+    vCOFINS: z,
+    vPISST: z,
+    vCOFINSST: z,
+    vFCPUFDest: z,
+    vICMSUFDest: z,
+    vICMSUFRemet: z,
+    vTotTrib: z,
+    vISSQN: z,
+    vBCISS: z
+  };
+  let issqnOpcionais = {};
+  const vTotTrib = ctx.opt(imp.vTotTrib, `${ip}.vTotTrib`, D1302);
+  if (vTotTrib !== undefined) {
+    imposto.vTotTrib = ctx.s(vTotTrib, D1302);
+    v.vTotTrib = vTotTrib;
+  }
+  if (imp.icms !== undefined && imp.issqn !== undefined) {
+    ctx.issues.add(ip, "combinacao_invalida", "o item tem ICMS ou ISSQN, nunca os dois");
+  }
+  if (imp.ipi !== undefined) {
+    const r = buildIpi(ctx, imp.ipi, vOp, `${ip}.ipi`);
+    imposto.IPI = r.grupo;
+    v.vIPI = r.vIPI;
+  }
+  let icms = zeroIcmsTotais();
+  if (imp.icms !== undefined) {
+    const r = buildIcms(ctx, imp.icms, { vOp, vIPI: v.vIPI }, `${ip}.icms`);
+    imposto.ICMS = r.grupo;
+    icms = r.totais;
+  } else if (imp.issqn === undefined && imp.ibsCbs === undefined) {
+    ctx.issues.add(`${ip}.icms`, "campo_obrigatorio", "o item precisa de ICMS (ou ISSQN, na NF-e conjugada)");
+  }
+  if (imp.ii !== undefined) {
+    const r = buildIi(ctx, imp.ii, `${ip}.ii`);
+    imposto.II = r.grupo;
+    v.vII = r.vII;
+  }
+  if (imp.issqn !== undefined) {
+    const r = buildIssqn(ctx, imp.issqn, `${ip}.issqn`);
+    imposto.ISSQN = r.grupo;
+    v.vISSQN = r.vISSQN;
+    v.vBCISS = r.vBC;
+    issqnOpcionais = r.opcionais;
+  }
+  if (imp.pis !== undefined) {
+    const r = buildPisCofins(ctx, imp.pis, "PIS", `${ip}.pis`);
+    imposto.PIS = r.grupo;
+    v.vPIS = r.valor;
+  }
+  if (imp.pisSt !== undefined) {
+    const r = buildPisCofinsSt(ctx, imp.pisSt, "PIS", `${ip}.pisSt`);
+    imposto.PISST = r.grupo;
+    if (r.soma)
+      v.vPISST = r.valor;
+  }
+  if (imp.cofins !== undefined) {
+    const r = buildPisCofins(ctx, imp.cofins, "COFINS", `${ip}.cofins`);
+    imposto.COFINS = r.grupo;
+    v.vCOFINS = r.valor;
+  }
+  if (imp.cofinsSt !== undefined) {
+    const r = buildPisCofinsSt(ctx, imp.cofinsSt, "COFINS", `${ip}.cofinsSt`);
+    imposto.COFINSST = r.grupo;
+    if (r.soma)
+      v.vCOFINSST = r.valor;
+  }
+  if (imp.icmsUfDest !== undefined) {
+    const r = buildIcmsUfDest(ctx, imp.icmsUfDest, `${ip}.icmsUfDest`);
+    imposto.ICMSUFDest = r.grupo;
+    v.vFCPUFDest = r.vFCPUFDest;
+    v.vICMSUFDest = r.vICMSUFDest;
+    v.vICMSUFRemet = r.vICMSUFRemet;
+  }
+  if (imp.is !== undefined)
+    imposto.IS = imp.is;
+  if (imp.ibsCbs?.grupo !== undefined)
+    imposto.IBSCBS = imp.ibsCbs.grupo;
+  const det = {
+    nItem: String(n + 1),
+    prod,
+    imposto
+  };
+  if (item.impostoDevol !== undefined) {
+    const pDevol = ctx.req(item.impostoDevol.pDevol, `${path}.impostoDevol.pDevol`, D0302);
+    const vIPIDevol = ctx.req(item.impostoDevol.vIPIDevol, `${path}.impostoDevol.vIPIDevol`, D1302);
+    det.impostoDevol = { pDevol: ctx.s(pDevol, D0302), IPI: { vIPIDevol: ctx.s(vIPIDevol, D1302) } };
+    v.vIPIDevol = vIPIDevol;
+  }
+  if (item.infAdProd !== undefined)
+    det.infAdProd = item.infAdProd;
+  if (item.obsItem !== undefined)
+    det.obsItem = item.obsItem;
+  if (item.DFeReferenciado !== undefined) {
+    const r = lerChaveAcesso(item.DFeReferenciado.chaveAcesso, { caminho: `${path}.DFeReferenciado.chaveAcesso` });
+    if (!r.ok)
+      ctx.issues.list.push(r.erro);
+    det.DFeReferenciado = clean({
+      chaveAcesso: r.ok ? r.valor.chave : item.DFeReferenciado.chaveAcesso,
+      nItem: item.DFeReferenciado.nItem === undefined ? undefined : String(item.DFeReferenciado.nItem)
+    });
+  }
+  return {
+    det,
+    icms,
+    indTot: (p.indTot ?? "1") === "1",
+    issqn: imp.issqn !== undefined,
+    faturamentoDireto: especifico.veicProd?.tpOp === "2",
+    v,
+    temUfDest: imp.icmsUfDest !== undefined,
+    temTotTrib: vTotTrib !== undefined,
+    issqnOpcionais
+  };
+}
+function composicao(m, incluirProd) {
+  const v = m.v;
+  let total = (incluirProd ? v.vProd : Decimal.ZERO).minus(v.vDesc).minus(m.icms.vICMSDesonDeduz).plus(v.vFrete).plus(v.vSeg).plus(v.vOutro).plus(v.vII).plus(v.vIPI).plus(v.vPISST).plus(v.vCOFINSST);
+  if (!m.faturamentoDireto) {
+    total = total.plus(m.icms.vST).plus(m.icms.vICMSMonoReten).plus(m.icms.vFCPST).plus(v.vIPIDevol);
+  }
+  return total;
+}
+async function montarNfe(entrada, opcoes) {
+  const issues = new Issues;
+  const finNFeIn = entrada.finNFe ?? "1";
+  const mod = entrada.modelo ?? "55";
+  if (mod !== "55" && mod !== "65") {
+    issues.add("modelo", "modelo_nao_suportado", `modelo ${String(mod)}: o builder monta NF-e (55) e NFC-e (65)`);
+    return { ok: false, ocorrencias: issues.classificadas };
+  }
+  const nfce = mod === "65";
+  const indPres = entrada.indPres ?? (nfce ? "1" : finNFeIn === "2" || finNFeIn === "3" ? "0" : "9");
+  const indFinal = entrada.indFinal ?? (nfce || entrada.destinatario?.indIEDest === "9" ? "1" : "0");
+  const ctx = new Ctx(issues, { ...MODES, ...opcoes.arredondamento }, finNFeIn !== "2" && finNFeIn !== "3");
+  const pRedutorGov = entrada.gCompraGov && ctx.req(entrada.gCompraGov.pRedutor, "gCompraGov.pRedutor", D0302A04);
+  const emitUf = entrada.emitente.endereco.UF;
+  if (!ehUf2(emitUf)) {
+    issues.add("emitente.endereco.UF", "campo_invalido", "UF do emitente inválida");
+    return { ok: false, ocorrencias: issues.classificadas };
+  }
+  const cUF = ufPorSigla2(emitUf)?.cUF ?? "";
+  const offset = opcoes.deslocamentoMin ?? deslocamentoDaUf(emitUf);
+  const agora = opcoes.tempo.emissao.agora();
+  const fatoGerador = opcoes.tempo.fatoGerador.agora();
+  const dhEmi = formatarDh(agora, offset);
+  const aamm = dhEmi.slice(2, 4) + dhEmi.slice(5, 7);
+  const tpAmb = tpAmbDoAmbiente2(opcoes.ambiente);
+  const pl = escolherPl(opcoes.ambiente, relogioFixo2(agora));
+  const e = entrada.emitente;
+  const emitDoc = documento(e, "emitente", issues);
+  const serie = Number(entrada.serie);
+  const nNF = Number(entrada.nNF);
+  if (!Number.isInteger(serie) || serie < 0 || serie > 999)
+    issues.add("serie", "serie_invalida", "série de 0 a 999");
+  if (!Number.isInteger(nNF) || nNF < 1 || nNF > 999999999)
+    issues.add("nNF", "campo_invalido", "nNF de 1 a 999999999");
+  const [cpfIni, cpfFim] = produtor_rural_default.series.cpf;
+  const [cnpjIni, cnpjFim] = produtor_rural_default.series.cnpj;
+  if ("CPF" in emitDoc && (serie < cpfIni || serie > cpfFim)) {
+    issues.add("serie", "serie_invalida", `emitente pessoa física usa as séries ${cpfIni} a ${cpfFim} (${produtor_rural_default.series.fonte})`);
+  } else if ("CNPJ" in emitDoc && Number.isInteger(serie) && serie >= 0 && (serie < cnpjIni || serie > cnpjFim)) {
+    issues.add("serie", "serie_invalida", `emitente CNPJ usa as séries ${cnpjIni} a ${cnpjFim} (${produtor_rural_default.series.fonteCnpj})`);
+  }
+  const emit = clean({
+    ...emitDoc,
+    xNome: e.xNome,
+    xFant: e.xFant,
+    enderEmit: clean({ ...endereco(e.endereco), cPais: "1058", xPais: "BRASIL" }),
+    IE: ie(e.IE, emitUf, "emitente.IE", issues, true),
+    IEST: e.IEST,
+    IM: e.IM,
+    CNAE: e.CNAE,
+    CRT: e.CRT,
+    ISUFEmit: e.ISUFEmit
+  });
+  const d = entrada.destinatario;
+  let dest;
+  let destUf;
+  if (d === undefined) {
+    if (!nfce)
+      issues.add("destinatario", "campo_obrigatorio", "a NF-e exige o destinatário (E01-10, rejeição 719)");
+  } else {
+    const docDest = "idEstrangeiro" in d && d.idEstrangeiro !== undefined ? { idEstrangeiro: d.idEstrangeiro } : documento(d, "destinatario", issues);
+    let enderDest;
+    if (isExterior(d.endereco)) {
+      destUf = "EX";
+      enderDest = clean({
+        xLgr: d.endereco.xLgr,
+        nro: d.endereco.nro,
+        xCpl: d.endereco.xCpl,
+        xBairro: d.endereco.xBairro,
+        cMun: "9999999",
+        xMun: "EXTERIOR",
+        UF: "EX",
+        cPais: d.endereco.cPais,
+        xPais: d.endereco.xPais,
+        fone: d.endereco.fone === undefined ? undefined : digits(d.endereco.fone)
+      });
+    } else if (d.endereco !== undefined) {
+      destUf = d.endereco.UF;
+      enderDest = clean({ ...endereco(d.endereco), cPais: "1058", xPais: "BRASIL" });
+    }
+    const destIe = d.IE !== undefined && destUf !== undefined && destUf !== "EX" ? ie(d.IE, destUf, "destinatario.IE", issues, false) : d.IE;
+    dest = clean({
+      ...docDest,
+      xNome: opcoes.ambiente === "homologacao" ? XNOME_HOMOLOGACAO : d.xNome,
+      enderDest,
+      indIEDest: d.indIEDest,
+      IE: destIe,
+      ISUF: d.ISUF,
+      IM: d.IM,
+      email: d.email
+    });
+  }
+  const cont = entrada.contingencia;
+  const tpEmis = cont?.tpEmis ?? "1";
+  if (cont !== undefined) {
+    if (cont.xJust.length < 15 || cont.xJust.length > 256) {
+      issues.add("contingencia.xJust", "contingencia_invalida", "justificativa da contingência com 15 a 256 caracteres");
+    }
+    if (cont.dhCont.getTime() > agora.getTime()) {
+      issues.add("contingencia.dhCont", "contingencia_invalida", "entrada em contingência posterior à emissão");
+    }
+    if (!nfce && tpEmis === "9") {
+      issues.add("contingencia.tpEmis", "contingencia_invalida", "contingência off-line (tpEmis 9) é só da NFC-e (B22-10, rejeição 711)");
+    }
+    if (nfce && (tpEmis === "6" || tpEmis === "7")) {
+      issues.add("contingencia.tpEmis", "contingencia_invalida", "a NFC-e não é autorizada pela SVC; a contingência dela é off-line, tpEmis 9 (B22-70, rejeição 783)");
+    }
+  }
+  const idDest = entrada.idDest ?? (nfce ? "1" : destUf === "EX" ? "3" : destUf !== undefined && destUf !== emitUf ? "2" : "1");
+  const tpImp = entrada.tpImp ?? (nfce ? "4" : "1");
+  conferirDestinatario(entrada, {
+    mod,
+    tpNF: entrada.tpNF,
+    idDest,
+    idDestInformado: entrada.idDest !== undefined,
+    indFinal,
+    producao: opcoes.ambiente === "producao"
+  }, issues);
+  if (nfce) {
+    conferirNfce(entrada, {
+      tpNF: entrada.tpNF,
+      idDest,
+      tpImp,
+      finNFe: finNFeIn,
+      indFinal,
+      indPres
+    }, issues);
+  } else if (tpImp === "4" || tpImp === "5") {
+    issues.add("tpImp", "campo_invalido", "tpImp 4 e 5 (DANFC-e) são da NFC-e (B21-20, rejeição 710)");
+  }
+  const qr = opcoes.qrCode ?? { versao: "3" };
+  if (nfce && qr.versao === "2") {
+    if (!/^\d{1,6}$/.test(qr.idCSC) || Number(qr.idCSC) === 0) {
+      issues.montagem("qrCode.idCSC", "qrcode_invalido", "idCSC tem de 1 a 6 algarismos, diferente de zero (Manual do DANFE NFC-e 6.0, 4.6)");
+    }
+    if (qr.CSC.length < 16 || qr.CSC.length > 36) {
+      issues.montagem("qrCode.CSC", "qrcode_invalido", "o CSC tem de 16 a 36 caracteres (Manual do DANFE NFC-e 6.0, 4.6)");
+    }
+    if ("CPF" in emitDoc) {
+      issues.montagem("qrCode.versao", "qrcode_invalido", "emitente pessoa física usa o QR Code versão 3 (NT 2025.001, ZX02-222, rejeição 444)");
+    }
+  }
+  const random = opcoes.aleatorio ?? ((b) => globalThis.crypto.getRandomValues(b));
+  const emitente14 = "CNPJ" in emitDoc ? emitDoc.CNPJ : emitDoc.CPF;
+  const gerada = issues.empty ? gerarChave({ cUF, aamm, emitente: emitente14, mod, serie: String(serie), nNF: String(nNF), tpEmis }, entrada.cNF, random, issues) : undefined;
+  const chave = gerada?.chave ?? "0".repeat(44);
+  const cNF = gerada?.cNF ?? "00000000";
+  const cDV = chave.slice(43);
+  if (entrada.itens.length === 0 || entrada.itens.length > 990) {
+    issues.add("itens", "itens_limite", "a NF-e tem de 1 a 990 itens");
+  }
+  const itens = entrada.itens.map((it, n) => montarItem(ctx, it, n, finNFeIn === "1"));
+  const primeiro = itens[0];
+  if (nfce && opcoes.ambiente === "homologacao" && primeiro !== undefined) {
+    primeiro.det.prod.xProd = XPROD_HOMOLOGACAO_NFCE;
+  }
+  const classificados = entrada.itens.map((it, n) => ({ it, n })).filter(({ it }) => it.impostos.ibsCbs?.classificacao !== undefined);
+  if (classificados.length > 0) {
+    const calculadora = opcoes.ibsCbs ?? calculadoraPadrao();
+    const reqs = classificados.map(({ it, n }) => {
+      const c = it.impostos.ibsCbs?.classificacao;
+      const m = itens[n];
+      const vBC = ctx.opt(c.vBC, `itens[${n}].impostos.ibsCbs.classificacao.vBC`, D1302);
+      const qTrib = Decimal.of(m.det.prod.qTrib);
+      return {
+        nItem: n + 1,
+        CST: c.CST,
+        cClassTrib: c.cClassTrib,
+        ...c.indDoacao ? { indDoacao: c.indDoacao } : {},
+        ...c.cCredPres ? { cCredPres: c.cCredPres } : {},
+        ...c.gTribRegular ? { gTribRegular: c.gTribRegular } : {},
+        ...vBC ? { vBC } : {},
+        NCM: m.det.prod.NCM,
+        CFOP: m.det.prod.CFOP,
+        uTrib: m.det.prod.uTrib,
+        qTrib,
+        vProd: m.v.vProd,
+        vDesc: m.v.vDesc,
+        vFrete: m.v.vFrete,
+        vSeg: m.v.vSeg,
+        vOutro: m.v.vOutro,
+        vICMS: m.icms.vICMS,
+        vICMSST: m.icms.vST,
+        vFCP: m.icms.vFCP,
+        vFCPST: m.icms.vFCPST,
+        vIPI: m.v.vIPI,
+        vPIS: m.v.vPIS,
+        vCOFINS: m.v.vCOFINS,
+        vII: m.v.vII,
+        vISSQN: m.v.vISSQN,
+        vICMSUFDest: m.v.vICMSUFDest,
+        vFCPUFDest: m.v.vFCPUFDest
+      };
+    });
+    const destino = entrada.entrega !== undefined ? { UF: entrada.entrega.UF, cMun: entrada.entrega.cMun } : d?.endereco !== undefined ? isExterior(d.endereco) ? { UF: "EX", cMun: "9999999" } : { UF: d.endereco.UF, cMun: d.endereco.cMun } : undefined;
+    const compra = entrada.gCompraGov;
+    const resp = await calculadora.calcular({
+      nota: {
+        fatoGerador,
+        emissao: agora,
+        ambiente: opcoes.ambiente,
+        mod,
+        tpNF: entrada.tpNF,
+        finNFe: finNFeIn,
+        ...entrada.tpNFDebito ? { tpNFDebito: entrada.tpNFDebito } : {},
+        ...entrada.tpNFCredito ? { tpNFCredito: entrada.tpNFCredito } : {},
+        indFinal,
+        indPres,
+        emitente: { UF: emitUf, cMun: e.endereco.cMun, CRT: e.CRT },
+        ...destino ? { destino } : {},
+        ...entrada.cMunFGIBS ? { cMunFGIBS: entrada.cMunFGIBS } : {},
+        ...compra && pRedutorGov ? {
+          compraGov: {
+            tpEnteGov: compra.tpEnteGov,
+            pRedutor: pRedutorGov,
+            tpOperGov: compra.tpOperGov
+          }
+        } : {}
+      },
+      itens: reqs
+    });
+    issues.addAll(resp.ocorrencias ?? [], "montagem");
+    for (const { n } of classificados) {
+      const g = resp.itens.find((x) => x.nItem === n + 1);
+      if (g === undefined) {
+        issues.montagem(`itens[${n}].impostos.ibsCbs`, "ibscbs_calculo", "a calculadora não devolveu o grupo IBSCBS do item");
+        continue;
+      }
+      itens[n].det.imposto.IBSCBS = g.IBSCBS;
+    }
+  }
+  itens.forEach((m, n) => {
+    const imp = m.det.imposto;
+    const ib = `itens[${n}].impostos.ibsCbs`;
+    const is = `itens[${n}].impostos.is`;
+    const ibsDaCalculadora = entrada.itens[n]?.impostos.ibsCbs?.grupo === undefined;
+    const antes = issues.list.length;
+    decimaisInvalidos(imp.IBSCBS, ib, issues);
+    if (ibsDaCalculadora)
+      issues.reclassificarDesde(antes, "montagem");
+    decimaisInvalidos(imp.IS, is, issues);
+    if (issues.list.length === antes) {
+      grupoInvalido(TTribNFeCt, "IBSCBS", imp.IBSCBS, ib, issues);
+      if (ibsDaCalculadora)
+        issues.reclassificarDesde(antes, "montagem");
+      grupoInvalido(TISCt, "IS", imp.IS, is, issues);
+    }
+  });
+  if (!issues.empty)
+    return { ok: false, ocorrencias: issues.classificadas };
+  const gruposIbsCbs = itens.map((m) => m.det.imposto.IBSCBS).filter((g) => g !== undefined);
+  const somaTributosNoItem = diaBrasilia(fatoGerador) >= reforma_default.vItemSomaTributosDesde;
+  let vNFTot = Decimal.ZERO;
+  const temReforma = gruposIbsCbs.length > 0 || itens.some((m) => m.det.imposto.IS !== undefined);
+  if (temReforma) {
+    for (const m of itens) {
+      let vItem = composicao(m, m.indTot);
+      const g = m.det.imposto.IBSCBS;
+      if (somaTributosNoItem) {
+        const is = m.det.imposto.IS?.vIS;
+        if (is !== undefined)
+          vItem = vItem.plus(Decimal.of(is));
+      }
+      if (g !== undefined && somaTributosNoItem) {
+        const t = ibsCbsDoItem(g);
+        vItem = vItem.plus(t.vIBS).plus(t.vCBS);
+        if (!m.faturamentoDireto)
+          vItem = vItem.plus(t.vTotIBSMonoItem).plus(t.vTotCBSMonoItem);
+      }
+      m.det.vItem = ctx.s(vItem, D1302);
+      vNFTot = vNFTot.plus(vItem);
+    }
+  }
+  const soma = (f, filtro = () => true) => itens.filter(filtro).reduce((acc, m) => acc.plus(f(m)), Decimal.ZERO);
+  const icmsItens = (m) => !m.issqn;
+  const icmsSoma = (k) => soma((m) => m.icms[k]);
+  const vProdTot = soma((m) => m.v.vProd, (m) => m.indTot && !m.issqn);
+  const vServ = soma((m) => m.v.vProd, (m) => m.indTot && m.issqn);
+  const vNF = itens.reduce((acc, m) => acc.plus(composicao(m, m.indTot && !m.issqn)), Decimal.ZERO).plus(vServ);
+  const S = (x) => ctx.s(x, D1302);
+  const mono = itens.some((m) => m.icms.mono);
+  const ufDest = itens.some((m) => m.temUfDest);
+  const ICMSTot = clean({
+    vBC: S(icmsSoma("vBC")),
+    vICMS: S(icmsSoma("vICMS")),
+    vICMSDeson: S(icmsSoma("vICMSDeson")),
+    vFCPUFDest: ufDest ? S(soma((m) => m.v.vFCPUFDest)) : undefined,
+    vICMSUFDest: ufDest ? S(soma((m) => m.v.vICMSUFDest)) : undefined,
+    vICMSUFRemet: ufDest ? S(soma((m) => m.v.vICMSUFRemet)) : undefined,
+    vFCP: S(icmsSoma("vFCP")),
+    vBCST: S(icmsSoma("vBCST")),
+    vST: S(icmsSoma("vST")),
+    vFCPST: S(icmsSoma("vFCPST")),
+    vFCPSTRet: S(icmsSoma("vFCPSTRet")),
+    qBCMono: mono ? S(ctx.round(icmsSoma("qBCMono"), D1302, "icms")) : undefined,
+    vICMSMono: mono ? S(icmsSoma("vICMSMono")) : undefined,
+    qBCMonoReten: mono ? S(ctx.round(icmsSoma("qBCMonoReten"), D1302, "icms")) : undefined,
+    vICMSMonoReten: mono ? S(icmsSoma("vICMSMonoReten")) : undefined,
+    qBCMonoRet: mono ? S(ctx.round(icmsSoma("qBCMonoRet"), D1302, "icms")) : undefined,
+    vICMSMonoRet: mono ? S(icmsSoma("vICMSMonoRet")) : undefined,
+    vProd: S(vProdTot),
+    vFrete: S(soma((m) => m.v.vFrete)),
+    vSeg: S(soma((m) => m.v.vSeg)),
+    vDesc: S(soma((m) => m.v.vDesc)),
+    vII: S(soma((m) => m.v.vII)),
+    vIPI: S(soma((m) => m.v.vIPI)),
+    vIPIDevol: S(soma((m) => m.v.vIPIDevol)),
+    vPIS: S(soma((m) => m.v.vPIS, icmsItens)),
+    vCOFINS: S(soma((m) => m.v.vCOFINS, icmsItens)),
+    vOutro: S(soma((m) => m.v.vOutro)),
+    vNF: S(vNF),
+    vTotTrib: itens.some((m) => m.temTotTrib) ? S(soma((m) => m.v.vTotTrib)) : undefined
+  });
+  const total = { ICMSTot };
+  if (itens.some((m) => m.issqn)) {
+    const iss = itens.filter((m) => m.issqn);
+    const so = (x) => ctx.so(x, D1302_OPC);
+    const opc = (k) => so(iss.reduce((a, m) => a.plus(m.issqnOpcionais[k] ?? Decimal.ZERO), Decimal.ZERO));
+    total.ISSQNtot = clean({
+      vServ: so(vServ),
+      vBC: so(soma((m) => m.v.vBCISS, (m) => m.issqn)),
+      vISS: so(soma((m) => m.v.vISSQN, (m) => m.issqn)),
+      vPIS: so(soma((m) => m.v.vPIS, (m) => m.issqn)),
+      vCOFINS: so(soma((m) => m.v.vCOFINS, (m) => m.issqn)),
+      dCompet: dhEmi.slice(0, 10),
+      vDeducao: opc("vDeducao"),
+      vOutro: opc("vOutro"),
+      vDescIncond: opc("vDescIncond"),
+      vDescCond: opc("vDescCond"),
+      vISSRet: opc("vISSRet")
+    });
+  }
+  const comIs = itens.filter((m) => m.det.imposto.IS !== undefined);
+  if (comIs.length > 0) {
+    total.ISTot = {
+      vIS: S(comIs.reduce((a, m) => a.plus(Decimal.of(m.det.imposto.IS.vIS ?? "0")), Decimal.ZERO))
+    };
+  }
+  if (gruposIbsCbs.length > 0)
+    total.IBSCBSTot = totalIbsCbs(gruposIbsCbs);
+  if (temReforma)
+    total.vNFTot = S(vNFTot);
+  const finNFe = finNFeIn;
+  const ide = clean({
+    cUF,
+    cNF,
+    natOp: entrada.natOp,
+    mod,
+    serie: String(serie),
+    nNF: String(nNF),
+    dhEmi,
+    dhSaiEnt: entrada.dhSaiEnt === undefined ? undefined : formatarDh(entrada.dhSaiEnt, offset),
+    dPrevEntrega: entrada.dPrevEntrega,
+    tpNF: entrada.tpNF,
+    idDest,
+    cMunFG: entrada.cMunFG ?? e.endereco.cMun,
+    cMunFGIBS: entrada.cMunFGIBS,
+    tpImp,
+    tpEmis,
+    cDV,
+    tpAmb,
+    finNFe,
+    tpNFDebito: entrada.tpNFDebito,
+    tpNFCredito: entrada.tpNFCredito,
+    indFinal,
+    indPres,
+    indIntermed: entrada.indIntermed ?? (["2", "3", "4", "9"].includes(indPres) ? "0" : undefined),
+    procEmi: "0",
+    verProc: opcoes.verProc ?? formatarVerProc("sinete", VERSAO_PACOTE),
+    dhCont: cont === undefined ? undefined : formatarDh(cont.dhCont, offset),
+    xJust: cont?.xJust,
+    NFref: entrada.referenciadas?.map((r, n) => referencia(r, `referenciadas[${n}]`, issues)),
+    gCompraGov: entrada.gCompraGov === undefined ? undefined : clean({
+      tpEnteGov: entrada.gCompraGov.tpEnteGov,
+      pRedutor: ctx.s(pRedutorGov ?? Decimal.ZERO, D0302A04),
+      tpOperGov: entrada.gCompraGov.tpOperGov,
+      refDFeAnt: entrada.gCompraGov.refDFeAnt
+    }),
+    gPagAntecipado: entrada.gPagAntecipado === undefined ? undefined : { refNFe: [...entrada.gPagAntecipado] }
+  });
+  const local = (l, path) => l === undefined ? undefined : clean({
+    ...documento(l, path, issues),
+    xNome: l.xNome,
+    ...endereco(l),
+    cPais: "1058",
+    xPais: "BRASIL",
+    email: l.email,
+    IE: l.IE
+  });
+  if ((entrada.autXML?.length ?? 0) > 10)
+    issues.add("autXML", "campo_invalido", "no máximo 10 autorizados");
+  const autXML = entrada.autXML?.map((a, n) => documento(a, `autXML[${n}]`, issues));
+  const tr = entrada.transporte;
+  const transp = { modFrete: tr?.modFrete ?? "9" };
+  if (tr?.transportador !== undefined) {
+    const t = tr.transportador;
+    const docT = t.CNPJ !== undefined || t.CPF !== undefined ? documento(t, "transporte.transportador", issues) : {};
+    transp.transporta = clean({ ...docT, xNome: t.xNome, IE: t.IE, xEnder: t.xEnder, xMun: t.xMun, UF: t.UF });
+  }
+  if (tr?.retTransp !== undefined) {
+    const r = tr.retTransp;
+    const vBCRet = ctx.req(r.vBCRet, "transporte.retTransp.vBCRet", D1302);
+    const pICMSRet = ctx.req(r.pICMSRet, "transporte.retTransp.pICMSRet", D0302A04);
+    const vICMSRet = ctx.calc(r.vICMSRet, vBCRet.percent(pICMSRet), "transporte.retTransp.vICMSRet", D1302, "icms");
+    transp.retTransp = {
+      vServ: S(ctx.req(r.vServ, "transporte.retTransp.vServ", D1302)),
+      vBCRet: S(vBCRet),
+      pICMSRet: ctx.s(pICMSRet, D0302A04),
+      vICMSRet: S(vICMSRet),
+      CFOP: r.CFOP,
+      cMunFG: r.cMunFG
+    };
+  }
+  if (tr?.veicTransp !== undefined)
+    transp.veicTransp = tr.veicTransp;
+  if (tr?.reboque !== undefined)
+    transp.reboque = tr.reboque;
+  if (tr?.vagao !== undefined)
+    transp.vagao = tr.vagao;
+  if (tr?.balsa !== undefined)
+    transp.balsa = tr.balsa;
+  if (tr?.volumes !== undefined) {
+    transp.vol = tr.volumes.map((vol, n) => clean({
+      qVol: vol.qVol === undefined ? undefined : String(vol.qVol),
+      esp: vol.esp,
+      marca: vol.marca,
+      nVol: vol.nVol,
+      pesoL: ctx.so(ctx.opt(vol.pesoL, `transporte.volumes[${n}].pesoL`, D1203), D1203),
+      pesoB: ctx.so(ctx.opt(vol.pesoB, `transporte.volumes[${n}].pesoB`, D1203), D1203),
+      lacres: vol.lacres?.map((nLacre) => ({ nLacre }))
+    }));
+  }
+  let cobr;
+  if (entrada.cobranca !== undefined) {
+    const c = entrada.cobranca;
+    cobr = {};
+    if (c.fatura !== undefined) {
+      const f = c.fatura;
+      const vOrig = ctx.opt(f.vOrig, "cobranca.fatura.vOrig", D1302);
+      const vDescF = ctx.opt(f.vDesc, "cobranca.fatura.vDesc", D1302);
+      const vLiq = vOrig === undefined ? ctx.opt(f.vLiq, "cobranca.fatura.vLiq", D1302) : ctx.calc(f.vLiq, vOrig.minus(vDescF ?? Decimal.ZERO), "cobranca.fatura.vLiq", D1302, "produto");
+      cobr.fat = clean({
+        nFat: f.nFat,
+        vOrig: ctx.so(vOrig, D1302),
+        vDesc: ctx.so(vDescF, D1302),
+        vLiq: ctx.so(vLiq, D1302)
+      });
+    }
+    if (c.duplicatas !== undefined) {
+      if (c.duplicatas.length > 120)
+        issues.add("cobranca.duplicatas", "campo_invalido", "no máximo 120 duplicatas");
+      cobr.dup = c.duplicatas.map((dup, n) => clean({
+        nDup: dup.nDup ?? String(n + 1).padStart(3, "0"),
+        dVenc: dup.dVenc,
+        vDup: ctx.s(ctx.req(dup.vDup, `cobranca.duplicatas[${n}].vDup`, D1302_OPC), D1302_OPC)
+      }));
+    }
+  }
+  const pagIn = entrada.pagamento ?? { detPag: [{ tPag: "90", vPag: "0" }] };
+  const igualTotal = opcoes.pagamentoIgualTotal === true;
+  if (igualTotal) {
+    const unico = entrada.pagamento?.detPag.length === 1 ? entrada.pagamento.detPag[0] : undefined;
+    if (unico === undefined) {
+      issues.add("pagamento.detPag", "pagamento_igual_total", "pagamentoIgualTotal pede exatamente um detPag");
+    } else if (unico.tPag === "90") {
+      issues.add("pagamento.detPag[0].tPag", "pagamento_igual_total", "tPag 90 (sem pagamento) não recebe o total");
+    }
+  }
+  const pag = clean({
+    detPag: pagIn.detPag.map((p, n) => clean({
+      indPag: p.indPag,
+      tPag: p.tPag,
+      xPag: p.xPag,
+      vPag: igualTotal ? S(vNF) : S(ctx.req(p.vPag, `pagamento.detPag[${n}].vPag`, D1302)),
+      dPag: p.dPag,
+      CNPJPag: p.CNPJPag,
+      UFPag: p.UFPag,
+      card: p.card
+    })),
+    vTroco: ctx.so(ctx.opt(pagIn.vTroco, "pagamento.vTroco", D1302), D1302)
+  });
+  if (nfce && entrada.pagamento !== undefined && entrada.pagamento.detPag.length > 0 && issues.empty) {
+    pagamentoNfce(pag, vNF, issues);
+  }
+  if (nfce && vNF.gt(Decimal.of(NFCE_LIMITE_SEM_DESTINATARIO)) && dest === undefined) {
+    issues.add("destinatario", "campo_obrigatorio", `NFC-e acima de R$ ${NFCE_LIMITE_SEM_DESTINATARIO} identifica o destinatário (W16-40, rejeição 750)`);
+  }
+  const ia = entrada.informacoesAdicionais;
+  const infAdic = ia === undefined || Object.values(ia).every((x) => x === undefined) ? undefined : clean({
+    infAdFisco: ia.infAdFisco,
+    infCpl: ia.infCpl,
+    obsCont: ia.obsCont,
+    obsFisco: ia.obsFisco,
+    procRef: ia.procRef
+  });
+  const exig = { ...exigenciaRespTec(emitUf, opcoes.ambiente, agora), ...opcoes.exigencias };
+  const rt = entrada.respTec ?? opcoes.respTec;
+  let infRespTec;
+  if (rt === undefined) {
+    if (exig.infRespTec === "obrigatorio") {
+      issues.add("respTec", "resp_tec_obrigatorio", `a UF ${emitUf} exige o responsável técnico (rejeição 972)`);
+    }
+  } else {
+    const cnpjRt = lerCnpj3(rt.CNPJ, { caminho: "respTec.CNPJ" });
+    if (!cnpjRt.ok)
+      issues.list.push(cnpjRt.erro);
+    infRespTec = {
+      CNPJ: cnpjRt.ok ? cnpjRt.valor : rt.CNPJ,
+      xContato: rt.xContato,
+      email: rt.email,
+      fone: digits(rt.fone)
+    };
+    if (rt.csrt !== undefined) {
+      infRespTec.idCSRT = rt.csrt.idCSRT;
+      infRespTec.hashCSRT = await hashCsrt(rt.csrt.CSRT, chave);
+    } else if (exig.csrt === "obrigatorio") {
+      issues.add("respTec.csrt", "csrt_obrigatorio", `a UF ${emitUf} exige idCSRT e hashCSRT (rejeição 975)`);
+    }
+  }
+  const inf = clean({
+    versao: "4.00",
+    Id: `NFe${chave}`,
+    ide,
+    emit,
+    dest,
+    retirada: local(entrada.retirada, "retirada"),
+    entrega: local(entrada.entrega, "entrega"),
+    autXML,
+    det: itens.map((m) => m.det),
+    total,
+    transp,
+    cobr,
+    pag,
+    infIntermed: entrada.infIntermed,
+    infAdic,
+    exporta: entrada.exporta,
+    compra: entrada.compra,
+    cana: entrada.cana,
+    infRespTec,
+    agropecuario: entrada.agropecuario
+  });
+  cstComIsento(entrada, idDest, issues);
+  vencimentos(entrada, { dhEmi, instante: agora }, issues);
+  camposForaDoPl(pl.infNFe, inf, "infNFe", pl.vigencia.pl, issues);
+  textosForaDoXml(inf, "infNFe", issues);
+  if (!issues.empty)
+    return { ok: false, ocorrencias: issues.classificadas };
+  let xml;
+  try {
+    xml = `<NFe xmlns="${NFE_NS3}">${serializar2(pl.infNFe, "infNFe", inf, NFE_NS3)}</NFe>`;
+  } catch (e) {
+    if (!(e instanceof ErroSerializacao))
+      throw e;
+    return {
+      ok: false,
+      ocorrencias: [{ caminho: e.caminho, code: "schema", mensagem: e.message, origem: "montagem" }]
+    };
+  }
+  const doc = lerXml3(xml);
+  const infEl = primeiroFilho3(doc.raiz, "infNFe", NFE_NS3);
+  const schemaIssues = infEl === undefined ? [] : validar3(pl.infNFe, infEl);
+  if (schemaIssues.length > 0) {
+    return {
+      ok: false,
+      ocorrencias: schemaIssues.map((i) => ({
+        caminho: i.caminho,
+        code: "schema",
+        mensagem: `${i.code}: ${i.mensagem}`,
+        origem: "montagem"
+      }))
+    };
+  }
+  let supl;
+  if (nfce) {
+    const tabela = urlsNfce(emitUf, opcoes.ambiente, diaBrasilia(agora));
+    const urlQr = opcoes.urlQrCode ?? tabela.qrCode;
+    const urlChave = opcoes.urlChave ?? tabela.urlChave;
+    if (urlQr === undefined || !/^https?:\/\//i.test(urlQr)) {
+      issues.montagem("urlQrCode", "qrcode_invalido", `sem endereço completo do QR Code da NFC-e para ${emitUf} em ${opcoes.ambiente}: informe urlQrCode (data/nfce-urls.json)`);
+    }
+    if (urlChave === undefined) {
+      issues.montagem("urlChave", "qrcode_invalido", `sem URL de consulta por chave da NFC-e para ${emitUf}: informe urlChave`);
+    }
+    if (urlQr === undefined || urlChave === undefined || !issues.empty)
+      return { ok: false, ocorrencias: issues.classificadas };
+    const p = await parametrosQrCode({
+      chave,
+      ambiente: opcoes.ambiente,
+      tpEmis,
+      dhEmi,
+      vNF: inf.total.ICMSTot.vNF,
+      ...dest === undefined ? {} : { dest },
+      xml
+    }, qr);
+    supl = { versao: qr.versao, urlChave, base: `${urlQr.replace(/\?+$/, "")}?p=`, ...p };
+    const suplIssues = conferirSupl(inserirSupl({ xml, nfce: supl }, supl.assinar ? ASSINATURA_2048 : undefined));
+    if (suplIssues.length > 0)
+      return { ok: false, ocorrencias: suplIssues };
+  }
+  return {
+    ok: true,
+    valor: {
+      chave,
+      id: `NFe${chave}`,
+      cNF,
+      cDV,
+      mod,
+      tpEmis,
+      dhEmi,
+      ...supl === undefined ? {} : { nfce: supl },
+      pl: pl.vigencia,
+      infNFe: inf,
+      xml
+    }
+  };
+}
+var ASSINATURA_2048 = codificarBase642(new Uint8Array(256));
+function conferirSupl(xml) {
+  const el = primeiroFilho3(lerXml3(xml).raiz, "infNFeSupl", NFE_NS3);
+  const erros = el === undefined ? [] : validar3(TNFe_infNFeSupl, el);
+  return erros.map((i) => ({
+    caminho: i.caminho,
+    code: "schema",
+    mensagem: `${i.code}: ${i.mensagem}`,
+    origem: "montagem"
+  }));
+}
+var escapeXml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+async function assinaturaQrCode(nota, assinador) {
+  return nota.nfce?.assinar === true ? assinarParametros(nota.nfce.parametros, assinador) : undefined;
+}
+function comQrCode(nota, assinatura) {
+  const xml = inserirSupl(nota, assinatura);
+  if (assinatura !== undefined) {
+    const issues = conferirSupl(xml);
+    if (issues.length > 0)
+      throw new ErroDeValidacao("o QR Code da NFC-e não passou no schema", issues);
+  }
+  return xml;
+}
+function inserirSupl(built, assinatura) {
+  const s = built.nfce;
+  if (s === undefined) {
+    if (assinatura !== undefined)
+      throw new ErroDeConfiguracao2("a NF-e (modelo 55) não tem QR Code");
+    return built.xml;
+  }
+  if (s.assinar && assinatura === undefined) {
+    throw new ErroDeConfiguracao2("NFC-e em contingência off-line com QR Code versão 3 precisa da assinatura (ZX02-334, rejeição 474)");
+  }
+  if (!s.assinar && assinatura !== undefined) {
+    throw new ErroDeConfiguracao2("este QR Code não leva assinatura (ZX02-330, rejeição 445)");
+  }
+  const fim = "</NFe>";
+  if (!built.xml.endsWith(fim))
+    throw new ErroDeConfiguracao2("NFC-e montada fora da forma esperada");
+  const qrCode = `${s.base}${s.parametros}${assinatura === undefined ? "" : `|${assinatura}`}`;
+  const supl = `<infNFeSupl><qrCode>${escapeXml(qrCode)}</qrCode><urlChave>${escapeXml(s.urlChave)}</urlChave></infNFeSupl>`;
+  return built.xml.slice(0, -fim.length) + supl + fim;
+}
+async function assinarNfe(nota, assinador) {
+  return assinarXml(comQrCode(nota, await assinaturaQrCode(nota, assinador)), { id: nota.id }, assinador);
+}
+// packages/nfe/src/model.ts
+var MotivoDesoneracaoIcms = {
+  TAXI: "1",
+  AGROPECUARIA: "3",
+  FROTISTA_LOCADORA: "4",
+  DIPLOMATICO_CONSULAR: "5",
+  UTILITARIOS_MOTOCICLETAS_AMAZONIA_ALC: "6",
+  SUFRAMA: "7",
+  VENDA_ORGAO_PUBLICO: "8",
+  OUTROS: "9",
+  DEFICIENTE_CONDUTOR: "10",
+  DEFICIENTE_NAO_CONDUTOR: "11",
+  FOMENTO_AGROPECUARIO: "12",
+  OLIMPIADAS_RIO_2016: "16",
+  SOLICITADO_PELO_FISCO: "90"
+};
+var TipoPagamento = {
+  DINHEIRO: "01",
+  CHEQUE: "02",
+  CARTAO_CREDITO: "03",
+  CARTAO_DEBITO: "04",
+  CREDITO_LOJA: "05",
+  VALE_ALIMENTACAO: "10",
+  VALE_REFEICAO: "11",
+  VALE_PRESENTE: "12",
+  VALE_COMBUSTIVEL: "13",
+  BOLETO: "15",
+  DEPOSITO: "16",
+  PIX_DINAMICO: "17",
+  TRANSFERENCIA_CARTEIRA_DIGITAL: "18",
+  FIDELIDADE_CASHBACK: "19",
+  PIX_ESTATICO: "20",
+  CREDITO_EM_LOJA: "21",
+  FALHA_HARDWARE: "22",
+  SEM_PAGAMENTO: "90",
+  PAGAMENTO_POSTERIOR: "91",
+  OUTROS: "99"
+};
+// packages/nfe/src/rotulo.ts
+import { criarRotuloDoCaminho } from "@sinete/core";
+var item = (prefixo) => (n) => `${prefixo} ${n}`;
+var GRUPOS = [
+  { 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" },
+  { padrao: /^(?:qrCode|urlQrCode|urlChave)\b/, rotulo: "QR Code da NFC-e" },
+  { padrao: /^(?:NFe\.)?infNFeSupl\b/, rotulo: "QR Code da NFC-e" },
+  { 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" }
+];
+var CAMPOS = {
+  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"
+};
+var rotular = criarRotuloDoCaminho({ grupos: GRUPOS, campos: CAMPOS, padrao: "Dados da NF-e" });
+function rotuloDoCaminho(caminho) {
+  return rotular(caminho);
+}
+// packages/nfe/src/services/client.ts
+import {
+  criarAutorizado,
+  criarDenegado,
+  criarPendente,
+  ErroDeConfiguracao as ErroDeConfiguracao4,
+  ErroDeValidacao as ErroDeValidacao2,
+  ErroRespostaInvalida as ErroRespostaInvalida4,
+  loggerSilencioso,
+  tpAmbDoAmbiente as tpAmbDoAmbiente3,
+  ufPorCUf as ufPorCUf2,
+  ufPorSigla as ufPorSigla3
+} from "@sinete/core";
+import { assinarXml as assinarXml2, elementosFilhos as elementosFilhos2, lerXml as lerXml6, primeiroFilho as primeiroFilho5, textoDe as textoDe2 } from "@sinete/core/xml";
+import { decodificar, decodificarXml, serializar as serializar3, serializarRaiz, validar as validar4 } from "@sinete/schemas";
+import { ConsCadElement, TRetConsCad } from "@sinete/schemas/nfe/consulta-cadastro/PL_010d";
+import { consSitNFeElement, TProtNFe, TRetConsSitNFe } from "@sinete/schemas/nfe/consulta-protocolo/PL_010d";
+import {
+  distDFeIntElement,
+  resEventoElement,
+  resNFeElement,
+  retDistDFeInt
+} from "@sinete/schemas/nfe/dist-dfe/PL_NFeDistDFe_104";
+import { TEvento_infEvento as TEventoCanc, TRetEnvEvento } from "@sinete/schemas/nfe/evento-cancelamento/PL_010d";
+import { TEvento_infEvento as TEventoCancSubst } from "@sinete/schemas/nfe/evento-cancelamento-substituicao/PL_010d";
+import { TEvento_infEvento as TEventoCce } from "@sinete/schemas/nfe/evento-cce/PL_010d";
+import { TEvento_infEvento as TEventoCiencia } from "@sinete/schemas/nfe/evento-ciencia-operacao/PL_010d";
+import { TEvento_infEvento as TEventoConfirmacao } from "@sinete/schemas/nfe/evento-confirmacao-operacao/PL_010d";
+import { TEvento_infEvento as TEventoDesconhecimento } from "@sinete/schemas/nfe/evento-desconhecimento-operacao/PL_010d";
+import { TEvento_infEvento as TEventoNaoRealizada } from "@sinete/schemas/nfe/evento-operacao-nao-realizada/PL_010d";
+import { TInutNFe_infInut, TRetInutNFe } from "@sinete/schemas/nfe/inutilizacao/PL_010d";
+import { TRetConsReciNFe, TRetEnviNFe } from "@sinete/schemas/nfe/PL_010f";
+import { consStatServElement, TRetConsStatServ } from "@sinete/schemas/nfe/status-servico/PL_009q";
+import { nfceEndpoint, nfeContingenciaDaUf, nfeEndpoint } from "@sinete/transport";
+import { lerChaveAcesso as lerChaveAcesso2, lerCnpj as lerCnpj4, lerCpf as lerCpf2 } from "@sinete/validators";
+
+// packages/nfe/src/services/gzip.ts
+import { ErroNaoSuportado as ErroNaoSuportado2, ErroRespostaInvalida } from "@sinete/core";
+import { decodificarBase64 } from "@sinete/core/xml";
+async function descomprimirGzipBase64(b64) {
+  const Ds = globalThis.DecompressionStream;
+  if (Ds === undefined)
+    throw new ErroNaoSuportado2("DecompressionStream indisponível nesta runtime; docZip não pode ser lido");
+  let bytes;
+  try {
+    bytes = decodificarBase64(b64.trim());
+  } catch (cause) {
+    throw new ErroRespostaInvalida("docZip com base64 inválido", { cause });
+  }
+  try {
+    const stream = new Blob([bytes]).stream().pipeThrough(new Ds("gzip"));
+    return await new Response(stream).text();
+  } catch (cause) {
+    throw new ErroRespostaInvalida("docZip não é um gzip válido", { cause });
+  }
+}
+
+// packages/nfe/src/services/outcome.ts
+import { criarRecusado } from "@sinete/core";
+import { completarRecusado } from "@sinete/rejeicoes";
+// packages/nfe/src/data/cstat.json
+var cstat_default = {
+  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)",
+  atualizadoEm: "2026-09-26",
+  autorizada: ["100", "150"],
+  denegada: ["110", "301", "302", "303"],
+  cancelada: ["101", "151", "155"],
+  loteRecebido: ["103"],
+  loteProcessado: ["104"],
+  loteEmProcessamento: ["105"],
+  loteNaoLocalizado: ["106"],
+  servicoEmOperacao: ["107"],
+  inutilizacaoHomologada: ["102"],
+  eventoRegistrado: ["135", "136", "155"],
+  loteEventoProcessado: ["128"],
+  cadastroEncontrado: ["111", "112"],
+  distribuicaoNenhumDocumento: ["137"],
+  distribuicaoDocumentos: ["138"],
+  duplicidade: ["204"],
+  duplicidadeChaveDiferente: ["539"],
+  naoConsta: ["217"],
+  outraNfeNoNumero: ["561", "562", "613"],
+  consumoIndevido: ["656"],
+  dicas: {
+    "656": {
+      causaProvavel: "Consumo indevido: consultas repetidas à Distribuição DF-e sem documento novo (ultNSU igual a maxNSU) ou acima do limite de requisições por hora.",
+      comoCorrigir: "Aguardar uma hora antes de consultar de novo e só repetir a consulta quando ultNSU for menor que maxNSU; guardar o ultNSU devolvido e continuar dele.",
+      fonte: "NT 2014.002 v1.02 (Distribuição DF-e), regras de consumo indevido"
+    },
+    "217": {
+      causaProvavel: "A chave consultada não consta na base do autorizador consultado: a nota não foi recebida, ou foi autorizada em outro ambiente ou autorizador (SVC).",
+      comoCorrigir: "Se o envio ficou sem resposta, reenviar exatamente o mesmo XML assinado; se foi emitida em contingência SVC, consultar no SVC.",
+      fonte: "MOC 7.0 Anexo I, serviço de consulta protocolo"
+    }
+  }
+};
+
+// packages/nfe/src/services/outcome.ts
+var CLASSES = cstat_default;
+var DICAS = cstat_default.dicas;
+function cstatEm(cStat, classe) {
+  return CLASSES[classe].includes(cStat);
+}
+function rejeitado(status) {
+  const r = completarRecusado(criarRecusado(status));
+  if (r.dica !== undefined)
+    return r;
+  const dica = Object.hasOwn(DICAS, status.cStat) ? DICAS[status.cStat] : undefined;
+  return dica === undefined ? r : criarRecusado(status, dica);
+}
+
+// packages/nfe/src/services/proc.ts
+import { ErroDeConfiguracao as ErroDeConfiguracao3, ErroRespostaInvalida as ErroRespostaInvalida2 } from "@sinete/core";
+import {
+  atributoDe,
+  descendentes,
+  lerXml as lerXml4,
+  namespacesEmEscopo,
+  primeiroFilho as primeiroFilho4,
+  textoDe,
+  XMLDSIG_NS
+} from "@sinete/core/xml";
+var NFE_NS4 = "http://www.portalfiscal.inf.br/nfe";
+var XML_DECL = /^?<\?xml[^?]*\?>\s*/;
+function recortarElemento(documento, el, nsPadraoDoPai = NFE_NS4) {
+  const slice = documento.texto.slice(el.inicio, el.fim);
+  const used = new Set;
+  const cobertoDentro = (d, p) => {
+    for (let e = d;e; e = e === el ? null : e.pai)
+      if (e.namespaces.has(p))
+        return true;
+    return false;
+  };
+  for (const d of descendentes(el)) {
+    const prefixos = [d.prefixo, ...d.atributos.map((a) => a.prefixo)].filter((p) => p !== "" && p !== "xml");
+    for (const p of prefixos)
+      if (!cobertoDentro(d, p))
+        used.add(p);
+  }
+  const extra = [];
+  const inScope = new Map;
+  for (let e = el.pai;e; e = e.pai) {
+    for (const [p, u] of e.namespaces)
+      if (!inScope.has(p))
+        inScope.set(p, u);
+  }
+  const herdado = inScope.get("") ?? "";
+  if (herdado !== nsPadraoDoPai && usaDefaultHerdado(el))
+    extra.push(` xmlns="${herdado}"`);
+  for (const p of [...used].sort()) {
+    const uri = inScope.get(p);
+    if (uri === undefined)
+      throw new ErroRespostaInvalida2(`prefixo ${p} sem declaração no recorte de ${el.nome}`);
+    extra.push(` xmlns:${p}="${uri}"`);
+  }
+  if (extra.length === 0)
+    return slice;
+  const at = 1 + el.nome.length;
+  return slice.slice(0, at) + extra.join("") + slice.slice(at);
+}
+function usaDefaultHerdado(raiz) {
+  for (const d of descendentes(raiz)) {
+    if (d.prefixo !== "")
+      continue;
+    let coberto = false;
+    for (let e = d;e; e = e === raiz ? null : e.pai) {
+      if (e.namespaces.has("")) {
+        coberto = true;
+        break;
+      }
+    }
+    if (!coberto)
+      return true;
+  }
+  return false;
+}
+function documentoAssinado(xml, raiz, elemento) {
+  const text = xml.replace(XML_DECL, "");
+  let doc;
+  try {
+    doc = lerXml4(text);
+  } catch (cause) {
+    throw new ErroDeConfiguracao3(`${raiz} assinado malformado`, { cause });
+  }
+  if (doc.raiz.local !== raiz || doc.raiz.ns !== NFE_NS4) {
+    throw new ErroDeConfiguracao3(`esperado <${raiz}> no namespace da NF-e, veio <${doc.raiz.nome}>`);
+  }
+  if (doc.raiz.namespaces.get("") !== NFE_NS4) {
+    throw new ErroDeConfiguracao3(`<${raiz}> assinado precisa declarar xmlns="${NFE_NS4}" na própria raiz`);
+  }
+  const alvo = primeiroFilho4(doc.raiz, elemento, NFE_NS4);
+  const id = alvo ? atributoDe(alvo, "Id") : undefined;
+  const sig = primeiroFilho4(doc.raiz, "Signature", XMLDSIG_NS);
+  const digest = sig && descendantText(sig, "DigestValue");
+  if (!id || digest === undefined)
+    throw new ErroDeConfiguracao3(`${raiz} sem ${elemento} identificado ou sem assinatura`);
+  return { xml: text, id, digestValue: digest, documento: doc };
+}
+function descendantText(el, local) {
+  for (const d of descendentes(el))
+    if (d.local === local && d.ns === XMLDSIG_NS)
+      return textoDe(d).trim();
+  return;
+}
+function nfeAssinadaDoProc(xml) {
+  const text = xml.replace(XML_DECL, "");
+  let doc;
+  try {
+    doc = lerXml4(text);
+  } catch (cause) {
+    throw new ErroDeConfiguracao3("nfeProc malformado", { cause });
+  }
+  const noProc = doc.raiz.local === "nfeProc" && doc.raiz.ns === NFE_NS4 ? primeiroFilho4(doc.raiz, "NFe", NFE_NS4) : undefined;
+  const el = noProc ?? (doc.raiz.local === "NFe" && doc.raiz.ns === NFE_NS4 ? doc.raiz : undefined);
+  if (el === undefined)
+    throw new ErroDeConfiguracao3(`esperado <nfeProc> ou <NFe> assinada, veio <${doc.raiz.nome}>`);
+  const fatia = doc.texto.slice(el.inicio, el.fim);
+  const herdados = [...namespacesEmEscopo(el)].filter(([p]) => p !== "xml" && !el.namespaces.has(p));
+  const decl = herdados.map(([p, uri]) => ` ${p === "" ? "xmlns" : `xmlns:${p}`}="${uri.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;")}"`).join("");
+  const at = 1 + el.nome.length;
+  const assinado = decl === "" ? fatia : fatia.slice(0, at) + decl + fatia.slice(at);
+  return documentoAssinado(assinado, "NFe", "infNFe").xml;
+}
+function envelope(raiz, versao, partes) {
+  return `<${raiz} xmlns="${NFE_NS4}" versao="${versao}">${partes.join("")}</${raiz}>`;
+}
+
+// packages/nfe/src/services/soap.ts
+import { ErroRespostaInvalida as ErroRespostaInvalida3 } from "@sinete/core";
+import { descendentes as descendentes2, elementosFilhos, lerXml as lerXml5 } from "@sinete/core/xml";
+import { contentTypeSoap12, envelopeSoap12, lerSoapFault } from "@sinete/transport";
+// packages/nfe/src/data/servicos.json
+var servicos_default = {
+  descricao: "Web services SOAP 1.2 da NF-e 4.00: namespace do WSDL e operação (a action do Content-Type é <namespace>/<operação>). Na NF-e 4.00 não existe cabeçalho nfeCabecMsg; a mensagem vai em nfeDadosMsg no namespace do WSDL, e a resposta volta em nfeResultMsg. A Distribuição DF-e usa o envelope do WSDL próprio, com nfeDadosMsg dentro de nfeDistDFeInteresse.",
+  fonte: "MOC 7.0, Visão Geral, item 3 (padrão de comunicação e WSDL dos serviços) e WSDLs do portal da NF-e; NT 2014.002 (Distribuição DF-e)",
+  atualizadoEm: "2026-09-28",
+  servicos: {
+    NfeStatusServico: {
+      namespace: "http://www.portalfiscal.inf.br/nfe/wsdl/NFeStatusServico4",
+      operacao: "nfeStatusServicoNF"
+    },
+    NFeAutorizacao: {
+      namespace: "http://www.portalfiscal.inf.br/nfe/wsdl/NFeAutorizacao4",
+      operacao: "nfeAutorizacaoLote"
+    },
+    NFeRetAutorizacao: {
+      namespace: "http://www.portalfiscal.inf.br/nfe/wsdl/NFeRetAutorizacao4",
+      operacao: "nfeRetAutorizacaoLote"
+    },
+    NfeConsultaProtocolo: {
+      namespace: "http://www.portalfiscal.inf.br/nfe/wsdl/NFeConsultaProtocolo4",
+      operacao: "nfeConsultaNF"
+    },
+    NfeInutilizacao: {
+      namespace: "http://www.portalfiscal.inf.br/nfe/wsdl/NFeInutilizacao4",
+      operacao: "nfeInutilizacaoNF"
+    },
+    RecepcaoEvento: {
+      namespace: "http://www.portalfiscal.inf.br/nfe/wsdl/NFeRecepcaoEvento4",
+      operacao: "nfeRecepcaoEvento"
+    },
+    NfeConsultaCadastro: {
+      namespace: "http://www.portalfiscal.inf.br/nfe/wsdl/CadConsultaCadastro4",
+      operacao: "consultaCadastro",
+      envelopeNoAutorizador: {
+        MT: "operacao"
+      },
+      fonteEnvelope: "Resposta da SEFAZ-MT em homologação em 28/09/2026: com a mensagem só em nfeDadosMsg, o MT responde 215 (falha no schema) e devolve o retorno dentro de consultaCadastroResult; com nfeDadosMsg dentro de consultaCadastro (o elemento da operação do WSDL), responde a consulta (259)."
+    },
+    NFeDistribuicaoDFe: {
+      namespace: "http://www.portalfiscal.inf.br/nfe/wsdl/NFeDistribuicaoDFe",
+      operacao: "nfeDistDFeInteresse",
+      envelope: "distDFeInteresse"
+    }
+  }
+};
+
+// packages/nfe/src/services/soap.ts
+var SERVICOS = servicos_default.servicos;
+function servicoInfo(servico) {
+  const s = SERVICOS[servico];
+  if (!s)
+    throw new ErroRespostaInvalida3(`serviço sem descrição em data/servicos.json: ${servico}`);
+  return s;
+}
+function soapBodyFor(servico, mensagem, autorizador) {
+  const s = servicoInfo(servico);
+  if (s.envelope === "distDFeInteresse" || autorizador && s.envelopeNoAutorizador?.[autorizador] === "operacao") {
+    return `<${s.operacao} xmlns="${s.namespace}"><nfeDadosMsg>${mensagem}</nfeDadosMsg></${s.operacao}>`;
+  }
+  return `<nfeDadosMsg xmlns="${s.namespace}">${mensagem}</nfeDadosMsg>`;
+}
+async function chamar(c) {
+  const s = servicoInfo(c.servico);
+  const started = { servico: c.servico, autorizador: c.endpoint.autorizador, host: c.endpoint.host };
+  const res = await c.transport.enviar({
+    url: c.endpoint.url,
+    endpoint: c.endpoint,
+    metodo: "POST",
+    cabecalhos: { "content-type": contentTypeSoap12(`${s.namespace}/${s.operacao}`) },
+    corpo: envelopeSoap12(soapBodyFor(c.servico, c.mensagem, c.endpoint.autorizador)),
+    ...c.timeoutMs === undefined ? {} : { timeoutMs: c.timeoutMs },
+    ...c.signal === undefined ? {} : { signal: c.signal }
+  });
+  const text = res.texto();
+  const fault = lerSoapFault(text);
+  if (fault) {
+    c.logger.warn("nfe.soap.fault", { ...started, status: res.status, code: fault.code });
+    throw new ErroRespostaInvalida3(`SOAP fault de ${c.endpoint.host}: ${fault.reason ?? fault.code ?? "sem motivo"}`, {
+      detalhes: { status: res.status, code: fault.code, reason: fault.reason, servico: c.servico }
+    });
+  }
+  let doc;
+  try {
+    doc = lerXml5(text.replace(/^/, ""));
+  } catch (cause) {
+    throw new ErroRespostaInvalida3(`resposta de ${c.endpoint.host} não é XML (HTTP ${res.status})`, {
+      cause,
+      detalhes: { status: res.status, servico: c.servico }
+    });
+  }
+  let ret;
+  for (const el of descendentes2(doc.raiz)) {
+    if (el.local === c.retorno && el.ns === NFE_NS4) {
+      ret = el;
+      break;
+    }
+  }
+  if (!ret)
+    ret = retornoForaDoNamespace(doc.raiz, c.retorno);
+  if (ret && ret.ns !== NFE_NS4) {
+    c.logger.warn("nfe.soap.retorno_fora_do_namespace", { ...started, retorno: c.retorno, ns: ret.ns });
+  }
+  if (!ret) {
+    throw new ErroRespostaInvalida3(`resposta de ${c.endpoint.host} sem <${c.retorno}> (HTTP ${res.status})`, {
+      detalhes: { status: res.status, servico: c.servico }
+    });
+  }
+  if (!Array.from(descendentes2(ret)).some((el) => el.local === "cStat" && el.ns === NFE_NS4)) {
+    throw new ErroRespostaInvalida3(`<${c.retorno}> de ${c.endpoint.host} sem cStat (HTTP ${res.status})`, {
+      detalhes: { status: res.status, servico: c.servico }
+    });
+  }
+  c.logger.debug("nfe.soap.resposta", { ...started, status: res.status });
+  return { doc, ret, status: res.status };
+}
+function retornoForaDoNamespace(root, retorno) {
+  for (const el of descendentes2(root)) {
+    if (el.local !== retorno)
+      continue;
+    const filhos = elementosFilhos(el);
+    if (filhos.length > 0 && filhos.every((f) => f.ns === NFE_NS4))
+      return el;
+  }
+  return;
+}
+
+// packages/nfe/src/services/client.ts
+function autorizadorContingencia(uf, ambiente) {
+  const autorizador = nfeContingenciaDaUf(uf, ambiente);
+  return { autorizador, tpEmis: autorizador === "SVC-AN" ? "6" : "7" };
+}
+var defaultSleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(signal.reason);
+    return;
+  }
+  const onAbort = () => {
+    clearTimeout(t);
+    reject(signal?.reason);
+  };
+  const t = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+function chaveValida(chave, path) {
+  const r = lerChaveAcesso2(chave, { caminho: path });
+  if (!r.ok)
+    throw new ErroDeValidacao2(`chave de acesso inválida: ${r.erro.mensagem}`, [r.erro]);
+  return r.valor;
+}
+function schemaIssues(what, issues) {
+  if (issues.length > 0)
+    throw new ErroDeValidacao2(`${what} não confere com o schema`, issues);
+}
+function documentoAutor(a, path) {
+  if (a.CNPJ !== undefined) {
+    const r = lerCnpj4(a.CNPJ, { caminho: `${path}.CNPJ` });
+    if (!r.ok)
+      throw new ErroDeValidacao2("CNPJ do autor inválido", [r.erro]);
+    return { CNPJ: r.valor };
+  }
+  const r = lerCpf2(a.CPF ?? "", { caminho: `${path}.CPF` });
+  if (!r.ok)
+    throw new ErroDeValidacao2("CPF do autor inválido", [r.erro]);
+  return { CPF: r.valor };
+}
+function autorDaChave(c) {
+  return c.cnpj !== undefined ? { CNPJ: c.cnpj } : { CPF: c.cpf ?? c.emitente.slice(3) };
+}
+function autorDoEmitente(a, c) {
+  const daChave = autorDaChave(c);
+  if (a === undefined)
+    return daChave;
+  const autor = documentoAutor(a, "autor");
+  const [campo, valor] = "CNPJ" in autor ? ["CNPJ", autor.CNPJ] : ["CPF", autor.CPF];
+  if (valor !== ("CNPJ" in daChave ? daChave.CNPJ : daChave.CPF) || campo !== ("CNPJ" in daChave ? "CNPJ" : "CPF")) {
+    throw new ErroDeValidacao2("o autor do evento não é o emitente da NF-e", [
+      {
+        caminho: `autor.${campo}`,
+        code: "autor_difere_do_emitente",
+        mensagem: `o autor de um evento do emitente é o ${"CNPJ" in daChave ? "CNPJ" : "CPF"} da chave (P12-44, rejeição 574)`,
+        origem: "entrada"
+      }
+    ]);
+  }
+  return autor;
+}
+var SVC_DO_TPEMIS = { "6": "SVC-AN", "7": "SVC-RS" };
+function chaveDoDocumento(a) {
+  const r = lerChaveAcesso2(a.id.slice(3), { caminho: "infNFe.Id", conferirEmitente: false });
+  if (!r.ok)
+    throw new ErroDeConfiguracao4(`Id da NF-e assinada não é uma chave de acesso: ${r.erro.mensagem}`);
+  return r.valor;
+}
+function avulso(doc, el) {
+  return recortarElemento(doc, el, "");
+}
+function lerProtocolo(doc, el) {
+  const { valor: value } = decodificar(TProtNFe, el, doc.texto);
+  const inf = value.infProt;
+  if (!inf)
+    throw new ErroRespostaInvalida4("protNFe sem infProt");
+  const p = {
+    chNFe: inf.chNFe,
+    cStat: inf.cStat,
+    xMotivo: inf.xMotivo,
+    dhRecbto: inf.dhRecbto,
+    verAplic: inf.verAplic,
+    protNFe: avulso(doc, el),
+    ...inf.nProt === undefined ? {} : { nProt: inf.nProt },
+    ...inf.digVal === undefined ? {} : { digVal: inf.digVal }
+  };
+  return { p, embutido: recortarElemento(doc, el) };
+}
+function desfechoDoProtocolo({ p, embutido }, a) {
+  const status = { cStat: p.cStat, xMotivo: p.xMotivo };
+  const autorizada = cstatEm(p.cStat, "autorizada");
+  const denegada = cstatEm(p.cStat, "denegada");
+  if (!autorizada && !denegada)
+    return rejeitado(status);
+  let full = p;
+  if (a) {
+    if (`NFe${p.chNFe}` !== a.id) {
+      throw new ErroRespostaInvalida4("protocolo de outra chave de acesso", { detalhes: { chNFe: p.chNFe } });
+    }
+    if (p.digVal !== undefined && p.digVal !== a.digestValue) {
+      throw new ErroRespostaInvalida4("digVal do protocolo difere do DigestValue da NF-e enviada", {
+        detalhes: { chNFe: p.chNFe, cStat: p.cStat }
+      });
+    }
+    if (p.digVal !== undefined)
+      full = { ...p, nfeProc: envelope("nfeProc", "4.00", [a.xml, embutido]) };
+  }
+  return autorizada ? criarAutorizado(status, full) : criarDenegado(status, full);
+}
+function protNFeDaChave(parent, a) {
+  const prots = elementosFilhos2(parent).filter((e) => e.local === "protNFe" && e.ns === NFE_NS4);
+  if (!a)
+    return prots[0];
+  const chave = a.id.slice(3);
+  return prots.find((e) => {
+    const inf = primeiroFilho5(e, "infProt", NFE_NS4);
+    const ch = inf && primeiroFilho5(inf, "chNFe", NFE_NS4);
+    return ch !== undefined && textoDe2(ch).trim() === chave;
+  }) ?? (prots.length === 1 ? prots[0] : undefined);
+}
+var EVENTO_VERSAO = "1.00";
+var XCONDUSO = "A Carta de Correção é disciplinada pelo § 1º-A do art. 7º do Convênio S/N, de 15 de dezembro de 1970 e pode ser utilizada para regularização de erro ocorrido na emissão de documento fiscal, desde que o erro não esteja relacionado com: I - as variáveis que determinam o valor do imposto tais como: base de cálculo, alíquota, diferença de preço, quantidade, valor da operação ou da prestação; II - a correção de dados cadastrais que implique mudança do remetente ou do destinatário; III - a data de emissão ou de saída.";
+var MANIFESTACOES = {
+  confirmacao: { tpEvento: "210200", descEvento: "Confirmacao da Operacao", ct: TEventoConfirmacao },
+  ciencia: { tpEvento: "210210", descEvento: "Ciencia da Operacao", ct: TEventoCiencia },
+  desconhecimento: { tpEvento: "210220", descEvento: "Desconhecimento da Operacao", ct: TEventoDesconhecimento },
+  "nao-realizada": { tpEvento: "210240", descEvento: "Operacao nao Realizada", ct: TEventoNaoRealizada }
+};
+function criarClienteNfe(opcoesDoCliente) {
+  const logger = (opcoesDoCliente.logger ?? loggerSilencioso).child({
+    modulo: "nfe",
+    ambiente: opcoesDoCliente.ambiente
+  });
+  const sleep = opcoesDoCliente.esperar ?? defaultSleep;
+  const tpAmb = tpAmbDoAmbiente3(opcoesDoCliente.ambiente);
+  const ufInfo = opcoesDoCliente.uf === undefined ? undefined : ufPorSigla3(opcoesDoCliente.uf);
+  if (opcoesDoCliente.uf !== undefined && !ufInfo)
+    throw new ErroDeConfiguracao4(`UF inválida: ${String(opcoesDoCliente.uf)}`);
+  const ufPadrao = (servico) => {
+    if (opcoesDoCliente.uf === undefined || ufInfo === undefined) {
+      throw new ErroDeConfiguracao4(`${servico} precisa da UF: informe ClienteNfeOpcoes.uf`);
+    }
+    return { uf: opcoesDoCliente.uf, cUF: ufInfo.cUF };
+  };
+  const offsetDe = (uf) => opcoesDoCliente.deslocamentoMin ?? deslocamentoDaUf(uf);
+  const idLote = () => {
+    const id = opcoesDoCliente.idLote ? opcoesDoCliente.idLote() : String(opcoesDoCliente.relogio.agora().getTime()).slice(-15);
+    if (!/^[0-9]{1,15}$/.test(id))
+      throw new ErroDeConfiguracao4(`idLote inválido: ${id}`);
+    return id;
+  };
+  const endpointNfce = (servico, uf) => opcoesDoCliente.endpointNfce ? opcoesDoCliente.endpointNfce(servico, uf) : nfceEndpoint({ ambiente: opcoesDoCliente.ambiente, servico, uf });
+  const endpoint = (servico, mod = "55") => {
+    const { uf } = ufPadrao(servico);
+    if (mod === "65")
+      return endpointNfce(servico, uf);
+    return nfeEndpoint({
+      ambiente: opcoesDoCliente.ambiente,
+      servico,
+      uf,
+      ...opcoesDoCliente.contingencia === undefined ? {} : { contingencia: opcoesDoCliente.contingencia }
+    });
+  };
+  const endpointDaChave = (servico, c, naUf = false) => {
+    if (c.mod === "65")
+      return endpointNfce(servico, c.uf);
+    const svc = naUf || c.tpEmis === undefined ? undefined : SVC_DO_TPEMIS[c.tpEmis];
+    return nfeEndpoint({
+      ambiente: opcoesDoCliente.ambiente,
+      servico,
+      ...svc === undefined ? { uf: c.uf } : { autorizador: svc }
+    });
+  };
+  const call = (ep, servico, mensagem, retorno, signal) => chamar({
+    transport: opcoesDoCliente.transporte,
+    endpoint: ep,
+    servico,
+    mensagem,
+    retorno,
+    logger,
+    ...opcoesDoCliente.timeoutMs === undefined ? {} : { timeoutMs: opcoesDoCliente.timeoutMs },
+    ...signal === undefined ? {} : { signal }
+  });
+  const autorPadrao = (a, path) => {
+    const autor = a ?? opcoesDoCliente.autor;
+    if (!autor)
+      throw new ErroDeConfiguracao4(`informe o CNPJ ou CPF do autor (${path} ou ClienteNfeOpcoes.autor)`);
+    return documentoAutor(autor, path);
+  };
+  async function consultarRecibo(nRec, nfeAssinada, opcoes = {}) {
+    if (!/^[0-9]{15}$/.test(nRec))
+      throw new ErroDeConfiguracao4(`número de recibo inválido: ${nRec}`);
+    const a = nfeAssinada === undefined ? undefined : documentoAssinado(nfeAssinada, "NFe", "infNFe");
+    const c = a === undefined ? undefined : chaveDoDocumento(a);
+    if (c !== undefined && opcoes.mod !== undefined && opcoes.mod !== c.mod) {
+      throw new ErroDeConfiguracao4(`mod ${opcoes.mod} não é o da NF-e assinada (${c.mod})`);
+    }
+    const msg = envelope("consReciNFe", "4.00", [`<tpAmb>${tpAmb}</tpAmb><nRec>${nRec}</nRec>`]);
+    const ep = c === undefined ? endpoint("NFeRetAutorizacao", opcoes.mod ?? "55") : endpointDaChave("NFeRetAutorizacao", c);
+    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) {
+      throw new ErroRespostaInvalida4("retorno de outro recibo", { detalhes: { nRec: v.nRec } });
+    }
+    const status = { cStat: v.cStat, xMotivo: v.xMotivo };
+    logger.info("nfe.recibo", { nRec, cStat: v.cStat });
+    if (cstatEm(v.cStat, "loteEmProcessamento") || cstatEm(v.cStat, "loteRecebido"))
+      return criarPendente(status, { referencia: nRec });
+    if (cstatEm(v.cStat, "loteProcessado")) {
+      const el = protNFeDaChave(r.ret, a);
+      if (!el)
+        throw new ErroRespostaInvalida4("lote processado sem o protNFe da NF-e", { detalhes: { nRec } });
+      return desfechoDoProtocolo(lerProtocolo(r.doc, el), a);
+    }
+    return rejeitado(status);
+  }
+  async function consultar(chave, nfeAssinada, opcoes) {
+    const c = chaveValida(chave, "chNFe");
+    const a = nfeAssinada === undefined ? undefined : documentoAssinado(nfeAssinada, "NFe", "infNFe");
+    if (a && a.id !== `NFe${c.chave}`)
+      throw new ErroDeConfiguracao4("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 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 };
+    logger.info("nfe.consulta", { chNFe: c.chave, cStat: v.cStat });
+    const situacao = cstatEm(v.cStat, "autorizada") ? "autorizada" : cstatEm(v.cStat, "cancelada") ? "cancelada" : cstatEm(v.cStat, "denegada") ? "denegada" : undefined;
+    if (situacao === undefined)
+      return rejeitado(status);
+    const protEl = primeiroFilho5(r.ret, "protNFe", NFE_NS4);
+    const eventos = elementosFilhos2(r.ret).filter((e) => e.local === "procEventoNFe" && e.ns === NFE_NS4).map((e) => avulso(r.doc, e));
+    let protocolo;
+    let digValConfere;
+    if (protEl) {
+      const { p, embutido } = lerProtocolo(r.doc, protEl);
+      if (p.chNFe !== c.chave) {
+        throw new ErroRespostaInvalida4("protocolo de outra chave de acesso na consulta", {
+          detalhes: { chNFe: p.chNFe }
+        });
+      }
+      protocolo = p;
+      if (a) {
+        digValConfere = p.digVal !== undefined && p.digVal === a.digestValue;
+        if (digValConfere)
+          protocolo = { ...p, nfeProc: envelope("nfeProc", "4.00", [a.xml, embutido]) };
+      }
+    }
+    const value = {
+      chNFe: c.chave,
+      situacao,
+      eventos,
+      ...protocolo === undefined ? {} : { protocolo },
+      ...digValConfere === undefined ? {} : { digValConfere }
+    };
+    return situacao === "denegada" ? criarDenegado(status, value) : criarAutorizado(status, value);
+  }
+  async function enviarEvento(p) {
+    const nSeq = p.nSeqEvento;
+    if (!Number.isInteger(nSeq) || nSeq < 1 || nSeq > 99)
+      throw new ErroDeConfiguracao4(`nSeqEvento inválido: ${nSeq}`);
+    const nSeqEvento = String(nSeq);
+    const id = `ID${p.tpEvento}${p.chave}${nSeqEvento.padStart(2, "0")}`;
+    const inf = {
+      Id: id,
+      cOrgao: p.cOrgao,
+      tpAmb,
+      ...p.autor,
+      chNFe: p.chave,
+      dhEvento: formatarDh(opcoesDoCliente.relogio.agora(), p.offsetMinutes),
+      tpEvento: p.tpEvento,
+      nSeqEvento,
+      verEvento: EVENTO_VERSAO,
+      detEvento: p.detEvento
+    };
+    const infXml = serializar3(p.ct, "infEvento", inf, NFE_NS4);
+    const evento = `<evento xmlns="${NFE_NS4}" versao="${EVENTO_VERSAO}">${infXml}</evento>`;
+    const infEl = primeiroFilho5(lerXml6(evento).raiz, "infEvento", NFE_NS4);
+    schemaIssues("evento", validar4(p.ct, infEl));
+    const assinado = await assinarXml2(evento, { id }, opcoesDoCliente.assinador);
+    const msg = envelope("envEvento", EVENTO_VERSAO, [`<idLote>${idLote()}</idLote>`, assinado]);
+    const r = await call(p.endpoint, "RecepcaoEvento", msg, "retEnvEvento", p.signal);
+    const v = decodificar(TRetEnvEvento, r.ret, r.doc.texto).valor;
+    logger.info("nfe.evento", { chNFe: p.chave, tpEvento: p.tpEvento, cStat: v.cStat });
+    if (!cstatEm(v.cStat, "loteEventoProcessado"))
+      return rejeitado({ cStat: v.cStat, xMotivo: v.xMotivo });
+    const retEl = elementosFilhos2(r.ret).find((e) => e.local === "retEvento" && e.ns === NFE_NS4);
+    const ret = v.retEvento?.[0]?.infEvento;
+    if (!retEl || !ret)
+      throw new ErroRespostaInvalida4("lote de evento processado sem retEvento");
+    const divergentes = [
+      ["chNFe", ret.chNFe, p.chave],
+      ["tpEvento", ret.tpEvento, p.tpEvento],
+      ["nSeqEvento", ret.nSeqEvento === undefined ? undefined : String(Number(ret.nSeqEvento)), nSeqEvento]
+    ].filter(([, veio, enviado]) => veio !== undefined && veio !== enviado);
+    if (divergentes.length > 0) {
+      throw new ErroRespostaInvalida4("retEvento de outro evento", {
+        detalhes: Object.fromEntries(divergentes.map(([k, veio]) => [k, veio]))
+      });
+    }
+    const status = { cStat: ret.cStat, xMotivo: ret.xMotivo };
+    if (!cstatEm(ret.cStat, "eventoRegistrado"))
+      return rejeitado(status);
+    return criarAutorizado(status, {
+      chNFe: p.chave,
+      tpEvento: p.tpEvento,
+      nSeqEvento,
+      dhRegEvento: ret.dhRegEvento,
+      retEvento: avulso(r.doc, retEl),
+      procEventoNFe: envelope("procEventoNFe", EVENTO_VERSAO, [assinado, recortarElemento(r.doc, retEl)]),
+      ...ret.nProt === undefined ? {} : { nProt: ret.nProt }
+    });
+  }
+  const client = {
+    opcoes: opcoesDoCliente,
+    async statusServico(opcoes) {
+      const { cUF } = ufPadrao("NfeStatusServico");
+      const msg = serializarRaiz(consStatServElement, { versao: "4.00", tpAmb, cUF, xServ: "STATUS" });
+      const r = await call(endpoint("NfeStatusServico", opcoes?.mod), "NfeStatusServico", msg, "retConsStatServ", opcoes?.signal);
+      const v = decodificar(TRetConsStatServ, r.ret, r.doc.texto).valor;
+      const status = { cStat: v.cStat, xMotivo: v.xMotivo };
+      logger.info("nfe.status", { cStat: v.cStat });
+      if (!cstatEm(v.cStat, "servicoEmOperacao"))
+        return rejeitado(status);
+      return criarAutorizado(status, {
+        cUF: v.cUF,
+        verAplic: v.verAplic,
+        dhRecbto: v.dhRecbto,
+        ...v.tMed === undefined ? {} : { tMed: v.tMed },
+        ...v.dhRetorno === undefined ? {} : { dhRetorno: v.dhRetorno },
+        ...v.xObs === undefined ? {} : { xObs: v.xObs }
+      });
+    },
+    async autorizar(nfeAssinada, opcoes = {}) {
+      const a = documentoAssinado(nfeAssinada, "NFe", "infNFe");
+      const sincrono = opcoes.sincrono ?? true;
+      const msg = envelope("enviNFe", "4.00", [
+        `<idLote>${idLote()}</idLote><indSinc>${sincrono ? "1" : "0"}</indSinc>`,
+        a.xml
+      ]);
+      const ep = endpointDaChave("NFeAutorizacao", chaveDoDocumento(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 };
+      logger.info("nfe.autorizacao", { chNFe: a.id.slice(3), cStat: v.cStat, sincrono });
+      if (cstatEm(v.cStat, "loteRecebido")) {
+        const nRec = v.infRec?.nRec;
+        if (!nRec)
+          throw new ErroRespostaInvalida4("lote recebido sem número de recibo");
+        const tMed = Number(v.infRec?.tMed ?? "0");
+        return criarPendente(status, { referencia: nRec, aguardarMs: Math.max(1, tMed) * 1000 });
+      }
+      const protEl = protNFeDaChave(r.ret, a);
+      if (protEl)
+        return desfechoDoProtocolo(lerProtocolo(r.doc, protEl), a);
+      return rejeitado(status);
+    },
+    consultarRecibo,
+    async aguardarRecibo(nRec, nfeAssinada, politica = {}) {
+      const max = politica.maxTentativas ?? 10;
+      const minimo = politica.esperaMinimaMs ?? 2000;
+      const mult = politica.multiplicador ?? 1.5;
+      const teto = politica.esperaMaximaMs ?? 30000;
+      if (!(max >= 1) || !(minimo >= 0) || !(mult >= 1) || !(teto >= minimo)) {
+        throw new ErroDeConfiguracao4("política de consulta do recibo inválida", {
+          detalhes: { max, minimo, mult, teto }
+        });
+      }
+      let espera = minimo;
+      let ultimo;
+      for (let i = 0;i < max; i++) {
+        await sleep(espera, politica.signal);
+        ultimo = await consultarRecibo(nRec, nfeAssinada, politica);
+        if (ultimo.tipo !== "pendente")
+          return ultimo;
+        espera = Math.min(teto, Math.max(minimo, Math.round(espera * mult), ultimo.aguardarMs ?? 0));
+      }
+      return ultimo;
+    },
+    consultar,
+    async cancelar(p, opcoes) {
+      const c = chaveValida(p.chave, "chave");
+      return enviarEvento({
+        ct: TEventoCanc,
+        tpEvento: "110111",
+        chave: c.chave,
+        nSeqEvento: 1,
+        cOrgao: c.cUF,
+        autor: autorDoEmitente(p.autor, c),
+        detEvento: { versao: EVENTO_VERSAO, descEvento: "Cancelamento", nProt: p.nProt, xJust: p.xJust },
+        endpoint: endpointDaChave("RecepcaoEvento", c),
+        offsetMinutes: offsetDe(c.uf),
+        signal: opcoes?.signal
+      });
+    },
+    async cancelarPorSubstituicao(p, opcoes) {
+      const c = chaveValida(p.chave, "chave");
+      if (c.mod !== "65") {
+        throw new ErroDeValidacao2("cancelamento por substituição só existe para NFC-e", [
+          {
+            caminho: "chave",
+            code: "modelo_nao_suportado",
+            mensagem: "O evento 110112 é exclusivo da NFC-e (modelo 65)"
+          }
+        ]);
+      }
+      const ref = chaveValida(p.chNFeRef, "chNFeRef");
+      const detEvento = {
+        versao: EVENTO_VERSAO,
+        descEvento: "Cancelamento por substituicao",
+        cOrgaoAutor: p.cOrgaoAutor,
+        tpAutor: p.tpAutor ?? "1",
+        verAplic: p.verAplic,
+        nProt: p.nProt,
+        xJust: p.xJust,
+        chNFeRef: ref.chave
+      };
+      return enviarEvento({
+        ct: TEventoCancSubst,
+        tpEvento: "110112",
+        chave: c.chave,
+        nSeqEvento: 1,
+        cOrgao: c.cUF,
+        autor: autorDoEmitente(p.autor, c),
+        detEvento,
+        endpoint: endpointDaChave("RecepcaoEvento", c),
+        offsetMinutes: offsetDe(c.uf),
+        signal: opcoes?.signal
+      });
+    },
+    async cartaCorrecao(p, opcoes) {
+      const c = chaveValida(p.chave, "chave");
+      if (!Number.isInteger(p.nSeqEvento) || p.nSeqEvento < 1 || p.nSeqEvento > 20) {
+        throw new ErroDeConfiguracao4(`nSeqEvento da CC-e vai de 1 a 20: ${p.nSeqEvento}`);
+      }
+      return enviarEvento({
+        ct: TEventoCce,
+        tpEvento: "110110",
+        chave: c.chave,
+        nSeqEvento: p.nSeqEvento,
+        cOrgao: c.cUF,
+        autor: autorDoEmitente(p.autor, c),
+        detEvento: {
+          versao: EVENTO_VERSAO,
+          descEvento: "Carta de Correção",
+          xCorrecao: p.xCorrecao,
+          xCondUso: XCONDUSO
+        },
+        endpoint: endpointDaChave("RecepcaoEvento", c, true),
+        offsetMinutes: offsetDe(c.uf),
+        signal: opcoes?.signal
+      });
+    },
+    async manifestar(p, opcoes) {
+      const c = chaveValida(p.chave, "chave");
+      const m = MANIFESTACOES[p.tipo];
+      if (!m)
+        throw new ErroDeConfiguracao4(`tipo de manifestação desconhecido: ${String(p.tipo)}`);
+      return enviarEvento({
+        ct: m.ct,
+        tpEvento: m.tpEvento,
+        chave: c.chave,
+        nSeqEvento: 1,
+        cOrgao: "91",
+        autor: autorPadrao(p.autor, "autor"),
+        detEvento: {
+          versao: EVENTO_VERSAO,
+          descEvento: m.descEvento,
+          ...p.xJust === undefined ? {} : { xJust: p.xJust }
+        },
+        endpoint: nfeEndpoint({ ambiente: opcoesDoCliente.ambiente, servico: "RecepcaoEvento", autorizador: "AN" }),
+        offsetMinutes: offsetDe(opcoesDoCliente.uf ?? c.uf),
+        signal: opcoes?.signal
+      });
+    },
+    async inutilizar(p, opcoes) {
+      const autor = autorPadrao(p.autor, "autor");
+      if (!("CNPJ" in autor)) {
+        throw new ErroDeValidacao2("inutilização não se aplica ao emitente pessoa física", [
+          {
+            caminho: "autor.CPF",
+            code: "inutilizacao_emitente_cpf",
+            mensagem: "O pedido de inutilização só existe para emitente CNPJ (NT 2018.001 v1.10, item 6.1)"
+          }
+        ]);
+      }
+      const cnpj = autor.CNPJ;
+      const { uf, cUF } = ufPadrao("NfeInutilizacao");
+      const anoTxt = String(p.ano);
+      const ano = anoTxt.length === 4 ? anoTxt.slice(2) : anoTxt.padStart(2, "0");
+      const mod = p.mod ?? "55";
+      const serie = String(p.serie);
+      const ini = String(p.nNFIni);
+      const fin = String(p.nNFFin);
+      for (const [k, x, re] of [
+        ["ano", ano, /^[0-9]{2}$/],
+        ["serie", serie, /^(0|[1-9][0-9]{0,2})$/],
+        ["nNFIni", ini, /^[1-9][0-9]{0,8}$/],
+        ["nNFFin", fin, /^[1-9][0-9]{0,8}$/]
+      ]) {
+        if (!re.test(x))
+          throw new ErroDeConfiguracao4(`${k} inválido para inutilização: ${x}`);
+      }
+      if (Number(fin) < Number(ini))
+        throw new ErroDeConfiguracao4("nNFFin menor que nNFIni");
+      if (Number(serie) >= 910 && Number(serie) <= 969) {
+        throw new ErroDeValidacao2("série de emitente pessoa física não se inutiliza", [
+          {
+            caminho: "serie",
+            code: "inutilizacao_serie_cpf",
+            mensagem: "Série 910 a 969 identifica emitente CPF: a SEFAZ rejeita com 266 (NT 2018.001 v1.10, regra I02a)"
+          }
+        ]);
+      }
+      const id = `ID${cUF}${ano}${cnpj}${mod}${serie.padStart(3, "0")}${ini.padStart(9, "0")}${fin.padStart(9, "0")}`;
+      const inf = {
+        Id: id,
+        tpAmb,
+        xServ: "INUTILIZAR",
+        cUF,
+        ano,
+        CNPJ: cnpj,
+        mod,
+        serie,
+        nNFIni: ini,
+        nNFFin: fin,
+        xJust: p.xJust
+      };
+      const infXml = serializar3(TInutNFe_infInut, "infInut", inf, NFE_NS4);
+      const inut = envelope("inutNFe", "4.00", [infXml]);
+      const infEl = primeiroFilho5(lerXml6(inut).raiz, "infInut", NFE_NS4);
+      schemaIssues("pedido de inutilização", validar4(TInutNFe_infInut, infEl));
+      const assinado = await assinarXml2(inut, { id }, opcoesDoCliente.assinador);
+      const ep = mod === "65" ? endpointNfce("NfeInutilizacao", uf) : nfeEndpoint({ ambiente: opcoesDoCliente.ambiente, servico: "NfeInutilizacao", uf });
+      const r = await call(ep, "NfeInutilizacao", assinado, "retInutNFe", opcoes?.signal);
+      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);
+      const r0 = v.infInut;
+      const n = (x) => x === undefined ? undefined : String(Number(x));
+      const confere = [
+        ["ano", r0.ano, ano],
+        ["CNPJ", r0.CNPJ ?? r0.CPF, cnpj],
+        ["mod", r0.mod, mod],
+        ["serie", n(r0.serie), String(Number(serie))],
+        ["nNFIni", n(r0.nNFIni), String(Number(ini))],
+        ["nNFFin", n(r0.nNFFin), String(Number(fin))]
+      ];
+      const fora = confere.filter(([, veio, pedido]) => veio !== undefined && veio !== pedido);
+      if (fora.length > 0) {
+        throw new ErroRespostaInvalida4("retInutNFe de outra faixa", {
+          detalhes: Object.fromEntries(fora.map(([k, v]) => [k, v]))
+        });
+      }
+      return criarAutorizado(status, {
+        dhRecbto: v.infInut.dhRecbto,
+        retInutNFe: avulso(r.doc, r.ret),
+        procInutNFe: envelope("ProcInutNFe", "4.00", [assinado, recortarElemento(r.doc, r.ret)]),
+        ...v.infInut.nProt === undefined ? {} : { nProt: v.infInut.nProt }
+      });
+    },
+    async consultarCadastro(p, opcoes) {
+      const doc = "CNPJ" in p ? documentoAutor({ CNPJ: p.CNPJ }, "CNPJ") : ("CPF" in p) ? documentoAutor({ CPF: p.CPF }, "CPF") : { IE: p.IE.replace(/[^0-9A-Za-z]/g, "").toUpperCase() };
+      const msg = serializarRaiz(ConsCadElement, { versao: "2.00", infCons: { xServ: "CONS-CAD", UF: p.uf, ...doc } });
+      const ep = nfeEndpoint({ ambiente: opcoesDoCliente.ambiente, servico: "NfeConsultaCadastro", uf: p.uf });
+      const r = await call(ep, "NfeConsultaCadastro", msg, "retConsCad", opcoes?.signal);
+      const v = decodificar(TRetConsCad, r.ret, r.doc.texto).valor;
+      const i = v.infCons;
+      const status = { cStat: i.cStat, xMotivo: i.xMotivo };
+      logger.info("nfe.cadastro", { uf: p.uf, cStat: i.cStat });
+      if (!cstatEm(i.cStat, "cadastroEncontrado"))
+        return rejeitado(status);
+      return criarAutorizado(status, { UF: i.UF, dhCons: i.dhCons, infCad: i.infCad ?? [] });
+    },
+    async distribuicaoDFe(consulta, opcoes = {}) {
+      const autor = autorPadrao(opcoes.autor, "autor");
+      const nsu = (x, k) => {
+        const s = String(x);
+        if (!/^[0-9]{1,15}$/.test(s))
+          throw new ErroDeConfiguracao4(`${k} inválido: ${s}`);
+        return s.padStart(15, "0");
+      };
+      const grupo = "ultNSU" in consulta ? { distNSU: { ultNSU: nsu(consulta.ultNSU, "ultNSU") } } : ("NSU" in consulta) ? { consNSU: { NSU: nsu(consulta.NSU, "NSU") } } : { consChNFe: { chNFe: chaveValida(consulta.chNFe, "chNFe").chave } };
+      const cUFAutor = opcoes.cUFAutor ?? ufPadrao("NFeDistribuicaoDFe").cUF;
+      if (ufPorCUf2(cUFAutor) === undefined)
+        throw new ErroDeConfiguracao4(`cUFAutor inválido: ${cUFAutor}`);
+      const msg = serializarRaiz(distDFeIntElement, {
+        versao: "1.01",
+        tpAmb,
+        cUFAutor,
+        ...autor,
+        ...grupo
+      });
+      const ep = nfeEndpoint({ ambiente: opcoesDoCliente.ambiente, servico: "NFeDistribuicaoDFe" });
+      const r = await call(ep, "NFeDistribuicaoDFe", msg, "retDistDFeInt", opcoes.signal);
+      const v = decodificar(retDistDFeInt, r.ret, r.doc.texto).valor;
+      const status = { cStat: v.cStat, xMotivo: v.xMotivo };
+      logger.info("nfe.distribuicao", { cStat: v.cStat, ultNSU: v.ultNSU, maxNSU: v.maxNSU });
+      const base = { ultNSU: v.ultNSU, maxNSU: v.maxNSU, dhResp: v.dhResp };
+      if (cstatEm(v.cStat, "distribuicaoNenhumDocumento"))
+        return criarAutorizado(status, { ...base, documentos: [] });
+      if (!cstatEm(v.cStat, "distribuicaoDocumentos"))
+        return rejeitado(status);
+      const documentos = [];
+      for (const z of v.loteDistDFeInt?.docZip ?? []) {
+        const xml = await descomprimirGzipBase64(z.$text);
+        documentos.push(documentoDistribuido(z.NSU ?? "", z.schema, xml));
+      }
+      return criarAutorizado(status, { ...base, documentos });
+    }
+  };
+  return client;
+}
+function documentoDistribuido(NSU, schema, xml) {
+  const nome = schema.replace(/_v?\d.*$/, "");
+  const base = { NSU, schema, xml };
+  if (nome === "resNFe")
+    return { ...base, tipo: "resNFe", resNFe: decodificarXml(resNFeElement, xml).valor };
+  if (nome === "resEvento")
+    return { ...base, tipo: "resEvento", resEvento: decodificarXml(resEventoElement, xml).valor };
+  if (nome === "procNFe")
+    return { ...base, tipo: "procNFe" };
+  if (nome === "procEventoNFe")
+    return { ...base, tipo: "procEventoNFe" };
+  return { ...base, tipo: "outro" };
+}
+// packages/nfe/src/services/recuperar.ts
+import { lerXml as lerXml7, primeiroFilho as primeiroFilho6, textoDe as textoDe3 } from "@sinete/core/xml";
+function campo(el, local) {
+  const c = primeiroFilho6(el, local, NFE_NS4);
+  return c === undefined ? undefined : textoDe3(c).trim();
+}
+function lerProcEvento(xml) {
+  let doc;
+  try {
+    doc = lerXml7(xml);
+  } catch {
+    return;
+  }
+  const evento = primeiroFilho6(doc.raiz, "evento", NFE_NS4);
+  const pedido = evento === undefined ? undefined : primeiroFilho6(evento, "infEvento", NFE_NS4);
+  const retEl = primeiroFilho6(doc.raiz, "retEvento", NFE_NS4);
+  const ret = retEl === undefined ? undefined : primeiroFilho6(retEl, "infEvento", NFE_NS4);
+  if (doc.raiz.local !== "procEventoNFe" || pedido === undefined || retEl === undefined || ret === undefined) {
+    return;
+  }
+  const cStat = campo(ret, "cStat");
+  const chNFe = campo(ret, "chNFe");
+  const tpEvento = campo(ret, "tpEvento");
+  const nSeq = campo(ret, "nSeqEvento");
+  const dhRegEvento = campo(ret, "dhRegEvento");
+  if (cStat === undefined || !cstatEm(cStat, "eventoRegistrado"))
+    return;
+  if (chNFe === undefined || tpEvento === undefined || nSeq === undefined)
+    return;
+  const nSeqPedido = campo(pedido, "nSeqEvento");
+  if (campo(pedido, "chNFe") !== chNFe || campo(pedido, "tpEvento") !== tpEvento)
+    return;
+  if (nSeqPedido === undefined || Number(nSeqPedido) !== Number(nSeq))
+    return;
+  if (chNFe === undefined || tpEvento === undefined || nSeq === undefined || dhRegEvento === undefined)
+    return;
+  const nProt = campo(ret, "nProt");
+  return {
+    chNFe,
+    tpEvento,
+    nSeqEvento: String(Number(nSeq)),
+    dhRegEvento,
+    retEvento: recortarElemento(doc, retEl, ""),
+    procEventoNFe: xml,
+    ...nProt === undefined ? {} : { nProt }
+  };
+}
+async function recuperarEventoRegistrado(cliente, chave, tpEvento, nSeqEvento) {
+  const consulta = await cliente.consultar(chave);
+  if (consulta.tipo !== "autorizado" && consulta.tipo !== "denegado")
+    return { registrado: false, consulta };
+  let achado;
+  for (const xml of consulta.valor.eventos) {
+    const e = lerProcEvento(xml);
+    if (e === undefined || e.chNFe !== consulta.valor.chNFe || e.tpEvento !== tpEvento)
+      continue;
+    if (nSeqEvento !== undefined && Number(e.nSeqEvento) !== nSeqEvento)
+      continue;
+    if (achado === undefined || Number(e.nSeqEvento) > Number(achado.nSeqEvento))
+      achado = e;
+  }
+  return achado === undefined ? { registrado: false, consulta } : { registrado: true, evento: achado, consulta };
+}
+// packages/nfe/src/services/resolver.ts
+import { criarAutorizado as criarAutorizado2, criarDenegado as criarDenegado2 } from "@sinete/core";
+var CHAVE_NO_MOTIVO = /\[\s*chNFe\s*:\s*([0-9]{6}[0-9A-Z]{12}[0-9]{26})\s*\]/i;
+function chaveDaDuplicidade(xMotivo) {
+  return CHAVE_NO_MOTIVO.exec(xMotivo)?.[1]?.toUpperCase();
+}
+async function resolverEnvioSemResposta(cliente, nfeAssinada, anterior) {
+  const a = documentoAssinado(nfeAssinada, "NFe", "infNFe");
+  const chave = a.id.slice(3);
+  if (anterior && anterior.tipo === "recusado" && cstatEm(anterior.cStat, "duplicidadeChaveDiferente")) {
+    const outra = chaveDaDuplicidade(anterior.xMotivo);
+    return { acao: "divergente", motivo: anterior, ...outra === undefined ? {} : { chNFe: outra } };
+  }
+  const consulta = await cliente.consultar(chave, nfeAssinada);
+  if (consulta.tipo === "recusado") {
+    if (cstatEm(consulta.cStat, "naoConsta"))
+      return { acao: "reenviar", nfeAssinada: a.xml };
+    if (cstatEm(consulta.cStat, "outraNfeNoNumero")) {
+      const outra = chaveDaDuplicidade(consulta.xMotivo);
+      return { acao: "divergente", motivo: consulta, ...outra === undefined ? {} : { chNFe: outra } };
+    }
+    return { acao: "indefinida", resultado: consulta };
+  }
+  if (consulta.tipo === "pendente")
+    return { acao: "indefinida", resultado: consulta };
+  const v = consulta.valor;
+  const p = v.protocolo;
+  if (!p)
+    return { acao: "indefinida", resultado: consulta };
+  const conteudo = p.digVal === undefined ? "sem-digval" : v.digValConfere === true ? "confere" : "difere";
+  const protStatus = { cStat: p.cStat, xMotivo: p.xMotivo };
+  if (v.situacao === "denegada")
+    return { acao: "concluida", situacao: "denegada", conteudo, resultado: criarDenegado2(protStatus, p) };
+  if (conteudo === "difere")
+    return { acao: "divergente", chNFe: chave, consulta, motivo: consulta };
+  if (conteudo === "sem-digval")
+    return { acao: "sem-prova", situacao: v.situacao, consulta };
+  if (p.nfeProc === undefined)
+    return { acao: "indefinida", resultado: consulta };
+  return { acao: "concluida", situacao: v.situacao, conteudo, resultado: criarAutorizado2(protStatus, p) };
+}
+export {
+  CODIGOS_OCORRENCIA_NFE,
+  Decimal,
+  MotivoDesoneracaoIcms,
+  NFCE_LIMITE_SEM_DESTINATARIO,
+  NFE_NS3 as NFE_NS,
+  TipoPagamento,
+  XNOME_HOMOLOGACAO,
+  XPROD_HOMOLOGACAO_NFCE,
+  assinarNfe,
+  assinaturaQrCode,
+  autorizadorContingencia,
+  calculadoraIbsCbs,
+  carregarDatasetEmbarcado,
+  chaveDaDuplicidade,
+  comQrCode,
+  conferirEmitenteDoCertificado,
+  criarClienteNfe,
+  dec,
+  descomprimirGzipBase64,
+  deslocamentoDaUf,
+  documentoAssinado,
+  exigenciaRespTec,
+  formatarDecimal,
+  formatarDh,
+  hashCsrt,
+  localDaOperacao,
+  montarNfe,
+  nfeAssinadaDoProc,
+  problemaDeFormato,
+  recortarElemento,
+  recuperarEventoRegistrado,
+  resolverEnvioSemResposta,
+  rotuloDoCaminho,
+  sum,
+  urlsNfce
+};
+
+//# debugId=82CED6CBF6EFA38F64756E2164756E21
+//# sourceMappingURL=index.js.map