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

package/dist/cli.js

@@ -100,6 +100,222 @@ function getConfigFilePath() {
   return path2.join(os2.homedir(), ".config", "cnpj-db-loader", "config.json");
 }
 
+// src/services/federal-revenue/client.ts
+var DEFAULT_FEDERAL_REVENUE_WEBDAV_URL = "https://arquivos.receitafederal.gov.br/public.php/webdav";
+var DEFAULT_FEDERAL_REVENUE_USER_AGENT = "cnpj-db-loader federal-revenue-client";
+var REFERENCE_PATTERN = /^\d{4}-\d{2}$/;
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/g, "");
+}
+function normalizeBaseUrl(value) {
+  return trimTrailingSlash(value ?? DEFAULT_FEDERAL_REVENUE_WEBDAV_URL);
+}
+function getShareToken(value) {
+  const shareToken = value?.trim();
+  if (!shareToken) {
+    throw new ValidationError(
+      "Federal Revenue public share token is not configured. Run `cnpj-db-loader federal-revenue config set share-token <token>` or pass --share-token."
+    );
+  }
+  return shareToken;
+}
+function encodePathSegment(value) {
+  return encodeURIComponent(value).replace(/%2F/gi, "/");
+}
+function decodeXml(value) {
+  return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+function decodeHrefSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function getAuthHeader(shareToken) {
+  return `Basic ${Buffer.from(`${shareToken}:`).toString("base64")}`;
+}
+function buildUrl(baseUrl, segments = []) {
+  if (segments.length === 0) {
+    return `${baseUrl}/`;
+  }
+  return `${baseUrl}/${segments.map(encodePathSegment).join("/")}`;
+}
+function extractFirst(block, tagName) {
+  const pattern = new RegExp(
+    `<(?:[a-zA-Z0-9_-]+:)?${tagName}\\b[^>]*>([\\s\\S]*?)<\\/(?:[a-zA-Z0-9_-]+:)?${tagName}>`,
+    "i"
+  );
+  const match = block.match(pattern);
+  return match?.[1] ? decodeXml(match[1].trim()) : void 0;
+}
+function isCollectionResponse(block) {
+  return /<(?:[a-zA-Z0-9_-]+:)?collection\b/i.test(block);
+}
+function getNameFromHref(href) {
+  const cleanHref = href.split("?")[0] ?? href;
+  const withoutTrailingSlash = cleanHref.replace(/\/+$/g, "");
+  const rawName = withoutTrailingSlash.split("/").pop() ?? withoutTrailingSlash;
+  return decodeHrefSegment(rawName);
+}
+function parsePropfindXml(xml) {
+  const responseBlocks = xml.match(
+    /<(?:[a-zA-Z0-9_-]+:)?response\b[\s\S]*?<\/(?:[a-zA-Z0-9_-]+:)?response>/gi
+  );
+  if (!responseBlocks) {
+    return [];
+  }
+  return responseBlocks.map((block) => {
+    const href = extractFirst(block, "href");
+    if (!href) {
+      return void 0;
+    }
+    const size = extractFirst(block, "getcontentlength");
+    const parsedSize = size ? Number.parseInt(size, 10) : void 0;
+    const lastModified = extractFirst(block, "getlastmodified");
+    const etag = extractFirst(block, "getetag");
+    return {
+      href,
+      name: getNameFromHref(href),
+      isCollection: isCollectionResponse(block),
+      ...Number.isFinite(parsedSize) ? { sizeInBytes: parsedSize } : {},
+      ...lastModified ? { lastModified } : {},
+      ...etag ? { etag } : {}
+    };
+  }).filter((entry) => entry !== void 0);
+}
+async function propfind(pathSegments, options = {}) {
+  const baseUrl = normalizeBaseUrl(options.baseUrl);
+  const shareToken = getShareToken(options.shareToken);
+  let response;
+  try {
+    response = await fetch(buildUrl(baseUrl, pathSegments), {
+      method: "PROPFIND",
+      headers: {
+        Accept: "application/xml,text/xml,*/*",
+        Authorization: getAuthHeader(shareToken),
+        Depth: "1",
+        "User-Agent": options.userAgent ?? DEFAULT_FEDERAL_REVENUE_USER_AGENT
+      }
+    });
+  } catch (error) {
+    throw new ValidationError(
+      `Federal Revenue WebDAV request failed before receiving a response: ${error instanceof Error ? error.message : String(error)}.`,
+      { baseUrl, pathSegments }
+    );
+  }
+  if (!response.ok) {
+    throw new ValidationError(
+      `Federal Revenue WebDAV request failed with status ${response.status} ${response.statusText}.`,
+      { status: response.status, statusText: response.statusText }
+    );
+  }
+  const xml = await response.text();
+  return {
+    entries: parsePropfindXml(xml),
+    baseUrl,
+    shareToken
+  };
+}
+function validateFederalRevenueReference(reference) {
+  if (!REFERENCE_PATTERN.test(reference)) {
+    throw new ValidationError(
+      `Federal Revenue reference is invalid: ${reference}. Expected YYYY-MM.`
+    );
+  }
+}
+function getCurrentFederalRevenueReference(date = /* @__PURE__ */ new Date()) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  return `${year}-${month}`;
+}
+async function listFederalRevenueReferences(options = {}) {
+  const result = await propfind([], options);
+  const references = result.entries.filter((entry) => entry.isCollection && REFERENCE_PATTERN.test(entry.name)).map((entry) => ({
+    reference: entry.name,
+    href: entry.href
+  })).sort((left, right) => left.reference.localeCompare(right.reference));
+  return {
+    references,
+    remoteBaseUrl: result.baseUrl
+  };
+}
+async function resolveFederalRevenueReference(input2 = {}) {
+  const { references } = await listFederalRevenueReferences(input2);
+  const availableReferences = references.map((item) => item.reference);
+  const latest = availableReferences.at(-1);
+  if (!latest) {
+    throw new ValidationError(
+      "Federal Revenue reference discovery failed: no monthly references were found in the public share."
+    );
+  }
+  if (input2.reference) {
+    validateFederalRevenueReference(input2.reference);
+    if (!availableReferences.includes(input2.reference)) {
+      throw new ValidationError(
+        `Federal Revenue reference not found: ${input2.reference}. Latest available reference is ${latest}.`,
+        {
+          requestedReference: input2.reference,
+          latestAvailableReference: latest,
+          availableReferences
+        }
+      );
+    }
+    return {
+      mode: "explicit",
+      selectedReference: input2.reference,
+      availableReferences
+    };
+  }
+  if (input2.current) {
+    const currentReference = getCurrentFederalRevenueReference();
+    if (!availableReferences.includes(currentReference)) {
+      throw new ValidationError(
+        `Federal Revenue current reference is not available yet: ${currentReference}. Latest available reference is ${latest}.`,
+        {
+          requestedReference: currentReference,
+          latestAvailableReference: latest,
+          availableReferences
+        }
+      );
+    }
+    return {
+      mode: "current",
+      selectedReference: currentReference,
+      availableReferences
+    };
+  }
+  return {
+    mode: "latest",
+    selectedReference: latest,
+    availableReferences
+  };
+}
+async function listFederalRevenueFiles(reference, options = {}) {
+  validateFederalRevenueReference(reference);
+  const result = await propfind([reference], options);
+  const files = result.entries.filter(
+    (entry) => !entry.isCollection && entry.name.toLowerCase().endsWith(".zip")
+  ).map((entry) => ({
+    name: entry.name,
+    href: entry.href,
+    downloadUrl: buildUrl(result.baseUrl, [reference, entry.name]),
+    ...entry.sizeInBytes !== void 0 ? { sizeInBytes: entry.sizeInBytes } : {},
+    ...entry.lastModified ? { lastModified: entry.lastModified } : {},
+    ...entry.etag ? { etag: entry.etag } : {}
+  })).sort((left, right) => left.name.localeCompare(right.name));
+  return {
+    files,
+    remoteBaseUrl: result.baseUrl
+  };
+}
+function buildFederalRevenueDownloadHeaders(options = {}) {
+  return {
+    Authorization: getAuthHeader(getShareToken(options.shareToken)),
+    "User-Agent": options.userAgent ?? DEFAULT_FEDERAL_REVENUE_USER_AGENT
+  };
+}
+
 // src/services/config.service.ts
 async function readDatabaseConfig() {
   const raw = await safeReadText(getConfigFilePath());
@@ -127,12 +343,149 @@ function assertPostgresUrl(url) {
     );
   }
 }
