@br-validators/cli 1.8.3 → 1.10.0

package/dist/run-captured.js

@@ -1,10 +1,3 @@
-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/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"];
 var EXIT = {
@@ -16,47 +9,56 @@ var EXIT = {
 // 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 {
+  CSOSN_DATA_VERSION,
+  lookupCsosnPorCodigo
+} from "@br-validators/core/csosn";
+import { NCM_DATA_VERSION, lookupNcmPorCodigo } from "@br-validators/core/ncm";
+import { CBO_DATA_VERSION, lookupCboPorCodigo } from "@br-validators/core/cbo";
+import {
+  lookupInvalidFormat,
+  lookupInvalidInput
+} from "@br-validators/core/lookup";
 var REFERENCE_LOOKUP_COMMANDS = [
   "natureza-juridica",
   "nbs",
   "cest",
   "cnae",
   "cfop",
+  "csosn",
   "ncm",
   "cbo",
   "moedas",
@@ -65,16 +67,19 @@ var REFERENCE_LOOKUP_COMMANDS = [
   "portos",
   "aeroportos"
 ];
-var REFERENCE_SEARCH_COMMANDS = ["cnae", "cfop", "ncm", "cbo"];
+var REFERENCE_SEARCH_COMMANDS = ["cnae", "cfop", "csosn", "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 lookupInvalidFormat("Airport code must be 3-character IATA or 4-character ICAO");
 }
 var REFERENCE_LOOKUP_MODULES = {
   "natureza-juridica": {
@@ -82,7 +87,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}`;
@@ -93,7 +98,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}`;
@@ -104,7 +109,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}`;
@@ -115,7 +120,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}`;
@@ -126,7 +131,18 @@ 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}`;
+    }
+  },
+  csosn: {
+    command: "csosn",
+    description: "CONFAZ CSOSN Simples Nacional \u2014 offline lookup",
+    resultKey: "csosn",
+    capturadoEm: CSOSN_DATA_VERSION.capturadoEm,
+    lookup: (input) => lookupCsosnPorCodigo(input),
     formatHuman: (result) => {
       const row = result;
       return `${row.codigo} \u2014 ${row.descricao}`;
@@ -137,7 +153,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}`;
@@ -148,7 +164,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}`;
@@ -159,7 +175,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";
@@ -171,7 +187,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}`;
@@ -182,7 +198,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})`;
@@ -193,7 +209,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})`;
@@ -219,15 +235,85 @@ function isReferenceSearchCommand(value) {
   return REFERENCE_SEARCH_COMMANDS.includes(value);
 }
 
+// src/commands/reference-lookup/validate.ts
+import { validateCfop } from "@br-validators/core/cfop";
+import { validateCsosn } from "@br-validators/core/csosn";
+import { validateNcm } from "@br-validators/core/ncm";
+var REFERENCE_VALIDATE_COMMANDS = ["ncm", "cfop", "csosn"];
+var VALIDATORS = {
+  ncm: validateNcm,
+  cfop: validateCfop,
+  csosn: validateCsosn
+};
+var CAPTURED_AT = {
+  ncm: "ncm",
+  cfop: "cfop",
+  csosn: "csosn"
+};
+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/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/commands/bancos/lookup.ts
 import {
   BANCOS_DATA_VERSION,
-  getBancoPorCodigo,
-  getBancoPorIspb
+  lookupBancoPorCodigo,
+  lookupBancoPorIspb
 } from "@br-validators/core/bancos";
