@danielarndt0/cnpj-db-loader 2.3.1 → 2.4.0-beta.2

package/dist/cli.js

@@ -3237,6 +3237,15 @@ function createFieldValueParser(dataType) {
       };
   }
 }
+function toDatabaseValue(dataType, rawValue) {
+  return createFieldValueParser(dataType)(rawValue);
+}
+function normalizeCode(value, fallback) {
+  if (typeof value === "string" && value.trim() !== "") {
+    return value.trim();
+  }
+  return fallback;
+}
 function createPartnerDedupeKeyBuilder(indices) {
   const orderedIndices = [
     indices.cnpjRoot,
@@ -3264,6 +3273,60 @@ function createEstablishmentCnpjFullBuilder(indices) {
     return `${root}${order}${digits}`;
   };
 }
+function buildPartnerDedupeKey(recordByColumn) {
+  return [
+    recordByColumn.cnpj_root,
+    recordByColumn.partner_type_code,
+    recordByColumn.partner_name,
+    recordByColumn.partner_document,
+    recordByColumn.partner_qualification_code,
+    recordByColumn.entry_date,
+    recordByColumn.country_code,
+    recordByColumn.legal_representative_document,
+    recordByColumn.legal_representative_name,
+    recordByColumn.legal_representative_qualification_code,
+    recordByColumn.age_group_code
+  ].map((value) => value == null ? "" : String(value).trim()).join("|");
+}
+function transformRecord(dataset, layout, rawFields, schemaCapabilities, writeTarget) {
+  const values = layout.fields.map(
+    (field, index) => toDatabaseValue(field.dataType, rawFields[index] ?? "")
+  );
+  const recordByColumn = Object.fromEntries(
+    layout.fields.map((field, index) => [field.columnName, values[index]])
+  );
+  if (dataset === "companies") {
+    recordByColumn.company_size_code = normalizeCode(
+      recordByColumn.company_size_code,
+      "00"
+    );
+  }
+  if (dataset === "establishments") {
+    recordByColumn.branch_type_code = normalizeCode(
+      recordByColumn.branch_type_code,
+      "1"
+    );
+    recordByColumn.registration_status_code = normalizeCode(
+      recordByColumn.registration_status_code,
+      "01"
+    );
+  }
+  const normalizedValues = layout.fields.map(
+    (field) => recordByColumn[field.columnName]
+  );
+  if (writeTarget === "final") {
+    if (dataset === "establishments" && schemaCapabilities.includeEstablishmentCnpjFullInInsert) {
+      return [
+        ...normalizedValues,
+        `${recordByColumn.cnpj_root ?? ""}${recordByColumn.cnpj_order ?? ""}${recordByColumn.cnpj_check_digits ?? ""}`
+      ];
+    }
+    if (dataset === "partners" && schemaCapabilities.includePartnerDedupeKeyInInsert) {
+      return [...normalizedValues, buildPartnerDedupeKey(recordByColumn)];
+    }
+  }
+  return normalizedValues;
+}
 function buildParsedPayload(columns, values) {
   return Object.fromEntries(
     columns.map((column, index) => [column, values[index] ?? null])
@@ -3403,7 +3466,7 @@ function createImportRowNormalizer(input2) {
       "cnpj_check_digits"
     )
   }) : null;
-  const buildPartnerDedupeKey = appendPartnerDedupeKey ? createPartnerDedupeKeyBuilder({
+  const buildPartnerDedupeKey2 = appendPartnerDedupeKey ? createPartnerDedupeKeyBuilder({
     cnpjRoot: resolveLayoutColumnIndex(input2.layout, "cnpj_root"),
     partnerTypeCode: resolveLayoutColumnIndex(
       input2.layout,
@@ -3463,8 +3526,8 @@ function createImportRowNormalizer(input2) {
       if (buildEstablishmentCnpjFull) {
         values.push(buildEstablishmentCnpjFull(values));
       }
-      if (buildPartnerDedupeKey) {
-        values.push(buildPartnerDedupeKey(values));
+      if (buildPartnerDedupeKey2) {
+        values.push(buildPartnerDedupeKey2(values));
       }
       return {
         values,
@@ -7758,81 +7821,264 @@ function isRecognizedSanitizeEntry(entry) {
   return entry.entryKind === "file" && entry.inferredType !== "zip-archive" && entry.inferredType !== "unknown";
 }
 
+// src/services/sanitize/encoding.ts
+import { StringDecoder } from "string_decoder";
+var WINDOWS_1252_C1_MAP = {
+  128: "\u20AC",
+  130: "\u201A",
+  131: "\u0192",
+  132: "\u201E",
+  133: "\u2026",
+  134: "\u2020",
+  135: "\u2021",
+  136: "\u02C6",
+  137: "\u2030",
+  138: "\u0160",
+  139: "\u2039",
+  140: "\u0152",
+  142: "\u017D",
+  145: "\u2018",
+  146: "\u2019",
+  147: "\u201C",
+  148: "\u201D",
+  149: "\u2022",
+  150: "\u2013",
+  151: "\u2014",
+  152: "\u02DC",
+  153: "\u2122",
+  154: "\u0161",
+  155: "\u203A",
+  156: "\u0153",
+  158: "\u017E",
+  159: "\u0178"
+};
+function normalizeSanitizeSourceEncoding(value) {
+  const normalized = (value ?? "WIN1252").trim().toUpperCase().replace(/_/g, "-");
+  switch (normalized) {
+    case "WIN1252":
+    case "WINDOWS-1252":
+    case "CP1252":
+      return "WIN1252";
+    case "LATIN1":
+    case "LATIN-1":
+    case "ISO-8859-1":
+    case "ISO8859-1":
+      return "LATIN1";
+    case "UTF8":
+    case "UTF-8":
+      return "UTF8";
+    default:
+      throw new ValidationError(
+        `Unsupported sanitize source encoding: ${value}. Supported values: WIN1252, LATIN1, UTF8.`
+      );
+  }
+}
+function isAllowedControlCodePoint(codePoint) {
+  return codePoint === 9 || codePoint === 10 || codePoint === 13;
+}
+function isProblematicControlCodePoint(codePoint) {
+  if (isAllowedControlCodePoint(codePoint)) {
+    return false;
+  }
+  return codePoint >= 0 && codePoint <= 31 || codePoint === 127 || codePoint >= 128 && codePoint <= 159 || codePoint === 65279;
+}
+function sanitizeDecodedText(text) {
+  const output2 = [];
+  let invalidBytesRemoved = 0;
+  let controlCharsRemoved = 0;
+  for (const char of text) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint === 65533) {
+      invalidBytesRemoved += 1;
+      continue;
+    }
+    if (isProblematicControlCodePoint(codePoint)) {
+      controlCharsRemoved += 1;
+      continue;
+    }
+    output2.push(char);
+  }
+  return {
+    text: output2.join(""),
+    invalidBytesRemoved,
+    controlCharsRemoved
+  };
+}
+var SanitizeEncodingNormalizer = class {
+  constructor(sourceEncoding) {
+    this.sourceEncoding = sourceEncoding;
+    this.utf8Decoder = sourceEncoding === "UTF8" ? new StringDecoder("utf8") : void 0;
+  }
+  sourceEncoding;
+  utf8Decoder;
+  normalizeChunk(chunk) {
+    if (this.sourceEncoding === "UTF8") {
+      const decoded = this.utf8Decoder.write(chunk);
+      const sanitized = sanitizeDecodedText(decoded);
+      const nulBytesRemoved = [...decoded].filter(
+        (char) => char === "\0"
+      ).length;
+      return {
+        ...sanitized,
+        nulBytesRemoved
+      };
+    }
+    return this.normalizeSingleByteChunk(chunk);
+  }
+  flush() {
+    if (!this.utf8Decoder) {
+      return {
+        text: "",
+        nulBytesRemoved: 0,
+        invalidBytesRemoved: 0,
+        controlCharsRemoved: 0
+      };
+    }
+    const decoded = this.utf8Decoder.end();
+    const sanitized = sanitizeDecodedText(decoded);
+    const nulBytesRemoved = [...decoded].filter((char) => char === "\0").length;
+    return {
+      ...sanitized,
+      nulBytesRemoved
+    };
+  }
+  normalizeSingleByteChunk(chunk) {
+    const output2 = [];
+    let nulBytesRemoved = 0;
+    let invalidBytesRemoved = 0;
+    let controlCharsRemoved = 0;
+    for (const byte of chunk) {
+      if (byte === 0) {
+        nulBytesRemoved += 1;
+        continue;
+      }
+      if (byte < 32 || byte === 127) {
+        if (isAllowedControlCodePoint(byte)) {
+          output2.push(String.fromCharCode(byte));
+        } else {
+          controlCharsRemoved += 1;
+        }
+        continue;
+      }
+      if (byte >= 128 && byte <= 159) {
+        if (this.sourceEncoding === "WIN1252") {
+          const mapped = WINDOWS_1252_C1_MAP[byte];
+          if (mapped === void 0) {
+            invalidBytesRemoved += 1;
+          } else {
+            output2.push(mapped);
+          }
+        } else {
+          controlCharsRemoved += 1;
+        }
+        continue;
+      }
+      output2.push(String.fromCharCode(byte));
+    }
+    return {
+      text: output2.join(""),
+      nulBytesRemoved,
+      invalidBytesRemoved,
+      controlCharsRemoved
+    };
+  }
+};
+
 // src/services/sanitize/runner.ts
 import { createReadStream as createReadStream2, createWriteStream as createWriteStream2 } from "fs";
 import { mkdir as mkdir7 } from "fs/promises";
 import path13 from "path";
-function stripNulBytes(chunk) {
-  let removed = 0;
-  for (let index = 0; index < chunk.length; index += 1) {
-    if (chunk[index] === 0) {
-      removed += 1;
-    }
+async function writeUtf8(output2, value) {
+  if (value.length === 0) {
+    return;
   }
-  if (removed === 0) {
-    return { buffer: chunk, removed: 0 };
+  if (!output2.write(value, "utf8")) {
+    await new Promise((resolve2, reject) => {
+      output2.once("drain", resolve2);
+      output2.once("error", reject);
+    });
   }
-  const sanitized = Buffer.allocUnsafe(chunk.length - removed);
-  let outputIndex = 0;
-  for (let index = 0; index < chunk.length; index += 1) {
-    const value = chunk[index];
-    if (value !== 0) {
-      sanitized[outputIndex] = value;
-      outputIndex += 1;
+}
+function countNewlines(value) {
+  let count = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] === "\n") {
+      count += 1;
     }
   }
-  return { buffer: sanitized, removed };
+  return count;
 }
-async function sanitizeDatasetFile(plan, onChunk) {
+async function sanitizeDatasetFile(plan, onChunk, options = {}) {
   await mkdir7(path13.dirname(plan.outputPath), { recursive: true });
+  const sourceEncoding = normalizeSanitizeSourceEncoding(
+    options.sourceEncoding
+  );
+  const normalizer = new SanitizeEncodingNormalizer(sourceEncoding);
   const input2 = createReadStream2(plan.absolutePath);
-  const output2 = createWriteStream2(plan.outputPath);
+  const output2 = createWriteStream2(plan.outputPath, { encoding: "utf8" });
   let totalBytesRead = 0;
   let totalBytesWritten = 0;
   let nulBytesRemoved = 0;
+  let invalidBytesRemoved = 0;
+  let controlCharsRemoved = 0;
   let lineCount = 0;
-  let sawAnyByte = false;
-  let lastByteWasNewline = false;
+  let sawAnyCharacter = false;
+  let lastCharacterWasNewline = false;
+  const processText = async (text) => {
+    if (text.length === 0) {
+      return;
+    }
+    sawAnyCharacter = true;
+    lineCount += countNewlines(text);
+    lastCharacterWasNewline = text.endsWith("\n");
+    totalBytesWritten += Buffer.byteLength(text, "utf8");
+    await writeUtf8(output2, text);
+  };
   try {
     for await (const chunk of input2) {
       const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
       totalBytesRead += chunkBuffer.length;
-      const { buffer, removed } = stripNulBytes(chunkBuffer);
-      nulBytesRemoved += removed;
-      sawAnyByte = sawAnyByte || buffer.length > 0;
-      for (let index = 0; index < buffer.length; index += 1) {
-        if (buffer[index] === 10) {
-          lineCount += 1;
-        }
-      }
-      if (buffer.length > 0) {
-        lastByteWasNewline = buffer[buffer.length - 1] === 10;
-      }
-      totalBytesWritten += buffer.length;
-      output2.write(buffer);
+      const normalized = normalizer.normalizeChunk(chunkBuffer);
+      nulBytesRemoved += normalized.nulBytesRemoved;
+      invalidBytesRemoved += normalized.invalidBytesRemoved;
+      controlCharsRemoved += normalized.controlCharsRemoved;
+      await processText(normalized.text);
       onChunk?.({
         bytesProcessed: chunkBuffer.length,
         fileBytesProcessed: totalBytesRead,
         currentFileSize: plan.fileSize,
         processedRows: lineCount,
-        nulBytesRemoved
+        nulBytesRemoved,
+        invalidBytesRemoved,
+        controlCharsRemoved
       });
     }
-    if (sawAnyByte && !lastByteWasNewline) {
+    const flushed = normalizer.flush();
+    nulBytesRemoved += flushed.nulBytesRemoved;
+    invalidBytesRemoved += flushed.invalidBytesRemoved;
+    controlCharsRemoved += flushed.controlCharsRemoved;
+    await processText(flushed.text);
+    if (sawAnyCharacter && !lastCharacterWasNewline) {
       lineCount += 1;
     }
   } finally {
     input2.close();
     output2.end();
-    await new Promise((resolve2) => output2.on("finish", () => resolve2()));
+    await new Promise((resolve2, reject) => {
+      output2.on("finish", () => resolve2());
+      output2.on("error", (error) => reject(error));
+    });
   }
   return {
     plan,
     totalBytesRead,
     totalBytesWritten,
+    sourceEncoding,
     nulBytesRemoved,
+    invalidBytesRemoved,
+    controlCharsRemoved,
     lineCount,
-    changed: nulBytesRemoved > 0 || totalBytesRead !== totalBytesWritten
+    changed: nulBytesRemoved > 0 || invalidBytesRemoved > 0 || controlCharsRemoved > 0 || totalBytesRead !== totalBytesWritten
   };
 }
 
@@ -7895,40 +8141,54 @@ async function sanitizeInputDirectory(inputPath, options = {}) {
       "No recognized validated dataset files were found for sanitization."
     );
   }
+  const sourceEncoding = normalizeSanitizeSourceEncoding(
+    options.sourceEncoding
+  );
   options.onProgress?.({
     kind: "start",
     validatedPath,
     outputPath,
     totalFiles: plan.totalFiles,
     totalBytes: plan.totalBytes,
-    datasets: plan.datasets
+    datasets: plan.datasets,
+    sourceEncoding
   });
   let processedFiles = 0;
   let processedRows = 0;
   let processedBytes = 0;
   let nulBytesRemoved = 0;
+  let invalidBytesRemoved = 0;
+  let controlCharsRemoved = 0;
   let changedFiles = 0;
   const fileSummaries = [];
   for (const [index, filePlan] of plan.files.entries()) {
-    const fileResult = await sanitizeDatasetFile(filePlan, (chunk) => {
-      options.onProgress?.({
-        kind: "progress",
-        currentFileDisplayPath: filePlan.displayPath,
-        fileIndex: index + 1,
-        totalFiles: plan.totalFiles,
-        bytesProcessed: processedBytes + chunk.fileBytesProcessed,
-        totalBytes: plan.totalBytes,
-        fileBytesProcessed: chunk.fileBytesProcessed,
-        currentFileSize: chunk.currentFileSize,
-        processedRows: processedRows + chunk.processedRows,
-        nulBytesRemoved: nulBytesRemoved + chunk.nulBytesRemoved,
-        changedFiles
-      });
-    });
+    const fileResult = await sanitizeDatasetFile(
+      filePlan,
+      (chunk) => {
+        options.onProgress?.({
+          kind: "progress",
+          currentFileDisplayPath: filePlan.displayPath,
+          fileIndex: index + 1,
+          totalFiles: plan.totalFiles,
+          bytesProcessed: processedBytes + chunk.fileBytesProcessed,
+          totalBytes: plan.totalBytes,
+          fileBytesProcessed: chunk.fileBytesProcessed,
+          currentFileSize: chunk.currentFileSize,
+          processedRows: processedRows + chunk.processedRows,
+          nulBytesRemoved: nulBytesRemoved + chunk.nulBytesRemoved,
+          invalidBytesRemoved: invalidBytesRemoved + chunk.invalidBytesRemoved,
+          controlCharsRemoved: controlCharsRemoved + chunk.controlCharsRemoved,
+          changedFiles
+        });
+      },
+      { sourceEncoding }
+    );
     processedFiles += 1;
     processedRows += fileResult.lineCount;
     processedBytes += fileResult.totalBytesRead;
     nulBytesRemoved += fileResult.nulBytesRemoved;
+    invalidBytesRemoved += fileResult.invalidBytesRemoved;
+    controlCharsRemoved += fileResult.controlCharsRemoved;
     changedFiles += fileResult.changed ? 1 : 0;
     fileSummaries.push({
       dataset: filePlan.dataset,
@@ -7936,7 +8196,9 @@ async function sanitizeInputDirectory(inputPath, options = {}) {
       outputPath: filePlan.outputPath,
       lineCount: fileResult.lineCount,
       changed: fileResult.changed,
-      nulBytesRemoved: fileResult.nulBytesRemoved
+      nulBytesRemoved: fileResult.nulBytesRemoved,
+      invalidBytesRemoved: fileResult.invalidBytesRemoved,
+      controlCharsRemoved: fileResult.controlCharsRemoved
     });
   }
   options.onProgress?.({
@@ -7944,6 +8206,8 @@ async function sanitizeInputDirectory(inputPath, options = {}) {
     totalFiles: plan.totalFiles,
     processedRows,
     nulBytesRemoved,
+    invalidBytesRemoved,
+    controlCharsRemoved,
     changedFiles,
     totalBytes: plan.totalBytes
   });
@@ -7955,13 +8219,17 @@ async function sanitizeInputDirectory(inputPath, options = {}) {
     totalBytes: plan.totalBytes,
     processedFiles,
     processedRows,
+    sourceEncoding,
     nulBytesRemoved,
+    invalidBytesRemoved,
+    controlCharsRemoved,
     changedFiles,
     unchangedFiles: plan.totalFiles - changedFiles,
     datasets: plan.datasets,
     files: fileSummaries,
     warnings: [
-      "Sanitization prepares a clean dataset tree for import by removing known low-level byte issues such as NUL bytes before PostgreSQL loading begins.",
+      "Sanitization now writes UTF-8 output and removes invalid bytes plus problematic control characters before PostgreSQL loading begins.",
+      "The PostgreSQL direct import path can use --source-encoding UTF8 when reading files generated by this sanitization command.",
       "The import command still keeps quarantine and row-level recovery for unexpected issues, but sanitizing first reduces the amount of slow fallback work during import."
     ],
     nextStep: inferNextStep3(outputPath)
@@ -8065,117 +8333,963 @@ async function syncFederalRevenueDataset(options = {}) {
   );
 }
 
-// src/cli/ui/theme.ts
-var colorsEnabled = process.stdout.isTTY && !process.argv.includes("--no-color") && process.env.NO_COLOR === void 0;
-function paint(code, value) {
-  if (!colorsEnabled) {
-    return value;
-  }
-  return `\x1B[${code}m${value}\x1B[0m`;
-}
-var theme = {
-  muted: (value) => paint(90, value),
-  red: (value) => paint(31, value),
-  green: (value) => paint(32, value),
-  yellow: (value) => paint(33, value),
-  blue: (value) => paint(34, value),
-  command: (value) => paint(36, value),
-  flag: (value) => paint(33, value),
-  section: (value) => paint(36, paint(1, value)),
-  successLabel: (value) => paint(32, paint(1, value)),
-  warningLabel: (value) => paint(33, paint(1, value)),
-  infoLabel: (value) => paint(36, paint(1, value)),
-  errorLabel: (value) => paint(31, paint(1, value))
-};
-
-// src/cli/ui/output/program-ui.ts
-function configureProgramUi(program) {
-  program.configureOutput({
-    writeErr: (str) => process.stderr.write(str),
-    outputError: (str, write) => {
-      write(theme.red(str));
-    }
-  });
-  program.configureHelp({
-    subcommandTerm: (cmd) => theme.command(cmd.name()),
-    optionTerm: (option) => theme.flag(option.flags)
-  });
-}
+// src/services/postgres-direct/exporter.ts
+import { createWriteStream as createWriteStream3 } from "fs";
+import { mkdir as mkdir8, writeFile as writeFile5 } from "fs/promises";
+import path16 from "path";
 
-// src/cli/ui/output/errors.ts
-function handleCliError(error) {
-  if (error instanceof AppError) {
-    console.error(`${theme.errorLabel(error.code)} ${error.message}`);
-    process.exit(1);
+// src/services/postgres-direct/csv.ts
+function formatCsvValue(value) {
+  if (value === null || value === void 0) {
+    return "";
   }
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(`${theme.errorLabel("UNEXPECTED_ERROR")} ${message}`);
-  process.exit(1);
+  if (value instanceof Date) {
+    return formatCsvValue(value.toISOString());
+  }
+  const text = String(value);
+  const shouldQuote = /[",\r\n]/.test(text);
+  if (!shouldQuote) {
+    return text;
+  }
+  return `"${text.replace(/"/g, '""')}"`;
+}
+function formatCsvRow(values) {
+  return values.map(formatCsvValue).join(",");
 }
 
-// src/cli/ui/output/shared.ts
+// src/services/postgres-direct/script.ts
 import path15 from "path";
-function resolveLogFilePath(logFilePath) {
-  return path15.resolve(logFilePath);
+var STAGING_DATASETS = [
+  "companies",
+  "establishments",
+  "partners",
+  "simples_options"
+];
+var DOMAIN_DATASETS = [
+  "partner_qualifications",
+  "legal_natures",
+  "countries",
+  "cities",
+  "reasons",
+  "cnaes"
+];
+var STAGING_TABLE_BY_DATASET3 = {
+  companies: "staging_companies",
+  establishments: "staging_establishments",
+  partners: "staging_partners",
+  simples_options: "staging_simples_options"
+};
+function quoteSqlLiteral(value) {
+  return `'${value.replace(/'/g, "''")}'`;
 }
-function formatKeyValue(label, value) {
-  return `${theme.muted(`- ${label}:`)} ${value}`;
+function quoteIdentifier(value) {
+  return `"${value.replace(/"/g, '""')}"`;
 }
-function printNotes(notes) {
-  if (notes.length === 0) {
-    return;
-  }
-  console.log(theme.infoLabel("NOTES"));
-  for (const note of notes) {
-    console.log(`  ${theme.blue("\u2022")} ${note}`);
-  }
+function normalizePathForPsql(filePath) {
+  return path15.resolve(filePath).replace(/\\/g, "/");
 }
-function printWarnings(warnings) {
-  if (warnings.length === 0) {
-    return;
-  }
-  console.log(theme.warningLabel("WARNINGS"));
-  for (const warning of warnings) {
-    console.log(`  ${theme.yellow("\u2022")} ${warning}`);
+function csvCopyCommand(tableName, columns, filePath) {
+  const normalizedFilePath = normalizePathForPsql(filePath);
+  return `\\copy ${tableName} (${columns.join(", ")}) from ${quoteSqlLiteral(normalizedFilePath)} with (format csv, header true, delimiter ',', quote '"', escape '"', null '')`;
+}
+function receitaCopyCommand(tableName, columns, filePath) {
+  const normalizedFilePath = normalizePathForPsql(filePath);
+  return `\\copy ${tableName} (${columns.join(", ")}) from ${quoteSqlLiteral(normalizedFilePath)} with (format csv, header false, delimiter ';', quote '"', escape '"')`;
+}
+function datasetColumns(dataset) {
+  return DATASET_LAYOUTS[dataset].fields.map((field) => field.columnName);
+}
+function updateAssignments(columns, excludedColumns) {
+  return columns.filter((column) => !excludedColumns.includes(column)).map((column) => `${column} = excluded.${column}`).concat(["updated_at = now()"]).join(",\n  ");
+}
+function partnerDedupeExpression(alias) {
+  return [
+    "md5(",
+    `  coalesce(${alias}.cnpj_root, '') || '|' ||`,
+    `  coalesce(${alias}.partner_type_code, '') || '|' ||`,
+    `  coalesce(${alias}.partner_name, '') || '|' ||`,
+    `  coalesce(${alias}.partner_document, '') || '|' ||`,
+    `  coalesce(${alias}.partner_qualification_code, '') || '|' ||`,
+    `  coalesce((${alias}.entry_date - date '2000-01-01')::text, '') || '|' ||`,
+    `  coalesce(${alias}.country_code, '') || '|' ||`,
+    `  coalesce(${alias}.legal_representative_document, '') || '|' ||`,
+    `  coalesce(${alias}.legal_representative_name, '') || '|' ||`,
+    `  coalesce(${alias}.legal_representative_qualification_code, '') || '|' ||`,
+    `  coalesce(${alias}.age_group_code, '')`,
+    ")"
+  ].join("\n");
+}
+function materializeCompaniesSql() {
+  const columns = companiesLayout.fields.map((field) => field.columnName);
+  return [
+    "\\echo 'Materializing companies...'",
+    "with source as (",
+    "  select",
+    `    ${columns.map((column) => `source.${column}`).join(",\n    ")},`,
+    "    row_number() over (partition by source.cnpj_root order by source.staging_id desc) as dedupe_rank",
+    "  from staging_companies source",
+    "),",
+    "deduped as (",
+    "  select * from source where dedupe_rank = 1",
+    ")",
+    `insert into companies (${columns.join(", ")})`,
+    `select ${columns.join(", ")}`,
+    "from deduped",
+    "on conflict (cnpj_root) do update set",
+    `  ${updateAssignments(columns, ["cnpj_root"])};`
+  ].join("\n");
+}
+function materializeEstablishmentsSql() {
+  const baseColumns = establishmentsLayout.fields.map(
+    (field) => field.columnName
+  );
+  const insertColumns = [...baseColumns, "cnpj_full"];
+  return [
+    "\\echo 'Materializing establishments and secondary CNAEs...'",
+    "with source as (",
+    "  select",
+    `    ${baseColumns.map((column) => `source.${column}`).join(",\n    ")},`,
+    "    source.cnpj_root || source.cnpj_order || source.cnpj_check_digits as cnpj_full,",
+    "    row_number() over (partition by source.cnpj_root || source.cnpj_order || source.cnpj_check_digits order by source.staging_id desc) as dedupe_rank",
+    "  from staging_establishments source",
+    "),",
+    "deduped as (",
+    "  select * from source where dedupe_rank = 1",
+    "),",
+    "upserted as (",
+    `  insert into establishments (${insertColumns.join(", ")})`,
+    `  select ${insertColumns.join(", ")}`,
+    "  from deduped",
+    "  on conflict (cnpj_full) do update set",
+    `    ${updateAssignments(insertColumns, ["cnpj_root", "cnpj_order", "cnpj_check_digits", "cnpj_full"])}`,
+    "  returning cnpj_full",
+    "),",
+    "deleted_secondary_cnaes as (",
+    "  delete from establishment_secondary_cnaes target",
+    "  using (select cnpj_full from deduped) source_keys",
+    "  where target.cnpj_full = source_keys.cnpj_full",
+    "  returning 1",
+    "),",
+    "secondary_cnaes_source as (",
+    "  select distinct",
+    "    deduped.cnpj_full,",
+    "    btrim(cnae_code) as cnae_code",
+    "  from deduped",
+    "  cross join lateral unnest(string_to_array(deduped.secondary_cnaes_raw, ',')) as cnae_code",
+    "  where deduped.secondary_cnaes_raw is not null",
+    "    and deduped.secondary_cnaes_raw <> ''",
+    "    and btrim(cnae_code) <> ''",
+    ")",
+    "insert into establishment_secondary_cnaes (cnpj_full, cnae_code)",
+    "select cnpj_full, cnae_code",
+    "from secondary_cnaes_source",
+    "on conflict (cnpj_full, cnae_code) do nothing;"
+  ].join("\n");
+}
+function materializePartnersSql() {
+  const baseColumns = partnersLayout.fields.map((field) => field.columnName);
+  const insertColumns = [...baseColumns, "partner_dedupe_key"];
+  return [
+    "\\echo 'Materializing partners...'",
+    "with source as (",
+    "  select",
+    `    ${baseColumns.map((column) => `source.${column}`).join(",\n    ")},`,
+    `    ${partnerDedupeExpression("source")} as partner_dedupe_key`,
+    "  from staging_partners source",
+    "),",
+    "ranked as (",
+    "  select",
+    "    source.*,",
+    "    row_number() over (partition by source.partner_dedupe_key order by source.cnpj_root asc) as dedupe_rank",
+    "  from source",
+    "),",
+    "deduped as (",
+    "  select * from ranked where dedupe_rank = 1",
+    ")",
+    `insert into partners (${insertColumns.join(", ")})`,
+    `select ${insertColumns.join(", ")}`,
+    "from deduped",
+    "on conflict (partner_dedupe_key) do update set",
+    `  ${updateAssignments(insertColumns, ["partner_dedupe_key"])};`
+  ].join("\n");
+}
+function materializeSimplesSql() {
+  const columns = simplesLayout.fields.map((field) => field.columnName);
+  return [
+    "\\echo 'Materializing simples options...'",
+    "with source as (",
+    "  select",
+    `    ${columns.map((column) => `source.${column}`).join(",\n    ")},`,
+    "    row_number() over (partition by source.cnpj_root order by source.staging_id desc) as dedupe_rank",
+    "  from staging_simples_options source",
+    "),",
+    "deduped as (",
+    "  select * from source where dedupe_rank = 1",
+    ")",
+    `insert into simples_options (${columns.join(", ")})`,
+    `select ${columns.join(", ")}`,
+    "from deduped",
+    "on conflict (cnpj_root) do update set",
+    `  ${updateAssignments(columns, ["cnpj_root"])};`
+  ].join("\n");
+}
+function copyDomainSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
   }
+  const columns = datasetColumns(dataset);
+  const tempTable = `tmp_hybrid_${dataset}`;
+  const lines = [
+    `\\echo 'Loading ${dataset} lookup data...'`,
+    `drop table if exists ${tempTable};`,
+    `create temporary table ${tempTable} (code text, description text);`
+  ];
+  for (const file of files) {
+    lines.push(csvCopyCommand(tempTable, columns, file.absolutePath));
+  }
+  lines.push(
+    `insert into ${dataset} (${columns.join(", ")})`,
+    `select distinct on (code) ${columns.join(", ")}`,
+    `from ${tempTable}`,
+    "where code is not null and code <> ''",
+    "order by code",
+    "on conflict (code) do update set description = excluded.description;"
+  );
+  return lines;
 }
-function printErrors(errors) {
-  if (errors.length === 0) {
-    return;
+function copyStagingSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
   }
-  console.log(theme.errorLabel("ERRORS"));
-  for (const error of errors) {
-    console.log(`  ${theme.red("\u2022")} ${error}`);
+  const tableName = STAGING_TABLE_BY_DATASET3[dataset];
+  if (!tableName) {
+    return [];
   }
+  const columns = datasetColumns(dataset);
+  return [
+    `\\echo 'Loading ${dataset} staging data...'`,
+    ...files.map(
+      (file) => csvCopyCommand(tableName, columns, file.absolutePath)
+    )
+  ];
 }
-function formatBytes(value) {
-  if (value < 1024) {
-    return `${value} B`;
+function csvFilesByDataset(files) {
+  const grouped = {};
+  for (const file of files) {
+    const items = grouped[file.dataset] ?? [];
+    items.push(file);
+    grouped[file.dataset] = items;
   }
-  const units = ["KB", "MB", "GB", "TB"];
-  let currentValue = value / 1024;
-  let unitIndex = 0;
-  while (currentValue >= 1024 && unitIndex < units.length - 1) {
-    currentValue /= 1024;
-    unitIndex += 1;
+  return grouped;
+}
+function directFilesByDataset(files) {
+  const grouped = {};
+  for (const file of files) {
+    const items = grouped[file.dataset] ?? [];
+    items.push(file);
+    grouped[file.dataset] = items;
   }
-  return `${currentValue.toFixed(currentValue >= 100 ? 0 : currentValue >= 10 ? 1 : 2)} ${units[unitIndex]}`;
+  return grouped;
 }
-function formatCount(value) {
-  return new Intl.NumberFormat("en-US").format(value);
+function rawTableName(dataset) {
+  return `tmp_hybrid_raw_${dataset}`;
 }
-function formatDecimal(value, fractionDigits = 2) {
-  return new Intl.NumberFormat("en-US", {
-    maximumFractionDigits: fractionDigits,
-    minimumFractionDigits: 0
-  }).format(value);
+function createRawTempTableSql(dataset) {
+  const columns = DATASET_LAYOUTS[dataset].fields.map((field) => `  ${quoteIdentifier(field.columnName)} text`).join(",\n");
+  return [
+    `drop table if exists ${rawTableName(dataset)};`,
+    `create temporary table ${rawTableName(dataset)} (`,
+    columns,
+    ");"
+  ].join("\n");
 }
-function formatDuration(valueMs) {
-  if (valueMs < 1e3) {
-    return `${Math.round(valueMs)} ms`;
+function textExpression(alias, column) {
+  return `nullif(btrim(${alias}.${quoteIdentifier(column)}), '')`;
+}
+function dateExpression(alias, column) {
+  const value = `btrim(${alias}.${quoteIdentifier(column)})`;
+  return [
+    "case",
+    `  when ${value} = '' or ${value} = '00000000' then null`,
+    `  when ${value} ~ '^\\d{8}$' then to_date(${value}, 'YYYYMMDD')`,
+    "  else null",
+    "end"
+  ].join(" ");
+}
+function numericExpression(alias, column) {
+  const value = `btrim(${alias}.${quoteIdentifier(column)})`;
+  return [
+    "case",
+    `  when ${value} = '' then null`,
+    `  when ${value} like '%,%' and ${value} like '%.%' then replace(replace(${value}, '.', ''), ',', '.')::numeric`,
+    `  when ${value} like '%,%' then replace(${value}, ',', '.')::numeric`,
+    `  else ${value}::numeric`,
+    "end"
+  ].join(" ");
+}
+function integerExpression(alias, column) {
+  const value = `btrim(${alias}.${quoteIdentifier(column)})`;
+  return [
+    "case",
+    `  when ${value} = '' then null`,
+    `  when ${value} ~ '^-?\\d+$' then ${value}::integer`,
+    "  else null",
+    "end"
+  ].join(" ");
+}
+function booleanExpression(alias, column) {
+  const value = `lower(btrim(${alias}.${quoteIdentifier(column)}))`;
+  return [
+    "case",
+    `  when ${value} in ('1', 'true', 't', 'y', 'yes', 's') then true`,
+    `  when ${value} in ('0', 'false', 'f', 'n', 'no') then false`,
+    "  else null",
+    "end"
+  ].join(" ");
+}
+function fieldExpression(dataset, field, alias) {
+  const column = field.columnName;
+  if (dataset === "companies" && column === "company_size_code") {
+    return `coalesce(${textExpression(alias, column)}, '00')`;
   }
-  const seconds = valueMs / 1e3;
-  if (seconds < 60) {
+  if (dataset === "establishments" && column === "branch_type_code") {
+    return `coalesce(${textExpression(alias, column)}, '1')`;
+  }
+  if (dataset === "establishments" && column === "registration_status_code") {
+    return `coalesce(${textExpression(alias, column)}, '01')`;
+  }
+  switch (field.dataType) {
+    case "date":
+      return dateExpression(alias, column);
+    case "numeric":
+      return numericExpression(alias, column);
+    case "integer":
+      return integerExpression(alias, column);
+    case "boolean":
+      return booleanExpression(alias, column);
+    default:
+      return textExpression(alias, column);
+  }
+}
+function rawDomainSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const layout = DATASET_LAYOUTS[dataset];
+  const columns = layout.fields.map((field) => field.columnName);
+  const tableName = rawTableName(dataset);
+  const lines = [
+    `\\echo 'Loading ${dataset} lookup data directly from sanitized Receita files...'`,
+    createRawTempTableSql(dataset)
+  ];
+  for (const file of files) {
+    lines.push(receitaCopyCommand(tableName, columns, file.absolutePath));
+  }
+  lines.push(
+    `insert into ${dataset} (${columns.join(", ")})`,
+    "select distinct on (code)",
+    "  nullif(btrim(code), '') as code,",
+    "  nullif(btrim(description), '') as description",
+    `from ${tableName}`,
+    "where nullif(btrim(code), '') is not null",
+    "order by code",
+    "on conflict (code) do update set description = excluded.description;"
+  );
+  return lines;
+}
+function rawStagingSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const targetTable = STAGING_TABLE_BY_DATASET3[dataset];
+  if (!targetTable) {
+    return [];
+  }
+  const layout = DATASET_LAYOUTS[dataset];
+  const columns = layout.fields.map((field) => field.columnName);
+  const tableName = rawTableName(dataset);
+  const alias = "source";
+  const expressions = layout.fields.map(
+    (field) => `  ${fieldExpression(dataset, field, alias)} as ${field.columnName}`
+  );
+  const lines = [
+    `\\echo 'Loading ${dataset} staging data directly from sanitized Receita files...'`,
+    createRawTempTableSql(dataset)
+  ];
+  for (const file of files) {
+    lines.push(receitaCopyCommand(tableName, columns, file.absolutePath));
+  }
+  lines.push(
+    `insert into ${targetTable} (${columns.join(", ")})`,
+    "select",
+    expressions.join(",\n"),
+    `from ${tableName} ${alias};`
+  );
+  return lines;
+}
+function generatePostgresDirectImportScript(input2) {
+  const grouped = csvFilesByDataset(input2.files);
+  const lines = [
+    "-- CNPJ DB Loader hybrid PostgreSQL import script",
+    "-- Generated from PostgreSQL-ready CSV files exported by cnpj-db-loader postgres export-csv.",
+    "-- Execute with psql, for example:",
+    '--   psql "postgres://postgres:postgres@localhost:5432/cnpj" -f import-postgres-direct.sql',
+    "",
+    "\\set ON_ERROR_STOP on",
+    "\\echo 'Starting CNPJ DB Loader hybrid PostgreSQL import...'",
+    "",
+    "begin;",
+    "",
+    "-- Keep the final schema and seed data managed by sql/schema.sql.",
+    "-- This script only resets staging tables and then upserts final data.",
+    "truncate table staging_companies restart identity;",
+    "truncate table staging_establishments restart identity;",
+    "truncate table staging_partners restart identity;",
+    "truncate table staging_simples_options restart identity;",
+    ""
+  ];
+  for (const dataset of DOMAIN_DATASETS) {
+    lines.push(...copyDomainSql(dataset, grouped[dataset] ?? []), "");
+  }
+  for (const dataset of STAGING_DATASETS) {
+    lines.push(...copyStagingSql(dataset, grouped[dataset] ?? []), "");
+  }
+  lines.push(...materializationAndAnalyzeSql());
+  return lines.join("\n");
+}
+function generatePostgresSanitizedDirectImportScript(input2) {
+  const grouped = directFilesByDataset(input2.files);
+  const lines = [
+    "-- CNPJ DB Loader direct PostgreSQL import script",
+    "-- Generated from sanitized Receita files by cnpj-db-loader postgres generate-script.",
+    "-- This path avoids rewriting the dataset into a second CSV tree.",
+    "-- Execute with psql, for example:",
+    '--   psql "postgres://postgres:postgres@localhost:5432/cnpj" -f import-postgres-direct.sql',
+    "",
+    "\\set ON_ERROR_STOP on",
+    `\\echo 'Using source file encoding ${input2.sourceEncoding} for psql copy operations...'`,
+    `set client_encoding to ${quoteSqlLiteral(input2.sourceEncoding)};`,
+    "\\echo 'Starting CNPJ DB Loader direct PostgreSQL import from sanitized files...'",
+    "",
+    "begin;",
+    "",
+    "-- Keep the final schema and seed data managed by sql/schema.sql.",
+    "-- This script copies sanitized Receita files into temporary raw tables,",
+    "-- transforms values inside PostgreSQL, resets staging tables and upserts final data.",
+    "truncate table staging_companies restart identity;",
+    "truncate table staging_establishments restart identity;",
+    "truncate table staging_partners restart identity;",
+    "truncate table staging_simples_options restart identity;",
+    ""
+  ];
+  for (const dataset of DOMAIN_DATASETS) {
+    lines.push(...rawDomainSql(dataset, grouped[dataset] ?? []), "");
+  }
+  for (const dataset of STAGING_DATASETS) {
+    lines.push(...rawStagingSql(dataset, grouped[dataset] ?? []), "");
+  }
+  lines.push(...materializationAndAnalyzeSql());
+  return lines.join("\n");
+}
+function materializationAndAnalyzeSql() {
+  return [
+    materializeCompaniesSql(),
+    "",
+    materializeEstablishmentsSql(),
+    "",
+    materializePartnersSql(),
+    "",
+    materializeSimplesSql(),
+    "",
+    "\\echo 'Refreshing planner statistics...'",
+    "analyze companies;",
+    "analyze establishments;",
+    "analyze establishment_secondary_cnaes;",
+    "analyze partners;",
+    "analyze simples_options;",
+    "analyze cnaes;",
+    "analyze cities;",
+    "analyze countries;",
+    "analyze legal_natures;",
+    "analyze partner_qualifications;",
+    "analyze reasons;",
+    "",
+    "commit;",
+    "",
+    "\\echo 'CNPJ DB Loader hybrid PostgreSQL import completed.'",
+    ""
+  ];
+}
+
+// src/services/postgres-direct/exporter.ts
+var POSTGRES_DIRECT_SCHEMA_CAPABILITIES = {
+  includeEstablishmentCnpjFullInInsert: true,
+  includeEstablishmentSecondaryCnaesTable: true,
+  includePartnerDedupeKeyInInsert: true,
+  requiresLookupReconciliation: false
+};
+function defaultPostgresCsvOutputPath(inputPath) {
+  const baseName = path16.basename(inputPath);
+  return path16.join(path16.dirname(inputPath), `${baseName}-postgres-csv`);
+}
+function normalizeOutputFileName(relativePath) {
+  const parsed = path16.parse(relativePath);
+  const baseName = parsed.name || parsed.base || "dataset";
+  return path16.join(parsed.dir, `${baseName}.csv`);
+}
+function resolveDatasetOutputPath(outputPath, dataset, relativePath) {
+  return path16.join(outputPath, dataset, normalizeOutputFileName(relativePath));
+}
+function inferNextStep4(scriptPath) {
+  return `psql "postgres://postgres:postgres@localhost:5432/cnpj" -f ${scriptPath.replace(/\\/g, "/")}`;
+}
+async function writeCsvFile(input2) {
+  const layout = DATASET_LAYOUTS[input2.dataset];
+  const columns = layout.fields.map((field) => field.columnName);
+  await mkdir8(path16.dirname(input2.outputFile), { recursive: true });
+  const output2 = createWriteStream3(input2.outputFile, { encoding: "utf8" });
+  let rows = 0;
+  try {
+    output2.write(`${formatCsvRow(columns)}
+`);
+    for await (const sourceLine of readImportSourceLines(input2.inputFile)) {
+      if (sourceLine.rawLine.trim() === "") {
+        continue;
+      }
+      const parsed = parseImportSourceLine(sourceLine);
+      const normalizedFields = normalizeFieldCount(
+        parsed.fields,
+        layout.fields.length,
+        input2.inputFile,
+        parsed.lineNumber
+      );
+      const values = transformRecord(
+        input2.dataset,
+        layout,
+        normalizedFields,
+        POSTGRES_DIRECT_SCHEMA_CAPABILITIES,
+        "staging"
+      );
+      output2.write(`${formatCsvRow(values)}
+`);
+      rows += 1;
+    }
+  } finally {
+    output2.end();
+    await new Promise((resolve2, reject) => {
+      output2.on("finish", () => resolve2());
+      output2.on("error", (error) => reject(error));
+    });
+  }
+  return rows;
+}
+async function exportPostgresCsvDataset(inputPath, options = {}) {
+  if (options.dataset && !isImportDatasetType(options.dataset)) {
+    throw new ValidationError(`Unsupported dataset type: ${options.dataset}.`);
+  }
+  const validation = await validateInputDirectory(inputPath);
+  if (!validation.ok) {
+    throw new ValidationError(
+      `The input directory is not ready for PostgreSQL CSV export. ${validation.errors.join(" ")}`
+    );
+  }
+  const validatedPath = validation.validatedPath;
+  const outputPath = path16.resolve(
+    options.outputPath ?? defaultPostgresCsvOutputPath(validatedPath)
+  );
+  const inspected = await inspectFiles(validatedPath);
+  const recognizedFiles = inspected.entries.filter((entry) => entry.entryKind === "file").flatMap((entry) => {
+    if (!isImportDatasetType(entry.inferredType)) {
+      return [];
+    }
+    if (options.dataset && entry.inferredType !== options.dataset) {
+      return [];
+    }
+    return [{ ...entry, inferredType: entry.inferredType }];
+  }).sort(sortEntries);
+  if (recognizedFiles.length === 0) {
+    throw new ValidationError(
+      "No recognized dataset files were found for PostgreSQL CSV export."
+    );
+  }
+  const datasets = [
+    ...new Set(recognizedFiles.map((entry) => entry.inferredType))
+  ].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left) - IMPORT_ORDER.indexOf(right)
+  );
+  options.onProgress?.({
+    kind: "start",
+    inputPath: path16.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    totalFiles: recognizedFiles.length,
+    datasets
+  });
+  const exportedFiles = [];
+  const summariesByDataset = /* @__PURE__ */ new Map();
+  for (const [index, entry] of recognizedFiles.entries()) {
+    const dataset = entry.inferredType;
+    const inputFile = path16.join(validatedPath, entry.relativePath);
+    const outputFile = resolveDatasetOutputPath(
+      outputPath,
+      dataset,
+      entry.relativePath
+    );
+    options.onProgress?.({
+      kind: "file_start",
+      dataset,
+      fileIndex: index + 1,
+      totalFiles: recognizedFiles.length,
+      inputFile: buildDisplayPath(inputFile),
+      outputFile
+    });
+    const rowCount = await writeCsvFile({ dataset, inputFile, outputFile });
+    exportedFiles.push({
+      dataset,
+      absolutePath: outputFile,
+      relativePath: path16.relative(outputPath, outputFile),
+      rowCount
+    });
+    const currentSummary = summariesByDataset.get(dataset) ?? {
+      dataset,
+      files: 0,
+      rows: 0,
+      outputFiles: []
+    };
+    currentSummary.files += 1;
+    currentSummary.rows += rowCount;
+    currentSummary.outputFiles.push(outputFile);
+    summariesByDataset.set(dataset, currentSummary);
+    options.onProgress?.({
+      kind: "file_finish",
+      dataset,
+      fileIndex: index + 1,
+      totalFiles: recognizedFiles.length,
+      inputFile: buildDisplayPath(inputFile),
+      outputFile,
+      rows: rowCount
+    });
+  }
+  const scriptName = options.scriptName ?? "import-postgres-direct.sql";
+  const scriptPath = path16.join(outputPath, scriptName);
+  const script = generatePostgresDirectImportScript({ files: exportedFiles });
+  await writeFile5(scriptPath, script, "utf8");
+  const manifestPath = path16.join(outputPath, "manifest.json");
+  const summaryDatasets = [...summariesByDataset.values()].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left.dataset) - IMPORT_ORDER.indexOf(right.dataset)
+  );
+  const totalRows = summaryDatasets.reduce((sum, item) => sum + item.rows, 0);
+  const manifest = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    inputPath: path16.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    totalFiles: exportedFiles.length,
+    totalRows,
+    datasets: summaryDatasets
+  };
+  await writeFile5(
+    manifestPath,
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  options.onProgress?.({
+    kind: "finish",
+    outputPath,
+    scriptPath,
+    totalFiles: exportedFiles.length,
+    totalRows
+  });
+  return {
+    inputPath: path16.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    manifestPath,
+    totalFiles: exportedFiles.length,
+    totalRows,
+    datasets: summaryDatasets,
+    warnings: [
+      "PostgreSQL-ready CSV export is intended for hybrid bulk imports after extraction, validation and sanitization.",
+      "The generated SQL script resets staging tables and then upserts final tables. Review it before running against production databases."
+    ],
+    nextStep: inferNextStep4(scriptPath)
+  };
+}
+
+// src/services/postgres-direct/generator.ts
+import { mkdir as mkdir9, stat as stat7, writeFile as writeFile6 } from "fs/promises";
+import path17 from "path";
+var DEFAULT_SOURCE_ENCODING = "UTF8";
+function defaultPostgresDirectOutputPath(inputPath) {
+  const baseName = path17.basename(inputPath);
+  if (baseName.toLowerCase() === "sanitized") {
+    return path17.join(path17.dirname(inputPath), "postgres-direct");
+  }
+  return path17.join(path17.dirname(inputPath), `${baseName}-postgres-direct`);
+}
+function inferNextStep5(scriptPath) {
+  return `psql "postgres://postgres:postgres@localhost:5432/cnpj" -f ${scriptPath.replace(/\\/g, "/")}`;
+}
+function normalizeSourceEncoding(value) {
+  const encoding = (value ?? DEFAULT_SOURCE_ENCODING).trim();
+  if (!/^[A-Za-z0-9_-]+$/.test(encoding)) {
+    throw new ValidationError(
+      `Invalid source encoding: ${value}. Use a PostgreSQL client encoding name such as UTF8, WIN1252 or LATIN1.`
+    );
+  }
+  return encoding.toUpperCase();
+}
+async function generatePostgresDirectScript(inputPath, options = {}) {
+  if (options.dataset && !isImportDatasetType(options.dataset)) {
+    throw new ValidationError(`Unsupported dataset type: ${options.dataset}.`);
+  }
+  const validation = await validateInputDirectory(inputPath);
+  if (!validation.ok && !options.dataset) {
+    throw new ValidationError(
+      `The input directory is not ready for PostgreSQL direct script generation. ${validation.errors.join(" ")}`
+    );
+  }
+  const validatedPath = validation.ok ? validation.validatedPath : path17.resolve(inputPath);
+  const outputPath = path17.resolve(
+    options.outputPath ?? defaultPostgresDirectOutputPath(validatedPath)
+  );
+  const sourceEncoding = normalizeSourceEncoding(options.sourceEncoding);
+  const inspected = await inspectFiles(validatedPath);
+  const recognizedFiles = inspected.entries.filter((entry) => entry.entryKind === "file").flatMap((entry) => {
+    if (!isImportDatasetType(entry.inferredType)) {
+      return [];
+    }
+    if (options.dataset && entry.inferredType !== options.dataset) {
+      return [];
+    }
+    return [{ ...entry, inferredType: entry.inferredType }];
+  }).sort(sortEntries);
+  if (recognizedFiles.length === 0) {
+    throw new ValidationError(
+      "No recognized dataset files were found for PostgreSQL direct script generation."
+    );
+  }
+  const datasets = [
+    ...new Set(recognizedFiles.map((entry) => entry.inferredType))
+  ].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left) - IMPORT_ORDER.indexOf(right)
+  );
+  options.onProgress?.({
+    kind: "start",
+    inputPath: path17.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    totalFiles: recognizedFiles.length,
+    datasets,
+    sourceEncoding
+  });
+  await mkdir9(outputPath, { recursive: true });
+  const sourceFiles = [];
+  const summariesByDataset = /* @__PURE__ */ new Map();
+  for (const [index, entry] of recognizedFiles.entries()) {
+    const dataset = entry.inferredType;
+    const absolutePath = path17.join(validatedPath, entry.relativePath);
+    const fileStats = await stat7(absolutePath);
+    sourceFiles.push({
+      dataset,
+      absolutePath,
+      relativePath: entry.relativePath,
+      fileSize: fileStats.size
+    });
+    const currentSummary = summariesByDataset.get(dataset) ?? {
+      dataset,
+      files: 0,
+      totalBytes: 0,
+      sourceFiles: []
+    };
+    currentSummary.files += 1;
+    currentSummary.totalBytes += fileStats.size;
+    currentSummary.sourceFiles.push(absolutePath);
+    summariesByDataset.set(dataset, currentSummary);
+    options.onProgress?.({
+      kind: "file_registered",
+      dataset,
+      fileIndex: index + 1,
+      totalFiles: recognizedFiles.length,
+      inputFile: buildDisplayPath(absolutePath),
+      fileSize: fileStats.size
+    });
+  }
+  const scriptName = options.scriptName ?? "import-postgres-direct.sql";
+  const scriptPath = path17.join(outputPath, scriptName);
+  const script = generatePostgresSanitizedDirectImportScript({
+    files: sourceFiles,
+    sourceEncoding
+  });
+  await writeFile6(scriptPath, script, "utf8");
+  const manifestPath = path17.join(outputPath, "manifest.json");
+  const summaryDatasets = [...summariesByDataset.values()].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left.dataset) - IMPORT_ORDER.indexOf(right.dataset)
+  );
+  const totalBytes = summaryDatasets.reduce(
+    (sum, item) => sum + item.totalBytes,
+    0
+  );
+  const manifest = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: "direct-sanitized-script",
+    inputPath: path17.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    sourceEncoding,
+    totalFiles: sourceFiles.length,
+    totalBytes,
+    datasets: summaryDatasets
+  };
+  await writeFile6(
+    manifestPath,
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  options.onProgress?.({
+    kind: "finish",
+    outputPath,
+    scriptPath,
+    totalFiles: sourceFiles.length,
+    totalBytes
+  });
+  return {
+    inputPath: path17.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    manifestPath,
+    sourceEncoding,
+    totalFiles: sourceFiles.length,
+    totalBytes,
+    datasets: summaryDatasets,
+    warnings: [
+      ...validation.ok ? [] : validation.errors,
+      "This script imports sanitized Receita files directly with psql \\copy. It avoids rewriting the full dataset into a second CSV tree.",
+      "The generated script expects the database schema generated by cnpj-db-loader to be applied before execution.",
+      "The direct PostgreSQL script now defaults to UTF8 because the sanitize command writes clean UTF-8 files.",
+      "Use --source-encoding WIN1252 or LATIN1 only when generating scripts for legacy sanitized files produced by older loader versions."
+    ],
+    nextStep: inferNextStep5(scriptPath)
+  };
+}
+
+// src/cli/ui/theme.ts
+var colorsEnabled = process.stdout.isTTY && !process.argv.includes("--no-color") && process.env.NO_COLOR === void 0;
+function paint(code, value) {
+  if (!colorsEnabled) {
+    return value;
+  }
+  return `\x1B[${code}m${value}\x1B[0m`;
+}
+var theme = {
+  muted: (value) => paint(90, value),
+  red: (value) => paint(31, value),
+  green: (value) => paint(32, value),
+  yellow: (value) => paint(33, value),
+  blue: (value) => paint(34, value),
+  command: (value) => paint(36, value),
+  flag: (value) => paint(33, value),
+  section: (value) => paint(36, paint(1, value)),
+  successLabel: (value) => paint(32, paint(1, value)),
+  warningLabel: (value) => paint(33, paint(1, value)),
+  infoLabel: (value) => paint(36, paint(1, value)),
+  errorLabel: (value) => paint(31, paint(1, value))
+};
+
+// src/cli/ui/output/program-ui.ts
+function configureProgramUi(program) {
+  program.configureOutput({
+    writeErr: (str) => process.stderr.write(str),
+    outputError: (str, write) => {
+      write(theme.red(str));
+    }
+  });
+  program.configureHelp({
+    subcommandTerm: (cmd) => theme.command(cmd.name()),
+    optionTerm: (option) => theme.flag(option.flags)
+  });
+}
+
+// src/cli/ui/output/errors.ts
+function handleCliError(error) {
+  if (error instanceof AppError) {
+    console.error(`${theme.errorLabel(error.code)} ${error.message}`);
+    process.exit(1);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`${theme.errorLabel("UNEXPECTED_ERROR")} ${message}`);
+  process.exit(1);
+}
+
+// src/cli/ui/output/shared.ts
+import path18 from "path";
+function resolveLogFilePath(logFilePath) {
+  return path18.resolve(logFilePath);
+}
+function formatKeyValue(label, value) {
+  return `${theme.muted(`- ${label}:`)} ${value}`;
+}
+function printNotes(notes) {
+  if (notes.length === 0) {
+    return;
+  }
+  console.log(theme.infoLabel("NOTES"));
+  for (const note of notes) {
+    console.log(`  ${theme.blue("\u2022")} ${note}`);
+  }
+}
+function printWarnings(warnings) {
+  if (warnings.length === 0) {
+    return;
+  }
+  console.log(theme.warningLabel("WARNINGS"));
+  for (const warning of warnings) {
+    console.log(`  ${theme.yellow("\u2022")} ${warning}`);
+  }
+}
+function printErrors(errors) {
+  if (errors.length === 0) {
+    return;
+  }
+  console.log(theme.errorLabel("ERRORS"));
+  for (const error of errors) {
+    console.log(`  ${theme.red("\u2022")} ${error}`);
+  }
+}
+function formatBytes(value) {
+  if (value < 1024) {
+    return `${value} B`;
+  }
+  const units = ["KB", "MB", "GB", "TB"];
+  let currentValue = value / 1024;
+  let unitIndex = 0;
+  while (currentValue >= 1024 && unitIndex < units.length - 1) {
+    currentValue /= 1024;
+    unitIndex += 1;
+  }
+  return `${currentValue.toFixed(currentValue >= 100 ? 0 : currentValue >= 10 ? 1 : 2)} ${units[unitIndex]}`;
+}
+function formatCount(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+function formatDecimal(value, fractionDigits = 2) {
+  return new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: fractionDigits,
+    minimumFractionDigits: 0
+  }).format(value);
+}
+function formatDuration(valueMs) {
+  if (valueMs < 1e3) {
+    return `${Math.round(valueMs)} ms`;
+  }
+  const seconds = valueMs / 1e3;
+  if (seconds < 60) {
     return `${formatDecimal(seconds)} s`;
   }
   const minutes = Math.floor(seconds / 60);
@@ -8363,9 +9477,23 @@ function printSanitizeSummary(summary, logFilePath) {
   console.log(
     formatKeyValue("Processed bytes", formatBytes(summary.totalBytes))
   );
+  console.log(formatKeyValue("Source encoding", summary.sourceEncoding));
+  console.log(formatKeyValue("Output encoding", "UTF8"));
   console.log(
     formatKeyValue("Removed NUL bytes", formatCount(summary.nulBytesRemoved))
   );
+  console.log(
+    formatKeyValue(
+      "Removed invalid bytes",
+      formatCount(summary.invalidBytesRemoved)
+    )
+  );
+  console.log(
+    formatKeyValue(
+      "Removed control chars",
+      formatCount(summary.controlCharsRemoved)
+    )
+  );
   console.log(formatKeyValue("Changed files", summary.changedFiles));
   console.log(formatKeyValue("Unchanged files", summary.unchangedFiles));
   if (summary.datasets.length > 0) {
@@ -8656,6 +9784,59 @@ function printFederalRevenueSyncSummary(summary, logFilePath) {
     `${theme.muted("Import progress log:")} ${resolveLogFilePath(summary.import.progressLogPath)}`
   );
 }
+function printPostgresCsvExportSummary(summary, logFilePath) {
+  console.log(
+    theme.successLabel("POSTGRES"),
+    "PostgreSQL-ready CSV export completed."
+  );
+  console.log(formatKeyValue("Input path", summary.inputPath));
+  console.log(formatKeyValue("Validated path", summary.validatedPath));
+  console.log(formatKeyValue("Output path", summary.outputPath));
+  console.log(formatKeyValue("Generated script", summary.scriptPath));
+  console.log(formatKeyValue("Manifest", summary.manifestPath));
+  console.log(formatKeyValue("Exported files", summary.totalFiles));
+  console.log(formatKeyValue("Exported rows", formatCount(summary.totalRows)));
+  if (summary.datasets.length > 0) {
+    console.log(theme.infoLabel("DATASETS"));
+    for (const dataset of summary.datasets) {
+      console.log(
+        `  ${theme.blue("\u2022")} ${dataset.dataset}: ${dataset.files} file(s), ${formatCount(dataset.rows)} row(s)`
+      );
+    }
+  }
+  printWarnings(summary.warnings);
+  if (summary.nextStep) {
+    console.log(`${theme.infoLabel("NEXT")} ${summary.nextStep}`);
+  }
+  console.log(`${theme.muted("Log file:")} ${resolveLogFilePath(logFilePath)}`);
+}
+function printPostgresDirectScriptSummary(summary, logFilePath) {
+  console.log(
+    theme.successLabel("POSTGRES"),
+    "Direct PostgreSQL import script generated."
+  );
+  console.log(formatKeyValue("Input path", summary.inputPath));
+  console.log(formatKeyValue("Validated path", summary.validatedPath));
+  console.log(formatKeyValue("Output path", summary.outputPath));
+  console.log(formatKeyValue("Generated script", summary.scriptPath));
+  console.log(formatKeyValue("Manifest", summary.manifestPath));
+  console.log(formatKeyValue("Source encoding", summary.sourceEncoding));
+  console.log(formatKeyValue("Source files", summary.totalFiles));
+  console.log(formatKeyValue("Source bytes", formatBytes(summary.totalBytes)));
+  if (summary.datasets.length > 0) {
+    console.log(theme.infoLabel("DATASETS"));
+    for (const dataset of summary.datasets) {
+      console.log(
+        `  ${theme.blue("\u2022")} ${dataset.dataset}: ${dataset.files} file(s), ${formatBytes(dataset.totalBytes)}`
+      );
+    }
+  }
+  printWarnings(summary.warnings);
+  if (summary.nextStep) {
+    console.log(`${theme.infoLabel("NEXT")} ${summary.nextStep}`);
+  }
+  console.log(`${theme.muted("Log file:")} ${resolveLogFilePath(logFilePath)}`);
+}
 
 // src/cli/ui/output/progress.ts
 function createExtractionProgressReporter() {
@@ -9092,8 +10273,9 @@ function createSanitizeProgressReporter() {
         `Validated: ${shortPath(event.validatedPath)}`,
         `Output: ${shortPath(event.outputPath)}`,
         `Datasets: ${event.datasets.join(" > ")}`,
+        `Source encoding: ${event.sourceEncoding} > UTF8`,
         `Files: 0/${formatCount(event.totalFiles)} | Bytes: ${formatBytes(0)} / ${formatBytes(event.totalBytes)}`,
-        `Rows counted: ${formatCount(0)} | NUL removed: ${formatCount(0)}`,
+        `Rows: ${formatCount(0)} | NUL: ${formatCount(0)} | Invalid bytes: ${formatCount(0)} | Controls: ${formatCount(0)}`,
         `Current: waiting...`
       ];
       renderBlock([
@@ -9109,8 +10291,9 @@ function createSanitizeProgressReporter() {
         currentLines[1] ?? "",
         currentLines[2] ?? "",
         currentLines[3] ?? "",
+        currentLines[4] ?? "",
         `Files: ${formatCount(event.fileIndex)}/${formatCount(event.totalFiles)} | Bytes: ${formatBytes(event.bytesProcessed)} / ${formatBytes(event.totalBytes)}`,
-        `Rows counted: ${formatCount(event.processedRows)} | NUL removed: ${formatCount(event.nulBytesRemoved)} | Changed files: ${formatCount(event.changedFiles)}`,
+        `Rows: ${formatCount(event.processedRows)} | NUL: ${formatCount(event.nulBytesRemoved)} | Invalid bytes: ${formatCount(event.invalidBytesRemoved)} | Controls: ${formatCount(event.controlCharsRemoved)} | Changed: ${formatCount(event.changedFiles)}`,
         `Current: ${shortPath(event.currentFileDisplayPath)}`
       ];
       renderBlock([
@@ -9130,6 +10313,18 @@ function createSanitizeProgressReporter() {
     console.log(
       formatKeyValue("Removed NUL bytes", formatCount(event.nulBytesRemoved))
     );
+    console.log(
+      formatKeyValue(
+        "Removed invalid bytes",
+        formatCount(event.invalidBytesRemoved)
+      )
+    );
+    console.log(
+      formatKeyValue(
+        "Removed control chars",
+        formatCount(event.controlCharsRemoved)
+      )
+    );
     console.log(
       formatKeyValue("Changed files", formatCount(event.changedFiles))
     );
@@ -9276,6 +10471,65 @@ function createFederalRevenueDownloadProgressReporter() {
     );
   };
 }
+function createPostgresCsvExportProgressReporter() {
+  return (event) => {
+    if (event.kind === "start") {
+      console.log(
+        theme.infoLabel("POSTGRES"),
+        "Starting PostgreSQL-ready CSV export..."
+      );
+      console.log(formatKeyValue("Input path", event.inputPath));
+      console.log(formatKeyValue("Validated path", event.validatedPath));
+      console.log(formatKeyValue("Output path", event.outputPath));
+      console.log(formatKeyValue("Files queued", event.totalFiles));
+      return;
+    }
+    if (event.kind === "file_finish") {
+      console.log(
+        `${theme.infoLabel("POSTGRES")} ${event.fileIndex}/${event.totalFiles} ${event.dataset} exported with ${formatCount(event.rows)} row(s).`
+      );
+      return;
+    }
+    if (event.kind === "finish") {
+      console.log(
+        theme.successLabel("POSTGRES"),
+        `Exported ${event.totalFiles} file(s) with ${formatCount(event.totalRows)} row(s).`
+      );
+      console.log(formatKeyValue("Output path", event.outputPath));
+      console.log(formatKeyValue("Script path", event.scriptPath));
+    }
+  };
+}
+function createPostgresDirectScriptProgressReporter() {
+  return (event) => {
+    if (event.kind === "start") {
+      console.log(
+        theme.infoLabel("POSTGRES"),
+        "Starting direct PostgreSQL script generation..."
+      );
+      console.log(formatKeyValue("Input path", event.inputPath));
+      console.log(formatKeyValue("Validated path", event.validatedPath));
+      console.log(formatKeyValue("Output path", event.outputPath));
+      console.log(formatKeyValue("Source encoding", event.sourceEncoding));
+      console.log(formatKeyValue("Files queued", event.totalFiles));
+      return;
+    }
+    if (event.kind === "file_registered") {
+      console.log(
+        `${theme.infoLabel("POSTGRES")} ${event.fileIndex}/${event.totalFiles} ${event.dataset} registered (${formatBytes(event.fileSize)}).`
+      );
+      return;
+    }
+    if (event.kind === "finish") {
+      console.log(
+        theme.successLabel("POSTGRES"),
+        `Generated direct import script for ${event.totalFiles} file(s) (${formatBytes(event.totalBytes)}).`
+      );
+      console.log(formatKeyValue("Output path", event.outputPath));
+      console.log(formatKeyValue("Script path", event.scriptPath));
+    }
+  };
+}
 
 // src/cli/ui/output/quarantine.ts
 function printAppliedFilters(summaryFilters) {
@@ -10164,8 +11418,116 @@ function registerQuarantineCommands(program) {
   });
 }
 
+// src/cli/commands/register-postgres.ts
+function registerPostgresCommands(program) {
+  const postgres = program.command("postgres").description(
+    "PostgreSQL-oriented helpers for hybrid loading and database operations."
+  );
+  postgres.command("generate-script").argument(
+    "<input>",
+    "Path to the sanitized dataset directory generated by cnpj-db-loader sanitize."
+  ).option(
+    "--output <path>",
+    "Custom output directory for the generated psql script and manifest."
+  ).option(
+    "--dataset <dataset>",
+    "Generate a script only for one dataset block, for example establishments or companies."
+  ).option(
+    "--script-name <name>",
+    "Generated psql script file name. Defaults to import-postgres-direct.sql."
+  ).option(
+    "--source-encoding <encoding>",
+    "PostgreSQL client encoding used while reading sanitized Receita files. Defaults to UTF8."
+  ).option("-f, --force", "Skip the confirmation prompt.").description(
+    "Generate a direct psql import script that loads sanitized Receita files without rewriting them into new CSV files."
+  ).action(
+    async (input2, options) => {
+      if (!options.force) {
+        const confirmed = await confirm(
+          `Generate a direct PostgreSQL psql import script from ${input2}? This command does not rewrite the source files; it creates only a SQL script and manifest.`
+        );
+        if (!confirmed) {
+          console.log("PostgreSQL direct script generation cancelled.");
+          return;
+        }
+      }
+      const progress = createPostgresDirectScriptProgressReporter();
+      const generateOptions = {
+        onProgress: progress
+      };
+      if (options.output) {
+        generateOptions.outputPath = options.output;
+      }
+      if (options.dataset) {
+        generateOptions.dataset = options.dataset;
+      }
+      if (options.scriptName) {
+        generateOptions.scriptName = options.scriptName;
+      }
+      if (options.sourceEncoding) {
+        generateOptions.sourceEncoding = options.sourceEncoding;
+      }
+      const summary = await generatePostgresDirectScript(
+        input2,
+        generateOptions
+      );
+      const logFilePath = await writeCommandLog(
+        "postgres-generate-script",
+        summary
+      );
+      printPostgresDirectScriptSummary(summary, logFilePath);
+    }
+  );
+  postgres.command("export-csv").argument(
+    "<input>",
+    "Path to the sanitized or validated extracted dataset directory."
+  ).option(
+    "--output <path>",
+    "Custom output directory for PostgreSQL-ready CSV files."
+  ).option(
+    "--dataset <dataset>",
+    "Export only one dataset block, for example establishments or companies."
+  ).option(
+    "--script-name <name>",
+    "Generated psql script file name. Defaults to import-postgres-direct.sql."
+  ).option("-f, --force", "Skip the confirmation prompt.").description(
+    "Convert sanitized Receita files into real PostgreSQL-ready CSV files and generate a direct psql import script."
+  ).action(
+    async (input2, options) => {
+      if (!options.force) {
+        const confirmed = await confirm(
+          `Export PostgreSQL-ready CSV files from ${input2}? This command creates normalized CSV files and a generated psql import script.`
+        );
+        if (!confirmed) {
+          console.log("PostgreSQL CSV export cancelled.");
+          return;
+        }
+      }
+      const progress = createPostgresCsvExportProgressReporter();
+      const exportOptions = {
+        onProgress: progress
+      };
+      if (options.output) {
+        exportOptions.outputPath = options.output;
+      }
+      if (options.dataset) {
+        exportOptions.dataset = options.dataset;
+      }
+      if (options.scriptName) {
+        exportOptions.scriptName = options.scriptName;
+      }
+      const summary = await exportPostgresCsvDataset(input2, exportOptions);
+      const logFilePath = await writeCommandLog(
+        "postgres-export-csv",
+        summary
+      );
+      printPostgresCsvExportSummary(summary, logFilePath);
+    }
+  );
+}
+
 // src/cli/commands/register-schema.ts
-import path16 from "path";
+import path19 from "path";
 function ensureSqlExtension(fileName) {
   return fileName.toLowerCase().endsWith(".sql") ? fileName : `${fileName}.sql`;
 }
@@ -10183,7 +11545,7 @@ function resolveSchemaOutputPath(profile, name, output2) {
   const fileName = ensureSqlExtension(
     name?.trim() || getDefaultSchemaBaseName(profile)
   );
-  return path16.resolve(output2 ?? process.cwd(), fileName);
+  return path19.resolve(output2 ?? process.cwd(), fileName);
 }
 function registerSchemaCommands(program) {
   const schema = program.command("schema").description(
@@ -10225,6 +11587,9 @@ function registerSanitizeCommands(program) {
   ).option(
     "--dataset <dataset>",
     "Sanitize only one validated dataset block (for example: establishments or companies)."
+  ).option(
+    "--source-encoding <encoding>",
+    "Source file encoding used while reading Receita files. Defaults to WIN1252 and writes clean UTF-8 output."
   ).option("-f, --force", "Skip the confirmation prompt.").description(
     "Prepare a sanitized dataset tree before import by removing known low-level byte issues such as NUL bytes."
   ).action(
@@ -10248,6 +11613,9 @@ function registerSanitizeCommands(program) {
       if (options.dataset) {
         sanitizeOptions.dataset = options.dataset;
       }
+      if (options.sourceEncoding) {
+        sanitizeOptions.sourceEncoding = options.sourceEncoding;
+      }
       const summary = await sanitizeInputDirectory(input2, sanitizeOptions);
       const logFilePath = await writeCommandLog("sanitize", summary);
       printSanitizeSummary(summary, logFilePath);
@@ -10270,12 +11638,25 @@ function registerValidateCommands(program) {
 }
 
 // src/cli/shared/app-config.ts
-import { readFileSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { dirname as dirname2, resolve } from "path";
 import { fileURLToPath } from "url";
+function findPackageJsonPath() {
+  let currentDir = dirname2(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 6; depth += 1) {
+    const candidatePath = resolve(currentDir, "package.json");
+    if (existsSync(candidatePath)) {
+      return candidatePath;
+    }
+    currentDir = resolve(currentDir, "..");
+  }
+  return null;
+}
 function getPackageVersion() {
-  const currentDir = dirname2(fileURLToPath(import.meta.url));
-  const packageJsonPath = resolve(currentDir, "../package.json");
+  const packageJsonPath = findPackageJsonPath();
+  if (!packageJsonPath) {
+    return "0.0.0";
+  }
   const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
   return packageJson.version ?? "0.0.0";
 }
@@ -10302,9 +11683,14 @@ ${theme.section("Recommended flow")}
   ${theme.command("cnpj-db-loader database cleanup staging --force")}
   ${theme.command("cnpj-db-loader import ./downloads/<reference>/sanitized")}
 
+${theme.section("Hybrid PostgreSQL path")}
+  ${theme.command("cnpj-db-loader postgres generate-script ./downloads/<reference>/sanitized --output ./downloads/<reference>/postgres-direct --force")}
+  ${theme.command('psql "postgres://user:password@localhost:5432/cnpj" -f ./downloads/<reference>/postgres-direct/import-postgres-direct.sql')}
+
 ${theme.section("Notes")}
   ${theme.muted("Use federal-revenue when you want the CLI to check/download the remote monthly dataset first. Use inspect first when you already have local files.")}
   ${theme.muted("Generate the schema only when you need to create the database structure. Sanitization is the recommended preparation step before recurring imports.")}
+  ${theme.muted("Use postgres generate-script when you want PostgreSQL to run the heavy bulk load directly from sanitized Receita files through a generated psql script.")}
   ${theme.muted("JSON execution logs are written inside the user home directory at ~/.cnpjdbloader/logs with structured level/event metadata.")}
 `;
 }
@@ -10321,6 +11707,7 @@ function buildProgram() {
   registerSchemaCommands(program);
   registerFederalRevenueCommands(program);
   registerDatabaseCommands(program);
+  registerPostgresCommands(program);
   registerImportCommands(program);
   registerQuarantineCommands(program);
   registerDoctorCommands(program);