+function assertHttpUrl(url, label) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new ValidationError(`${label} is not a valid URL.`, { url });
+  }
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new ValidationError(`${label} must use the http or https protocol.`, {
+      url
+    });
+  }
+}
+function assertNonEmpty(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new ValidationError(`${label} cannot be empty.`);
+  }
+  return trimmed;
+}
+function normalizeFederalRevenueConfigKey(key) {
+  const normalized = key.trim().toLowerCase();
+  if (["share-token", "share_token", "token"].includes(normalized)) {
+    return "share-token";
+  }
+  if (["webdav-url", "webdav_url", "base-url", "base_url", "url"].includes(
+    normalized
+  )) {
+    return "webdav-url";
+  }
+  if (["user-agent", "user_agent"].includes(normalized)) {
+    return "user-agent";
+  }
+  throw new ValidationError(
+    `Unknown Federal Revenue config key: ${key}. Expected share-token, webdav-url, or user-agent.`
+  );
+}
+function assignFederalRevenueConfigValue(config, key, value) {
+  if (key === "share-token") {
+    return {
+      ...config,
+      shareToken: assertNonEmpty(value, "Federal Revenue share token")
+    };
+  }
+  if (key === "webdav-url") {
+    const webdavUrl = assertNonEmpty(value, "Federal Revenue WebDAV URL");
+    assertHttpUrl(webdavUrl, "Federal Revenue WebDAV URL");
+    return { ...config, webdavUrl };
+  }
+  return {
+    ...config,
+    userAgent: assertNonEmpty(value, "Federal Revenue user agent")
+  };
+}
+function deleteFederalRevenueConfigValue(config, key) {
+  const nextConfig = { ...config };
+  if (key === "share-token") {
+    delete nextConfig.shareToken;
+  }
+  if (key === "webdav-url") {
+    delete nextConfig.webdavUrl;
+  }
+  if (key === "user-agent") {
+    delete nextConfig.userAgent;
+  }
+  return nextConfig;
+}
+function isFederalRevenueConfigEmpty(config) {
+  return !config.shareToken && !config.webdavUrl && !config.userAgent;
+}
 async function setDefaultDbUrl(url) {
   assertPostgresUrl(url);
-  await writeDatabaseConfig({ defaultDbUrl: url });
+  const currentConfig = await readDatabaseConfig();
+  await writeDatabaseConfig({ ...currentConfig, defaultDbUrl: url });
 }
 async function resetDefaultDbUrl() {
-  await writeDatabaseConfig({});
+  const currentConfig = await readDatabaseConfig();
+  const nextConfig = { ...currentConfig };
+  delete nextConfig.defaultDbUrl;
+  await writeDatabaseConfig(nextConfig);
+}
+async function setFederalRevenueConfigValue(key, value) {
+  const normalizedKey = normalizeFederalRevenueConfigKey(key);
+  const currentConfig = await readDatabaseConfig();
+  const federalRevenueConfig = assignFederalRevenueConfigValue(
+    currentConfig.federalRevenue ?? {},
+    normalizedKey,
+    value
+  );
+  await writeDatabaseConfig({
+    ...currentConfig,
+    federalRevenue: federalRevenueConfig
+  });
+  return getFederalRevenueEffectiveConfig(federalRevenueConfig);
+}
+async function resetFederalRevenueConfig(key) {
+  const currentConfig = await readDatabaseConfig();
+  if (!key) {
+    const nextConfig2 = { ...currentConfig };
+    delete nextConfig2.federalRevenue;
+    await writeDatabaseConfig(nextConfig2);
+    return getFederalRevenueEffectiveConfig({});
+  }
+  const normalizedKey = normalizeFederalRevenueConfigKey(key);
+  const federalRevenueConfig = deleteFederalRevenueConfigValue(
+    currentConfig.federalRevenue ?? {},
+    normalizedKey
+  );
+  const nextConfig = { ...currentConfig };
+  if (isFederalRevenueConfigEmpty(federalRevenueConfig)) {
+    delete nextConfig.federalRevenue;
+  } else {
+    nextConfig.federalRevenue = federalRevenueConfig;
+  }
+  await writeDatabaseConfig(nextConfig);
+  return getFederalRevenueEffectiveConfig(federalRevenueConfig);
+}
+function getFederalRevenueEffectiveConfig(config = {}) {
+  return {
+    webdavUrl: config.webdavUrl ?? DEFAULT_FEDERAL_REVENUE_WEBDAV_URL,
+    userAgent: config.userAgent ?? DEFAULT_FEDERAL_REVENUE_USER_AGENT,
+    ...config.shareToken ? { shareToken: config.shareToken } : {},
+    configured: {
+      webdavUrl: Boolean(config.webdavUrl),
+      userAgent: Boolean(config.userAgent),
+      shareToken: Boolean(config.shareToken)
+    }
+  };
+}
+async function readFederalRevenueEffectiveConfig() {
+  const currentConfig = await readDatabaseConfig();
+  return getFederalRevenueEffectiveConfig(currentConfig.federalRevenue ?? {});
+}
+async function resolveFederalRevenueClientOptions(overrides = {}) {
+  const currentConfig = await readDatabaseConfig();
+  const effectiveConfig = getFederalRevenueEffectiveConfig(
+    currentConfig.federalRevenue ?? {}
+  );
+  return {
+    baseUrl: overrides.baseUrl ?? effectiveConfig.webdavUrl,
+    shareToken: overrides.shareToken ?? effectiveConfig.shareToken,
+    userAgent: overrides.userAgent ?? effectiveConfig.userAgent
+  };
 }
 
 // src/services/database.service.ts
@@ -6685,217 +7038,6 @@ async function showQuarantineRow(id, options) {
   return record;
 }
 