+import { lookupInvalidFormat as lookupInvalidFormat2 } from "@br-validators/core/lookup";
 function normalizeBancosLookupInput(raw) {
   const digits = raw.replace(/\D/g, "");
   if (digits.length === 8) {
@@ -241,33 +327,36 @@ function normalizeBancosLookupInput(raw) {
 function lookupBanco(raw) {
   const normalized = normalizeBancosLookupInput(raw);
   if (!normalized) {
-    return void 0;
+    return lookupInvalidFormat2(
+      "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}`);
   }
@@ -283,7 +372,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;
   }
@@ -316,6 +405,15 @@ function runBancosList(options, io = { stdout: [], stderr: [] }) {
 }
 
 // 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();
@@ -324,20 +422,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}`);
   }
@@ -359,6 +457,7 @@ function runReferenceLookup(command, value, options, io = { stdout: [], stderr:
 import { searchCbo } from "@br-validators/core/cbo";
 import { searchCnaes } from "@br-validators/core/cnaes";
 import { searchCfop } from "@br-validators/core/cfop";
+import { searchCsosn } from "@br-validators/core/csosn";
 import { searchNcm } from "@br-validators/core/ncm";
 function runSearch(command, query, limit) {
   switch (command) {
@@ -366,6 +465,8 @@ function runSearch(command, query, limit) {
       return searchCnaes(query, { limit });
     case "cfop":
       return searchCfop(query, { limit });
+    case "csosn":
+      return searchCsosn(query, { limit });
     case "ncm":
       return searchNcm(query, { limit });
     case "cbo":
@@ -421,11 +522,176 @@ function runReferenceSearch(command, query, options, io = { stdout: [], stderr:
   return runReferenceSearchCommand(command, query.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) {
@@ -433,24 +699,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;
@@ -458,7 +735,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}`);
   }
@@ -474,8 +751,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) {
@@ -488,7 +765,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,
@@ -511,7 +788,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,
@@ -543,7 +820,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) {
@@ -556,7 +833,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,
@@ -582,13 +859,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) {
@@ -619,11 +1076,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(", ")}`;
 }
@@ -767,6 +1224,339 @@ 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 {
+  getIssMunicipalPorUf,
+  getIssMunicipalPorUfMunicipio,
+  ISS_MUNICIPAL_DATA_VERSION,
+  ISS_MUNICIPAL_ESTIMATION_WARNING,
+  lookupIssMunicipalPorIbge,
+  searchIssMunicipal
+} from "@br-validators/core/iss-municipal";
+function sliceRows2(rows, limit) {
+  if (limit === void 0 || !Number.isFinite(limit) || limit <= 0) {
+    return rows;
+  }
+  return rows.slice(0, limit);
+}
+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 = lookupIssMunicipalPorIbge(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(`fonte: ${result.fonte}`);
+  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 runIssMunicipalList(options, io = { stdout: [], stderr: [] }) {
+  const uf = options.uf?.trim() ?? "";
+  if (uf.length === 0) {
+    io.stderr.push("Missing UF. Usage: br-validators iss-municipal list --uf <UF>");
+    return EXIT.USAGE;
+  }
+  const rows = sliceRows2(getIssMunicipalPorUf(uf), options.limit);
+  emitDisclaimer(options, io);
+  if (options.json) {
+    const payload = {
+      ok: true,
+      uf: uf.toUpperCase(),
+      total: rows.length,
+      results: rows
+    };
+    if (options.verbose) {
+      payload.capturadoEm = ISS_MUNICIPAL_DATA_VERSION.capturadoEm;
+    }
+    io.stdout.push(JSON.stringify(payload, null, 2));
+    return EXIT.OK;
+  }
+  if (rows.length === 0) {
+    io.stdout.push(`No ISS municipal rows embedded for UF ${uf.toUpperCase()}.`);
+    return EXIT.OK;
+  }
+  for (const row of rows) {
+    io.stdout.push(formatIssMunicipalHuman(row));
+  }
+  if (options.verbose) {
+    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,
+    ...options.uf !== void 0 && options.uf.trim().length > 0 ? { uf: options.uf } : {}
+  });
+  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/ptax/historico.ts
+import {
+  getPtaxHistorico,
+  PTAX_DATA_VERSION as PTAX_DATA_VERSION2
+} from "@br-validators/core/ptax";
+function formatPtaxHistoricoHuman(results) {
+  return results.map(
+    (cotacao) => `${cotacao.dataReferencia} \u2014 compra ${String(cotacao.cotacaoCompra)} / venda ${String(cotacao.cotacaoVenda)}`
+  );
+}
+function runPtaxHistoricoCommand(moeda, desde, ate, options, io = { stdout: [], stderr: [] }) {
+  const trimmedMoeda = moeda.trim();
+  const trimmedDesde = desde.trim();
+  const trimmedAte = ate.trim();
+  if (trimmedMoeda.length === 0) {
+    io.stderr.push("Missing currency code. Pass a 3-letter ISO code (e.g. USD).");
+    return EXIT.USAGE;
+  }
+  if (trimmedDesde.length === 0 || trimmedAte.length === 0) {
+    io.stderr.push("Missing date range. Pass desde and ate as YYYY-MM-DD.");
+    return EXIT.USAGE;
+  }
+  const results = getPtaxHistorico(trimmedMoeda, { desde: trimmedDesde, ate: trimmedAte });
+  if (results.length === 0) {
+    io.stderr.push(
+      `No PTAX quotes in embed for ${trimmedMoeda} between ${trimmedDesde} and ${trimmedAte}`
+    );
+    return EXIT.INVALID;
+  }
+  if (options.json) {
+    const payload = {
+      ok: true,
+      moeda: trimmedMoeda.toUpperCase(),
+      desde: trimmedDesde,
+      ate: trimmedAte,
+      total: results.length,
+      cotacoes: results
+    };
+    if (options.verbose) {
+      payload.capturadoEm = PTAX_DATA_VERSION2.capturadoEm;
+      payload.janelaDiasUteis = PTAX_DATA_VERSION2.janelaDiasUteis;
+    }
+    io.stdout.push(JSON.stringify(payload, null, 2));
+    return EXIT.OK;
+  }
+  io.stdout.push(`${trimmedMoeda.toUpperCase()} PTAX historico (${String(results.length)} rows)`);
+  for (const line of formatPtaxHistoricoHuman(results)) {
+    io.stdout.push(line);
+  }
+  if (options.verbose) {
+    io.stdout.push(`capturadoEm: ${PTAX_DATA_VERSION2.capturadoEm}`);
+    io.stdout.push(`janelaDiasUteis: ${String(PTAX_DATA_VERSION2.janelaDiasUteis)}`);
+  }
+  return EXIT.OK;
+}
+function runPtaxHistorico(moeda, desde, ate, options, io = { stdout: [], stderr: [] }) {
+  if (!moeda?.trim()) {
+    io.stderr.push("Missing currency code. Usage: ptax historico <moeda> <desde> <ate>");
+    return EXIT.USAGE;
+  }
+  if (!desde?.trim() || !ate?.trim()) {
+    io.stderr.push("Missing date range. Usage: ptax historico <moeda> <desde> <ate>");
+    return EXIT.USAGE;
+  }
+  return runPtaxHistoricoCommand(moeda.trim(), desde.trim(), ate.trim(), options, io);
+}
+
 // src/commands/brcode.ts
 import {
   BRCODE_OFFICIAL_SOURCE_URL,
@@ -2217,13 +3007,103 @@ function runDetect(value, options, io = { stdout: [], stderr: [] }) {
     return EXIT.USAGE;
   }
   const uf = options.uf?.toUpperCase();
-  const result = detect(input, uf ? { uf } : {});
-  return printDetect(result, options, io);
+  const result = detect(input, uf ? { uf } : {});
+  return printDetect(result, options, io);
+}
+
+// src/commands/sanitize.ts
+import { sanitize } from "@br-validators/core";
+var SANITIZABLE_TYPES = [
+  "cpf",
+  "cnpj",
+  "cep",
+  "placa",
+  "pis-pasep",
+  "telefone",
+  "cnh",
+  "renavam",
+  "titulo-eleitor",
+  "nfe-chave",
+  "boleto",
+  "cartao-credito",
+  "ean",
+  "inscricao-estadual",
+  "inscricao-estadual-produtor-rural",
+  "pix"
+];
+function isSanitizableType(type) {
+  return SANITIZABLE_TYPES.includes(type);
+}
+function resolveInput21(value, fileContent) {
+  const input = value ?? fileContent?.trim();
+  if (!input) {
+    return null;
+  }
+  return input;
+}
+function printSanitize(result, options, io = { stdout: [], stderr: [] }) {
+  if (options.json) {
+    io.stdout.push(JSON.stringify(result, null, 2));
+    return result.ok ? EXIT.OK : EXIT.INVALID;
+  }
+  if (options.quiet) {
+    return result.ok ? EXIT.OK : EXIT.INVALID;
+  }
+  if (result.ok) {
+    io.stdout.push("valid: yes");
+    io.stdout.push(`value: ${result.value}`);
+    io.stdout.push(`fixes: ${result.fixes.join(", ")}`);
+    return EXIT.OK;
+  }
+  io.stderr.push("valid: no");
+  io.stderr.push(`code: ${result.code}`);
+  io.stderr.push(`message: ${result.message}`);
+  return EXIT.INVALID;
+}
+function runSanitize(type, value, options, io = { stdout: [], stderr: [] }) {
+  if (!isSanitizableType(type)) {
+    io.stderr.push(`Unsupported sanitize type: ${type}`);
+    return EXIT.USAGE;
+  }
+  const input = resolveInput21(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 = sanitize(input, type, uf ? { uf } : {});
+  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/sanitize.ts
-import { sanitize } from "@br-validators/core";
-var SANITIZABLE_TYPES = [
+// src/commands/compare.ts
+import { compareRuntime } from "@br-validators/core";
+
+// src/commands/platform-document-types.ts
+var PLATFORM_DOCUMENT_TYPES = [
   "cpf",
   "cnpj",
   "cep",
@@ -2233,55 +3113,162 @@ var SANITIZABLE_TYPES = [
   "cnh",
   "renavam",
   "titulo-eleitor",
+  "processo-judicial",
+  "rg",
   "nfe-chave",
   "boleto",
   "cartao-credito",
   "ean",
   "inscricao-estadual",
-  "inscricao-estadual-produtor-rural"
+  "inscricao-estadual-produtor-rural",
+  "pix",
+  "brcode"
 ];
-function isSanitizableType(type) {
-  return SANITIZABLE_TYPES.includes(type);
+function isPlatformDocumentType(type) {
+  return PLATFORM_DOCUMENT_TYPES.includes(type);
 }
-function resolveInput21(value, fileContent) {
-  const input = value ?? fileContent?.trim();
-  if (!input) {
-    return null;
+
+// 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;
   }
-  return input;
+  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 printSanitize(result, options, io = { stdout: [], stderr: [] }) {
+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, parseBatchCsv } 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 { ok: false, reason: "missing_input" };
+  }
+  let parsed;
+  if (options.col !== void 0) {
+    const csv = parseBatchCsv(options.lines, {
+      col: options.col,
+      delimiter: options.delimiter,
+      skipHeader: options.skipHeader
+    });
+    if (!csv.ok) {
+      return { ok: false, reason: "parse_error", message: csv.message };
+    }
+    parsed = csv.values;
+  } else {
+    parsed = parseBatchLines(options.lines);
+  }
+  if (parsed.length === 0) {
+    return { ok: false, reason: "empty" };
+  }
+  if (options.limit !== void 0 && options.limit > 0) {
+    return { ok: true, values: parsed.slice(0, options.limit) };
+  }
+  return { ok: true, values: parsed };
+}
+function printBatch(result, options, io = { stdout: [], stderr: [] }) {
   if (options.json) {
     io.stdout.push(JSON.stringify(result, null, 2));
-    return result.ok ? EXIT.OK : EXIT.INVALID;
+    return result.summary.invalid === 0 ? EXIT.OK : EXIT.INVALID;
   }
   if (options.quiet) {
-    return result.ok ? EXIT.OK : EXIT.INVALID;
+    return result.summary.invalid === 0 ? EXIT.OK : EXIT.INVALID;
   }
-  if (result.ok) {
-    io.stdout.push("valid: yes");
-    io.stdout.push(`value: ${result.value}`);
-    io.stdout.push(`fixes: ${result.fixes.join(", ")}`);
-    return EXIT.OK;
+  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}`);
   }
