@br-validators/cli 1.8.3 → 1.9.0

package/dist/index.js

@@ -1,16 +1,13 @@
 #!/usr/bin/env node
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 
 // src/program.ts
 import { Command } from "commander";
 
+// src/handlers.ts
+import { createRequire } from "module";
+
 // src/commands/bancos/list.ts
-import { BANCOS_DATA_VERSION as BANCOS_DATA_VERSION2, getBancos } from "@br-validators/core/bancos";
+import { BANCOS_DATA_VERSION as BANCOS_DATA_VERSION2, getAllBancos } from "@br-validators/core/bancos";
 
 // src/constants.ts
 var SUPPORTED_TYPES = ["cnpj", "cpf", "cep", "telefone", "cnh", "renavam", "titulo-eleitor", "processo-judicial", "rg", "nfe-chave", "brcode", "placa", "pis-pasep", "pix", "boleto", "cartao", "ie"];
@@ -23,9 +20,10 @@ var EXIT = {
 // src/commands/bancos/lookup.ts
 import {
   BANCOS_DATA_VERSION,
-  getBancoPorCodigo,
-  getBancoPorIspb
+  lookupBancoPorCodigo,
+  lookupBancoPorIspb
 } from "@br-validators/core/bancos";
+import { lookupInvalidFormat } from "@br-validators/core/lookup";
 function normalizeBancosLookupInput(raw) {
   const digits = raw.replace(/\D/g, "");
   if (digits.length === 8) {
@@ -39,33 +37,36 @@ function normalizeBancosLookupInput(raw) {
 function lookupBanco(raw) {
   const normalized = normalizeBancosLookupInput(raw);
   if (!normalized) {
-    return void 0;
+    return lookupInvalidFormat(
+      "Invalid bank code or ISPB. Use 3-digit COMPE (e.g. 001) or 8-digit ISPB."
+    );
   }
-  return normalized.kind === "ispb" ? getBancoPorIspb(normalized.value) : getBancoPorCodigo(normalized.value);
+  return normalized.kind === "ispb" ? lookupBancoPorIspb(normalized.value) : lookupBancoPorCodigo(normalized.value);
 }
 function formatBancoHuman(banco) {
   return `${banco.codigo} \u2014 ${banco.nome} (ISPB ${banco.ispb})`;
 }
 function runBancosLookupCommand(input, options, io = { stdout: [], stderr: [] }) {
-  const normalized = normalizeBancosLookupInput(input);
-  if (!normalized) {
-    io.stderr.push("Invalid bank code or ISPB. Use 3-digit COMPE (e.g. 001) or 8-digit ISPB.");
-    return EXIT.USAGE;
-  }
-  const banco = lookupBanco(input);
-  if (!banco) {
-    io.stderr.push(`Bank not found: ${input}`);
-    return EXIT.INVALID;
+  const result = lookupBanco(input);
+  if (!result.ok) {
+    if (options.json) {
+      io.stdout.push(
+        JSON.stringify({ ok: false, code: result.code, message: result.message }, null, 2)
+      );
+    } else {
+      io.stderr.push(result.message);
+    }
+    return normalizeBancosLookupInput(input) === null ? EXIT.USAGE : EXIT.INVALID;
   }
   if (options.json) {
-    const payload = { ok: true, banco };
+    const payload = { ok: true, banco: result.value };
     if (options.verbose) {
       payload.capturadoEm = BANCOS_DATA_VERSION.capturadoEm;
     }
     io.stdout.push(JSON.stringify(payload, null, 2));
     return EXIT.OK;
   }
-  io.stdout.push(formatBancoHuman(banco));
+  io.stdout.push(formatBancoHuman(result.value));
   if (options.verbose) {
     io.stdout.push(`capturadoEm: ${BANCOS_DATA_VERSION.capturadoEm}`);
   }
@@ -81,7 +82,7 @@ function runBancosLookup(value, options, io = { stdout: [], stderr: [] }) {
 
 // src/commands/bancos/list.ts
 function sliceBancos(limit) {
-  const all = getBancos();
+  const all = getAllBancos();
   if (limit === void 0 || !Number.isFinite(limit) || limit <= 0) {
     return all;
   }
@@ -116,41 +117,45 @@ function runBancosList(options, io = { stdout: [], stderr: [] }) {
 // src/commands/reference-lookup/registry.ts
 import {
   CEST_DATA_VERSION,
-  getCestPorCodigo
+  lookupCestPorCodigo
 } from "@br-validators/core/cest";
 import {
   INCOTERMS_DATA_VERSION,
-  getIncotermPorCodigo
+  lookupIncotermPorCodigo
 } from "@br-validators/core/incoterms";
 import {
   MOEDAS_DATA_VERSION,
-  getMoedaPorCodigo
+  lookupMoedaPorCodigo
 } from "@br-validators/core/moedas";
 import {
   NATUREZA_JURIDICA_DATA_VERSION,
-  getNaturezaJuridicaPorCodigo
+  lookupNaturezaJuridicaPorCodigo
 } from "@br-validators/core/natureza-juridica";
-import { NBS_DATA_VERSION, getNbsPorCodigo } from "@br-validators/core/nbs";
+import { NBS_DATA_VERSION, lookupNbsPorCodigo } from "@br-validators/core/nbs";
 import {
   PAISES_BACEN_DATA_VERSION,
-  getPaisPorCodigoBacen
+  lookupPaisPorCodigoBacen
 } from "@br-validators/core/paises-bacen";
 import {
   AEROPORTOS_DATA_VERSION,
-  getAeroportoPorIata,
-  getAeroportoPorIcao
+  lookupAeroportoPorIata,
+  lookupAeroportoPorIcao
 } from "@br-validators/core/aeroportos";
-import { PORTOS_DATA_VERSION, getPortoPorCodigo } from "@br-validators/core/portos";
+import { PORTOS_DATA_VERSION, lookupPortoPorCodigo } from "@br-validators/core/portos";
 import {
   CNAES_DATA_VERSION,
-  getCnaePorCodigo
+  lookupCnaePorCodigo
 } from "@br-validators/core/cnaes";
 import {
   CFOP_DATA_VERSION,
-  getCfopPorCodigo
+  lookupCfopPorCodigo
 } from "@br-validators/core/cfop";
-import { NCM_DATA_VERSION, getNcmPorCodigo } from "@br-validators/core/ncm";
-import { CBO_DATA_VERSION, getCboPorCodigo } from "@br-validators/core/cbo";
+import { NCM_DATA_VERSION, lookupNcmPorCodigo } from "@br-validators/core/ncm";
+import { CBO_DATA_VERSION, lookupCboPorCodigo } from "@br-validators/core/cbo";
+import {
+  lookupInvalidFormat as lookupInvalidFormat2,
+  lookupInvalidInput
+} from "@br-validators/core/lookup";
 var REFERENCE_LOOKUP_COMMANDS = [
   "natureza-juridica",
   "nbs",
@@ -168,13 +173,16 @@ var REFERENCE_LOOKUP_COMMANDS = [
 var REFERENCE_SEARCH_COMMANDS = ["cnae", "cfop", "ncm", "cbo"];
 function lookupAeroporto(input) {
   const normalized = input.trim().toUpperCase();
+  if (normalized.length === 0) {
+    return lookupInvalidInput("Airport code is required");
+  }
   if (/^[A-Z0-9]{3}$/.test(normalized)) {
-    return getAeroportoPorIata(normalized);
+    return lookupAeroportoPorIata(normalized);
   }
   if (/^[A-Z]{4}$/.test(normalized)) {
-    return getAeroportoPorIcao(normalized);
+    return lookupAeroportoPorIcao(normalized);
   }
-  return void 0;
+  return lookupInvalidFormat2("Airport code must be 3-character IATA or 4-character ICAO");
 }
 var REFERENCE_LOOKUP_MODULES = {
   "natureza-juridica": {
@@ -182,7 +190,7 @@ var REFERENCE_LOOKUP_MODULES = {
     description: "RFB legal nature codes \u2014 offline lookup",
     resultKey: "naturezaJuridica",
     capturadoEm: NATUREZA_JURIDICA_DATA_VERSION.capturadoEm,
-    lookup: (input) => getNaturezaJuridicaPorCodigo(input),
+    lookup: (input) => lookupNaturezaJuridicaPorCodigo(input),
     formatHuman: (result) => {
       const row = result;
       return `${row.codigo} \u2014 ${row.descricao}`;
@@ -193,7 +201,7 @@ var REFERENCE_LOOKUP_MODULES = {
     description: "NFSe NBS service codes \u2014 offline lookup",
     resultKey: "nbs",
     capturadoEm: NBS_DATA_VERSION.capturadoEm,
-    lookup: (input) => getNbsPorCodigo(input),
+    lookup: (input) => lookupNbsPorCodigo(input),
     formatHuman: (result) => {
       const row = result;
       return `${row.codigo} \u2014 ${row.descricao}`;
@@ -204,7 +212,7 @@ var REFERENCE_LOOKUP_MODULES = {
     description: "CONFAZ CEST ST codes \u2014 offline lookup",
     resultKey: "cest",
     capturadoEm: CEST_DATA_VERSION.capturadoEm,
-    lookup: (input) => getCestPorCodigo(input),
+    lookup: (input) => lookupCestPorCodigo(input),
     formatHuman: (result) => {
       const row = result;
       return `${row.codigo} \u2014 ${row.descricao}`;
@@ -215,7 +223,7 @@ var REFERENCE_LOOKUP_MODULES = {
     description: "IBGE CNAE 2.3 subclasses \u2014 offline lookup",
     resultKey: "cnae",
     capturadoEm: CNAES_DATA_VERSION.capturadoEm,
-    lookup: (input) => getCnaePorCodigo(input),
+    lookup: (input) => lookupCnaePorCodigo(input),
     formatHuman: (result) => {
       const row = result;
       return `${row.codigo} \u2014 ${row.descricao}`;
@@ -226,7 +234,7 @@ var REFERENCE_LOOKUP_MODULES = {
     description: "CONFAZ CFOP fiscal operations \u2014 offline lookup",
     resultKey: "cfop",
     capturadoEm: CFOP_DATA_VERSION.capturadoEm,
-    lookup: (input) => getCfopPorCodigo(input),
+    lookup: (input) => lookupCfopPorCodigo(input),
     formatHuman: (result) => {
       const row = result;
       return `${row.codigo} \u2014 ${row.descricao}`;
@@ -237,7 +245,7 @@ var REFERENCE_LOOKUP_MODULES = {
     description: "Siscomex NCM Mercosur codes \u2014 offline lookup",
     resultKey: "ncm",
     capturadoEm: NCM_DATA_VERSION.capturadoEm,
-    lookup: (input) => getNcmPorCodigo(input),
+    lookup: (input) => lookupNcmPorCodigo(input),
     formatHuman: (result) => {
       const row = result;
       return `${row.codigo} \u2014 ${row.descricao}`;
@@ -248,7 +256,7 @@ var REFERENCE_LOOKUP_MODULES = {
     description: "MTE CBO 2002 occupations \u2014 offline lookup",
     resultKey: "cbo",
     capturadoEm: CBO_DATA_VERSION.capturadoEm,
-    lookup: (input) => getCboPorCodigo(input),
+    lookup: (input) => lookupCboPorCodigo(input),
     formatHuman: (result) => {
       const row = result;
       return `${row.codigo} \u2014 ${row.descricao}`;
@@ -259,7 +267,7 @@ var REFERENCE_LOOKUP_MODULES = {
     description: "ISO 4217 + Bacen PTAX currencies \u2014 offline lookup",
     resultKey: "moeda",
     capturadoEm: MOEDAS_DATA_VERSION.capturadoEm,
-    lookup: (input) => getMoedaPorCodigo(input),
+    lookup: (input) => lookupMoedaPorCodigo(input),
     formatHuman: (result) => {
       const row = result;
       const symbol = row.simbolo ?? "\u2014";
@@ -271,7 +279,7 @@ var REFERENCE_LOOKUP_MODULES = {
     description: "NF-e Bacen country codes \u2014 offline lookup",
     resultKey: "pais",
     capturadoEm: PAISES_BACEN_DATA_VERSION.capturadoEm,
-    lookup: (input) => getPaisPorCodigoBacen(input),
+    lookup: (input) => lookupPaisPorCodigoBacen(input),
     formatHuman: (result) => {
       const row = result;
       return `${row.codigo} \u2014 ${row.nome}`;
@@ -282,7 +290,7 @@ var REFERENCE_LOOKUP_MODULES = {
     description: "ICC Incoterms 2020 \u2014 offline lookup",
     resultKey: "incoterm",
     capturadoEm: INCOTERMS_DATA_VERSION.capturadoEm,
-    lookup: (input) => getIncotermPorCodigo(input),
+    lookup: (input) => lookupIncotermPorCodigo(input),
     formatHuman: (result) => {
       const row = result;
       return `${row.codigo} \u2014 ${row.nome} (${row.edicao})`;
@@ -293,7 +301,7 @@ var REFERENCE_LOOKUP_MODULES = {
     description: "ANTAQ port installations \u2014 offline lookup",
     resultKey: "porto",
     capturadoEm: PORTOS_DATA_VERSION.capturadoEm,
-    lookup: (input) => getPortoPorCodigo(input),
+    lookup: (input) => lookupPortoPorCodigo(input),
     formatHuman: (result) => {
       const row = result;
       return `${row.codigo} \u2014 ${row.nome} (${row.uf})`;
@@ -320,6 +328,15 @@ function isReferenceSearchCommand(value) {
 }
 
 // src/commands/reference-lookup/lookup.ts
+function emitLookupFailure(result, options, io) {
+  if (options.json) {
+    io.stdout.push(
+      JSON.stringify({ ok: false, code: result.code, message: result.message }, null, 2)
+    );
+    return;
+  }
+  io.stderr.push(result.message);
+}
 function runReferenceLookupCommand(command, input, options, io = { stdout: [], stderr: [] }) {
   const module = REFERENCE_LOOKUP_MODULES[command];
   const trimmed = input.trim();
@@ -328,20 +345,20 @@ function runReferenceLookupCommand(command, input, options, io = { stdout: [], s
     return EXIT.USAGE;
   }
   const result = module.lookup(trimmed);
-  if (!result) {
-    io.stderr.push(`Not found: ${trimmed}`);
+  if (!result.ok) {
+    emitLookupFailure(result, options, io);
     return EXIT.INVALID;
   }
   if (options.json) {
     const payload = {
       ok: true,
-      [module.resultKey]: result,
+      [module.resultKey]: result.value,
       ...options.verbose ? { capturadoEm: module.capturadoEm } : {}
     };
     io.stdout.push(JSON.stringify(payload, null, 2));
     return EXIT.OK;
   }
-  io.stdout.push(module.formatHuman(result));
+  io.stdout.push(module.formatHuman(result.value));
   if (options.verbose) {
     io.stdout.push(`capturadoEm: ${module.capturadoEm}`);
   }
@@ -425,11 +442,239 @@ function runReferenceSearch(command, query, options, io = { stdout: [], stderr:
   return runReferenceSearchCommand(command, query.trim(), options, io);
 }
 
+// src/commands/reference-lookup/validate.ts
+import { validateCfop } from "@br-validators/core/cfop";
+import { validateNcm } from "@br-validators/core/ncm";
+var REFERENCE_VALIDATE_COMMANDS = ["ncm", "cfop"];
+var VALIDATORS = {
+  ncm: validateNcm,
+  cfop: validateCfop
+};
+var CAPTURED_AT = {
+  ncm: "ncm",
+  cfop: "cfop"
+};
+function emitFailure(result, options, io) {
+  if (options.json) {
+    io.stdout.push(JSON.stringify({ ok: false, code: result.code, message: result.message }, null, 2));
+    return;
+  }
+  io.stderr.push(result.message);
+}
+function isReferenceValidateCommand(command) {
+  return REFERENCE_VALIDATE_COMMANDS.includes(command);
+}
+function runReferenceValidateCommand(command, input, options, io = { stdout: [], stderr: [] }) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    io.stderr.push(`Missing code. Pass a value to validate for ${command}.`);
+    return EXIT.USAGE;
+  }
+  const result = VALIDATORS[command](trimmed);
+  if (!result.ok) {
+    emitFailure(result, options, io);
+    return EXIT.INVALID;
+  }
+  if (options.json) {
+    const payload = {
+      ok: true,
+      value: result.value,
+      description: result.description,
+      ...result.format !== void 0 ? { format: result.format } : {},
+      ...options.verbose ? { module: CAPTURED_AT[command] } : {}
+    };
+    io.stdout.push(JSON.stringify(payload, null, 2));
+    return EXIT.OK;
+  }
+  const lines = [`${result.value} \u2014 ${result.description}`];
+  if (result.format !== void 0) {
+    lines.push(`format: ${result.format}`);
+  }
+  io.stdout.push(lines.join("\n"));
+  return EXIT.OK;
+}
+function runReferenceValidate(command, value, options, io = { stdout: [], stderr: [] }) {
+  if (!isReferenceValidateCommand(command)) {
+    io.stderr.push(`Unknown reference validate command: ${command}`);
+    return EXIT.USAGE;
+  }
+  if (!value?.trim()) {
+    io.stderr.push(`Missing code. Usage: br-validators ${command} validate <codigo>`);
+    return EXIT.USAGE;
+  }
+  return runReferenceValidateCommand(command, value.trim(), options, io);
+}
+
+// src/commands/cst/index.ts
+import {
+  CST_DATA_VERSION,
+  lookupCstCofinsPorCodigo,
+  lookupCstIcmsPorCodigo,
+  lookupCstIpiPorCodigo,
+  lookupCstPisPorCodigo,
+  searchCstCofins,
+  searchCstIcms,
+  searchCstIpi,
+  searchCstPis,
+  validateCst
+} from "@br-validators/core/cst";
+var CST_TAXES = ["icms", "ipi", "pis", "cofins"];
+function parseCstTax(raw) {
+  if (raw === void 0) {
+    return null;
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (CST_TAXES.includes(normalized)) {
+    return normalized;
+  }
+  return null;
+}
+function lookupByTax(tax, codigo) {
+  switch (tax) {
+    case "icms":
+      return lookupCstIcmsPorCodigo(codigo);
+    case "ipi":
+      return lookupCstIpiPorCodigo(codigo);
+    case "pis":
+      return lookupCstPisPorCodigo(codigo);
+    case "cofins":
+      return lookupCstCofinsPorCodigo(codigo);
+  }
+}
+function searchByTax(tax, query, limit) {
+  const options = limit !== void 0 ? { limit } : void 0;
+  switch (tax) {
+    case "icms":
+      return searchCstIcms(query, options);
+    case "ipi":
+      return searchCstIpi(query, options);
+    case "pis":
+      return searchCstPis(query, options);
+    case "cofins":
+      return searchCstCofins(query, options);
+  }
+}
+function emitLookupFailure2(result, options, io) {
+  if (options.json) {
+    io.stdout.push(JSON.stringify({ ok: false, code: result.code, message: result.message }, null, 2));
+    return;
+  }
+  io.stderr.push(result.message);
+}
+function emitValidateFailure(result, options, io) {
+  if (options.json) {
+    io.stdout.push(JSON.stringify({ ok: false, code: result.code, message: result.message }, null, 2));
+    return;
+  }
+  io.stderr.push(result.message);
+}
+function runCstLookup(codigo, options, io = { stdout: [], stderr: [] }) {
+  const tax = parseCstTax(options.tax);
+  if (tax === null) {
+    io.stderr.push("Missing or invalid --tax. Expected: icms | ipi | pis | cofins");
+    return EXIT.USAGE;
+  }
+  const trimmed = codigo?.trim() ?? "";
+  if (trimmed.length === 0) {
+    io.stderr.push("Missing code. Usage: br-validators cst lookup <codigo> --tax icms");
+    return EXIT.USAGE;
+  }
+  const result = lookupByTax(tax, trimmed);
+  if (!result.ok) {
+    emitLookupFailure2(result, options, io);
+    return EXIT.INVALID;
+  }
+  if (options.json) {
+    io.stdout.push(
+      JSON.stringify(
+        {
+          ok: true,
+          cst: result.value,
+          tax,
+          ...options.verbose ? { capturadoEm: CST_DATA_VERSION.capturadoEm } : {}
+        },
+        null,
+        2
+      )
+    );
+    return EXIT.OK;
+  }
+  io.stdout.push(`${result.value.codigo} \u2014 ${result.value.descricao}`);
+  if (options.verbose) {
+    io.stdout.push(`tax: ${tax}`);
+    io.stdout.push(`capturadoEm: ${CST_DATA_VERSION.capturadoEm}`);
+  }
+  return EXIT.OK;
+}
+function runCstSearch(query, options, io = { stdout: [], stderr: [] }) {
+  const tax = parseCstTax(options.tax);
+  if (tax === null) {
+    io.stderr.push("Missing or invalid --tax. Expected: icms | ipi | pis | cofins");
+    return EXIT.USAGE;
+  }
+  const trimmed = query?.trim() ?? "";
+  if (trimmed.length === 0) {
+    io.stderr.push("Missing query. Usage: br-validators cst search <query> --tax icms");
+    return EXIT.USAGE;
+  }
+  const rows = searchByTax(tax, trimmed, options.limit);
+  if (options.json) {
+    io.stdout.push(JSON.stringify({ ok: true, tax, results: rows }, null, 2));
+    return EXIT.OK;
+  }
+  if (rows.length === 0) {
+    io.stdout.push("No matches.");
+    return EXIT.OK;
+  }
+  for (const row of rows) {
+    io.stdout.push(`${row.codigo} \u2014 ${row.descricao}`);
+  }
+  return EXIT.OK;
+}
+function runCstValidate(codigo, options, io = { stdout: [], stderr: [] }) {
+  const tax = parseCstTax(options.tax);
+  if (tax === null) {
+    io.stderr.push("Missing or invalid --tax. Expected: icms | ipi | pis | cofins");
+    return EXIT.USAGE;
+  }
+  const trimmed = codigo?.trim() ?? "";
+  if (trimmed.length === 0) {
+    io.stderr.push("Missing code. Usage: br-validators cst validate <codigo> --tax icms");
+    return EXIT.USAGE;
+  }
+  const result = validateCst(trimmed, { tax });
+  if (!result.ok) {
+    emitValidateFailure(result, options, io);
+    return EXIT.INVALID;
+  }
+  if (options.json) {
+    io.stdout.push(
+      JSON.stringify(
+        {
+          ok: true,
+          tax,
+          value: result.value,
+          description: result.description
+        },
+        null,
+        2
+      )
+    );
+    return EXIT.OK;
+  }
+  io.stdout.push(`${result.value} \u2014 ${result.description}`);
+  if (options.verbose) {
+    io.stdout.push(`tax: ${tax}`);
+  }
+  return EXIT.OK;
+}
+
 // src/commands/ibge/lookup.ts
 import {
-  getMunicipioPorCodigo,
+  lookupMunicipioPorCodigo,
   IBGE_DATA_VERSION
 } from "@br-validators/core/ibge";
+import { lookupInvalidFormat as lookupInvalidFormat3 } from "@br-validators/core/lookup";
 function normalizeIbgeMunicipioCode(raw) {
   const digits = raw.replace(/\D/g, "");
   if (digits.length !== 7) {
@@ -437,24 +682,35 @@ function normalizeIbgeMunicipioCode(raw) {
   }
   return Number(digits);
 }
+function lookupMunicipio(raw) {
+  const codigo = normalizeIbgeMunicipioCode(raw);
+  if (codigo === null) {
+    return lookupInvalidFormat3("Invalid IBGE municipality code. Use 7 digits (e.g. 3550308).");
+  }
+  return lookupMunicipioPorCodigo(codigo);
+}
 function formatMunicipioHuman(municipio) {
   return `${municipio.codigo} \u2014 ${municipio.nome} (${municipio.uf})`;
 }
-function runIbgeLookupCommand(input, options, io = { stdout: [], stderr: [] }) {
-  const codigo = normalizeIbgeMunicipioCode(input);
-  if (codigo === null) {
-    io.stderr.push("Invalid IBGE municipality code. Use 7 digits (e.g. 3550308).");
-    return EXIT.USAGE;
+function emitLookupFailure3(result, options, io) {
+  if (options.json) {
+    io.stdout.push(
+      JSON.stringify({ ok: false, code: result.code, message: result.message }, null, 2)
+    );
+    return result.code === "INVALID_FORMAT" ? EXIT.USAGE : EXIT.INVALID;
   }
-  const municipio = getMunicipioPorCodigo(codigo);
-  if (!municipio) {
-    io.stderr.push(`Municipality not found: ${input}`);
-    return EXIT.INVALID;
+  io.stderr.push(result.message);
+  return result.code === "INVALID_FORMAT" ? EXIT.USAGE : EXIT.INVALID;
+}
+function runIbgeLookupCommand(input, options, io = { stdout: [], stderr: [] }) {
+  const result = lookupMunicipio(input);
+  if (!result.ok) {
+    return emitLookupFailure3(result, options, io);
   }
   if (options.json) {
     const payload = {
       ok: true,
-      municipio
+      municipio: result.value
     };
     if (options.verbose) {
       payload.capturadoEm = IBGE_DATA_VERSION.capturadoEm;
@@ -462,7 +718,7 @@ function runIbgeLookupCommand(input, options, io = { stdout: [], stderr: [] }) {
     io.stdout.push(JSON.stringify(payload, null, 2));
     return EXIT.OK;
   }
-  io.stdout.push(formatMunicipioHuman(municipio));
+  io.stdout.push(formatMunicipioHuman(result.value));
   if (options.verbose) {
     io.stdout.push(`capturadoEm: ${IBGE_DATA_VERSION.capturadoEm}`);
   }
@@ -478,8 +734,8 @@ function runIbgeLookup(value, options, io = { stdout: [], stderr: [] }) {
 
 // src/commands/ibge/list.ts
 import {
-  getEstados,
-  getMunicipios,
+  getAllEstados,
+  getAllMunicipios,
   IBGE_DATA_VERSION as IBGE_DATA_VERSION2
 } from "@br-validators/core/ibge";
 function sliceRows(rows, limit) {
@@ -492,7 +748,7 @@ function formatEstadoHuman(estado) {
   return `${estado.codigo} \u2014 ${estado.sigla} \u2014 ${estado.nome}`;
 }
 function runIbgeListEstadosCommand(options, io = { stdout: [], stderr: [] }) {
-  const estados = sliceRows(getEstados(), options.limit);
+  const estados = sliceRows(getAllEstados(), options.limit);
   if (options.json) {
     const payload = {
       ok: true,
@@ -515,7 +771,7 @@ function runIbgeListEstadosCommand(options, io = { stdout: [], stderr: [] }) {
 }
 function runIbgeListMunicipiosCommand(options, io = { stdout: [], stderr: [] }) {
   const uf = options.uf?.trim().toUpperCase();
-  const municipios = sliceRows(getMunicipios(uf ? { uf } : void 0), options.limit);
+  const municipios = sliceRows(getAllMunicipios(uf ? { uf } : void 0), options.limit);
   if (options.json) {
     const payload = {
       ok: true,
@@ -547,7 +803,7 @@ function runIbgeList(target, options, io = { stdout: [], stderr: [] }) {
 // src/commands/feriados/list.ts
 import {
   FERIADOS_DATA_VERSION,
-  getFeriadosNacionais
+  getAllFeriados
 } from "@br-validators/core/feriados";
 function resolveYear(year) {
   if (year !== void 0 && Number.isInteger(year) && year >= 1900 && year <= 2100) {
@@ -560,7 +816,7 @@ function formatFeriadoHuman(feriado) {
 }
 function runFeriadosListCommand(options, io = { stdout: [], stderr: [] }) {
   const year = resolveYear(options.year);
-  const feriados = getFeriadosNacionais(year);
+  const feriados = getAllFeriados(year);
   if (options.json) {
     const payload = {
       ok: true,
@@ -586,13 +842,193 @@ function runFeriadosList(options, io = { stdout: [], stderr: [] }) {
   return runFeriadosListCommand(options, io);
 }
 
+// src/commands/inss/index.ts
+import {
+  calcularInssMensal,
+  getInssTabelaContribuicao,
+  INSS_DATA_VERSION,
+  INSS_DEFAULT_ANO
+} from "@br-validators/core/inss";
+function resolveAno(ano) {
+  if (ano !== void 0 && Number.isInteger(ano) && ano >= 1900 && ano <= 2100) {
+    return ano;
+  }
+  return INSS_DEFAULT_ANO;
+}
+function formatInssFaixaHuman(faixa) {
+  const aliquotaPct = `${String(faixa.aliquota * 100).replace(".", ",")}%`;
+  return `Faixa ${String(faixa.faixa)} \u2014 ${faixa.descricao} \u2014 ${aliquotaPct}`;
+}
+function runInssTabelaCommand(options, io = { stdout: [], stderr: [] }) {
+  const ano = resolveAno(options.ano);
+  const tabela = getInssTabelaContribuicao(ano);
+  if (tabela === void 0) {
+    io.stderr.push(`INSS contribution table not found for year ${String(ano)}`);
+    return EXIT.INVALID;
+  }
+  if (options.json) {
+    const payload = {
+      ok: true,
+      ano,
+      teto: tabela.teto,
+      faixas: tabela.faixas
+    };
+    if (options.verbose) {
+      payload.capturadoEm = INSS_DATA_VERSION.capturadoEm;
+    }
+    io.stdout.push(JSON.stringify(payload, null, 2));
+    return EXIT.OK;
+  }
+  io.stdout.push(`Teto: R$ ${tabela.teto.toFixed(2)}`);
+  for (const faixa of tabela.faixas) {
+    io.stdout.push(formatInssFaixaHuman(faixa));
+  }
+  if (options.verbose) {
+    io.stdout.push(`capturadoEm: ${INSS_DATA_VERSION.capturadoEm}`);
+  }
+  return EXIT.OK;
+}
+function runInssCalcCommand(salarioRaw, options, io = { stdout: [], stderr: [] }) {
+  const trimmed = salarioRaw.trim().replace(",", ".");
+  const salarioContribuicao = Number(trimmed);
+  if (!Number.isFinite(salarioContribuicao)) {
+    io.stderr.push("Invalid sal\xE1rio de contribui\xE7\xE3o. Pass a numeric value (e.g. 3000).");
+    return EXIT.USAGE;
+  }
+  const ano = resolveAno(options.ano);
+  const result = calcularInssMensal(salarioContribuicao, ano);
+  if (result === void 0) {
+    if (getInssTabelaContribuicao(ano) === void 0) {
+      io.stderr.push(`INSS contribution table not found for year ${String(ano)}`);
+      return EXIT.INVALID;
+    }
+    io.stderr.push("Sal\xE1rio de contribui\xE7\xE3o must be a non-negative number");
+    return EXIT.INVALID;
+  }
+  if (options.json) {
+    const payload = {
+      ok: true,
+      ...result,
+      ...options.verbose ? { capturadoEm: INSS_DATA_VERSION.capturadoEm } : {}
+    };
+    io.stdout.push(JSON.stringify(payload, null, 2));
+    return EXIT.OK;
+  }
+  io.stdout.push(
+    `INSS ${String(result.ano)} \u2014 sal\xE1rio R$ ${result.salarioContribuicao.toFixed(2)} \u2014 faixa ${String(result.faixa)} \u2014 contribui\xE7\xE3o R$ ${result.contribuicao.toFixed(2)}`
+  );
+  if (options.verbose) {
+    io.stdout.push(`capturadoEm: ${INSS_DATA_VERSION.capturadoEm}`);
+  }
+  return EXIT.OK;
+}
+function runInssTabela(options, io = { stdout: [], stderr: [] }) {
+  return runInssTabelaCommand(options, io);
+}
+function runInssCalc(salario, options, io = { stdout: [], stderr: [] }) {
+  if (!salario?.trim()) {
+    io.stderr.push("Missing sal\xE1rio de contribui\xE7\xE3o. Usage: br-validators inss calc <salario>");
+    return EXIT.USAGE;
+  }
+  return runInssCalcCommand(salario.trim(), options, io);
+}
+
+// src/commands/irpf/index.ts
+import {
+  calcularIrpfMensal,
+  getIrpfTabelaProgressiva,
+  IRPF_DATA_VERSION,
+  IRPF_DEFAULT_ANO
+} from "@br-validators/core/irpf";
+function resolveAno2(ano) {
+  if (ano !== void 0 && Number.isInteger(ano) && ano >= 1900 && ano <= 2100) {
+    return ano;
+  }
+  return IRPF_DEFAULT_ANO;
+}
+function formatIrpfFaixaHuman(faixa) {
+  const aliquotaPct = `${String(faixa.aliquota * 100).replace(".", ",")}%`;
+  return `Faixa ${String(faixa.faixa)} \u2014 ${faixa.descricao} \u2014 ${aliquotaPct} \u2014 deduzir R$ ${faixa.parcelaDeduzir.toFixed(2)}`;
+}
+function runIrpfTabelaCommand(options, io = { stdout: [], stderr: [] }) {
+  const ano = resolveAno2(options.ano);
+  const faixas = getIrpfTabelaProgressiva(ano);
+  if (faixas === void 0) {
+    io.stderr.push(`IRPF progressive table not found for year ${String(ano)}`);
+    return EXIT.INVALID;
+  }
+  if (options.json) {
+    const payload = {
+      ok: true,
+      ano,
+      faixas
+    };
+    if (options.verbose) {
+      payload.capturadoEm = IRPF_DATA_VERSION.capturadoEm;
+    }
+    io.stdout.push(JSON.stringify(payload, null, 2));
+    return EXIT.OK;
+  }
+  for (const faixa of faixas) {
+    io.stdout.push(formatIrpfFaixaHuman(faixa));
+  }
+  if (options.verbose) {
+    io.stdout.push(`capturadoEm: ${IRPF_DATA_VERSION.capturadoEm}`);
+  }
+  return EXIT.OK;
+}
+function runIrpfCalcCommand(baseRaw, options, io = { stdout: [], stderr: [] }) {
+  const trimmed = baseRaw.trim().replace(",", ".");
+  const baseCalculo = Number(trimmed);
+  if (!Number.isFinite(baseCalculo)) {
+    io.stderr.push("Invalid base de c\xE1lculo. Pass a numeric value (e.g. 3000).");
+    return EXIT.USAGE;
+  }
+  const ano = resolveAno2(options.ano);
+  const result = calcularIrpfMensal(baseCalculo, ano);
+  if (result === void 0) {
+    if (getIrpfTabelaProgressiva(ano) === void 0) {
+      io.stderr.push(`IRPF progressive table not found for year ${String(ano)}`);
+      return EXIT.INVALID;
+    }
+    io.stderr.push("Base de c\xE1lculo must be a non-negative number");
+    return EXIT.INVALID;
+  }
+  if (options.json) {
+    const payload = {
+      ok: true,
+      ...result,
+      ...options.verbose ? { capturadoEm: IRPF_DATA_VERSION.capturadoEm } : {}
+    };
+    io.stdout.push(JSON.stringify(payload, null, 2));
+    return EXIT.OK;
+  }
+  io.stdout.push(
+    `IRPF ${String(result.ano)} \u2014 base R$ ${result.baseCalculo.toFixed(2)} \u2014 faixa ${String(result.faixa)} \u2014 imposto R$ ${result.imposto.toFixed(2)}`
+  );
+  if (options.verbose) {
+    io.stdout.push(`capturadoEm: ${IRPF_DATA_VERSION.capturadoEm}`);
+  }
+  return EXIT.OK;
+}
+function runIrpfTabela(options, io = { stdout: [], stderr: [] }) {
+  return runIrpfTabelaCommand(options, io);
+}
+function runIrpfCalc(base, options, io = { stdout: [], stderr: [] }) {
+  if (!base?.trim()) {
+    io.stderr.push("Missing base de c\xE1lculo. Usage: br-validators irpf calc <base>");
+    return EXIT.USAGE;
+  }
+  return runIrpfCalcCommand(base.trim(), options, io);
+}
+
 // src/commands/tse-municipios/lookup.ts
 import {
   getCodigosTsePorMunicipio,
   getMunicipioIbgePorCodigoTse,
   TSE_MUNICIPIOS_DATA_VERSION
 } from "@br-validators/core/tse-municipios";
-import { getMunicipioPorCodigo as getMunicipioPorCodigo2 } from "@br-validators/core/ibge";
+import { getMunicipioPorCodigo } from "@br-validators/core/ibge";
 function normalizeTseInput(raw) {
   const digits = raw.replace(/\D/g, "");
   if (digits.length === 5) {
@@ -623,11 +1059,11 @@ function lookupTseMunicipio(raw) {
 }
 function formatTseLookupHuman(result) {
   if (result.kind === "tse-to-ibge") {
-    const municipio2 = getMunicipioPorCodigo2(result.ibgeCodigo);
+    const municipio2 = getMunicipioPorCodigo(result.ibgeCodigo);
     const name2 = municipio2 ? `${municipio2.nome} (${municipio2.uf})` : String(result.ibgeCodigo);
     return `TSE ${result.codigoTse} \u2192 IBGE ${result.ibgeCodigo} \u2014 ${name2}`;
   }
-  const municipio = getMunicipioPorCodigo2(result.ibgeCodigo);
+  const municipio = getMunicipioPorCodigo(result.ibgeCodigo);
   const name = municipio ? `${municipio.nome} (${municipio.uf})` : String(result.ibgeCodigo);
   return `IBGE ${result.ibgeCodigo} \u2014 ${name} \u2192 TSE ${result.codigosTse.join(", ")}`;
 }
@@ -771,6 +1207,228 @@ function runDddLookup(value, options, io = { stdout: [], stderr: [] }) {
   return runDddLookupCommand(value.trim(), options, io);
 }
 
+// src/commands/nfe-cuf/lookup.ts
+import {
+  lookupCufPorCodigo,
+  NFE_CUF_DATA_VERSION
+} from "@br-validators/core/nfe-cuf";
+function formatNfeCufHuman(row) {
+  return `cUF ${row.codigo} \u2014 ${row.uf} \u2014 ${row.nome} (IBGE UF ${row.codigoIbge})`;
+}
+function runNfeCufLookupCommand(input, options, io = { stdout: [], stderr: [] }) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    io.stderr.push("Invalid cUF code. Use 2 digits (e.g. 35).");
+    return EXIT.USAGE;
+  }
+  const result = lookupCufPorCodigo(trimmed);
+  if (!result.ok) {
+    if (options.json) {
+      io.stdout.push(JSON.stringify({ ok: false, code: result.code, message: result.message }, null, 2));
+      return EXIT.INVALID;
+    }
+    io.stderr.push(result.message);
+    return EXIT.INVALID;
+  }
+  if (options.json) {
+    const payload = {
+      ok: true,
+      cuf: result.value
+    };
+    if (options.verbose) {
+      payload.capturadoEm = NFE_CUF_DATA_VERSION.capturadoEm;
+    }
+    io.stdout.push(JSON.stringify(payload, null, 2));
+    return EXIT.OK;
+  }
+  io.stdout.push(formatNfeCufHuman(result.value));
+  if (options.verbose) {
+    io.stdout.push(`capturadoEm: ${NFE_CUF_DATA_VERSION.capturadoEm}`);
+  }
+  return EXIT.OK;
+}
+function runNfeCufLookup(value, options, io = { stdout: [], stderr: [] }) {
+  if (!value?.trim()) {
+    io.stderr.push("Missing cUF code. Usage: br-validators nfe-cuf lookup <code>");
+    return EXIT.USAGE;
+  }
+  return runNfeCufLookupCommand(value.trim(), options, io);
+}
+
+// src/commands/selic/index.ts
+import {
+  getSelicMeta,
+  getSelicMetaPorData,
+  SELIC_DATA_VERSION
+} from "@br-validators/core/selic";
+function formatSelicMetaHuman(meta) {
+  return `SELIC meta ${meta.dataReferencia} \u2014 ${String(meta.valor)}% a.a.`;
+}
+function runSelicCommand(options, io = { stdout: [], stderr: [] }) {
+  const meta = options.date === void 0 || options.date.trim().length === 0 ? getSelicMeta() : getSelicMetaPorData(options.date.trim());
+  if (meta === void 0) {
+    io.stderr.push(
+      options.date ? `SELIC meta not found for date ${options.date}` : "SELIC meta series is empty"
+    );
+    return EXIT.INVALID;
+  }
+  if (options.json) {
+    const payload = {
+      ok: true,
+      meta
+    };
+    if (options.verbose) {
+      payload.capturadoEm = SELIC_DATA_VERSION.capturadoEm;
+    }
+    io.stdout.push(JSON.stringify(payload, null, 2));
+    return EXIT.OK;
+  }
+  io.stdout.push(formatSelicMetaHuman(meta));
+  if (options.verbose) {
+    io.stdout.push(`dataReferencia: ${meta.dataReferencia}`);
+    io.stdout.push(`isStale: ${String(meta.isStale)}`);
+    if (meta.warning !== void 0) {
+      io.stdout.push(`warning: ${meta.warning}`);
+    }
+    io.stdout.push(`capturadoEm: ${SELIC_DATA_VERSION.capturadoEm}`);
+  }
+  return EXIT.OK;
+}
+
+// src/commands/iss-municipal/index.ts
+import {
+  getIssMunicipalPorIbge,
+  getIssMunicipalPorUfMunicipio,
+  ISS_MUNICIPAL_DATA_VERSION,
+  ISS_MUNICIPAL_ESTIMATION_WARNING,
+  searchIssMunicipal
+} from "@br-validators/core/iss-municipal";
+function formatIssMunicipalHuman(row) {
+  return `${row.nome}/${row.uf} \u2014 ISS ${String(row.aliquotaMin)}%\u2013${String(row.aliquotaMax)}%`;
+}
+function emitDisclaimer(options, io) {
+  if (options.json) {
+    return;
+  }
+  io.stderr.push(ISS_MUNICIPAL_ESTIMATION_WARNING);
+}
+function runIssMunicipalLookup(codigo, options, io = { stdout: [], stderr: [] }) {
+  const trimmed = codigo?.trim() ?? "";
+  if (trimmed.length === 0) {
+    io.stderr.push("Missing IBGE code. Usage: br-validators iss-municipal lookup <codigoIbge>");
+    return EXIT.USAGE;
+  }
+  const result = getIssMunicipalPorIbge(trimmed);
+  if (result === void 0) {
+    io.stderr.push(`ISS municipal row not found for IBGE code ${trimmed}`);
+    return EXIT.INVALID;
+  }
+  emitDisclaimer(options, io);
+  if (options.json) {
+    const payload = {
+      ok: true,
+      iss: result
+    };
+    if (options.verbose) {
+      payload.capturadoEm = ISS_MUNICIPAL_DATA_VERSION.capturadoEm;
+    }
+    io.stdout.push(JSON.stringify(payload, null, 2));
+    return EXIT.OK;
+  }
+  io.stdout.push(formatIssMunicipalHuman(result));
+  io.stdout.push(`warning: ${result.warning}`);
+  if (options.verbose) {
+    io.stdout.push(`leiUrl: ${result.leiUrl}`);
+    io.stdout.push(`estimativa: ${String(result.estimativa)}`);
+    io.stdout.push(`capturadoEm: ${ISS_MUNICIPAL_DATA_VERSION.capturadoEm}`);
+  }
+  return EXIT.OK;
+}
+function runIssMunicipalSearch(query, options, io = { stdout: [], stderr: [] }) {
+  const trimmed = query?.trim() ?? "";
+  if (trimmed.length === 0) {
+    io.stderr.push("Missing query. Usage: br-validators iss-municipal search <query>");
+    return EXIT.USAGE;
+  }
+  const rows = searchIssMunicipal(trimmed, { limit: options.limit });
+  emitDisclaimer(options, io);
+  if (options.json) {
+    io.stdout.push(JSON.stringify({ ok: true, results: rows }, null, 2));
+    return EXIT.OK;
+  }
+  if (rows.length === 0) {
+    io.stdout.push("No ISS municipal rows matched.");
+    return EXIT.OK;
+  }
+  for (const row of rows) {
+    io.stdout.push(formatIssMunicipalHuman(row));
+  }
+  return EXIT.OK;
+}
+function runIssMunicipalResolve(uf, nome, options, io = { stdout: [], stderr: [] }) {
+  const normalizedUf = uf?.trim() ?? "";
+  const normalizedNome = nome?.trim() ?? "";
+  if (normalizedUf.length === 0 || normalizedNome.length === 0) {
+    io.stderr.push("Missing UF or municipality name. Usage: br-validators iss-municipal resolve <uf> <nome>");
+    return EXIT.USAGE;
+  }
+  const result = getIssMunicipalPorUfMunicipio(normalizedUf, normalizedNome);
+  if (result === void 0) {
+    io.stderr.push(`ISS municipal row not found for ${normalizedNome}/${normalizedUf}`);
+    return EXIT.INVALID;
+  }
+  return runIssMunicipalLookup(String(result.codigoIbge), options, io);
+}
+
+// src/commands/ptax/lookup.ts
+import {
+  getPtaxCotacao,
+  PTAX_DATA_VERSION
+} from "@br-validators/core/ptax";
+function formatPtaxCotacaoHuman(cotacao) {
+  return `${cotacao.moeda} Fechamento PTAX \u2014 compra ${String(cotacao.cotacaoCompra)} / venda ${String(cotacao.cotacaoVenda)} (${cotacao.dataReferencia})`;
+}
+function runPtaxLookupCommand(moeda, data, options, io = { stdout: [], stderr: [] }) {
+  const trimmedMoeda = moeda.trim();
+  if (trimmedMoeda.length === 0) {
+    io.stderr.push("Missing currency code. Pass a 3-letter ISO code (e.g. USD).");
+    return EXIT.USAGE;
+  }
+  const cotacao = data === void 0 || data.trim().length === 0 ? getPtaxCotacao(trimmedMoeda) : getPtaxCotacao(trimmedMoeda, data.trim());
+  if (cotacao === void 0) {
+    io.stderr.push(`PTAX quote not found: ${trimmedMoeda}${data ? ` ${data}` : ""}`);
+    return EXIT.INVALID;
+  }
+  if (options.json) {
+    const payload = {
+      ok: true,
+      cotacao
+    };
+    if (options.verbose) {
+      payload.capturadoEm = PTAX_DATA_VERSION.capturadoEm;
+    }
+    io.stdout.push(JSON.stringify(payload, null, 2));
+    return EXIT.OK;
+  }
+  io.stdout.push(formatPtaxCotacaoHuman(cotacao));
+  if (options.verbose) {
+    io.stdout.push(`dataReferencia: ${cotacao.dataReferencia}`);
+    io.stdout.push(`isStale: ${String(cotacao.isStale)}`);
+    if (cotacao.warning !== void 0) {
+      io.stdout.push(`warning: ${cotacao.warning}`);
+    }
+    io.stdout.push(`capturadoEm: ${PTAX_DATA_VERSION.capturadoEm}`);
+  }
+  return EXIT.OK;
+}
+function runPtaxLookup(moeda, data, options, io = { stdout: [], stderr: [] }) {
+  if (!moeda?.trim()) {
+    io.stderr.push("Missing currency code. Usage: ptax lookup <moeda> [data]");
+    return EXIT.USAGE;
+  }
+  return runPtaxLookupCommand(moeda.trim(), data?.trim(), options, io);
+}
+
 // src/commands/brcode.ts
 import {
   BRCODE_OFFICIAL_SOURCE_URL,
@@ -2288,6 +2946,184 @@ function runSanitize(type, value, options, io = { stdout: [], stderr: [] }) {
   return printSanitize(result, options, io);
 }
 
+// src/commands/mask.ts
+import { isMaskableDocumentType, maskRuntime } from "@br-validators/core";
+function resolveInput22(value, fileContent) {
+  const input = value ?? fileContent?.trim();
+  if (!input) {
+    return null;
+  }
+  return input;
+}
+function runMask(type, value, options, io = { stdout: [], stderr: [] }) {
+  if (!isMaskableDocumentType(type)) {
+    io.stderr.push(`Unsupported mask type: ${type}`);
+    return EXIT.USAGE;
+  }
+  const input = resolveInput22(value, options.file);
+  if (input === null) {
+    io.stderr.push("Missing value. Pass an argument or use --file.");
+    return EXIT.USAGE;
+  }
+  const uf = options.uf?.toUpperCase();
+  const result = maskRuntime(type, input, uf ? { uf } : {});
+  return printFormat(result, options, io);
+}
+
+// src/commands/compare.ts
+import { compareRuntime } from "@br-validators/core";
+
+// src/commands/platform-document-types.ts
+var PLATFORM_DOCUMENT_TYPES = [
+  "cpf",
+  "cnpj",
+  "cep",
+  "placa",
+  "pis-pasep",
+  "telefone",
+  "cnh",
+  "renavam",
+  "titulo-eleitor",
+  "processo-judicial",
+  "rg",
+  "nfe-chave",
+  "boleto",
+  "cartao-credito",
+  "ean",
+  "inscricao-estadual",
+  "inscricao-estadual-produtor-rural",
+  "pix",
+  "brcode"
+];
+function isPlatformDocumentType(type) {
+  return PLATFORM_DOCUMENT_TYPES.includes(type);
+}
+
+// src/commands/compare.ts
+function printCompare(result, options, io = { stdout: [], stderr: [] }) {
+  if (options.json) {
+    io.stdout.push(JSON.stringify(result, null, 2));
+    if ("code" in result) {
+      return EXIT.USAGE;
+    }
+    return result.equal ? EXIT.OK : EXIT.INVALID;
+  }
+  if (options.quiet) {
+    if ("code" in result) {
+      return EXIT.USAGE;
+    }
+    return result.equal ? EXIT.OK : EXIT.INVALID;
+  }
+  if ("code" in result) {
+    io.stderr.push(`code: ${result.code}`);
+    io.stderr.push(`message: ${result.message}`);
+    return EXIT.USAGE;
+  }
+  io.stdout.push(`equal: ${result.equal ? "yes" : "no"}`);
+  return result.equal ? EXIT.OK : EXIT.INVALID;
+}
+function runCompare(type, valueA, valueB, options, io = { stdout: [], stderr: [] }) {
+  if (!isPlatformDocumentType(type)) {
+    io.stderr.push(`Unsupported compare type: ${type}`);
+    return EXIT.USAGE;
+  }
+  if (!valueA || !valueB) {
+    io.stderr.push("Missing values. Usage: compare <type> <valueA> <valueB>");
+    return EXIT.USAGE;
+  }
+  const uf = options.uf?.toUpperCase();
+  const platformOptions = uf ? { uf } : {};
+  const result = compareRuntime(valueA, valueB, type, platformOptions);
+  return printCompare(result, options, io);
+}
+
+// src/commands/batch.ts
+import { batch } from "@br-validators/core";
+function parseBatchLines(raw) {
+  return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function resolveBatchInputs(options) {
+  if (options.lines === void 0) {
+    return null;
+  }
+  const parsed = parseBatchLines(options.lines);
+  if (options.limit !== void 0 && options.limit > 0) {
+    return parsed.slice(0, options.limit);
+  }
+  return parsed;
+}
+function printBatch(result, options, io = { stdout: [], stderr: [] }) {
+  if (options.json) {
+    io.stdout.push(JSON.stringify(result, null, 2));
+    return result.summary.invalid === 0 ? EXIT.OK : EXIT.INVALID;
+  }
+  if (options.quiet) {
+    return result.summary.invalid === 0 ? EXIT.OK : EXIT.INVALID;
+  }
+  io.stdout.push(`total: ${String(result.summary.total)}`);
+  io.stdout.push(`valid: ${String(result.summary.valid)}`);
+  io.stdout.push(`invalid: ${String(result.summary.invalid)}`);
+  for (const entry of result.valid) {
+    io.stdout.push(`ok[${String(entry.index)}]: ${entry.value}`);
+  }
+  for (const entry of result.invalid) {
+    io.stderr.push(`fail[${String(entry.index)}]: ${entry.code} \u2014 ${entry.message}`);
+  }
+  return result.summary.invalid === 0 ? EXIT.OK : EXIT.INVALID;
+}
+function runBatch(type, options, io = { stdout: [], stderr: [] }) {
+  if (!isPlatformDocumentType(type)) {
+    io.stderr.push(`Unsupported batch type: ${type}`);
+    return EXIT.USAGE;
+  }
+  const inputs = resolveBatchInputs(options);
+  if (inputs === null) {
+    io.stderr.push("Missing input. Pass --file <path> or pipe one value per line on stdin.");
+    return EXIT.USAGE;
+  }
+  if (inputs.length === 0) {
+    io.stderr.push("No values to validate.");
+    return EXIT.USAGE;
+  }
+  const uf = options.uf?.toUpperCase();
+  const platformOptions = uf ? { uf } : {};
+  const result = batch(inputs, type, platformOptions);
+  return printBatch(result, options, io);
+}
+
+// src/commands/diff.ts
+import { diff } from "@br-validators/core";
+function printDiff(result, options, io = { stdout: [], stderr: [] }) {
+  if (options.json) {
+    io.stdout.push(JSON.stringify(result, null, 2));
+    return result.changed ? EXIT.INVALID : EXIT.OK;
+  }
+  if (options.quiet) {
+    return result.changed ? EXIT.INVALID : EXIT.OK;
+  }
+  io.stdout.push(`changed: ${result.changed ? "yes" : "no"}`);
+  for (const field of result.fields) {
+    io.stdout.push(`field: ${field.field}`);
+    io.stdout.push(`  a: ${field.a}`);
+    io.stdout.push(`  b: ${field.b}`);
+  }
+  return result.changed ? EXIT.INVALID : EXIT.OK;
+}
+function runDiff(type, valueA, valueB, options, io = { stdout: [], stderr: [] }) {
+  if (!isPlatformDocumentType(type)) {
+    io.stderr.push(`Unsupported diff type: ${type}`);
+    return EXIT.USAGE;
+  }
+  if (!valueA || !valueB) {
+    io.stderr.push("Missing values. Usage: diff <type> <valueA> <valueB>");
+    return EXIT.USAGE;
+  }
+  const uf = options.uf?.toUpperCase();
+  const platformOptions = uf ? { uf } : {};
+  const result = diff(valueA, valueB, type, platformOptions);
+  return printDiff(result, options, io);
+}
+
 // src/commands/generate.ts
 import { generate, isGeneratableCardBrand } from "@br-validators/core";
 var GENERATABLE_TYPES = [
@@ -2317,6 +3153,9 @@ function buildGenerateOptions(options) {
   if (options.masked) {
     core.masked = true;
   }
+  if (options.stripped) {
+    core.stripped = true;
+  }
   if (options.seed !== void 0) {
     core.seed = options.seed;
   }
@@ -2360,10 +3199,14 @@ function listSupportedTypes(io = { stdout: [] }) {
 }
 
 // src/handlers.ts
+var nodeRequire = createRequire(import.meta.url);
+function readNodeFileSync(path, encoding) {
+  const fs = nodeRequire("node:fs");
+  return fs.readFileSync(path, encoding);
+}
 function readInputFile(path, io) {
   try {
-    const fsModule = __require("fs");
-    return fsModule.readFileSync(path, "utf8");
+    return readNodeFileSync(path, "utf8");
   } catch {
     io.stderr.push(`Cannot read file: ${path}`);
     return null;
@@ -2840,6 +3683,90 @@ function handleSanitizeCli(type, value, opts, io = { stdout: [], stderr: [] }) {
     io
   );
 }
+function handleMaskCli(type, value, opts, io = { stdout: [], stderr: [] }) {
+  let fileContent;
+  if (opts.file) {
+    const content = readInputFile(opts.file, io);
+    if (content === null) {
+      return EXIT.USAGE;
+    }
+    fileContent = content;
+  }
+  return runMask(
+    type,
+    value,
+    {
+      json: Boolean(opts.json),
+      quiet: Boolean(opts.quiet),
+      uf: opts.uf,
+      file: fileContent
+    },
+    io
+  );
+}
+function readStdinSync(io) {
+  try {
+    if (process.stdin.isTTY) {
+      return null;
+    }
+    return readNodeFileSync(0, "utf8");
+  } catch {
+    io.stderr.push("Cannot read stdin.");
+    return null;
+  }
+}
+function handleCompareCli(type, valueA, valueB, opts, io = { stdout: [], stderr: [] }) {
+  return runCompare(
+    type,
+    valueA,
+    valueB,
+    {
+      json: Boolean(opts.json),
+      quiet: Boolean(opts.quiet),
+      uf: opts.uf
+    },
+    io
+  );
+}
+function handleDiffCli(type, valueA, valueB, opts, io = { stdout: [], stderr: [] }) {
+  return runDiff(
+    type,
+    valueA,
+    valueB,
+    {
+      json: Boolean(opts.json),
+      quiet: Boolean(opts.quiet),
+      uf: opts.uf
+    },
+    io
+  );
+}
+function handleBatchCli(type, opts, io = { stdout: [], stderr: [] }) {
+  let lines;
+  if (opts.file) {
+    const content = readInputFile(opts.file, io);
+    if (content === null) {
+      return EXIT.USAGE;
+    }
+    lines = content;
+  } else {
+    const stdin = readStdinSync(io);
+    if (stdin !== null) {
+      lines = stdin;
+    }
+  }
+  return runBatch(
+    type,
+    {
+      json: Boolean(opts.json),
+      quiet: Boolean(opts.quiet),
+      uf: opts.uf,
+      lines,
+      limit: opts.limit
+    },
+    io
+  );
+}
 function handleGenerateCli(type, opts, io = { stdout: [], stderr: [] }) {
   return runGenerate(
     type,
@@ -2847,6 +3774,7 @@ function handleGenerateCli(type, opts, io = { stdout: [], stderr: [] }) {
       json: Boolean(opts.json),
       quiet: Boolean(opts.quiet),
       masked: Boolean(opts.masked),
+      stripped: Boolean(opts.stripped),
       format: opts.format,
       seed: opts.seed,
       uf: opts.uf,
@@ -2898,6 +3826,39 @@ function handleReferenceSearchCli(command, query, opts, io = { stdout: [], stder
     io
   );
 }
+function handleReferenceValidateCli(command, value, opts, io = { stdout: [], stderr: [] }) {
+  return runReferenceValidate(
+    command,
+    value,
+    {
+      json: Boolean(opts.json),
+      verbose: Boolean(opts.verbose)
+    },
+    io
+  );
+}
+function handleCstLookupCli(value, opts, io = { stdout: [], stderr: [] }) {
+  return runCstLookup(value, {
+    json: Boolean(opts.json),
+    verbose: Boolean(opts.verbose),
+    tax: opts.tax
+  }, io);
+}
+function handleCstSearchCli(query, opts, io = { stdout: [], stderr: [] }) {
+  return runCstSearch(query, {
+    json: Boolean(opts.json),
+    verbose: Boolean(opts.verbose),
+    tax: opts.tax,
+    limit: opts.limit
+  }, io);
+}
+function handleCstValidateCli(value, opts, io = { stdout: [], stderr: [] }) {
+  return runCstValidate(value, {
+    json: Boolean(opts.json),
+    verbose: Boolean(opts.verbose),
+    tax: opts.tax
+  }, io);
+}
 function handleIbgeLookupCli(value, opts, io = { stdout: [], stderr: [] }) {
   return runIbgeLookup(value, { json: Boolean(opts.json), verbose: Boolean(opts.verbose) }, io);
 }
@@ -2916,6 +3877,34 @@ function handleFeriadosListCli(opts, io = { stdout: [], stderr: [] }) {
     year: opts.year
   }, io);
 }
+function handleInssTabelaCli(opts, io = { stdout: [], stderr: [] }) {
+  return runInssTabela({
+    json: Boolean(opts.json),
+    verbose: Boolean(opts.verbose),
+    ano: opts.year
+  }, io);
+}
+function handleInssCalcCli(value, opts, io = { stdout: [], stderr: [] }) {
+  return runInssCalc(value, {
+    json: Boolean(opts.json),
+    verbose: Boolean(opts.verbose),
+    ano: opts.year
+  }, io);
+}
+function handleIrpfTabelaCli(opts, io = { stdout: [], stderr: [] }) {
+  return runIrpfTabela({
+    json: Boolean(opts.json),
+    verbose: Boolean(opts.verbose),
+    ano: opts.year
+  }, io);
+}
+function handleIrpfCalcCli(value, opts, io = { stdout: [], stderr: [] }) {
+  return runIrpfCalc(value, {
+    json: Boolean(opts.json),
+    verbose: Boolean(opts.verbose),
+    ano: opts.year
+  }, io);
+}
 function handleTseMunicipiosLookupCli(value, opts, io = { stdout: [], stderr: [] }) {
   return runTseMunicipiosLookup(value, { json: Boolean(opts.json), verbose: Boolean(opts.verbose) }, io);
 }
@@ -2925,6 +3914,32 @@ function handleCepFaixaCli(value, opts, io = { stdout: [], stderr: [] }) {
 function handleDddLookupCli(value, opts, io = { stdout: [], stderr: [] }) {
   return runDddLookup(value, { json: Boolean(opts.json), verbose: Boolean(opts.verbose) }, io);
 }
+function handleNfeCufLookupCli(value, opts, io = { stdout: [], stderr: [] }) {
+  return runNfeCufLookup(value, { json: Boolean(opts.json), verbose: Boolean(opts.verbose) }, io);
+}
+function handleSelicCli(opts, io = { stdout: [], stderr: [] }) {
+  return runSelicCommand({
+    json: Boolean(opts.json),
+    verbose: Boolean(opts.verbose),
+    date: opts.date
+  }, io);
+}
+function handleIssMunicipalLookupCli(codigo, opts, io = { stdout: [], stderr: [] }) {
+  return runIssMunicipalLookup(codigo, { json: Boolean(opts.json), verbose: Boolean(opts.verbose) }, io);
+}
+function handleIssMunicipalSearchCli(query, opts, io = { stdout: [], stderr: [] }) {
+  return runIssMunicipalSearch(query, {
+    json: Boolean(opts.json),
+    verbose: Boolean(opts.verbose),
+    limit: opts.limit
+  }, io);
+}
+function handleIssMunicipalResolveCli(uf, nome, opts, io = { stdout: [], stderr: [] }) {
+  return runIssMunicipalResolve(uf, nome, { json: Boolean(opts.json), verbose: Boolean(opts.verbose) }, io);
+}
+function handlePtaxLookupCli(moeda, data, opts, io = { stdout: [], stderr: [] }) {
+  return runPtaxLookup(moeda, data, { json: Boolean(opts.json), verbose: Boolean(opts.verbose) }, io);
+}
 function writeCliIo(io) {
   for (const line of io.stdout) console.log(line);
   for (const line of io.stderr) console.error(line);
@@ -2940,6 +3955,13 @@ function registerReferenceLookupCommands(program) {
       process.exitCode = handleReferenceLookupCli(command, codigo, opts, io);
       writeCliIo(io);
     });
+    if (REFERENCE_VALIDATE_COMMANDS.includes(command)) {
+      root.command("validate").description(`Validate ${command} format and embedded table`).argument("<codigo>", "Code to validate").option("--json", "JSON output").option("--verbose", "Include module metadata").action((codigo, opts) => {
+        const io = { stdout: [], stderr: [] };
+        process.exitCode = handleReferenceValidateCli(command, codigo, opts, io);
+        writeCliIo(io);
+      });
+    }
     if (REFERENCE_SEARCH_COMMANDS.includes(command)) {
       root.command("search").description(`Search ${command} by description fragment`).argument("<query>", "Search query").option("--json", "JSON output").option("--verbose", "Include dataset capture date").option("--limit <n>", "Maximum rows", (v) => Number(v)).action((query, opts) => {
         const io = { stdout: [], stderr: [] };
@@ -3194,6 +4216,28 @@ function createProgram() {
     process.exitCode = handleFeriadosListCli(opts, io);
     writeCliIo(io);
   });
+  const inss = program.command("inss").description("INSS employee contribution progressive table \u2014 offline");
+  inss.command("tabela").description("Show embedded progressive contribution brackets").option("--ano <yyyy>", "Compet\xEAncia year", (v) => Number(v)).option("--json", "JSON output").option("--verbose", "Include dataset capture date").action((opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleInssTabelaCli({ ...opts, year: opts.ano ?? opts.year }, io);
+    writeCliIo(io);
+  });
+  inss.command("calc").description("Estimate monthly INSS contribution from salary").argument("<salario>", "Monthly contribution salary (BRL)").option("--ano <yyyy>", "Compet\xEAncia year", (v) => Number(v)).option("--json", "JSON output").option("--verbose", "Include dataset capture date").action((salario, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleInssCalcCli(salario, { ...opts, year: opts.ano ?? opts.year }, io);
+    writeCliIo(io);
+  });
+  const irpf = program.command("irpf").description("RFB IRPF progressive monthly table \u2014 offline");
+  irpf.command("tabela").description("Show embedded monthly progressive brackets").option("--ano <yyyy>", "Tax year", (v) => Number(v)).option("--json", "JSON output").option("--verbose", "Include dataset capture date").action((opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleIrpfTabelaCli({ ...opts, year: opts.ano ?? opts.year }, io);
+    writeCliIo(io);
+  });
+  irpf.command("calc").description("Estimate monthly IRPF from taxable base").argument("<base>", "Monthly taxable base (BRL)").option("--ano <yyyy>", "Tax year", (v) => Number(v)).option("--json", "JSON output").option("--verbose", "Include dataset capture date").action((base, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleIrpfCalcCli(base, { ...opts, year: opts.ano ?? opts.year }, io);
+    writeCliIo(io);
+  });
   const tseMunicipios = program.command("tse-municipios").description("TSE \u2194 IBGE municipality cross-walk \u2014 offline lookup");
   tseMunicipios.command("lookup").description("Resolve TSE (5 digits) or IBGE (7 digits) municipality code").argument("<codigo>", "TSE or IBGE code").option("--json", "JSON output").option("--verbose", "Include dataset capture date").action((codigo, opts) => {
     const io = { stdout: [], stderr: [] };
@@ -3206,6 +4250,56 @@ function createProgram() {
     process.exitCode = handleDddLookupCli(code, opts, io);
     writeCliIo(io);
   });
+  const nfeCuf = program.command("nfe-cuf").description("NF-e cUF \u2014 SEFAZ federative unit codes (offline)");
+  nfeCuf.command("lookup").description("Resolve NF-e cUF code to UF sigla and IBGE cross-ref").argument("<code>", "2-digit cUF code (e.g. 35 for SP)").option("--json", "JSON output").option("--verbose", "Include dataset capture date").action((code, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleNfeCufLookupCli(code, opts, io);
+    writeCliIo(io);
+  });
+  const selic = program.command("selic").description("Bacen SELIC meta (SGS 432) \u2014 offline embedded series");
+  selic.description("Resolve Copom SELIC meta rate (optional historical date)").option("--date <yyyy-mm-dd>", "Observation date (ISO or MM-DD-YYYY)").option("--json", "JSON output").option("--verbose", "Include dataReferencia, staleness, and dataset capture date").action((opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleSelicCli(opts, io);
+    writeCliIo(io);
+  });
+  const issMunicipal = program.command("iss-municipal").description("Municipal ISS al\xEDquotas \u2014 partial embed (estimation only, not NFSe)");
+  issMunicipal.command("lookup").description("Resolve ISS band by IBGE municipality code").argument("<codigoIbge>", "IBGE municipality code (7 digits)").option("--json", "JSON output").option("--verbose", "Include leiUrl, estimativa flag, and dataset capture date").action((codigoIbge, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleIssMunicipalLookupCli(codigoIbge, opts, io);
+    writeCliIo(io);
+  });
+  issMunicipal.command("resolve").description("Resolve ISS band by UF and municipality name").argument("<uf>", "UF sigla (2 letters)").argument("<nome>", "Municipality name").option("--json", "JSON output").option("--verbose", "Include leiUrl, estimativa flag, and dataset capture date").action((uf, nome, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleIssMunicipalResolveCli(uf, nome, opts, io);
+    writeCliIo(io);
+  });
+  issMunicipal.command("search").description("Search embedded municipalities by name, UF, or IBGE code fragment").argument("<query>", "Search query").option("--json", "JSON output").option("--verbose", "Include dataset capture date in JSON responses").option("--limit <n>", "Maximum rows", (value) => Number(value)).action((query, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleIssMunicipalSearchCli(query, opts, io);
+    writeCliIo(io);
+  });
+  const ptax = program.command("ptax").description("Bacen PTAX Fechamento \u2014 offline embedded rates");
+  ptax.command("lookup").description("Resolve Fechamento PTAX for currency (optional ISO or Bacen date)").argument("<moeda>", "ISO 4217 currency code (e.g. USD)").argument("[data]", "Quote date \u2014 YYYY-MM-DD or MM-DD-YYYY").option("--json", "JSON output").option("--verbose", "Include dataReferencia, staleness, and dataset capture date").action((moeda, data, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handlePtaxLookupCli(moeda, data, opts, io);
+    writeCliIo(io);
+  });
+  const cst = program.command("cst").description("RFB SPED CST \u2014 offline ICMS, IPI, PIS, COFINS tables");
+  cst.command("lookup").description("Resolve CST by code and tax").argument("<codigo>", "CST code").requiredOption("--tax <tax>", "Tax table: icms | ipi | pis | cofins").option("--json", "JSON output").option("--verbose", "Include dataset capture date").action((codigo, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleCstLookupCli(codigo, opts, io);
+    writeCliIo(io);
+  });
+  cst.command("search").description("Search CST descriptions by tax").argument("<query>", "Search query").requiredOption("--tax <tax>", "Tax table: icms | ipi | pis | cofins").option("--json", "JSON output").option("--limit <n>", "Maximum rows", (v) => Number(v)).action((query, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleCstSearchCli(query, opts, io);
+    writeCliIo(io);
+  });
+  cst.command("validate").description("Validate CST format and embedded table").argument("<codigo>", "CST code").requiredOption("--tax <tax>", "Tax table: icms | ipi | pis | cofins").option("--json", "JSON output").option("--verbose", "Include tax metadata").action((codigo, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleCstValidateCli(codigo, opts, io);
+    writeCliIo(io);
+  });
   registerReferenceLookupCommands(program);
   program.command("detect").description("Detect document type from raw input").argument("[value]", "Raw value to classify").option("--uf <uf>", "State code for Inscri\xE7\xE3o Estadual detection").option("--json", "JSON output").option("-q, --quiet", "Exit code only").option("-f, --file <path>", "Read value from file").action((value, opts) => {
     const io = { stdout: [], stderr: [] };
@@ -3217,11 +4311,31 @@ function createProgram() {
     process.exitCode = handleSanitizeCli(type, value, opts, io);
     writeCliIo(io);
   });
-  program.command("generate <type>").description("Generate synthetic valid test document").option("--json", "JSON output").option("-q, --quiet", "Exit code only").option("--masked", "Return masked/formatted output").option("--format <format>", "Format variant (numeric, alphanumeric, legacy, mercosul, celular, fixo)").option("--seed <number>", "Deterministic PRNG seed", (v) => Number(v)).option("--uf <uf>", "State code (required for inscricao-estadual and titulo-eleitor)").option("--brand <brand>", "Card brand (visa, mastercard, amex, elo, hipercard)").action((type, opts) => {
+  program.command("mask <type> [value]").description("Apply unified display mask (validate first)").option("--uf <uf>", "State code (required for inscricao-estadual and rg)").option("--json", "JSON output").option("-q, --quiet", "Exit code only").option("-f, --file <path>", "Read value from file").action((type, value, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleMaskCli(type, value, opts, io);
+    writeCliIo(io);
+  });
+  program.command("generate <type>").description("Generate synthetic valid test document").option("--json", "JSON output").option("-q, --quiet", "Exit code only").option("--masked", "Return masked/formatted output").option("--stripped", "Return canonical stripped digits (default; explicit flag)").option("--format <format>", "Format variant (numeric, alphanumeric, legacy, mercosul, celular, fixo)").option("--seed <number>", "Deterministic PRNG seed", (v) => Number(v)).option("--uf <uf>", "State code (required for inscricao-estadual and titulo-eleitor)").option("--brand <brand>", "Card brand (visa, mastercard, amex, elo, hipercard)").action((type, opts) => {
     const io = { stdout: [], stderr: [] };
     process.exitCode = handleGenerateCli(type, opts, io);
     writeCliIo(io);
   });
+  program.command("compare <type> <valueA> [valueB...]").description("Compare two values for normalized equality").option("--uf <uf>", "State code (required for inscricao-estadual, rg, titulo-eleitor)").option("--json", "JSON output").option("-q, --quiet", "Exit code only").action((type, valueA, valueB, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleCompareCli(type, valueA, valueB.join(" ") || void 0, opts, io);
+    writeCliIo(io);
+  });
+  program.command("batch <type>").description("Bulk validate values from stdin or --file").option("--uf <uf>", "State code (required for inscricao-estadual, rg, titulo-eleitor)").option("--json", "JSON output").option("-q, --quiet", "Exit code only").option("-f, --file <path>", "Read values from file (one per line)").option("--limit <n>", "Max number of values to process", (v) => Number(v)).action((type, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleBatchCli(type, opts, io);
+    writeCliIo(io);
+  });
+  program.command("diff <type> <valueA> [valueB...]").description("Field-level structural diff between two values").option("--uf <uf>", "State code (required for inscricao-estadual, rg, titulo-eleitor)").option("--json", "JSON output").option("-q, --quiet", "Exit code only").action((type, valueA, valueB, opts) => {
+    const io = { stdout: [], stderr: [] };
+    process.exitCode = handleDiffCli(type, valueA, valueB.join(" ") || void 0, opts, io);
+    writeCliIo(io);
+  });
   return program;
 }
 function run(argv) {