-// src/services/federal-revenue/client.ts
-var DEFAULT_FEDERAL_REVENUE_SHARE_TOKEN = "YggdBLfdninEJX9";
-var DEFAULT_FEDERAL_REVENUE_WEBDAV_URL = "https://arquivos.receitafederal.gov.br/public.php/webdav";
-var DEFAULT_FEDERAL_REVENUE_USER_AGENT = "cnpj-db-loader federal-revenue-client";
-var REFERENCE_PATTERN = /^\d{4}-\d{2}$/;
-function trimTrailingSlash(value) {
-  return value.replace(/\/+$/g, "");
-}
-function normalizeBaseUrl(value) {
-  return trimTrailingSlash(value ?? DEFAULT_FEDERAL_REVENUE_WEBDAV_URL);
-}
-function getShareToken(value) {
-  return value ?? DEFAULT_FEDERAL_REVENUE_SHARE_TOKEN;
-}
-function encodePathSegment(value) {
-  return encodeURIComponent(value).replace(/%2F/gi, "/");
-}
-function decodeXml(value) {
-  return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
-}
-function decodeHrefSegment(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-function getAuthHeader(shareToken) {
-  return `Basic ${Buffer.from(`${shareToken}:`).toString("base64")}`;
-}
-function buildUrl(baseUrl, segments = []) {
-  if (segments.length === 0) {
-    return `${baseUrl}/`;
-  }
-  return `${baseUrl}/${segments.map(encodePathSegment).join("/")}`;
-}
-function extractFirst(block, tagName) {
-  const pattern = new RegExp(
-    `<(?:[a-zA-Z0-9_-]+:)?${tagName}\\b[^>]*>([\\s\\S]*?)<\\/(?:[a-zA-Z0-9_-]+:)?${tagName}>`,
-    "i"
-  );
-  const match = block.match(pattern);
-  return match?.[1] ? decodeXml(match[1].trim()) : void 0;
-}
-function isCollectionResponse(block) {
-  return /<(?:[a-zA-Z0-9_-]+:)?collection\b/i.test(block);
-}
-function getNameFromHref(href) {
-  const cleanHref = href.split("?")[0] ?? href;
-  const withoutTrailingSlash = cleanHref.replace(/\/+$/g, "");
-  const rawName = withoutTrailingSlash.split("/").pop() ?? withoutTrailingSlash;
-  return decodeHrefSegment(rawName);
-}
-function parsePropfindXml(xml) {
-  const responseBlocks = xml.match(
-    /<(?:[a-zA-Z0-9_-]+:)?response\b[\s\S]*?<\/(?:[a-zA-Z0-9_-]+:)?response>/gi
-  );
-  if (!responseBlocks) {
-    return [];
-  }
-  return responseBlocks.map((block) => {
-    const href = extractFirst(block, "href");
-    if (!href) {
-      return void 0;
-    }
-    const size = extractFirst(block, "getcontentlength");
-    const parsedSize = size ? Number.parseInt(size, 10) : void 0;
-    const lastModified = extractFirst(block, "getlastmodified");
-    const etag = extractFirst(block, "getetag");
-    return {
-      href,
-      name: getNameFromHref(href),
-      isCollection: isCollectionResponse(block),
-      ...Number.isFinite(parsedSize) ? { sizeInBytes: parsedSize } : {},
-      ...lastModified ? { lastModified } : {},
-      ...etag ? { etag } : {}
-    };
-  }).filter((entry) => entry !== void 0);
-}
-async function propfind(pathSegments, options = {}) {
-  const baseUrl = normalizeBaseUrl(options.baseUrl);
-  const shareToken = getShareToken(options.shareToken);
-  let response;
-  try {
-    response = await fetch(buildUrl(baseUrl, pathSegments), {
-      method: "PROPFIND",
-      headers: {
-        Accept: "application/xml,text/xml,*/*",
-        Authorization: getAuthHeader(shareToken),
-        Depth: "1",
-        "User-Agent": options.userAgent ?? DEFAULT_FEDERAL_REVENUE_USER_AGENT
-      }
-    });
-  } catch (error) {
-    throw new ValidationError(
-      `Federal Revenue WebDAV request failed before receiving a response: ${error instanceof Error ? error.message : String(error)}.`,
-      { baseUrl, pathSegments }
-    );
-  }
-  if (!response.ok) {
-    throw new ValidationError(
-      `Federal Revenue WebDAV request failed with status ${response.status} ${response.statusText}.`,
-      { status: response.status, statusText: response.statusText }
-    );
-  }
-  const xml = await response.text();
-  return {
-    entries: parsePropfindXml(xml),
-    baseUrl,
-    shareToken
-  };
-}
-function validateFederalRevenueReference(reference) {
-  if (!REFERENCE_PATTERN.test(reference)) {
-    throw new ValidationError(
-      `Federal Revenue reference is invalid: ${reference}. Expected YYYY-MM.`
-    );
-  }
-}
-function getCurrentFederalRevenueReference(date = /* @__PURE__ */ new Date()) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  return `${year}-${month}`;
-}
-async function listFederalRevenueReferences(options = {}) {
-  const result = await propfind([], options);
-  const references = result.entries.filter((entry) => entry.isCollection && REFERENCE_PATTERN.test(entry.name)).map((entry) => ({
-    reference: entry.name,
-    href: entry.href
-  })).sort((left, right) => left.reference.localeCompare(right.reference));
-  return {
-    references,
-    remoteBaseUrl: result.baseUrl
-  };
-}
-async function resolveFederalRevenueReference(input2 = {}) {
-  const { references } = await listFederalRevenueReferences(input2);
-  const availableReferences = references.map((item) => item.reference);
-  const latest = availableReferences.at(-1);
-  if (!latest) {
-    throw new ValidationError(
-      "Federal Revenue reference discovery failed: no monthly references were found in the public share."
-    );
-  }
-  if (input2.reference) {
-    validateFederalRevenueReference(input2.reference);
-    if (!availableReferences.includes(input2.reference)) {
-      throw new ValidationError(
-        `Federal Revenue reference not found: ${input2.reference}. Latest available reference is ${latest}.`,
-        {
-          requestedReference: input2.reference,
-          latestAvailableReference: latest,
-          availableReferences
-        }
-      );
-    }
-    return {
-      mode: "explicit",
-      selectedReference: input2.reference,
-      availableReferences
-    };
-  }
-  if (input2.current) {
-    const currentReference = getCurrentFederalRevenueReference();
-    if (!availableReferences.includes(currentReference)) {
-      throw new ValidationError(
-        `Federal Revenue current reference is not available yet: ${currentReference}. Latest available reference is ${latest}.`,
-        {
-          requestedReference: currentReference,
-          latestAvailableReference: latest,
-          availableReferences
-        }
-      );
-    }
-    return {
-      mode: "current",
-      selectedReference: currentReference,
-      availableReferences
-    };
-  }
-  return {
-    mode: "latest",
-    selectedReference: latest,
-    availableReferences
-  };
-}
-async function listFederalRevenueFiles(reference, options = {}) {
-  validateFederalRevenueReference(reference);
-  const result = await propfind([reference], options);
-  const files = result.entries.filter(
-    (entry) => !entry.isCollection && entry.name.toLowerCase().endsWith(".zip")
-  ).map((entry) => ({
-    name: entry.name,
-    href: entry.href,
-    downloadUrl: buildUrl(result.baseUrl, [reference, entry.name]),
-    ...entry.sizeInBytes !== void 0 ? { sizeInBytes: entry.sizeInBytes } : {},
-    ...entry.lastModified ? { lastModified: entry.lastModified } : {},
-    ...entry.etag ? { etag: entry.etag } : {}
-  })).sort((left, right) => left.name.localeCompare(right.name));
-  return {
-    files,
-    remoteBaseUrl: result.baseUrl
-  };
-}
-function buildFederalRevenueDownloadHeaders(options = {}) {
-  return {
-    Authorization: getAuthHeader(getShareToken(options.shareToken)),
-    "User-Agent": options.userAgent ?? DEFAULT_FEDERAL_REVENUE_USER_AGENT
-  };
-}
-
 // src/services/federal-revenue/download.ts
 import { createWriteStream } from "fs";
 import { mkdir as mkdir5, rename, stat as stat5, unlink } from "fs/promises";
@@ -8379,6 +8521,18 @@ var STAGING_TABLE_BY_DATASET3 = {
   partners: "staging_partners",
   simples_options: "staging_simples_options"
 };