-  io.stderr.push("valid: no");
-  io.stderr.push(`code: ${result.code}`);
-  io.stderr.push(`message: ${result.message}`);
-  return EXIT.INVALID;
+  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 runSanitize(type, value, options, io = { stdout: [], stderr: [] }) {
-  if (!isSanitizableType(type)) {
-    io.stderr.push(`Unsupported sanitize type: ${type}`);
+function runBatch(type, options, io = { stdout: [], stderr: [] }) {
+  if (!isPlatformDocumentType(type)) {
+    io.stderr.push(`Unsupported batch type: ${type}`);
     return EXIT.USAGE;
   }
-  const input = resolveInput21(value, options.file);
-  if (input === null) {
-    io.stderr.push("Missing value. Pass an argument or use --file.");
+  const resolved = resolveBatchInputs(options);
+  if (!resolved.ok) {
+    if (resolved.reason === "missing_input") {
+      io.stderr.push("Missing input. Pass --file <path> or pipe one value per line on stdin.");
+    } else if (resolved.reason === "empty") {
+      io.stderr.push("No values to validate.");
+    } else {
+      io.stderr.push(resolved.message);
+    }
     return EXIT.USAGE;
   }
   const uf = options.uf?.toUpperCase();
-  const result = sanitize(input, type, uf ? { uf } : {});
-  return printSanitize(result, options, io);
+  const platformOptions = uf ? { uf } : {};
+  const result = batch(resolved.values, 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
@@ -2313,6 +3300,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;
   }
@@ -2356,10 +3346,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;
@@ -2836,6 +3830,93 @@ 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,
+      col: opts.col,
+      delimiter: opts.delimiter,
+      skipHeader: opts.skipHeader
+    },
+    io
+  );
+}
 function handleGenerateCli(type, opts, io = { stdout: [], stderr: [] }) {
   return runGenerate(
     type,
@@ -2843,6 +3924,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,
@@ -2894,6 +3976,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);
 }
@@ -2912,6 +4027,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);
 }
