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

package/dist/index.js

@@ -3269,6 +3269,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,
@@ -3296,6 +3305,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])
@@ -3435,7 +3498,7 @@ function createImportRowNormalizer(input) {
       "cnpj_check_digits"
     )
   }) : null;
-  const buildPartnerDedupeKey = appendPartnerDedupeKey ? createPartnerDedupeKeyBuilder({
+  const buildPartnerDedupeKey2 = appendPartnerDedupeKey ? createPartnerDedupeKeyBuilder({
     cnpjRoot: resolveLayoutColumnIndex(input.layout, "cnpj_root"),
     partnerTypeCode: resolveLayoutColumnIndex(
       input.layout,
@@ -3495,8 +3558,8 @@ function createImportRowNormalizer(input) {
       if (buildEstablishmentCnpjFull) {
         values.push(buildEstablishmentCnpjFull(values));
       }
-      if (buildPartnerDedupeKey) {
-        values.push(buildPartnerDedupeKey(values));
+      if (buildPartnerDedupeKey2) {
+        values.push(buildPartnerDedupeKey2(values));
       }
       return {
         values,
@@ -7790,81 +7853,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 output = [];
+  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;
+    }
+    output.push(char);
+  }
+  return {
+    text: output.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 output = [];
+    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)) {
+          output.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 {
+            output.push(mapped);
+          }
+        } else {
+          controlCharsRemoved += 1;
+        }
+        continue;
+      }
+      output.push(String.fromCharCode(byte));
+    }
+    return {
+      text: output.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(output, value) {
+  if (value.length === 0) {
+    return;
   }
-  if (removed === 0) {
-    return { buffer: chunk, removed: 0 };
+  if (!output.write(value, "utf8")) {
+    await new Promise((resolve, reject) => {
+      output.once("drain", resolve);
+      output.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 input = createReadStream2(plan.absolutePath);
-  const output = createWriteStream2(plan.outputPath);
+  const output = 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(output, text);
+  };
   try {
     for await (const chunk of input) {
       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;
-      output.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 {
     input.close();
     output.end();
-    await new Promise((resolve) => output.on("finish", () => resolve()));
+    await new Promise((resolve, reject) => {
+      output.on("finish", () => resolve());
+      output.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
   };
 }
 
@@ -7927,40 +8173,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,
@@ -7968,7 +8228,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?.({
@@ -7976,6 +8238,8 @@ async function sanitizeInputDirectory(inputPath, options = {}) {
     totalFiles: plan.totalFiles,
     processedRows,
     nulBytesRemoved,
+    invalidBytesRemoved,
+    controlCharsRemoved,
     changedFiles,
     totalBytes: plan.totalBytes
   });
@@ -7987,13 +8251,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)
@@ -8096,6 +8364,852 @@ async function syncFederalRevenueDataset(options = {}) {
     () => runFederalRevenueSyncPipeline(options, check.selectedReference)
   );
 }
+
+// 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/services/postgres-direct/csv.ts
+function formatCsvValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  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/services/postgres-direct/script.ts
+import path15 from "path";
+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 quoteIdentifier(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function normalizePathForPsql(filePath) {
+  return path15.resolve(filePath).replace(/\\/g, "/");
+}
+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 copyStagingSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  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 csvFilesByDataset(files) {
+  const grouped = {};
+  for (const file of files) {
+    const items = grouped[file.dataset] ?? [];
+    items.push(file);
+    grouped[file.dataset] = items;
+  }
+  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 grouped;
+}
+function rawTableName(dataset) {
+  return `tmp_hybrid_raw_${dataset}`;
+}
+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 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')`;
+  }
+  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(input) {
+  const grouped = csvFilesByDataset(input.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(input) {
+  const grouped = directFilesByDataset(input.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 ${input.sourceEncoding} for psql copy operations...'`,
+    `set client_encoding to ${quoteSqlLiteral(input.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(input) {
+  const layout = DATASET_LAYOUTS[input.dataset];
+  const columns = layout.fields.map((field) => field.columnName);
+  await mkdir8(path16.dirname(input.outputFile), { recursive: true });
+  const output = createWriteStream3(input.outputFile, { encoding: "utf8" });
+  let rows = 0;
+  try {
+    output.write(`${formatCsvRow(columns)}
+`);
+    for await (const sourceLine of readImportSourceLines(input.inputFile)) {
+      if (sourceLine.rawLine.trim() === "") {
+        continue;
+      }
+      const parsed = parseImportSourceLine(sourceLine);
+      const normalizedFields = normalizeFieldCount(
+        parsed.fields,
+        layout.fields.length,
+        input.inputFile,
+        parsed.lineNumber
+      );
+      const values = transformRecord(
+        input.dataset,
+        layout,
+        normalizedFields,
+        POSTGRES_DIRECT_SCHEMA_CAPABILITIES,
+        "staging"
+      );
+      output.write(`${formatCsvRow(values)}
+`);
+      rows += 1;
+    }
+  } finally {
+    output.end();
+    await new Promise((resolve, reject) => {
+      output.on("finish", () => resolve());
+      output.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)
+  };
+}
 export {
   AppError,
   DEFAULT_FEDERAL_REVENUE_DOWNLOAD_ROOT,
@@ -8125,8 +9239,10 @@ export {
   ensureDirectory,
   evaluateFederalRevenueManifestFile,
   evaluateFederalRevenueManifestFiles,
+  exportPostgresCsvDataset,
   extractArchives,
   finalizeFederalRevenueManifest,
+  generatePostgresDirectScript,
   generateSchemaSql,
   getAllLayouts,
   getCurrentFederalRevenueReference,