+var STEP_ORDER = [
+  "setup",
+  "load-domains",
+  "load-companies",
+  "load-establishments",
+  "load-partners",
+  "load-simples",
+  "materialize",
+  "materialize-secondary-cnaes",
+  "indexes",
+  "analyze"
+];
 function quoteSqlLiteral(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
@@ -8396,6 +8550,9 @@ 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 echo(message) {
+  return `\\echo ${quoteSqlLiteral(message)}`;
+}
 function datasetColumns(dataset) {
   return DATASET_LAYOUTS[dataset].fields.map((field) => field.columnName);
 }
@@ -8422,7 +8579,7 @@ function partnerDedupeExpression(alias) {
 function materializeCompaniesSql() {
   const columns = companiesLayout.fields.map((field) => field.columnName);
   return [
-    "\\echo 'Materializing companies...'",
+    echo("[materialize] Materializing companies..."),
     "with source as (",
     "  select",
     `    ${columns.map((column) => `source.${column}`).join(",\n    ")},`,
@@ -8436,7 +8593,8 @@ function materializeCompaniesSql() {
     `select ${columns.join(", ")}`,
     "from deduped",
     "on conflict (cnpj_root) do update set",
-    `  ${updateAssignments(columns, ["cnpj_root"])};`
+    `  ${updateAssignments(columns, ["cnpj_root"])};`,
+    echo("[materialize] Companies materialization completed.")
   ].join("\n");
 }
 function materializeEstablishmentsSql() {
@@ -8445,7 +8603,7 @@ function materializeEstablishmentsSql() {
   );
   const insertColumns = [...baseColumns, "cnpj_full"];
   return [
-    "\\echo 'Materializing establishments and secondary CNAEs...'",
+    echo("[materialize] Materializing establishments..."),
     "with source as (",
     "  select",
     `    ${baseColumns.map((column) => `source.${column}`).join(",\n    ")},`,
@@ -8455,14 +8613,29 @@ function materializeEstablishmentsSql() {
     "),",
     "deduped as (",
     "  select * from source where dedupe_rank = 1",
+    ")",
+    `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"])};`,
+    echo("[materialize] Establishments materialization completed.")
+  ].join("\n");
+}
+function materializeSecondaryCnaesSql() {
+  return [
+    echo(
+      "[materialize-secondary-cnaes] Materializing establishment secondary CNAEs..."
+    ),
+    "with source as (",
+    "  select",
+    "    staging.cnpj_root || staging.cnpj_order || staging.cnpj_check_digits as cnpj_full,",
+    "    staging.secondary_cnaes_raw,",
+    "    row_number() over (partition by staging.cnpj_root || staging.cnpj_order || staging.cnpj_check_digits order by staging.staging_id desc) as dedupe_rank",
+    "  from staging_establishments staging",
     "),",
-    "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",
+    "deduped as (",
+    "  select * from source where dedupe_rank = 1",
     "),",
     "deleted_secondary_cnaes as (",
     "  delete from establishment_secondary_cnaes target",
@@ -8483,14 +8656,17 @@ function materializeEstablishmentsSql() {
     "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;"
+    "on conflict (cnpj_full, cnae_code) do nothing;",
+    echo(
+      "[materialize-secondary-cnaes] Secondary CNAEs materialization completed."
+    )
   ].join("\n");
 }
 function materializePartnersSql() {
   const baseColumns = partnersLayout.fields.map((field) => field.columnName);
   const insertColumns = [...baseColumns, "partner_dedupe_key"];
   return [
-    "\\echo 'Materializing partners...'",
+    echo("[materialize] Materializing partners..."),
     "with source as (",
     "  select",
     `    ${baseColumns.map((column) => `source.${column}`).join(",\n    ")},`,
@@ -8510,13 +8686,14 @@ function materializePartnersSql() {
     `select ${insertColumns.join(", ")}`,
     "from deduped",
     "on conflict (partner_dedupe_key) do update set",
-    `  ${updateAssignments(insertColumns, ["partner_dedupe_key"])};`
+    `  ${updateAssignments(insertColumns, ["partner_dedupe_key"])};`,
+    echo("[materialize] Partners materialization completed.")
   ].join("\n");
 }
 function materializeSimplesSql() {
   const columns = simplesLayout.fields.map((field) => field.columnName);
   return [
-    "\\echo 'Materializing simples options...'",
+    echo("[materialize] Materializing simples options..."),
     "with source as (",
     "  select",
     `    ${columns.map((column) => `source.${column}`).join(",\n    ")},`,
@@ -8530,7 +8707,8 @@ function materializeSimplesSql() {
     `select ${columns.join(", ")}`,
     "from deduped",
     "on conflict (cnpj_root) do update set",
-    `  ${updateAssignments(columns, ["cnpj_root"])};`
+    `  ${updateAssignments(columns, ["cnpj_root"])};`,
+    echo("[materialize] Simples options materialization completed.")
   ].join("\n");
 }
 function copyDomainSql(dataset, files) {
@@ -8540,12 +8718,20 @@ function copyDomainSql(dataset, files) {
   const columns = datasetColumns(dataset);
   const tempTable = `tmp_hybrid_${dataset}`;
   const lines = [
-    `\\echo 'Loading ${dataset} lookup data...'`,
+    echo(`[load-domains] 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));
+  for (const [index, file] of files.entries()) {
+    lines.push(
+      echo(
+        `[load-domains] Loading ${dataset} file ${index + 1} of ${files.length}: ${file.relativePath}`
+      ),
+      csvCopyCommand(tempTable, columns, file.absolutePath),
+      echo(
+        `[load-domains] Loaded ${dataset} file ${index + 1} of ${files.length}.`
+      )
+    );
   }
   lines.push(
     `insert into ${dataset} (${columns.join(", ")})`,
@@ -8566,12 +8752,17 @@ function copyStagingSql(dataset, files) {
     return [];
   }
   const columns = datasetColumns(dataset);
-  return [
-    `\\echo 'Loading ${dataset} staging data...'`,
-    ...files.map(
-      (file) => csvCopyCommand(tableName, columns, file.absolutePath)
-    )
-  ];
+  const lines = [echo(`[load-${dataset}] Loading ${dataset} staging data...`)];
+  for (const [index, file] of files.entries()) {
+    lines.push(
+      echo(
+        `[load-${dataset}] Loading file ${index + 1} of ${files.length}: ${file.relativePath}`
+      ),
+      csvCopyCommand(tableName, columns, file.absolutePath),
+      echo(`[load-${dataset}] Loaded file ${index + 1} of ${files.length}.`)
+    );
+  }
+  return lines;
 }
 function csvFilesByDataset(files) {
   const grouped = {};
@@ -8597,7 +8788,9 @@ function rawTableName(dataset) {
 function createRawTempTableSql(dataset) {
   const columns = DATASET_LAYOUTS[dataset].fields.map((field) => `  ${quoteIdentifier(field.columnName)} text`).join(",\n");
   return [
+    "set client_min_messages to warning;",
     `drop table if exists ${rawTableName(dataset)};`,
+    "reset client_min_messages;",
     `create temporary table ${rawTableName(dataset)} (`,
     columns,
     ");"
@@ -8679,11 +8872,21 @@ function rawDomainSql(dataset, files) {
   const columns = layout.fields.map((field) => field.columnName);
   const tableName = rawTableName(dataset);
   const lines = [
-    `\\echo 'Loading ${dataset} lookup data directly from sanitized Receita files...'`,
+    echo(
+      `[load-domains] Loading ${dataset} lookup data directly from sanitized Receita files...`
+    ),
     createRawTempTableSql(dataset)
   ];
-  for (const file of files) {
-    lines.push(receitaCopyCommand(tableName, columns, file.absolutePath));
+  for (const [index, file] of files.entries()) {
+    lines.push(
+      echo(
+        `[load-domains] Loading ${dataset} file ${index + 1} of ${files.length}: ${file.relativePath}`
+      ),
+      receitaCopyCommand(tableName, columns, file.absolutePath),
+      echo(
+        `[load-domains] Loaded ${dataset} file ${index + 1} of ${files.length}.`
+      )
+    );
   }
   lines.push(
     `insert into ${dataset} (${columns.join(", ")})`,
@@ -8693,7 +8896,8 @@ function rawDomainSql(dataset, files) {
     `from ${tableName}`,
     "where nullif(btrim(code), '') is not null",
     "order by code",
-    "on conflict (code) do update set description = excluded.description;"
+    "on conflict (code) do update set description = excluded.description;",
+    echo(`[load-domains] ${dataset} lookup data completed.`)
   );
   return lines;
 }
@@ -8712,70 +8916,363 @@ function rawStagingSql(dataset, files) {
   const expressions = layout.fields.map(
     (field) => `  ${fieldExpression(dataset, field, alias)} as ${field.columnName}`
   );
+  const stepName = loadStepName(dataset);
   const lines = [
-    `\\echo 'Loading ${dataset} staging data directly from sanitized Receita files...'`,
+    echo(
+      `[${stepName}] Loading ${dataset} staging data directly from sanitized Receita files...`
+    ),
+    `truncate table ${targetTable} restart identity;`,
     createRawTempTableSql(dataset)
   ];
-  for (const file of files) {
-    lines.push(receitaCopyCommand(tableName, columns, file.absolutePath));
+  for (const [index, file] of files.entries()) {
+    lines.push(
+      echo(
+        `[${stepName}] Loading file ${index + 1} of ${files.length}: ${file.relativePath}`
+      ),
+      receitaCopyCommand(tableName, columns, file.absolutePath),
+      echo(`[${stepName}] Loaded file ${index + 1} of ${files.length}.`)
+    );
   }
   lines.push(
+    echo(
+      `[${stepName}] Transforming ${dataset} raw rows into ${targetTable}...`
+    ),
     `insert into ${targetTable} (${columns.join(", ")})`,
     "select",
     expressions.join(",\n"),
-    `from ${tableName} ${alias};`
+    `from ${tableName} ${alias};`,
+    echo(`[${stepName}] ${dataset} staging load completed.`)
   );
   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',
-    "",
+function loadStepName(dataset) {
+  switch (dataset) {
+    case "companies":
+      return "load-companies";
+    case "establishments":
+      return "load-establishments";
+    case "partners":
+      return "load-partners";
+    case "simples_options":
+      return "load-simples";
+    default:
+      return `load-${dataset}`;
+  }
+}
+function scriptHeader(title, sourceEncoding) {
+  return [
+    `-- ${title}`,
+    "-- Generated by cnpj-db-loader postgres generate-script.",
     "\\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;",
+    ...sourceEncoding ? [
+      echo(
+        `Using source file encoding ${sourceEncoding} for psql copy operations...`
+      ),
+      `set client_encoding to ${quoteSqlLiteral(sourceEncoding)};`
+    ] : [],
     ""
   ];
-  for (const dataset of DOMAIN_DATASETS) {
-    lines.push(...copyDomainSql(dataset, grouped[dataset] ?? []), "");
+}
+function wrapTransaction(lines, mode, shouldWrap) {
+  if (!shouldWrap || mode !== "phase") {
+    return [...lines];
   }
-  for (const dataset of STAGING_DATASETS) {
-    lines.push(...copyStagingSql(dataset, grouped[dataset] ?? []), "");
+  return ["begin;", "", ...lines, "", "commit;"];
+}
+function buildStepScript(title, body, input2, wrapInPhaseTransaction) {
+  return [
+    ...scriptHeader(title, input2.sourceEncoding),
+    ...wrapTransaction(body, input2.transactionMode, wrapInPhaseTransaction),
+    ""
+  ].join("\n");
+}
+function includeSet(input2) {
+  const selected = new Set(input2.include);
+  if (input2.skipIndexes) {
+    selected.delete("indexes");
   }
-  lines.push(...materializationAndAnalyzeSql());
-  return lines.join("\n");
+  if (input2.skipAnalyze) {
+    selected.delete("analyze");
+  }
+  return selected;
+}
+function hasAnyFinalMaterialization(selected) {
+  return selected.has("companies") || selected.has("establishments") || selected.has("partners") || selected.has("simples");
 }
-function generatePostgresSanitizedDirectImportScript(input2) {
+function materializeSql(selected) {
+  const lines = [echo("[materialize] Starting final table materialization...")];
+  if (selected.has("companies")) {
+    lines.push(materializeCompaniesSql(), "");
+  }
+  if (selected.has("establishments")) {
+    lines.push(materializeEstablishmentsSql(), "");
+  }
+  if (selected.has("partners")) {
+    lines.push(materializePartnersSql(), "");
+  }
+  if (selected.has("simples")) {
+    lines.push(materializeSimplesSql(), "");
+  }
+  lines.push(echo("[materialize] Final table materialization completed."));
+  return lines;
+}
+function indexesSql() {
+  return [
+    echo(
+      "[indexes] No additional index operations are generated in this beta."
+    ),
+    "-- Indexes are expected to be managed by the schema generated by cnpj-db-loader schema generate.",
+    "-- A future fast-rebuild mode may generate DROP/CREATE INDEX operations here."
+  ];
+}
+function analyzeSql(selected) {
+  const tables = /* @__PURE__ */ new Set();
+  if (selected.has("companies")) {
+    tables.add("companies");
+  }
+  if (selected.has("establishments")) {
+    tables.add("establishments");
+  }
+  if (selected.has("secondary-cnaes")) {
+    tables.add("establishment_secondary_cnaes");
+  }
+  if (selected.has("partners")) {
+    tables.add("partners");
+  }
+  if (selected.has("simples")) {
+    tables.add("simples_options");
+  }
+  if (selected.has("domains")) {
+    for (const dataset of DOMAIN_DATASETS) {
+      tables.add(dataset);
+    }
+  }
+  return [
+    echo("[analyze] Refreshing planner statistics..."),
+    ...[...tables].map((table) => `analyze ${table};`),
+    echo("[analyze] Planner statistics refreshed.")
+  ];
+}
+function step(name, file, dependsOn, included) {
+  return { name, file, dependsOn, included };
+}
+function generatePostgresDirectScriptFiles(input2) {
   const grouped = directFilesByDataset(input2.files);
-  const lines = [
-    "-- CNPJ DB Loader direct PostgreSQL import script",
+  const selected = includeSet(input2);
+  if (!DOMAIN_DATASETS.some((dataset) => (grouped[dataset] ?? []).length > 0)) {
+    selected.delete("domains");
+  }
+  if ((grouped.companies ?? []).length === 0) {
+    selected.delete("companies");
+  }
+  if ((grouped.establishments ?? []).length === 0) {
+    selected.delete("establishments");
+    selected.delete("secondary-cnaes");
+  }
+  if ((grouped.partners ?? []).length === 0) {
+    selected.delete("partners");
+  }
+  if ((grouped.simples_options ?? []).length === 0) {
+    selected.delete("simples");
+  }
+  const scripts = {};
+  const steps = [];
+  const setupIncluded = true;
+  steps.push(step("setup", "setup.sql", [], setupIncluded));
+  scripts["setup.sql"] = [
+    ...scriptHeader(
+      "CNPJ DB Loader PostgreSQL direct import setup",
+      input2.sourceEncoding
+    ),
+    echo("[setup] Preparing PostgreSQL direct import session..."),
+    "-- The database schema must be applied before running these scripts.",
+    "-- This setup script configures the psql session used by the generated orchestrator.",
+    echo("[setup] Setup completed."),
+    ""
+  ].join("\n");
+  const domainsIncluded = selected.has("domains") && DOMAIN_DATASETS.some((dataset) => (grouped[dataset] ?? []).length > 0);
+  steps.push(
+    step("load-domains", "load-domains.sql", ["setup"], domainsIncluded)
+  );
+  if (domainsIncluded) {
+    const lines = [echo("[load-domains] Starting domain tables load...")];
+    for (const dataset of DOMAIN_DATASETS) {
+      lines.push(...rawDomainSql(dataset, grouped[dataset] ?? []), "");
+    }
+    lines.push(echo("[load-domains] Domain tables load completed."));
+    scripts["load-domains.sql"] = buildStepScript(
+      "CNPJ DB Loader PostgreSQL direct import domains step",
+      lines,
+      input2,
+      true
+    );
+  }
+  const datasetSteps = [
+    {
+      dataset: "companies",
+      name: "load-companies",
+      file: "load-companies.sql",
+      include: "companies"
+    },
+    {
+      dataset: "establishments",
+      name: "load-establishments",
+      file: "load-establishments.sql",
+      include: "establishments"
+    },
+    {
+      dataset: "partners",
+      name: "load-partners",
+      file: "load-partners.sql",
+      include: "partners"
+    },
+    {
+      dataset: "simples_options",
+      name: "load-simples",
+      file: "load-simples.sql",
+      include: "simples"
+    }
+  ];
+  for (const item of datasetSteps) {
+    const files = grouped[item.dataset] ?? [];
+    const included = selected.has(item.include) && files.length > 0;
+    steps.push(step(item.name, item.file, ["setup"], included));
+    if (included) {
+      scripts[item.file] = buildStepScript(
+        `CNPJ DB Loader PostgreSQL direct import ${item.name} step`,
+        rawStagingSql(item.dataset, files),
+        input2,
+        true
+      );
+    }
+  }
+  const materializeIncluded = hasAnyFinalMaterialization(selected);
+  steps.push(
+    step(
+      "materialize",
+      "materialize.sql",
+      datasetSteps.filter((item) => selected.has(item.include)).map((item) => item.name),
+      materializeIncluded
+    )
+  );
+  if (materializeIncluded) {
+    scripts["materialize.sql"] = buildStepScript(
+      "CNPJ DB Loader PostgreSQL direct import materialization step",
+      materializeSql(selected),
+      input2,
+      true
+    );
+  }
+  const secondaryIncluded = selected.has("secondary-cnaes") && selected.has("establishments");
+  steps.push(
+    step(
+      "materialize-secondary-cnaes",
+      "materialize-secondary-cnaes.sql",
+      ["load-establishments"],
+      secondaryIncluded
+    )
+  );
+  if (secondaryIncluded) {
+    scripts["materialize-secondary-cnaes.sql"] = buildStepScript(
+      "CNPJ DB Loader PostgreSQL direct import secondary CNAEs step",
+      [materializeSecondaryCnaesSql()],
+      input2,
+      true
+    );
+  }
+  const indexesIncluded = selected.has("indexes");
+  steps.push(
+    step(
+      "indexes",
+      "indexes.sql",
+      materializeIncluded ? ["materialize"] : ["setup"],
+      indexesIncluded
+    )
+  );
+  if (indexesIncluded) {
+    scripts["indexes.sql"] = buildStepScript(
+      "CNPJ DB Loader PostgreSQL direct import indexes step",
+      indexesSql(),
+      input2,
+      true
+    );
+  }
+  const analyzeIncluded = selected.has("analyze");
+  const analyzeDependencies = [
+    ...domainsIncluded ? ["load-domains"] : [],
+    ...materializeIncluded ? ["materialize"] : [],
+    ...secondaryIncluded ? ["materialize-secondary-cnaes"] : []
+  ];
+  steps.push(
+    step(
+      "analyze",
+      "analyze.sql",
+      analyzeDependencies.length > 0 ? analyzeDependencies : ["setup"],
+      analyzeIncluded
+    )
+  );
+  if (analyzeIncluded) {
+    scripts["analyze.sql"] = buildStepScript(
+      "CNPJ DB Loader PostgreSQL direct import analyze step",
+      analyzeSql(selected),
+      input2,
+      true
+    );
+  }
+  const orchestratorLines = [
+    "-- CNPJ DB Loader direct PostgreSQL import orchestrator",
     "-- 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',
+    '--   psql -d "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...'`,
+    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...'",
+    echo(
+      `Starting CNPJ DB Loader direct PostgreSQL import using transaction mode ${input2.transactionMode}...`
+    ),
+    "",
+    ...input2.transactionMode === "single" ? ["begin;", ""] : []
+  ];
+  for (const name of STEP_ORDER) {
+    const currentStep = steps.find((item) => item.name === name);
+    if (!currentStep?.included) {
+      continue;
+    }
+    orchestratorLines.push(
+      echo(
+        `[orchestrator] Running ${currentStep.name} (${currentStep.file})...`
+      ),
+      `\\ir ${currentStep.file}`,
+      echo(`[orchestrator] Completed ${currentStep.name}.`),
+      ""
+    );
+  }
+  orchestratorLines.push(
+    ...input2.transactionMode === "single" ? ["commit;", ""] : [],
+    echo("CNPJ DB Loader hybrid PostgreSQL import completed."),
+    ""
+  );
+  scripts["import-postgres-direct.sql"] = orchestratorLines.join("\n");
+  return { scripts, steps };
+}
+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 -d "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 copies sanitized Receita files into temporary raw tables,",
-    "-- transforms values inside PostgreSQL, resets staging tables and upserts final data.",
+    "-- 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;",
@@ -8783,10 +9280,10 @@ function generatePostgresSanitizedDirectImportScript(input2) {
     ""
   ];
   for (const dataset of DOMAIN_DATASETS) {
-    lines.push(...rawDomainSql(dataset, grouped[dataset] ?? []), "");
+    lines.push(...copyDomainSql(dataset, grouped[dataset] ?? []), "");
   }
   for (const dataset of STAGING_DATASETS) {
-    lines.push(...rawStagingSql(dataset, grouped[dataset] ?? []), "");
+    lines.push(...copyStagingSql(dataset, grouped[dataset] ?? []), "");
   }
   lines.push(...materializationAndAnalyzeSql());
   return lines.join("\n");
@@ -8797,11 +9294,13 @@ function materializationAndAnalyzeSql() {
     "",
     materializeEstablishmentsSql(),
     "",
+    materializeSecondaryCnaesSql(),
+    "",
     materializePartnersSql(),
     "",
     materializeSimplesSql(),
     "",
-    "\\echo 'Refreshing planner statistics...'",
+    echo("Refreshing planner statistics..."),
     "analyze companies;",
     "analyze establishments;",
     "analyze establishment_secondary_cnaes;",
@@ -8816,7 +9315,7 @@ function materializationAndAnalyzeSql() {
     "",
     "commit;",
     "",
-    "\\echo 'CNPJ DB Loader hybrid PostgreSQL import completed.'",
+    echo("CNPJ DB Loader hybrid PostgreSQL import completed."),
     ""
   ];
 }
@@ -9023,6 +9522,29 @@ async function exportPostgresCsvDataset(inputPath, options = {}) {
 import { mkdir as mkdir9, stat as stat7, writeFile as writeFile6 } from "fs/promises";
 import path17 from "path";
 var DEFAULT_SOURCE_ENCODING = "UTF8";
+var DEFAULT_TRANSACTION_MODE = "single";
+var ALL_INCLUDE_TARGETS = [
+  "domains",
+  "companies",
+  "establishments",
+  "partners",
+  "simples",
+  "secondary-cnaes",
+  "indexes",
+  "analyze"
+];
+var INCLUDE_TARGETS_BY_DATASET = {
+  companies: "companies",
+  establishments: "establishments",
+  partners: "partners",
+  simples_options: "simples",
+  countries: "domains",
+  cities: "domains",
+  partner_qualifications: "domains",
+  legal_natures: "domains",
+  reasons: "domains",
+  cnaes: "domains"
+};
 function defaultPostgresDirectOutputPath(inputPath) {
   const baseName = path17.basename(inputPath);
   if (baseName.toLowerCase() === "sanitized") {
@@ -9031,7 +9553,7 @@ function defaultPostgresDirectOutputPath(inputPath) {
   return path17.join(path17.dirname(inputPath), `${baseName}-postgres-direct`);
 }
 function inferNextStep5(scriptPath) {
-  return `psql "postgres://postgres:postgres@localhost:5432/cnpj" -f ${scriptPath.replace(/\\/g, "/")}`;
+  return `psql -d "postgres://postgres:postgres@localhost:5432/cnpj" -f ${scriptPath.replace(/\\/g, "/")}`;
 }
 function normalizeSourceEncoding(value) {
   const encoding = (value ?? DEFAULT_SOURCE_ENCODING).trim();
@@ -9042,6 +9564,41 @@ function normalizeSourceEncoding(value) {
   }
   return encoding.toUpperCase();
 }
+function normalizeTransactionMode(value) {
+  const mode = value ?? DEFAULT_TRANSACTION_MODE;
+  if (!["single", "phase", "none"].includes(mode)) {
+    throw new ValidationError(
+      `Invalid transaction mode: ${String(value)}. Use single, phase or none.`
+    );
+  }
+  return mode;
+}
+function isIncludeTarget(value) {
+  return ALL_INCLUDE_TARGETS.includes(value);
+}
+function normalizeIncludeTargets(include, dataset) {
+  if (include && include.length > 0) {
+    const unique = [...new Set(include)];
+    const invalid = unique.filter((item) => !isIncludeTarget(item));
+    if (invalid.length > 0) {
+      throw new ValidationError(
+        `Invalid include target(s): ${invalid.join(", ")}. Use ${ALL_INCLUDE_TARGETS.join(", ")}.`
+      );
+    }
+    return unique;
+  }
+  if (dataset) {
+    const target = INCLUDE_TARGETS_BY_DATASET[dataset];
+    if (!target) {
+      return [];
+    }
+    if (target === "establishments") {
+      return ["establishments", "secondary-cnaes", "analyze"];
+    }
+    return [target, "analyze"];
+  }
+  return [...ALL_INCLUDE_TARGETS];
+}
 async function generatePostgresDirectScript(inputPath, options = {}) {
   if (options.dataset && !isImportDatasetType(options.dataset)) {
     throw new ValidationError(`Unsupported dataset type: ${options.dataset}.`);
@@ -9057,6 +9614,10 @@ async function generatePostgresDirectScript(inputPath, options = {}) {
     options.outputPath ?? defaultPostgresDirectOutputPath(validatedPath)
   );
   const sourceEncoding = normalizeSourceEncoding(options.sourceEncoding);
+  const transactionMode = normalizeTransactionMode(options.transactionMode);
+  const include = normalizeIncludeTargets(options.include, options.dataset);
+  const skipIndexes = options.skipIndexes ?? false;
+  const skipAnalyze = options.skipAnalyze ?? false;
   const inspected = await inspectFiles(validatedPath);
   const recognizedFiles = inspected.entries.filter((entry) => entry.entryKind === "file").flatMap((entry) => {
     if (!isImportDatasetType(entry.inferredType)) {
@@ -9084,7 +9645,11 @@ async function generatePostgresDirectScript(inputPath, options = {}) {
     outputPath,
     totalFiles: recognizedFiles.length,
     datasets,
-    sourceEncoding
+    sourceEncoding,
+    transactionMode,
+    include,
+    skipIndexes,
+    skipAnalyze
   });
   await mkdir9(outputPath, { recursive: true });
   const sourceFiles = [];
@@ -9120,11 +9685,21 @@ async function generatePostgresDirectScript(inputPath, options = {}) {
   }
   const scriptName = options.scriptName ?? "import-postgres-direct.sql";
   const scriptPath = path17.join(outputPath, scriptName);
-  const script = generatePostgresSanitizedDirectImportScript({
+  const generated = generatePostgresDirectScriptFiles({
     files: sourceFiles,
-    sourceEncoding
+    sourceEncoding,
+    transactionMode,
+    include,
+    skipIndexes,
+    skipAnalyze
   });
-  await writeFile6(scriptPath, script, "utf8");
+  const scriptFiles = [];
+  for (const [fileName, script] of Object.entries(generated.scripts)) {
+    const outputFileName = fileName === "import-postgres-direct.sql" ? scriptName : fileName;
+    const outputFilePath = path17.join(outputPath, outputFileName);
+    await writeFile6(outputFilePath, script, "utf8");
+    scriptFiles.push(outputFilePath);
+  }
   const manifestPath = path17.join(outputPath, "manifest.json");
   const summaryDatasets = [...summariesByDataset.values()].sort(
     (left, right) => IMPORT_ORDER.indexOf(left.dataset) - IMPORT_ORDER.indexOf(right.dataset)
@@ -9136,13 +9711,19 @@ async function generatePostgresDirectScript(inputPath, options = {}) {
   const manifest = {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     mode: "direct-sanitized-script",
+    transactionMode,
+    include,
+    skipIndexes,
+    skipAnalyze,
     inputPath: path17.resolve(inputPath),
     validatedPath,
     outputPath,
     scriptPath,
+    scriptFiles,
     sourceEncoding,
     totalFiles: sourceFiles.length,
     totalBytes,
+    steps: generated.steps,
     datasets: summaryDatasets
   };
   await writeFile6(
@@ -9165,15 +9746,19 @@ async function generatePostgresDirectScript(inputPath, options = {}) {
     scriptPath,
     manifestPath,
     sourceEncoding,
+    transactionMode,
     totalFiles: sourceFiles.length,
     totalBytes,
     datasets: summaryDatasets,
+    scriptFiles,
+    steps: generated.steps,
     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 generated scripts expect 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."
+      "Use --source-encoding WIN1252 or LATIN1 only when generating scripts for legacy sanitized files produced by older loader versions.",
+      "The generated import is now modular. Use import-postgres-direct.sql as the orchestrator or run individual phase scripts manually."
     ],
     nextStep: inferNextStep5(scriptPath)
   };
@@ -9409,6 +9994,28 @@ function printDatabaseConfigSummary(config, logFilePath) {
   );
   console.log(`${theme.muted("Log file:")} ${resolveLogFilePath(logFilePath)}`);
 }
+function printFederalRevenueConfigSummary(config, logFilePath) {
+  console.log(
+    theme.successLabel("FEDERAL REVENUE"),
+    "Federal Revenue configuration loaded."
+  );
+  console.log(
+    formatKeyValue(
+      "WebDAV URL",
+      `${config.webdavUrl}${config.configured.webdavUrl ? "" : " (default)"}`
+    )
+  );
+  console.log(
+    formatKeyValue(
+      "User agent",
+      `${config.userAgent}${config.configured.userAgent ? "" : " (default)"}`
+    )
+  );
+  console.log(
+    formatKeyValue("Share token", config.shareToken ?? "not configured")
+  );
+  console.log(`${theme.muted("Log file:")} ${resolveLogFilePath(logFilePath)}`);
+}
 function printDatabaseCleanupSummary(summary, logFilePath) {
   console.log(
     theme.successLabel("DATABASE"),
@@ -9821,6 +10428,16 @@ function printPostgresDirectScriptSummary(summary, logFilePath) {
   console.log(formatKeyValue("Generated script", summary.scriptPath));
   console.log(formatKeyValue("Manifest", summary.manifestPath));
   console.log(formatKeyValue("Source encoding", summary.sourceEncoding));
+  console.log(formatKeyValue("Transaction mode", summary.transactionMode));
+  console.log(
+    formatKeyValue("Generated SQL files", summary.scriptFiles.length)
+  );
+  console.log(
+    formatKeyValue(
+      "Included steps",
+      summary.steps.filter((step2) => step2.included).map((step2) => step2.name).join(", ")
+    )
+  );
   console.log(formatKeyValue("Source files", summary.totalFiles));
   console.log(formatKeyValue("Source bytes", formatBytes(summary.totalBytes)));
   if (summary.datasets.length > 0) {
@@ -10511,6 +11128,14 @@ function createPostgresDirectScriptProgressReporter() {
       console.log(formatKeyValue("Validated path", event.validatedPath));
       console.log(formatKeyValue("Output path", event.outputPath));
       console.log(formatKeyValue("Source encoding", event.sourceEncoding));
+      console.log(formatKeyValue("Transaction mode", event.transactionMode));
+      console.log(formatKeyValue("Included steps", event.include.join(", ")));
+      console.log(
+        formatKeyValue("Skip indexes", event.skipIndexes ? "yes" : "no")
+      );
+      console.log(
+        formatKeyValue("Skip analyze", event.skipAnalyze ? "yes" : "no")
+      );
       console.log(formatKeyValue("Files queued", event.totalFiles));
       return;
     }
@@ -10916,8 +11541,21 @@ function applySharedOptions(options, target) {
   if (options.shareToken) {
     target.shareToken = options.shareToken;
   }
+  if (options.userAgent) {
+    target.userAgent = options.userAgent;
+  }
   return target;
 }
+async function resolveSharedOptions(referenceArgument, options) {
+  const mergedOptions = mergeSharedOptions(referenceArgument, options);
+  const clientOptions = await resolveFederalRevenueClientOptions(mergedOptions);
+  return {
+    ...mergedOptions,
+    ...clientOptions.baseUrl ? { baseUrl: clientOptions.baseUrl } : {},
+    ...clientOptions.shareToken ? { shareToken: clientOptions.shareToken } : {},
+    ...clientOptions.userAgent ? { userAgent: clientOptions.userAgent } : {}
+  };
+}
 function buildDownloadOptions(options) {
   const downloadOptions = applySharedOptions(
     options,
@@ -11002,6 +11640,9 @@ function registerSharedOptions(command) {
   ).option(
     "--share-token <token>",
     "Override the public Federal Revenue share token."
+  ).option(
+    "--user-agent <value>",
+    "Override the Federal Revenue HTTP user agent."
   );
 }
 function registerDownloadOptions(command) {
@@ -11036,6 +11677,70 @@ function registerFederalRevenueCommands(program) {
   const federalRevenue = program.command("federal-revenue").alias("revenue").description(
     "Check, download, sync, and maintain CNPJ monthly files from the Federal Revenue public share."
   );
+  const config = federalRevenue.command("config").description(
+    "Read, persist, test, or reset Federal Revenue public share settings."
+  );
+  config.command("set").argument(
+    "<key>",
+    "Configuration key: share-token, webdav-url, or user-agent."
+  ).argument("<value>", "Configuration value to persist.").description(
+    "Persist a Federal Revenue setting in the local CNPJ DB Loader config file."
+  ).action(async (key, value) => {
+    const effectiveConfig = await setFederalRevenueConfigValue(key, value);
+    const logFilePath = await writeCommandLog("federal-revenue-config-set", {
+      key,
+      effectiveConfig
+    });
+    printFederalRevenueConfigSummary(effectiveConfig, logFilePath);
+  });
+  config.command("show").description("Show the currently persisted Federal Revenue configuration.").action(async () => {
+    const effectiveConfig = await readFederalRevenueEffectiveConfig();
+    const logFilePath = await writeCommandLog(
+      "federal-revenue-config-show",
+      effectiveConfig
+    );
+    printFederalRevenueConfigSummary(effectiveConfig, logFilePath);
+  });
+  config.command("test").description("Test the configured Federal Revenue WebDAV connection.").action(async () => {
+    const clientOptions = await resolveFederalRevenueClientOptions();
+    const result = await listFederalRevenueReferences(clientOptions);
+    const references = result.references.map((item) => item.reference);
+    const latestReference = references.at(-1) ?? "not found";
+    const logFilePath = await writeCommandLog("federal-revenue-config-test", {
+      remoteBaseUrl: result.remoteBaseUrl,
+      referencesFound: references.length,
+      latestReference
+    });
+    printFederalRevenueConfigSummary(
+      await readFederalRevenueEffectiveConfig(),
+      logFilePath
+    );
+    console.log(
+      `Federal Revenue WebDAV connection succeeded. References found: ${references.length}. Latest reference: ${latestReference}.`
+    );
+  });
+  config.command("reset").argument(
+    "[key]",
+    "Optional key to reset: share-token, webdav-url, or user-agent. When omitted, all Federal Revenue settings are reset."
+  ).option("-f, --force", "Skip the confirmation prompt.").description(
+    "Reset one Federal Revenue setting or all persisted Federal Revenue settings."
+  ).action(async (key, options) => {
+    const target = key ? `Federal Revenue ${key}` : "all Federal Revenue";
+    const confirmed = await confirmFederalRevenueAction(
+      `Reset ${target} configuration?`,
+      options.force
+    );
+    if (!confirmed) {
+      console.log("Federal Revenue config reset cancelled.");
+      return;
+    }
+    const effectiveConfig = await resetFederalRevenueConfig(key);
+    const logFilePath = await writeCommandLog(
+      "federal-revenue-config-reset",
+      { key: key ?? "all", effectiveConfig }
+    );
+    printFederalRevenueConfigSummary(effectiveConfig, logFilePath);
+  });
   registerSharedOptions(
     federalRevenue.command("check").argument(
       "[reference]",
@@ -11045,7 +11750,10 @@ function registerFederalRevenueCommands(program) {
     )
   ).action(
     async (referenceArgument, options) => {
-      const resolvedOptions = mergeSharedOptions(referenceArgument, options);
+      const resolvedOptions = await resolveSharedOptions(
+        referenceArgument,
+        options
+      );
       const summary = await checkFederalRevenueDataset(
         applySharedOptions(resolvedOptions, {})
       );
@@ -11065,7 +11773,10 @@ function registerFederalRevenueCommands(program) {
     )
   ).action(
     async (referenceArgument, options) => {
-      const resolvedOptions = mergeSharedOptions(referenceArgument, options);
+      const resolvedOptions = await resolveSharedOptions(
+        referenceArgument,
+        options
+      );
       const confirmed = await confirmFederalRevenueAction(
         "Download Federal Revenue CNPJ ZIP files now? Existing completed files are skipped unless --overwrite is used.",
         options.force
@@ -11098,7 +11809,10 @@ function registerFederalRevenueCommands(program) {
     )
   ).action(
     async (referenceArgument, options) => {
-      const resolvedOptions = mergeSharedOptions(referenceArgument, options);
+      const resolvedOptions = await resolveSharedOptions(
+        referenceArgument,
+        options
+      );
       const summary = await getFederalRevenueStatus(
         buildStatusOptions({ ...options, ...resolvedOptions })
       );
@@ -11121,7 +11835,10 @@ function registerFederalRevenueCommands(program) {
     )
   ).action(
     async (referenceArgument, options) => {
-      const resolvedOptions = mergeSharedOptions(referenceArgument, options);
+      const resolvedOptions = await resolveSharedOptions(
+        referenceArgument,
+        options
+      );
       const confirmed = await confirmFederalRevenueAction(
         "Retry incomplete Federal Revenue files now? Completed files are kept.",
         options.force
@@ -11154,7 +11871,10 @@ function registerFederalRevenueCommands(program) {
     )
   ).action(
     async (referenceArgument, options) => {
-      const resolvedOptions = mergeSharedOptions(referenceArgument, options);
+      const resolvedOptions = await resolveSharedOptions(
+        referenceArgument,
+        options
+      );
       const actionLabel = options.all ? "remove the entire selected Federal Revenue reference folder" : options.failed ? "remove failed and partial Federal Revenue files" : "remove Federal Revenue .part files";
       const confirmed = await confirmFederalRevenueAction(
         `This will ${actionLabel}. Continue?`,
@@ -11209,7 +11929,10 @@ function registerFederalRevenueCommands(program) {
     )
   ).action(
     async (referenceArgument, options) => {
-      const resolvedOptions = mergeSharedOptions(referenceArgument, options);
+      const resolvedOptions = await resolveSharedOptions(
+        referenceArgument,
+        options
+      );
       const confirmed = await confirmFederalRevenueAction(
         "Run the full Federal Revenue sync now? This downloads files, extracts archives, sanitizes the dataset, and imports it into PostgreSQL.",
         options.force
@@ -11438,7 +12161,13 @@ function registerPostgresCommands(program) {
   ).option(
     "--source-encoding <encoding>",
     "PostgreSQL client encoding used while reading sanitized Receita files. Defaults to UTF8."
-  ).option("-f, --force", "Skip the confirmation prompt.").description(
+  ).option(
+    "--transaction-mode <mode>",
+    "Transaction mode for generated scripts: single, phase or none. Defaults to single."
+  ).option(
+    "--include <items>",
+    "Comma-separated steps to include: domains,companies,establishments,partners,simples,secondary-cnaes,indexes,analyze."
+  ).option("--skip-indexes", "Do not generate the indexes step.").option("--skip-analyze", "Do not generate the analyze step.").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) => {
@@ -11467,6 +12196,18 @@ function registerPostgresCommands(program) {
       if (options.sourceEncoding) {
         generateOptions.sourceEncoding = options.sourceEncoding;
       }
+      if (options.transactionMode) {
+        generateOptions.transactionMode = options.transactionMode;
+      }
+      if (options.include) {
+        generateOptions.include = options.include.split(",").map((item) => item.trim()).filter(Boolean);
+      }
+      if (options.skipIndexes) {
+        generateOptions.skipIndexes = true;
+      }
+      if (options.skipAnalyze) {
+        generateOptions.skipAnalyze = true;
+      }
       const summary = await generatePostgresDirectScript(
         input2,
         generateOptions