@@ -2921,6 +4064,50 @@ 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 handleIssMunicipalListCli(opts, io = { stdout: [], stderr: [] }) {
+  return runIssMunicipalList({
+    json: Boolean(opts.json),
+    verbose: Boolean(opts.verbose),
+    uf: opts.uf,
+    limit: opts.limit
+  }, 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,
+    uf: opts.uf
+  }, 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 handlePtaxHistoricoCli(moeda, desde, ate, opts, io = { stdout: [], stderr: [] }) {
+  return runPtaxHistorico(
+    moeda,
+    desde,
+    ate,
+    { json: Boolean(opts.json), verbose: Boolean(opts.verbose) },
+    io
+  );
+}
 
 // src/argv-dispatch.ts
 var STANDARD_ACTIONS = ["validate", "format", "strip"];
@@ -2955,6 +4142,10 @@ function parseArgv(tokens) {
       opts.masked = true;
       continue;
     }
+    if (token === "--stripped") {
+      opts.stripped = true;
+      continue;
+    }
     if (token === "-f" || token === "--file") {
       opts.file = tokens[index + 1];
       index += 1;
@@ -2994,11 +4185,26 @@ function parseArgv(tokens) {
       index += 1;
       continue;
     }
+    if (token === "--tax") {
+      opts.tax = tokens[index + 1];
+      index += 1;
+      continue;
+    }
     if (token === "--year") {
       opts.year = Number(tokens[index + 1]);
       index += 1;
       continue;
     }
+    if (token === "--ano") {
+      opts.year = Number(tokens[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (token === "--date") {
+      opts.date = tokens[index + 1];
+      index += 1;
+      continue;
+    }
     if (token.startsWith("-")) {
       continue;
     }
@@ -3021,7 +4227,7 @@ function dispatchArgv(tokens, io) {
   if (tokens.length === 0 || tokens.includes("--help") || tokens.includes("-h")) {
     io.stdout.push("br-validators \u2014 100% open-source Brazilian document validators");
     io.stdout.push("Usage: br-validators <command> ...");
-    io.stdout.push("Commands: list \xB7 cpf \xB7 cnpj \xB7 cep \xB7 telefone \xB7 cnh \xB7 renavam \xB7 titulo-eleitor \xB7 processo-judicial \xB7 rg \xB7 nfe-chave \xB7 brcode \xB7 placa \xB7 pis-pasep \xB7 cnis \xB7 pix \xB7 boleto \xB7 cartao \xB7 cartao-credito \xB7 ean \xB7 ie \xB7 bancos \xB7 ibge \xB7 feriados \xB7 tse-municipios \xB7 ddd \xB7 natureza-juridica \xB7 nbs \xB7 cest \xB7 cnae \xB7 cfop \xB7 ncm \xB7 cbo \xB7 moedas \xB7 paises-bacen \xB7 incoterms \xB7 portos \xB7 aeroportos \xB7 detect \xB7 sanitize \xB7 generate");
+    io.stdout.push("Commands: list \xB7 cpf \xB7 cnpj \xB7 cep \xB7 telefone \xB7 cnh \xB7 renavam \xB7 titulo-eleitor \xB7 processo-judicial \xB7 rg \xB7 nfe-chave \xB7 brcode \xB7 placa \xB7 pis-pasep \xB7 cnis \xB7 pix \xB7 boleto \xB7 cartao \xB7 cartao-credito \xB7 ean \xB7 ie \xB7 bancos \xB7 ibge \xB7 feriados \xB7 inss \xB7 irpf \xB7 tse-municipios \xB7 ddd \xB7 nfe-cuf \xB7 selic \xB7 iss-municipal \xB7 ptax \xB7 cst \xB7 csosn \xB7 natureza-juridica \xB7 nbs \xB7 cest \xB7 cnae \xB7 cfop \xB7 ncm \xB7 cbo \xB7 moedas \xB7 paises-bacen \xB7 incoterms \xB7 portos \xB7 aeroportos \xB7 detect \xB7 sanitize \xB7 mask \xB7 compare \xB7 batch \xB7 diff \xB7 generate");
     return EXIT.OK;
   }
   if (tokens.includes("--version") || tokens.includes("-V")) {
@@ -3199,6 +4405,28 @@ function dispatchArgv(tokens, io) {
       }
       return usage(io, "Expected: feriados list [--year YYYY]");
     }
+    case "inss": {
+      const action = rest[0];
+      if (action === "tabela") {
+        return handleInssTabelaCli(opts, io);
+      }
+      if (action === "calc") {
+        const value = rest.slice(1).join(" ") || void 0;
+        return handleInssCalcCli(value, opts, io);
+      }
+      return usage(io, "Expected: inss tabela [--ano YYYY] | inss calc <salario> [--ano YYYY]");
+    }
+    case "irpf": {
+      const action = rest[0];
+      if (action === "tabela") {
+        return handleIrpfTabelaCli(opts, io);
+      }
+      if (action === "calc") {
+        const value = rest.slice(1).join(" ") || void 0;
+        return handleIrpfCalcCli(value, opts, io);
+      }
+      return usage(io, "Expected: irpf tabela [--ano YYYY] | irpf calc <base> [--ano YYYY]");
+    }
     case "tse-municipios": {
       const action = rest[0];
       if (action === "lookup") {
@@ -3215,10 +4443,99 @@ function dispatchArgv(tokens, io) {
       }
       return usage(io, "Expected: ddd lookup <code>");
     }
+    case "nfe-cuf": {
+      const action = rest[0];
+      if (action === "lookup") {
+        const value = rest.slice(1).join(" ") || void 0;
+        return handleNfeCufLookupCli(value, opts, io);
+      }
+      return usage(io, "Expected: nfe-cuf lookup <code>");
+    }
+    case "selic": {
+      return handleSelicCli(opts, io);
+    }
+    case "iss-municipal": {
+      const action = rest[0];
+      if (action === "lookup") {
+        const value = rest[1];
+        return handleIssMunicipalLookupCli(value, opts, io);
+      }
+      if (action === "list") {
+        return handleIssMunicipalListCli(opts, io);
+      }
+      if (action === "resolve") {
+        const uf = rest[1];
+        const nome = rest.slice(2).join(" ") || void 0;
+        return handleIssMunicipalResolveCli(uf, nome, opts, io);
+      }
+      if (action === "search") {
+        const value = rest.slice(1).join(" ") || void 0;
+        return handleIssMunicipalSearchCli(value, opts, io);
+      }
+      return usage(io, "Expected: iss-municipal lookup|list|resolve|search <args>");
+    }
+    case "ptax": {
+      const action = rest[0];
+      if (action === "lookup") {
+        const moeda = rest[1];
+        const data = rest.slice(2).join(" ") || void 0;
+        return handlePtaxLookupCli(moeda, data, opts, io);
+      }
+      if (action === "historico") {
+        const moeda = rest[1];
+        const desde = rest[2];
+        const ate = rest[3];
+        return handlePtaxHistoricoCli(moeda, desde, ate, opts, io);
+      }
+      return usage(io, "Expected: ptax lookup <moeda> [data] | ptax historico <moeda> <desde> <ate>");
+    }
+    case "cst": {
+      const action = rest[0];
+      if (action === "lookup") {
+        const value = rest.slice(1).join(" ") || void 0;
+        return handleCstLookupCli(value, opts, io);
+      }
+      if (action === "search") {
+        const value = rest.slice(1).join(" ") || void 0;
+        return handleCstSearchCli(value, opts, io);
+      }
+      if (action === "validate") {
+        const value = rest.slice(1).join(" ") || void 0;
+        return handleCstValidateCli(value, opts, io);
+      }
+      return usage(io, "Expected: cst lookup|search|validate <codigo|query> --tax icms|ipi|pis|cofins");
+    }
     case "detect":
       return handleDetectCli(rest.join(" ") || void 0, opts, io);
     case "sanitize":
       return handleSanitizeCli(rest[0] ?? "", rest.slice(1).join(" ") || void 0, opts, io);
+    case "mask":
+      return handleMaskCli(rest[0] ?? "", rest.slice(1).join(" ") || void 0, opts, io);
+    case "compare": {
+      const type = rest[0];
+      const valueA = rest[1];
+      const valueB = rest.slice(2).join(" ") || void 0;
+      if (!type) {
+        return usage(io, "Expected: compare <type> <valueA> <valueB>");
+      }
+      return handleCompareCli(type, valueA, valueB, opts, io);
+    }
+    case "batch": {
+      const type = rest[0];
+      if (!type) {
+        return usage(io, "Expected: batch <type> [--file path]");
+      }
+      return handleBatchCli(type, opts, io);
+    }
+    case "diff": {
+      const type = rest[0];
+      const valueA = rest[1];
+      const valueB = rest.slice(2).join(" ") || void 0;
+      if (!type) {
+        return usage(io, "Expected: diff <type> <valueA> <valueB>");
+      }
+      return handleDiffCli(type, valueA, valueB, opts, io);
+    }
     case "generate":
       return handleGenerateCli(rest[0] ?? "", opts, io);
     default: {
@@ -3232,8 +4549,13 @@ function dispatchArgv(tokens, io) {
           const value = rest.slice(1).join(" ") || void 0;
           return handleReferenceSearchCli(root, value, opts, io);
         }
+        if (action === "validate" && isReferenceValidateCommand(root)) {
+          const value = rest.slice(1).join(" ") || void 0;
+          return handleReferenceValidateCli(root, value, opts, io);
+        }
         const searchHint = isReferenceSearchCommand(root) ? " | search <query>" : "";
-        return usage(io, `Expected: ${root} lookup <codigo>${searchHint}`);
+        const validateHint = isReferenceValidateCommand(root) ? " | validate <codigo>" : "";
+        return usage(io, `Expected: ${root} lookup <codigo>${searchHint}${validateHint}`);
       }
       return usage(io, `Unknown command: ${root}`);
     }