strapi-plugin-bulk-updater 1.4.3 → 1.4.6

package/dist/server/index.mjs

@@ -211,6 +211,30 @@ const routes = {
         config: {
           policies: []
         }
+      },
+      {
+        method: "POST",
+        path: "/csv/import-chunk",
+        handler: "csv.importChunk",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "POST",
+        path: "/csv/validate-preflight",
+        handler: "csv.validatePreflight",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "POST",
+        path: "/csv/submit-batch",
+        handler: "csv.submitBatch",
+        config: {
+          policies: []
+        }
       }
     ]
   }
@@ -663,6 +687,86 @@ const csvController = ({ strapi }) => ({
       ctx.status = 500;
       ctx.body = { success: false, error: err.message };
     }
+  },
+  async importChunk(ctx) {
+    try {
+      const { uid, rows, batchId, isFirstChunk, isLastChunk, startRowNumber, mode, publish } = ctx.request.body;
+      if (!uid) {
+        ctx.status = 400;
+        ctx.body = { success: false, error: "Target collection UID is required." };
+        return;
+      }
+      if (!Array.isArray(rows)) {
+        ctx.status = 400;
+        ctx.body = { success: false, error: "Rows array is required." };
+        return;
+      }
+      const csvService2 = strapi.plugin("bulk-updater").service("csv");
+      const result = await csvService2.importChunk(uid, rows, {
+        batchId: batchId ? String(batchId) : void 0,
+        isFirstChunk: Boolean(isFirstChunk),
+        isLastChunk: Boolean(isLastChunk),
+        startRowNumber: typeof startRowNumber === "number" ? startRowNumber : void 0,
+        mode: mode === "update" ? "update" : mode === "create_or_override" ? "create_or_override" : "auto",
+        publish: publish !== false,
+        user: ctx.state.user
+      });
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async validatePreflight(ctx) {
+    try {
+      const { uid, rows, mode } = ctx.request.body;
+      if (!uid) {
+        ctx.status = 400;
+        ctx.body = { success: false, error: "Target collection UID is required." };
+        return;
+      }
+      if (!Array.isArray(rows)) {
+        ctx.status = 400;
+        ctx.body = { success: false, error: "Rows array is required." };
+        return;
+      }
+      const csvService2 = strapi.plugin("bulk-updater").service("csv");
+      const result = await csvService2.validatePreflight(uid, rows, {
+        mode: mode === "update" ? "update" : mode === "create_or_override" ? "create_or_override" : "auto"
+      });
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async submitBatch(ctx) {
+    try {
+      const { uid, rows, executionMode, makerNotes, forceImmediate, mode, publish } = ctx.request.body;
+      if (!uid) {
+        ctx.status = 400;
+        ctx.body = { success: false, error: "Target collection UID is required." };
+        return;
+      }
+      if (!Array.isArray(rows)) {
+        ctx.status = 400;
+        ctx.body = { success: false, error: "Rows array is required." };
+        return;
+      }
+      const csvService2 = strapi.plugin("bulk-updater").service("csv");
+      const result = await csvService2.submitBatch(uid, rows, {
+        executionMode,
+        makerNotes,
+        forceImmediate: Boolean(forceImmediate),
+        mode: mode === "update" ? "update" : mode === "create_or_override" ? "create_or_override" : "auto",
+        publish: publish !== false,
+        user: ctx.state.user
+      });
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
   }
 });
 const FIELDS_TO_IGNORE = [
@@ -945,13 +1049,15 @@ function getAllNestedValues(obj, path) {
       if (!item || typeof item !== "object") return;
       if (parsed.targetIndex !== void 0 && idx !== parsed.targetIndex) return;
       if (parsed.targetComponentUid && item.__component !== parsed.targetComponentUid) return;
+      const compSchema = global.strapi?.components?.[item.__component];
+      const fieldInSchema = tail.length > 0 && compSchema?.attributes ? tail[0] in compSchema.attributes : false;
       const subVal = tail.length > 0 ? getDeepProperty(item, tail.join(".")) : item;
-      if (subVal !== void 0) {
+      if (subVal !== void 0 || fieldInSchema) {
         results.push({
           index: idx,
           componentUid: item.__component,
           componentName: formatComponentName(item.__component),
-          value: subVal,
+          value: subVal !== void 0 ? subVal : null,
           path: `${head}[#${idx}${item.__component ? ` ${formatComponentName(item.__component)}` : ""}].${tail.join(".")}`
         });
       }
@@ -1050,7 +1156,9 @@ function setDeepProperty(obj, pathParts, value, options) {
       if (options?.targetComponentUid) {
         if (item.__component !== options.targetComponentUid) return item;
       }
-      if (head in item || tail.length > 0 && typeof item[head] === "object") {
+      const compSchema = global.strapi?.components?.[item.__component];
+      const fieldExistsInSchema = compSchema?.attributes ? head in compSchema.attributes : true;
+      if (head in item || fieldExistsInSchema || tail.length === 0) {
         return {
           ...item,
           [head]: setDeepProperty(item[head], tail, value, options)
@@ -1164,6 +1272,12 @@ const pendingBatches = /* @__PURE__ */ new Map();
 const batchJobsMap = /* @__PURE__ */ new Map();
 let isRunnerRunning = false;
 let runnerInterval = null;
+function registerPendingBatch(batch, jobState) {
+  pendingBatches.set(batch.id, batch);
+  if (jobState) {
+    batchJobsMap.set(batch.id, jobState);
+  }
+}
 function invalidateCollectionCache(uid) {
   modelsCache.delete(uid);
   for (const key of queryCache.keys()) {
@@ -1786,6 +1900,22 @@ async function executePublishBatchInternal(strapi, {
     results
   };
 }
+async function executeBatchByPayload(strapi, batch, currentUser) {
+  if (batch.payload?.action === "csv_import") {
+    const csvService2 = strapi.plugin("bulk-updater").service("csv");
+    return await csvService2.executeCsvPendingBatch(
+      batch.payload.uid,
+      batch.payload.rows,
+      batch.id,
+      batch.payload.options,
+      currentUser
+    );
+  } else if (batch.payload?.action === "publish") {
+    return await executePublishBatchInternal(strapi, batch.payload, currentUser, batch.id);
+  } else {
+    return await executeBatchInternal(strapi, batch.payload, currentUser, batch.id);
+  }
+}
 const bulkUpdaterService = ({ strapi }) => {
   if (!runnerInterval) {
     runnerInterval = setInterval(async () => {
@@ -1797,7 +1927,7 @@ const bulkUpdaterService = ({ strapi }) => {
         for (const [id, batch] of pendingBatches.entries()) {
           if (batch.status === "queued_offpeak" && !isBusinessHours) {
             strapi.log.info(`[bulk-updater] Executing off-peak queued batch: ${id}`);
-            const result = batch.payload?.action === "publish" ? await executePublishBatchInternal(strapi, batch.payload, batch.createdBy, id) : await executeBatchInternal(strapi, batch.payload, batch.createdBy, id);
+            const result = await executeBatchByPayload(strapi, batch, batch.createdBy);
             batch.status = "executed";
             batch.executionResult = result;
           }
@@ -2410,7 +2540,12 @@ const bulkUpdaterService = ({ strapi }) => {
       for (const item of selectedEntries) {
         if (!item.uid || !item.documentId) continue;
         const key = `${item.uid}@@@${item.documentId}`;
-        targetsMap.set(key, { uid: item.uid, documentId: item.documentId });
+        targetsMap.set(key, {
+          uid: item.uid,
+          documentId: item.documentId,
+          dynamicZoneIndexes: item.dynamicZoneIndexes,
+          targetComponentUid: item.targetComponentUid
+        });
       }
       if (targetsMap.size === 0) {
         throw new Error("No collections or entries were selected for preview.");
@@ -2474,6 +2609,49 @@ const bulkUpdaterService = ({ strapi }) => {
           }
           const entryLabel = currentEntry?.name || currentEntry?.title || currentEntry?.email || `Entry #${target.documentId}`;
           if (isComponentNested) {
+            const parsed = parseDynamicZonePath(attribute);
+            const rootKey = parsed.rootKey;
+            const isRootDz = contentType?.attributes?.[rootKey]?.type === "dynamiczone";
+            const targetIndexes = target.dynamicZoneIndexes;
+            const targetComponentUid = target.targetComponentUid || parsed.targetComponentUid;
+            if (isRootDz && currentEntry?.[rootKey] && Array.isArray(currentEntry[rootKey])) {
+              let affectedMatches = getAllNestedValues({ [rootKey]: currentEntry[rootKey] }, attribute);
+              if (targetIndexes && targetIndexes.length > 0) {
+                affectedMatches = affectedMatches.filter((m) => targetIndexes.includes(m.index));
+              }
+              if (targetComponentUid) {
+                affectedMatches = affectedMatches.filter((m) => m.componentUid === targetComponentUid);
+              }
+              if (affectedMatches.length > 0) {
+                for (const match of affectedMatches) {
+                  let blockNewVal = value;
+                  if (regexObj && typeof match.value === "string") {
+                    blockNewVal = match.value.replace(regexObj, value);
+                  }
+                  const hasChange3 = String(match.value ?? "") !== String(blockNewVal ?? "");
+                  if (hasChange3) {
+                    willUpdateCount++;
+                  } else {
+                    unchangedCount++;
+                  }
+                  diffs.push({
+                    uid: target.uid,
+                    collectionName: displayName,
+                    documentId: target.documentId,
+                    label: `${entryLabel} [Block #${match.index} (${match.componentName})]`,
+                    attribute: `${rootKey}[#${match.index} ${match.componentName}].${parsed.subPath}`,
+                    oldValue: match.value ?? null,
+                    newValue: blockNewVal,
+                    oldDisplay: match.value !== void 0 && match.value !== null && String(match.value).trim() !== "" ? String(match.value) : "(empty)",
+                    newDisplay: String(blockNewVal ?? ""),
+                    hasChange: hasChange3,
+                    status: hasChange3 ? "will_update" : "unchanged",
+                    message: hasChange3 ? "Block value will be updated" : "Block already has target value"
+                  });
+                }
+                continue;
+              }
+            }
             const currentVal2 = getDeepProperty(currentEntry, attribute);
             let newValue2 = value;
             if (regexObj && typeof currentVal2 === "string") {
@@ -3053,7 +3231,7 @@ const bulkUpdaterService = ({ strapi }) => {
       const { isBusinessHours } = checkBusinessHours(config);
       if (options.executeImmediately || !isBusinessHours) {
         batch.status = "approved";
-        const result = batch.payload?.action === "publish" ? await executePublishBatchInternal(strapi, batch.payload, checkerUser, batch.id) : await executeBatchInternal(strapi, batch.payload, checkerUser, batch.id);
+        const result = await executeBatchByPayload(strapi, batch, checkerUser);
         batch.status = "executed";
         batch.executionResult = result;
         return {
@@ -3114,7 +3292,7 @@ const bulkUpdaterService = ({ strapi }) => {
       if (batch.status === "executed") {
         throw new Error(`Batch ${batchId} has already been executed.`);
       }
-      const result = batch.payload?.action === "publish" ? await executePublishBatchInternal(strapi, batch.payload, currentUser, batch.id) : await executeBatchInternal(strapi, batch.payload, currentUser, batch.id);
+      const result = await executeBatchByPayload(strapi, batch, currentUser);
       batch.status = "executed";
       batch.executionResult = result;
       return {
@@ -3361,6 +3539,20 @@ const bulkUpdaterService = ({ strapi }) => {
     },
     invalidateCollectionCache(uid) {
       invalidateCollectionCache(uid);
+    },
+    registerPendingBatch(batch, jobState) {
+      pendingBatches.set(batch.id, batch);
+      if (jobState) {
+        batchJobsMap.set(batch.id, jobState);
+      }
+      return batch;
+    },
+    getExecutionWindowConfig() {
+      return getExecutionWindowConfig(strapi);
+    },
+    checkBusinessHours(config) {
+      const cfg = config || getExecutionWindowConfig(strapi);
+      return checkBusinessHours(cfg);
     }
   };
 };
@@ -4567,92 +4759,645 @@ function getNestedExportValue(entry, path) {
   }
   return current;
 }
-const csvService = ({ strapi }) => ({
-  /**
-   * Generates a sample template CSV with schema attribute headers and sample values
-   */
-  async getTemplateCsv(uid) {
-    const ct = strapi.contentTypes[uid];
-    if (!ct) {
-      throw new Error(`Content type ${uid} not found`);
+const csvImportSessions = /* @__PURE__ */ new Map();
+function cleanupStaleSessions() {
+  const oneHourAgo = Date.now() - 36e5;
+  for (const [id, session] of csvImportSessions.entries()) {
+    if (session.createdAt < oneHourAgo) {
+      csvImportSessions.delete(id);
     }
-    const attrs = ct.attributes || {};
-    const excluded = ["createdAt", "updatedAt", "publishedAt", "createdBy", "updatedBy", "localizations"];
-    const headers = ["documentId"];
-    const sampleRow = ["(Leave empty to create new, or enter existing docId)"];
-    for (const [attrName, attrDef] of Object.entries(attrs)) {
-      if (excluded.includes(attrName)) continue;
-      if (attrDef.type === "relation") continue;
-      if (attrDef.type === "component" || attrDef.type === "dynamiczone") continue;
-      headers.push(attrName);
-      let sampleVal = "";
+  }
+}
+const SYSTEM_FIELD_KEYS = /* @__PURE__ */ new Set([
+  "documentid",
+  "document_id",
+  "docid",
+  "id",
+  "createdat",
+  "updatedat",
+  "publishedat",
+  "createdby",
+  "updatedby",
+  "localizations",
+  "locale",
+  "status"
+]);
+async function findExistingDocument(strapi, uid, targetDocId, docLocale) {
+  if (!targetDocId) return null;
+  try {
+    const queryArgs = { documentId: targetDocId };
+    if (docLocale) queryArgs.locale = docLocale;
+    const found = await strapi.documents(uid).findOne(queryArgs);
+    if (found) return found;
+  } catch {
+  }
+  if (/^\d+$/.test(targetDocId)) {
+    try {
+      const queryArgs = {
+        filters: { id: parseInt(targetDocId, 10) },
+        limit: 1
+      };
+      if (docLocale) queryArgs.locale = docLocale;
+      const list = await strapi.documents(uid).findMany(queryArgs);
+      if (list && list.length > 0) return list[0];
+    } catch {
+    }
+  }
+  return null;
+}
+async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
+  const attrs = ct.attributes || {};
+  const { mode = "auto", publish = true, user } = options;
+  const stats = {
+    total: rows.length,
+    created: 0,
+    updated: 0,
+    skipped: 0,
+    newWithoutDocId: 0,
+    errors: [],
+    diffs: []
+  };
+  for (let i = 0; i < rows.length; i++) {
+    const rowNumber = startRowNumber + i;
+    const row = rows[i];
+    let docId = extractDocId(row);
+    const rowLocale = extractLocale(row);
+    if (ct.kind === "singleType" && !docId) {
+      try {
+        const findSingleArgs = {};
+        if (rowLocale) findSingleArgs.locale = rowLocale;
+        const singleDoc = await strapi.documents(uid).findFirst(findSingleArgs);
+        if (singleDoc?.documentId) {
+          docId = singleDoc.documentId;
+        }
+      } catch {
+      }
+    }
+    const payload = {};
+    for (const [key, rawVal] of Object.entries(row)) {
+      const normalizedKey = key.toLowerCase().replace(/[\s_-]/g, "");
+      if (SYSTEM_FIELD_KEYS.has(normalizedKey)) continue;
+      if (key.includes(".")) {
+        const [parent, child] = key.split(".");
+        const parentDef = attrs[parent];
+        if (parentDef?.type === "component" && !parentDef.repeatable && parentDef.component) {
+          const comp = strapi.components[parentDef.component];
+          const childDef = comp?.attributes?.[child];
+          if (childDef) {
+            if (!payload[parent]) payload[parent] = {};
+            let val = rawVal;
+            if (rawVal === "" || rawVal === null || rawVal === void 0) {
+              val = null;
+            } else if (childDef.type === "integer" || childDef.type === "biginteger") {
+              const parsedInt = parseInt(rawVal, 10);
+              val = isNaN(parsedInt) ? null : parsedInt;
+            } else if (childDef.type === "float" || childDef.type === "decimal") {
+              const parsedFloat = parseFloat(rawVal);
+              val = isNaN(parsedFloat) ? null : parsedFloat;
+            } else if (childDef.type === "boolean") {
+              val = rawVal.toLowerCase() === "true" || rawVal === "1";
+            } else if (childDef.type === "json") {
+              try {
+                val = JSON.parse(rawVal);
+              } catch {
+                val = rawVal;
+              }
+            }
+            payload[parent][child] = val;
+          }
+        }
+        continue;
+      }
+      let attrDef = attrs[key];
+      if (!attrDef) {
+        const matchKey = Object.keys(attrs).find(
+          (k) => k.toLowerCase() === key.toLowerCase() || k.toLowerCase() === key.toLowerCase().replace(/\s+/g, "")
+        );
+        if (matchKey) {
+          attrDef = attrs[matchKey];
+        }
+      }
+      if (!attrDef) continue;
+      if (rawVal === "" || rawVal === null || rawVal === void 0) {
+        if (attrDef.type !== "dynamiczone" && !(attrDef.type === "component" && attrDef.repeatable)) {
+          payload[key] = null;
+        }
+        continue;
+      }
       switch (attrDef.type) {
-        case "string":
-        case "text":
-        case "richtext":
-          sampleVal = `Sample ${attrName}`;
-          break;
         case "integer":
-        case "biginteger":
+        case "biginteger": {
+          const parsedInt = parseInt(rawVal, 10);
+          payload[key] = isNaN(parsedInt) ? null : parsedInt;
+          break;
+        }
         case "float":
-        case "decimal":
-          sampleVal = "10";
+        case "decimal": {
+          const parsedFloat = parseFloat(rawVal);
+          payload[key] = isNaN(parsedFloat) ? null : parsedFloat;
           break;
+        }
         case "boolean":
-          sampleVal = "true";
+          payload[key] = rawVal.toLowerCase() === "true" || rawVal === "1";
           break;
-        case "email":
-          sampleVal = "sample@example.com";
+        case "json":
+          try {
+            payload[key] = JSON.parse(rawVal);
+          } catch {
+            payload[key] = rawVal;
+          }
           break;
-        case "enumeration":
-          sampleVal = attrDef.enum?.[0] || "option1";
+        case "dynamiczone": {
+          try {
+            const parsed = JSON.parse(rawVal);
+            if (Array.isArray(parsed) && parsed.every((item) => item && typeof item === "object" && typeof item.__component === "string")) {
+              payload[key] = parsed;
+            }
+          } catch {
+          }
           break;
-        case "customField":
-          sampleVal = "value";
+        }
+        case "component": {
+          if (attrDef.repeatable) {
+            try {
+              const parsed = JSON.parse(rawVal);
+              if (Array.isArray(parsed) && parsed.every((item) => item && typeof item === "object")) {
+                payload[key] = parsed;
+              }
+            } catch {
+            }
+          } else {
+            try {
+              const parsed = JSON.parse(rawVal);
+              if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+                payload[key] = parsed;
+              }
+            } catch {
+            }
+          }
           break;
+        }
+        case "relation": {
+          try {
+            const parsed = JSON.parse(rawVal);
+            if (Array.isArray(parsed) || typeof parsed === "object" && parsed !== null) {
+              payload[key] = parsed;
+              break;
+            }
+          } catch {
+          }
+          if (isValidDocId(rawVal)) {
+            payload[key] = rawVal;
+          } else if (rawVal.includes(";") || rawVal.includes(",")) {
+            const parts = rawVal.split(/[;,]/).map((s) => s.trim()).filter(Boolean);
+            if (parts.length > 0 && parts.every((p) => isValidDocId(p))) {
+              payload[key] = parts;
+            }
+          }
+          break;
+        }
+        case "media": {
+          if (/^\d+$/.test(rawVal.trim())) {
+            payload[key] = parseInt(rawVal.trim(), 10);
+          } else {
+            try {
+              const parsed = JSON.parse(rawVal);
+              if (typeof parsed === "number" || typeof parsed === "object") {
+                payload[key] = parsed;
+              }
+            } catch {
+            }
+          }
+          break;
+        }
         default:
-          sampleVal = "sample";
+          payload[key] = rawVal;
       }
-      sampleRow.push(sampleVal);
-    }
-    const csvContent = "\uFEFF" + headers.map(escapeCsvValue).join(",") + "\r\n" + sampleRow.map(escapeCsvValue).join(",") + "\r\n";
-    return {
-      filename: `${ct.info?.singularName || "template"}_template.csv`,
-      csvContent,
-      headers
-    };
-  },
-  /**
-   * Exports entries of a collection to CSV with deep nested component support,
-   * RFC-4180 CRLF line endings, and UTF-8 BOM for 100% Microsoft Excel compatibility.
-   */
-  async exportCollectionCsv(uid, options = {}) {
-    const ct = strapi.contentTypes[uid];
-    if (!ct) {
-      throw new Error(`Content type ${uid} not found`);
-    }
-    const allComponents = strapi.components || {};
-    const fields = discoverExportFields(ct, allComponents);
-    const filters = {};
-    const { attribute, filterOperator, filterQuery, search, documentIds } = options;
-    if (documentIds && Array.isArray(documentIds) && documentIds.length > 0) {
-      filters.documentId = { $in: documentIds };
     }
-    if (attribute && filterOperator && filterOperator !== "none") {
-      const isNested = attribute.includes(".");
-      if (filterOperator === "empty") {
-        if (isNested) {
-          const [parent, child] = attribute.split(".");
-          filters[parent] = { [child]: { $null: true } };
-        } else {
-          filters[attribute] = { $null: true };
-        }
-      } else if (filterOperator === "not_empty") {
-        if (isNested) {
-          const [parent, child] = attribute.split(".");
-          filters[parent] = { [child]: { $notNull: true } };
-        } else {
-          filters[attribute] = { $notNull: true };
+    try {
+      if (mode === "update") {
+        if (!docId) {
+          stats.skipped++;
+          stats.errors.push({
+            row: rowNumber,
+            error: "Missing or invalid documentId for Update mode. (Tip: Use Smart Auto-Detect mode to auto-add entries without document IDs)."
+          });
+          continue;
+        }
+        const existing = await findExistingDocument(strapi, uid, docId, rowLocale);
+        if (!existing) {
+          stats.skipped++;
+          stats.errors.push({
+            row: rowNumber,
+            documentId: docId,
+            error: `Document with ID "${docId}" not found in database.`
+          });
+          continue;
+        }
+        const resolvedDocId = existing.documentId || docId;
+        const mergedPayload = { ...payload };
+        for (const key of Object.keys(payload)) {
+          if (attrs[key]?.type === "component" && typeof payload[key] === "object" && payload[key] !== null) {
+            mergedPayload[key] = { ...existing[key] || {}, ...payload[key] };
+          }
+        }
+        if (Object.keys(mergedPayload).length === 0) {
+          stats.skipped++;
+          stats.diffs.push({
+            uid,
+            collectionName: ct.info?.displayName || uid,
+            documentId: resolvedDocId,
+            label: existing.title || existing.name || `Entry #${resolvedDocId}`,
+            attribute: "",
+            oldValue: existing,
+            newValue: {},
+            status: "skipped",
+            message: `Skipped (no editable attributes in row ${rowNumber})`
+          });
+          continue;
+        }
+        const updateArgs = {
+          documentId: resolvedDocId,
+          data: mergedPayload
+        };
+        if (rowLocale) updateArgs.locale = rowLocale;
+        await strapi.documents(uid).update(updateArgs);
+        if (publish && ct.options?.draftAndPublish) {
+          try {
+            const pubArgs = { documentId: resolvedDocId };
+            if (rowLocale) pubArgs.locale = rowLocale;
+            await strapi.documents(uid).publish(pubArgs);
+          } catch (pubErr) {
+            strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
+          }
+        }
+        try {
+          await recordContentHistoryVersion(strapi, {
+            uid,
+            documentId: resolvedDocId,
+            userId: user?.id,
+            statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+          });
+        } catch {
+        }
+        stats.updated++;
+        for (const attrKey of Object.keys(payload)) {
+          const oldVal = existing?.[attrKey] ?? null;
+          const newVal = payload[attrKey];
+          stats.diffs.push({
+            uid,
+            collectionName: ct.info?.displayName || uid,
+            documentId: resolvedDocId,
+            label: existing.title || existing.name || `Entry #${resolvedDocId}`,
+            attribute: attrKey,
+            oldValue: oldVal,
+            newValue: newVal,
+            status: "updated",
+            message: `Updated "${attrKey}" via CSV import (row ${rowNumber})`
+          });
+        }
+      } else if (mode === "create_or_override") {
+        let existing = null;
+        if (docId) {
+          existing = await findExistingDocument(strapi, uid, docId, rowLocale);
+        }
+        if (existing) {
+          const resolvedDocId = existing.documentId || docId;
+          const mergedPayload = { ...payload };
+          for (const key of Object.keys(payload)) {
+            if (attrs[key]?.type === "component" && typeof payload[key] === "object" && payload[key] !== null) {
+              mergedPayload[key] = { ...existing[key] || {}, ...payload[key] };
+            }
+          }
+          const updateArgs = {
+            documentId: resolvedDocId,
+            data: mergedPayload
+          };
+          if (rowLocale) updateArgs.locale = rowLocale;
+          await strapi.documents(uid).update(updateArgs);
+          if (publish && ct.options?.draftAndPublish) {
+            try {
+              const pubArgs = { documentId: resolvedDocId };
+              if (rowLocale) pubArgs.locale = rowLocale;
+              await strapi.documents(uid).publish(pubArgs);
+            } catch (pubErr) {
+              strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
+            }
+          }
+          try {
+            await recordContentHistoryVersion(strapi, {
+              uid,
+              documentId: resolvedDocId,
+              userId: user?.id,
+              statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+            });
+          } catch {
+          }
+          stats.updated++;
+          for (const attrKey of Object.keys(payload)) {
+            const oldVal = existing?.[attrKey] ?? null;
+            const newVal = payload[attrKey];
+            stats.diffs.push({
+              uid,
+              collectionName: ct.info?.displayName || uid,
+              documentId: resolvedDocId,
+              label: existing.title || existing.name || `Entry #${resolvedDocId}`,
+              attribute: attrKey,
+              oldValue: oldVal,
+              newValue: newVal,
+              status: "updated",
+              message: `Overridden "${attrKey}" via CSV import (row ${rowNumber})`
+            });
+          }
+          continue;
+        }
+        const createArgs = { data: payload };
+        if (rowLocale) createArgs.locale = rowLocale;
+        const created = await strapi.documents(uid).create(createArgs);
+        const newDocId = created?.documentId || docId;
+        if (publish && ct.options?.draftAndPublish && newDocId) {
+          try {
+            const pubArgs = { documentId: newDocId };
+            if (rowLocale) pubArgs.locale = rowLocale;
+            await strapi.documents(uid).publish(pubArgs);
+          } catch (pubErr) {
+            strapi.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
+          }
+        }
+        try {
+          await recordContentHistoryVersion(strapi, {
+            uid,
+            documentId: newDocId,
+            userId: user?.id,
+            statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+          });
+        } catch {
+        }
+        stats.created++;
+        if (!docId) {
+          stats.newWithoutDocId++;
+        }
+        for (const attrKey of Object.keys(payload)) {
+          stats.diffs.push({
+            uid,
+            collectionName: ct.info?.displayName || uid,
+            documentId: newDocId,
+            label: created?.title || created?.name || `New Entry #${newDocId}`,
+            attribute: attrKey,
+            oldValue: null,
+            newValue: payload[attrKey],
+            status: "created",
+            message: docId ? `Created "${attrKey}" via CSV import (row ${rowNumber})` : `Created "${attrKey}" as new entry (row ${rowNumber})`
+          });
+        }
+      } else {
+        let existing = null;
+        if (docId) {
+          existing = await findExistingDocument(strapi, uid, docId, rowLocale);
+        }
+        if (existing) {
+          const resolvedDocId = existing.documentId || docId;
+          const mergedPayload = { ...payload };
+          for (const key of Object.keys(payload)) {
+            if (attrs[key]?.type === "component" && typeof payload[key] === "object" && payload[key] !== null) {
+              mergedPayload[key] = { ...existing[key] || {}, ...payload[key] };
+            }
+          }
+          const updateArgs = {
+            documentId: resolvedDocId,
+            data: mergedPayload
+          };
+          if (rowLocale) updateArgs.locale = rowLocale;
+          await strapi.documents(uid).update(updateArgs);
+          if (publish && ct.options?.draftAndPublish) {
+            try {
+              const pubArgs = { documentId: resolvedDocId };
+              if (rowLocale) pubArgs.locale = rowLocale;
+              await strapi.documents(uid).publish(pubArgs);
+            } catch (pubErr) {
+              strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
+            }
+          }
+          try {
+            await recordContentHistoryVersion(strapi, {
+              uid,
+              documentId: resolvedDocId,
+              userId: user?.id,
+              statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+            });
+          } catch {
+          }
+          stats.updated++;
+          for (const attrKey of Object.keys(payload)) {
+            const oldVal = existing?.[attrKey] ?? null;
+            const newVal = payload[attrKey];
+            stats.diffs.push({
+              uid,
+              collectionName: ct.info?.displayName || uid,
+              documentId: resolvedDocId,
+              label: existing.title || existing.name || `Entry #${resolvedDocId}`,
+              attribute: attrKey,
+              oldValue: oldVal,
+              newValue: newVal,
+              status: "updated",
+              message: `Updated "${attrKey}" via CSV import (row ${rowNumber})`
+            });
+          }
+          continue;
+        }
+        const createArgs = { data: payload };
+        if (rowLocale) createArgs.locale = rowLocale;
+        const created = await strapi.documents(uid).create(createArgs);
+        const newDocId = created?.documentId || docId;
+        if (publish && ct.options?.draftAndPublish && newDocId) {
+          try {
+            const pubArgs = { documentId: newDocId };
+            if (rowLocale) pubArgs.locale = rowLocale;
+            await strapi.documents(uid).publish(pubArgs);
+          } catch (pubErr) {
+            strapi.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
+          }
+        }
+        try {
+          await recordContentHistoryVersion(strapi, {
+            uid,
+            documentId: newDocId,
+            userId: user?.id,
+            statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+          });
+        } catch {
+        }
+        stats.created++;
+        if (!docId) {
+          stats.newWithoutDocId++;
+        }
+        for (const attrKey of Object.keys(payload)) {
+          stats.diffs.push({
+            uid,
+            collectionName: ct.info?.displayName || uid,
+            documentId: newDocId,
+            label: created?.title || created?.name || `New Entry #${newDocId}`,
+            attribute: attrKey,
+            oldValue: null,
+            newValue: payload[attrKey],
+            status: "created",
+            message: docId ? `Created "${attrKey}" as new entry (documentId "${docId}" not found in database - row ${rowNumber})` : `Created "${attrKey}" as new entry (no documentId provided in CSV - row ${rowNumber})`
+          });
+        }
+      }
+    } catch (err) {
+      stats.errors.push({
+        row: rowNumber,
+        documentId: docId || void 0,
+        error: extractDetailedErrorMessage(err)
+      });
+    }
+  }
+  return stats;
+}
+async function recordCsvAuditLog(strapi, ct, uid, batchId, stats, user) {
+  if (stats.updated === 0 && stats.created === 0) return;
+  try {
+    const auditService2 = strapi.plugin("bulk-updater").service("audit");
+    if (!auditService2) return;
+    const isEnabled = typeof auditService2.isAuditEnabled === "function" ? auditService2.isAuditEnabled() : Boolean(auditService2.getAuditConfig?.().enabled ?? true);
+    if (!isEnabled) return;
+    const userEmail = user?.email || "admin@strapi.io";
+    const userName = user ? `${user.firstname || ""} ${user.lastname || ""}`.trim() : "CSV Importer";
+    const collectionDisplayName = ct.info?.displayName || uid;
+    const updatedDiffs = stats.diffs.filter(
+      (d) => d.status === "updated" || d.status === "created"
+    );
+    const uniqueAttributes = Array.from(
+      new Set(updatedDiffs.map((d) => d.attribute))
+    ).filter(Boolean);
+    const attrListStr = uniqueAttributes.length > 0 ? uniqueAttributes.join(", ") : "fields";
+    const batchAttribute = `CSV [${collectionDisplayName}]: ${attrListStr}`;
+    let batchValue = "";
+    if (updatedDiffs.length === 1) {
+      const d = updatedDiffs[0];
+      const newStr = d.newValue !== null && d.newValue !== void 0 ? String(d.newValue) : "(empty)";
+      batchValue = `"${d.label}": ${d.attribute} → "${newStr}"`;
+    } else if (updatedDiffs.length > 1 && stats.updated === 1 && stats.created === 0) {
+      const d = updatedDiffs[0];
+      const changes = updatedDiffs.map((ud) => `${ud.attribute}: "${ud.newValue ?? ""}"`).join(", ");
+      batchValue = `"${d.label}": ${changes}`;
+    } else {
+      const sampleVal = updatedDiffs[0] ? ` (e.g. ${updatedDiffs[0].attribute}: "${updatedDiffs[0].newValue ?? ""}")` : "";
+      batchValue = `${stats.updated} updated, ${stats.created} created in ${collectionDisplayName}${sampleVal}`;
+    }
+    const batchSummary = {
+      batchId,
+      attribute: batchAttribute,
+      value: batchValue,
+      updatedCount: stats.updated + stats.created,
+      skippedCount: stats.skipped,
+      totalTargets: stats.total
+    };
+    const userObj = {
+      email: userEmail || "admin@strapi.io",
+      firstname: userName || "Admin"
+    };
+    if (typeof auditService2.recordBatch === "function") {
+      await auditService2.recordBatch(batchSummary, stats.diffs, userObj);
+    } else if (typeof auditService2.logOperation === "function") {
+      await auditService2.logOperation({
+        ...batchSummary,
+        userEmail,
+        userName,
+        diffs: stats.diffs
+      });
+    }
+  } catch (auditErr) {
+    strapi.log.warn("[bulk-updater] Failed logging CSV import audit:", auditErr);
+  }
+}
+const csvService = ({ strapi }) => ({
+  /**
+   * Generates a sample template CSV with schema attribute headers and sample values
+   */
+  async getTemplateCsv(uid) {
+    const ct = strapi.contentTypes[uid];
+    if (!ct) {
+      throw new Error(`Content type ${uid} not found`);
+    }
+    const attrs = ct.attributes || {};
+    const excluded = ["createdAt", "updatedAt", "publishedAt", "createdBy", "updatedBy", "localizations"];
+    const headers = ["documentId"];
+    const sampleRow = ["(Leave empty to create new, or enter existing docId)"];
+    for (const [attrName, attrDef] of Object.entries(attrs)) {
+      if (excluded.includes(attrName)) continue;
+      if (attrDef.type === "relation") continue;
+      if (attrDef.type === "component" || attrDef.type === "dynamiczone") continue;
+      headers.push(attrName);
+      let sampleVal = "";
+      switch (attrDef.type) {
+        case "string":
+        case "text":
+        case "richtext":
+          sampleVal = `Sample ${attrName}`;
+          break;
+        case "integer":
+        case "biginteger":
+        case "float":
+        case "decimal":
+          sampleVal = "10";
+          break;
+        case "boolean":
+          sampleVal = "true";
+          break;
+        case "email":
+          sampleVal = "sample@example.com";
+          break;
+        case "enumeration":
+          sampleVal = attrDef.enum?.[0] || "option1";
+          break;
+        case "customField":
+          sampleVal = "value";
+          break;
+        default:
+          sampleVal = "sample";
+      }
+      sampleRow.push(sampleVal);
+    }
+    const csvContent = "\uFEFF" + headers.map(escapeCsvValue).join(",") + "\r\n" + sampleRow.map(escapeCsvValue).join(",") + "\r\n";
+    return {
+      filename: `${ct.info?.singularName || "template"}_template.csv`,
+      csvContent,
+      headers
+    };
+  },
+  /**
+   * Exports entries of a collection to CSV with deep nested component support,
+   * RFC-4180 CRLF line endings, and UTF-8 BOM for 100% Microsoft Excel compatibility.
+   */
+  async exportCollectionCsv(uid, options = {}) {
+    const ct = strapi.contentTypes[uid];
+    if (!ct) {
+      throw new Error(`Content type ${uid} not found`);
+    }
+    const allComponents = strapi.components || {};
+    const fields = discoverExportFields(ct, allComponents);
+    const filters = {};
+    const { attribute, filterOperator, filterQuery, search, documentIds } = options;
+    if (documentIds && Array.isArray(documentIds) && documentIds.length > 0) {
+      filters.documentId = { $in: documentIds };
+    }
+    if (attribute && filterOperator && filterOperator !== "none") {
+      const isNested = attribute.includes(".");
+      if (filterOperator === "empty") {
+        if (isNested) {
+          const [parent, child] = attribute.split(".");
+          filters[parent] = { [child]: { $null: true } };
+        } else {
+          filters[attribute] = { $null: true };
+        }
+      } else if (filterOperator === "not_empty") {
+        if (isNested) {
+          const [parent, child] = attribute.split(".");
+          filters[parent] = { [child]: { $notNull: true } };
+        } else {
+          filters[attribute] = { $notNull: true };
         }
       } else if (filterQuery !== void 0 && filterQuery !== "") {
         const opMap = {
@@ -4690,40 +5435,64 @@ const csvService = ({ strapi }) => ({
       }
     }
     const deepPopulate = buildDeepPopulate(ct.attributes || {}, allComponents);
-    let entries = [];
+    const lines = [];
+    lines.push(fields.map((f) => escapeCsvValue(f.key)).join(","));
+    let totalExported = 0;
+    const maxLimit = options.limit && options.limit > 0 ? options.limit : Infinity;
+    const CHUNK_SIZE = 1e3;
     if (ct.kind === "singleType") {
       const findFirstArgs = {};
       if (deepPopulate) {
         findFirstArgs.populate = deepPopulate;
       }
       const doc = await strapi.documents(uid).findFirst(findFirstArgs);
-      entries = doc ? [doc] : [];
+      if (doc) {
+        const rowValues = fields.map((f) => escapeCsvValue(getNestedExportValue(doc, f.key)));
+        lines.push(rowValues.join(","));
+        totalExported = 1;
+      }
     } else {
-      const findManyArgs = {
-        filters: Object.keys(filters).length > 0 ? filters : void 0,
-        limit: options.limit || 5e3,
-        sort: { createdAt: "desc" }
-      };
-      if (deepPopulate) {
-        findManyArgs.populate = deepPopulate;
+      let currentPage = 1;
+      let hasMore = true;
+      while (hasMore && totalExported < maxLimit) {
+        const remaining = maxLimit - totalExported;
+        const currentBatchLimit = Math.min(CHUNK_SIZE, remaining);
+        const findPageArgs = {
+          filters: Object.keys(filters).length > 0 ? filters : void 0,
+          page: currentPage,
+          pageSize: currentBatchLimit,
+          sort: { createdAt: "desc" }
+        };
+        if (deepPopulate) {
+          findPageArgs.populate = deepPopulate;
+        }
+        const chunkEntries = await strapi.documents(uid).findMany(findPageArgs);
+        if (!chunkEntries || chunkEntries.length === 0) {
+          hasMore = false;
+          break;
+        }
+        for (const entry of chunkEntries) {
+          const rowValues = fields.map((f) => escapeCsvValue(getNestedExportValue(entry, f.key)));
+          lines.push(rowValues.join(","));
+          totalExported++;
+          if (totalExported >= maxLimit) {
+            hasMore = false;
+            break;
+          }
+        }
+        if (chunkEntries.length < currentBatchLimit) {
+          hasMore = false;
+        } else {
+          currentPage++;
+        }
       }
-      entries = await strapi.documents(uid).findMany(findManyArgs);
-    }
-    const lines = [];
-    lines.push(fields.map((f) => escapeCsvValue(f.key)).join(","));
-    for (const entry of entries || []) {
-      const rowValues = fields.map((f) => {
-        const val = getNestedExportValue(entry, f.key);
-        return escapeCsvValue(val);
-      });
-      lines.push(rowValues.join(","));
     }
     const csvContent = "\uFEFF" + lines.join("\r\n") + "\r\n";
     const filename = `${ct.info?.singularName || uid}_export_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.csv`;
     return {
       filename,
       csvContent,
-      count: entries ? entries.length : 0,
+      count: totalExported,
       fields: fields.map((f) => f.key)
     };
   },
@@ -4784,7 +5553,7 @@ const csvService = ({ strapi }) => ({
     const uids = Object.keys(byUid);
     if (uids.length === 1) {
       const uid = uids[0];
-      return await this.exportCollectionCsv(uid, { documentIds: byUid[uid] });
+      return await this.exportCollectionCsv(uid, { documentIds: byUid[uid], limit: 0 });
     }
     const rows = [];
     const headers = [
@@ -4835,7 +5604,77 @@ const csvService = ({ strapi }) => ({
     };
   },
   /**
-   * Imports CSV records to update existing records or insert/override records
+   * Imports a single chunk of CSV rows (for large dataset streaming/batching).
+   * Aggregates stats across chunks and writes unified audit trail on the final chunk.
+   */
+  async importChunk(uid, rows, options) {
+    const ct = strapi.contentTypes[uid];
+    if (!ct) {
+      throw new Error(`Content type ${uid} not found`);
+    }
+    cleanupStaleSessions();
+    const batchId = options.batchId || `csv_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+    let session = csvImportSessions.get(batchId);
+    if (!session || options.isFirstChunk) {
+      session = {
+        batchId,
+        uid,
+        createdAt: Date.now(),
+        total: 0,
+        created: 0,
+        updated: 0,
+        skipped: 0,
+        newWithoutDocId: 0,
+        errors: [],
+        diffs: []
+      };
+      csvImportSessions.set(batchId, session);
+    }
+    const startRowNumber = options.startRowNumber || session.total + 2;
+    const chunkStats = await processCsvRows(strapi, ct, uid, rows || [], startRowNumber, options);
+    session.total += chunkStats.total;
+    session.created += chunkStats.created;
+    session.updated += chunkStats.updated;
+    session.skipped += chunkStats.skipped;
+    session.newWithoutDocId += chunkStats.newWithoutDocId;
+    session.errors.push(...chunkStats.errors);
+    session.diffs.push(...chunkStats.diffs);
+    if (options.isLastChunk) {
+      await recordCsvAuditLog(strapi, ct, uid, batchId, session, options.user);
+      try {
+        const bulkService = strapi.plugin("bulk-updater").service("bulkUpdater");
+        if (bulkService && bulkService.invalidateCollectionCache) {
+          bulkService.invalidateCollectionCache(uid);
+        }
+      } catch {
+      }
+      const aggregateStats = {
+        total: session.total,
+        created: session.created,
+        updated: session.updated,
+        skipped: session.skipped,
+        newWithoutDocId: session.newWithoutDocId,
+        errors: session.errors,
+        diffs: session.diffs
+      };
+      csvImportSessions.delete(batchId);
+      return {
+        success: true,
+        batchId,
+        chunkStats,
+        stats: aggregateStats,
+        isFinished: true
+      };
+    }
+    return {
+      success: true,
+      batchId,
+      chunkStats,
+      isFinished: false
+    };
+  },
+  /**
+   * Imports CSV records to update existing records or insert/override records (single payload).
    */
   async importCsv(uid, csvText, options) {
     const ct = strapi.contentTypes[uid];
@@ -4846,560 +5685,433 @@ const csvService = ({ strapi }) => ({
     if (!parsedRows || parsedRows.length === 0) {
       throw new Error("CSV is empty or could not be parsed.");
     }
-    const attrs = ct.attributes || {};
-    const { mode = "auto", publish = true, user } = options;
-    const stats = {
-      total: parsedRows.length,
-      created: 0,
-      updated: 0,
-      skipped: 0,
-      newWithoutDocId: 0,
-      errors: [],
-      diffs: []
-    };
     const batchId = `csv_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
-    const userEmail = user?.email || "admin@strapi.io";
-    const userName = user ? `${user.firstname || ""} ${user.lastname || ""}`.trim() : "CSV Importer";
-    const findExistingDocument = async (targetDocId, docLocale) => {
-      if (!targetDocId) return null;
-      try {
-        const queryArgs = { documentId: targetDocId };
-        if (docLocale) queryArgs.locale = docLocale;
-        const found = await strapi.documents(uid).findOne(queryArgs);
-        if (found) return found;
-      } catch {
-      }
-      if (/^\d+$/.test(targetDocId)) {
-        try {
-          const queryArgs = {
-            filters: { id: parseInt(targetDocId, 10) },
-            limit: 1
-          };
-          if (docLocale) queryArgs.locale = docLocale;
-          const list = await strapi.documents(uid).findMany(queryArgs);
-          if (list && list.length > 0) return list[0];
-        } catch {
-        }
+    const stats = await processCsvRows(strapi, ct, uid, parsedRows, 2, options);
+    try {
+      const bulkService = strapi.plugin("bulk-updater").service("bulkUpdater");
+      if (bulkService && bulkService.invalidateCollectionCache) {
+        bulkService.invalidateCollectionCache(uid);
       }
-      return null;
+    } catch {
+    }
+    await recordCsvAuditLog(strapi, ct, uid, batchId, stats, options.user);
+    return {
+      success: true,
+      batchId,
+      stats
     };
-    const SYSTEM_FIELD_KEYS = /* @__PURE__ */ new Set([
-      "documentid",
-      "document_id",
-      "docid",
-      "id",
-      "createdat",
-      "updatedat",
-      "publishedat",
-      "createdby",
-      "updatedby",
-      "localizations",
-      "locale",
-      "status"
-    ]);
-    for (let i = 0; i < parsedRows.length; i++) {
-      const rowNumber = i + 2;
-      const row = parsedRows[i];
-      let docId = extractDocId(row);
-      const rowLocale = extractLocale(row);
-      if (ct.kind === "singleType" && !docId) {
-        try {
-          const findSingleArgs = {};
-          if (rowLocale) findSingleArgs.locale = rowLocale;
-          const singleDoc = await strapi.documents(uid).findFirst(findSingleArgs);
-          if (singleDoc?.documentId) {
-            docId = singleDoc.documentId;
-          }
-        } catch {
-        }
-      }
-      const payload = {};
-      for (const [key, rawVal] of Object.entries(row)) {
-        const normalizedKey = key.toLowerCase().replace(/[\s_-]/g, "");
-        if (SYSTEM_FIELD_KEYS.has(normalizedKey)) continue;
-        if (key.includes(".")) {
-          const [parent, child] = key.split(".");
-          const parentDef = attrs[parent];
-          if (parentDef?.type === "component" && !parentDef.repeatable && parentDef.component) {
-            const comp = strapi.components[parentDef.component];
-            const childDef = comp?.attributes?.[child];
-            if (childDef) {
-              if (!payload[parent]) payload[parent] = {};
-              let val = rawVal;
-              if (rawVal === "" || rawVal === null || rawVal === void 0) {
-                val = null;
-              } else if (childDef.type === "integer" || childDef.type === "biginteger") {
-                const parsedInt = parseInt(rawVal, 10);
-                val = isNaN(parsedInt) ? null : parsedInt;
-              } else if (childDef.type === "float" || childDef.type === "decimal") {
-                const parsedFloat = parseFloat(rawVal);
-                val = isNaN(parsedFloat) ? null : parsedFloat;
-              } else if (childDef.type === "boolean") {
-                val = rawVal.toLowerCase() === "true" || rawVal === "1";
-              } else if (childDef.type === "json") {
-                try {
-                  val = JSON.parse(rawVal);
-                } catch {
-                  val = rawVal;
-                }
-              }
-              payload[parent][child] = val;
-            }
-          }
-          continue;
-        }
-        let attrDef = attrs[key];
-        if (!attrDef) {
-          const matchKey = Object.keys(attrs).find(
-            (k) => k.toLowerCase() === key.toLowerCase() || k.toLowerCase() === key.toLowerCase().replace(/\s+/g, "")
-          );
-          if (matchKey) {
-            attrDef = attrs[matchKey];
-          }
-        }
-        if (!attrDef) continue;
-        if (rawVal === "" || rawVal === null || rawVal === void 0) {
-          if (attrDef.type !== "dynamiczone" && !(attrDef.type === "component" && attrDef.repeatable)) {
-            payload[key] = null;
-          }
-          continue;
-        }
-        switch (attrDef.type) {
-          case "integer":
-          case "biginteger": {
-            const parsedInt = parseInt(rawVal, 10);
-            payload[key] = isNaN(parsedInt) ? null : parsedInt;
-            break;
-          }
-          case "float":
-          case "decimal": {
-            const parsedFloat = parseFloat(rawVal);
-            payload[key] = isNaN(parsedFloat) ? null : parsedFloat;
-            break;
-          }
-          case "boolean":
-            payload[key] = rawVal.toLowerCase() === "true" || rawVal === "1";
-            break;
-          case "json":
-            try {
-              payload[key] = JSON.parse(rawVal);
-            } catch {
-              payload[key] = rawVal;
-            }
-            break;
-          case "dynamiczone": {
-            try {
-              const parsed = JSON.parse(rawVal);
-              if (Array.isArray(parsed) && parsed.every((item) => item && typeof item === "object" && typeof item.__component === "string")) {
-                payload[key] = parsed;
-              }
-            } catch {
-            }
-            break;
-          }
-          case "component": {
-            if (attrDef.repeatable) {
-              try {
-                const parsed = JSON.parse(rawVal);
-                if (Array.isArray(parsed) && parsed.every((item) => item && typeof item === "object")) {
-                  payload[key] = parsed;
-                }
-              } catch {
-              }
-            } else {
-              try {
-                const parsed = JSON.parse(rawVal);
-                if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-                  payload[key] = parsed;
-                }
-              } catch {
-              }
-            }
-            break;
-          }
-          case "relation": {
-            try {
-              const parsed = JSON.parse(rawVal);
-              if (Array.isArray(parsed) || typeof parsed === "object" && parsed !== null) {
-                payload[key] = parsed;
-                break;
-              }
-            } catch {
-            }
-            if (isValidDocId(rawVal)) {
-              payload[key] = rawVal;
-            } else if (rawVal.includes(";") || rawVal.includes(",")) {
-              const parts = rawVal.split(/[;,]/).map((s) => s.trim()).filter(Boolean);
-              if (parts.length > 0 && parts.every((p) => isValidDocId(p))) {
-                payload[key] = parts;
-              }
-            }
-            break;
-          }
-          case "media": {
-            if (/^\d+$/.test(rawVal.trim())) {
-              payload[key] = parseInt(rawVal.trim(), 10);
-            } else {
-              try {
-                const parsed = JSON.parse(rawVal);
-                if (typeof parsed === "number" || typeof parsed === "object") {
-                  payload[key] = parsed;
-                }
-              } catch {
-              }
-            }
-            break;
-          }
-          default:
-            payload[key] = rawVal;
-        }
+  },
+  /**
+   * Executes a pending CSV batch approved by Checker or queued for off-peak execution
+   */
+  async executeCsvPendingBatch(uid, rows, batchId, options = {}, checkerUser) {
+    const ct = strapi.contentTypes[uid];
+    if (!ct) {
+      throw new Error(`Content type ${uid} not found`);
+    }
+    const effectiveUser = checkerUser || options.user;
+    const stats = await processCsvRows(strapi, ct, uid, rows || [], 2, {
+      ...options,
+      user: effectiveUser
+    });
+    await recordCsvAuditLog(strapi, ct, uid, batchId, stats, effectiveUser);
+    try {
+      const bulkService = strapi.plugin("bulk-updater").service("bulkUpdater");
+      if (bulkService && bulkService.invalidateCollectionCache) {
+        bulkService.invalidateCollectionCache(uid);
       }
-      try {
-        if (mode === "update") {
-          if (!docId) {
-            stats.skipped++;
-            stats.errors.push({
-              row: rowNumber,
-              error: "Missing or invalid documentId for Update mode. (Tip: Use Smart Auto-Detect mode to auto-add entries without document IDs)."
-            });
-            continue;
-          }
-          const existing = await findExistingDocument(docId, rowLocale);
-          if (!existing) {
-            stats.skipped++;
-            stats.errors.push({
+    } catch {
+    }
+    return {
+      success: true,
+      batchId,
+      stats
+    };
+  },
+  /**
+   * Pre-Flight Dry-Run Validation: Non-mutating analysis verifying document existence,
+   * data types, schema integrity, and quota rule violations before execution.
+   */
+  async validatePreflight(uid, rows, options = {}) {
+    const ct = strapi.contentTypes[uid];
+    if (!ct) {
+      throw new Error(`Content type ${uid} not found`);
+    }
+    const { mode = "auto" } = options;
+    const attrs = ct.attributes || {};
+    let validationRulesService2 = null;
+    let activeRules = [];
+    try {
+      validationRulesService2 = strapi.plugin("bulk-updater").service("validationRules");
+      if (validationRulesService2) {
+        const rulesRes = await validationRulesService2.getRules();
+        activeRules = (rulesRes || []).filter((r) => r.enabled);
+      }
+    } catch {
+    }
+    let validRows = 0;
+    let estimatedUpdates = 0;
+    let estimatedCreates = 0;
+    const errors2 = [];
+    const warnings = [];
+    for (let i = 0; i < rows.length; i++) {
+      const rowNumber = i + 2;
+      const row = rows[i];
+      const docId = extractDocId(row);
+      const rowLocale = extractLocale(row);
+      let rowHasError = false;
+      let existing = null;
+      if (docId) {
+        existing = await findExistingDocument(strapi, uid, docId, rowLocale);
+      }
+      if (mode === "update") {
+        if (!docId) {
+          errors2.push({
+            row: rowNumber,
+            error: "Missing or invalid documentId for Update Only mode."
+          });
+          rowHasError = true;
+        } else if (!existing) {
+          errors2.push({
+            row: rowNumber,
+            documentId: docId,
+            error: `Document with ID "${docId}" not found in database.`
+          });
+          rowHasError = true;
+        } else {
+          estimatedUpdates++;
+        }
+      } else if (mode === "create_or_override") {
+        if (existing) {
+          estimatedUpdates++;
+        } else {
+          estimatedCreates++;
+        }
+      } else {
+        if (existing) {
+          estimatedUpdates++;
+        } else {
+          estimatedCreates++;
+          if (docId) {
+            warnings.push({
               row: rowNumber,
               documentId: docId,
-              error: `Document with ID "${docId}" not found in database.`
-            });
-            continue;
-          }
-          const resolvedDocId = existing.documentId || docId;
-          const mergedPayload = { ...payload };
-          for (const key of Object.keys(payload)) {
-            if (attrs[key]?.type === "component" && typeof payload[key] === "object" && payload[key] !== null) {
-              mergedPayload[key] = { ...existing[key] || {}, ...payload[key] };
-            }
-          }
-          if (Object.keys(mergedPayload).length === 0) {
-            stats.skipped++;
-            stats.diffs.push({
-              uid,
-              collectionName: ct.info?.displayName || uid,
-              documentId: resolvedDocId,
-              label: existing.title || existing.name || `Entry #${resolvedDocId}`,
-              attribute: "",
-              oldValue: existing,
-              newValue: {},
-              status: "skipped",
-              message: `Skipped (no editable attributes in row ${rowNumber})`
-            });
-            continue;
-          }
-          const updateArgs = {
-            documentId: resolvedDocId,
-            data: mergedPayload
-          };
-          if (rowLocale) updateArgs.locale = rowLocale;
-          await strapi.documents(uid).update(updateArgs);
-          if (publish && ct.options?.draftAndPublish) {
-            try {
-              const pubArgs = { documentId: resolvedDocId };
-              if (rowLocale) pubArgs.locale = rowLocale;
-              await strapi.documents(uid).publish(pubArgs);
-            } catch (pubErr) {
-              strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
-            }
-          }
-          try {
-            await recordContentHistoryVersion(strapi, {
-              uid,
-              documentId: resolvedDocId,
-              userId: user?.id,
-              statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
-            });
-          } catch {
-          }
-          stats.updated++;
-          for (const attrKey of Object.keys(payload)) {
-            const oldVal = existing?.[attrKey] ?? null;
-            const newVal = payload[attrKey];
-            stats.diffs.push({
-              uid,
-              collectionName: ct.info?.displayName || uid,
-              documentId: resolvedDocId,
-              label: existing.title || existing.name || `Entry #${resolvedDocId}`,
-              attribute: attrKey,
-              oldValue: oldVal,
-              newValue: newVal,
-              status: "updated",
-              message: `Updated "${attrKey}" via CSV import (row ${rowNumber})`
+              warning: `Document ID "${docId}" not found in DB; will create as a new entry.`
             });
           }
-        } else if (mode === "create_or_override") {
-          let existing = null;
-          if (docId) {
-            existing = await findExistingDocument(docId, rowLocale);
-          }
-          if (existing) {
-            const resolvedDocId = existing.documentId || docId;
-            const mergedPayload = { ...payload };
-            for (const key of Object.keys(payload)) {
-              if (attrs[key]?.type === "component" && typeof payload[key] === "object" && payload[key] !== null) {
-                mergedPayload[key] = { ...existing[key] || {}, ...payload[key] };
-              }
-            }
-            const updateArgs = {
-              documentId: resolvedDocId,
-              data: mergedPayload
-            };
-            if (rowLocale) updateArgs.locale = rowLocale;
-            await strapi.documents(uid).update(updateArgs);
-            if (publish && ct.options?.draftAndPublish) {
-              try {
-                const pubArgs = { documentId: resolvedDocId };
-                if (rowLocale) pubArgs.locale = rowLocale;
-                await strapi.documents(uid).publish(pubArgs);
-              } catch (pubErr) {
-                strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
-              }
-            }
-            try {
-              await recordContentHistoryVersion(strapi, {
-                uid,
-                documentId: resolvedDocId,
-                userId: user?.id,
-                statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+        }
+      }
+      for (const [colKey, rawVal] of Object.entries(row)) {
+        if (!rawVal || rawVal.trim() === "") continue;
+        const normalizedKey = colKey.toLowerCase().replace(/[\s_-]/g, "");
+        if (SYSTEM_FIELD_KEYS.has(normalizedKey)) continue;
+        let attrDef = attrs[colKey];
+        if (!attrDef && !colKey.includes(".")) {
+          const matchKey = Object.keys(attrs).find(
+            (k) => k.toLowerCase() === colKey.toLowerCase() || k.toLowerCase() === colKey.toLowerCase().replace(/\s+/g, "")
+          );
+          if (matchKey) attrDef = attrs[matchKey];
+        }
+        if (attrDef) {
+          if (attrDef.type === "integer" || attrDef.type === "biginteger") {
+            const num = parseInt(rawVal, 10);
+            if (isNaN(num)) {
+              errors2.push({
+                row: rowNumber,
+                documentId: docId || void 0,
+                error: `Column "${colKey}" expects an integer, received: "${rawVal}"`
               });
-            } catch {
+              rowHasError = true;
             }
-            stats.updated++;
-            for (const attrKey of Object.keys(payload)) {
-              const oldVal = existing?.[attrKey] ?? null;
-              const newVal = payload[attrKey];
-              stats.diffs.push({
-                uid,
-                collectionName: ct.info?.displayName || uid,
-                documentId: resolvedDocId,
-                label: existing.title || existing.name || `Entry #${resolvedDocId}`,
-                attribute: attrKey,
-                oldValue: oldVal,
-                newValue: newVal,
-                status: "updated",
-                message: `Overridden "${attrKey}" via CSV import (row ${rowNumber})`
+          } else if (attrDef.type === "float" || attrDef.type === "decimal") {
+            const num = parseFloat(rawVal);
+            if (isNaN(num)) {
+              errors2.push({
+                row: rowNumber,
+                documentId: docId || void 0,
+                error: `Column "${colKey}" expects a numeric float/decimal, received: "${rawVal}"`
               });
+              rowHasError = true;
             }
-            continue;
-          }
-          const createArgs = { data: payload };
-          if (rowLocale) createArgs.locale = rowLocale;
-          const created = await strapi.documents(uid).create(createArgs);
-          const newDocId = created?.documentId || docId;
-          if (publish && ct.options?.draftAndPublish && newDocId) {
-            try {
-              const pubArgs = { documentId: newDocId };
-              if (rowLocale) pubArgs.locale = rowLocale;
-              await strapi.documents(uid).publish(pubArgs);
-            } catch (pubErr) {
-              strapi.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
-            }
-          }
-          try {
-            await recordContentHistoryVersion(strapi, {
-              uid,
-              documentId: newDocId,
-              userId: user?.id,
-              statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
-            });
-          } catch {
-          }
-          stats.created++;
-          if (!docId) {
-            stats.newWithoutDocId++;
-          }
-          for (const attrKey of Object.keys(payload)) {
-            stats.diffs.push({
-              uid,
-              collectionName: ct.info?.displayName || uid,
-              documentId: newDocId,
-              label: created?.title || created?.name || `New Entry #${newDocId}`,
-              attribute: attrKey,
-              oldValue: null,
-              newValue: payload[attrKey],
-              status: "created",
-              message: docId ? `Created "${attrKey}" via CSV import (row ${rowNumber})` : `Created "${attrKey}" as new entry (row ${rowNumber})`
-            });
-          }
-        } else {
-          let existing = null;
-          if (docId) {
-            existing = await findExistingDocument(docId, rowLocale);
-          }
-          if (existing) {
-            const resolvedDocId = existing.documentId || docId;
-            const mergedPayload = { ...payload };
-            for (const key of Object.keys(payload)) {
-              if (attrs[key]?.type === "component" && typeof payload[key] === "object" && payload[key] !== null) {
-                mergedPayload[key] = { ...existing[key] || {}, ...payload[key] };
-              }
-            }
-            const updateArgs = {
-              documentId: resolvedDocId,
-              data: mergedPayload
-            };
-            if (rowLocale) updateArgs.locale = rowLocale;
-            await strapi.documents(uid).update(updateArgs);
-            if (publish && ct.options?.draftAndPublish) {
-              try {
-                const pubArgs = { documentId: resolvedDocId };
-                if (rowLocale) pubArgs.locale = rowLocale;
-                await strapi.documents(uid).publish(pubArgs);
-              } catch (pubErr) {
-                strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
-              }
+          } else if (attrDef.type === "enumeration" && Array.isArray(attrDef.enum)) {
+            if (!attrDef.enum.includes(rawVal.trim())) {
+              warnings.push({
+                row: rowNumber,
+                documentId: docId || void 0,
+                warning: `Column "${colKey}" value "${rawVal}" is not in defined enum options: [${attrDef.enum.join(", ")}]`
+              });
             }
+          } else if (attrDef.type === "json") {
             try {
-              await recordContentHistoryVersion(strapi, {
-                uid,
-                documentId: resolvedDocId,
-                userId: user?.id,
-                statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
-              });
+              JSON.parse(rawVal);
             } catch {
-            }
-            stats.updated++;
-            for (const attrKey of Object.keys(payload)) {
-              const oldVal = existing?.[attrKey] ?? null;
-              const newVal = payload[attrKey];
-              stats.diffs.push({
-                uid,
-                collectionName: ct.info?.displayName || uid,
-                documentId: resolvedDocId,
-                label: existing.title || existing.name || `Entry #${resolvedDocId}`,
-                attribute: attrKey,
-                oldValue: oldVal,
-                newValue: newVal,
-                status: "updated",
-                message: `Updated "${attrKey}" via CSV import (row ${rowNumber})`
+              warnings.push({
+                row: rowNumber,
+                documentId: docId || void 0,
+                warning: `Column "${colKey}" is type JSON but contains non-JSON text.`
               });
             }
-            continue;
           }
-          const createArgs = { data: payload };
-          if (rowLocale) createArgs.locale = rowLocale;
-          const created = await strapi.documents(uid).create(createArgs);
-          const newDocId = created?.documentId || docId;
-          if (publish && ct.options?.draftAndPublish && newDocId) {
-            try {
-              const pubArgs = { documentId: newDocId };
-              if (rowLocale) pubArgs.locale = rowLocale;
-              await strapi.documents(uid).publish(pubArgs);
-            } catch (pubErr) {
-              strapi.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
+        }
+        if (activeRules.length > 0) {
+          for (const rule of activeRules) {
+            if (rule.collectionUid && rule.collectionUid !== "*" && rule.collectionUid !== uid) continue;
+            if (rule.includeRichTextHtml && (rawVal.includes("<h") || rawVal.includes("# "))) {
+              const headings = extractHeadingsFromRichText(rawVal);
+              for (const [tag, count] of Object.entries(headings)) {
+                const max = rule.quotas?.[tag.toLowerCase()];
+                if (max !== void 0 && count > max) {
+                  warnings.push({
+                    row: rowNumber,
+                    documentId: docId || void 0,
+                    warning: `Rule "${rule.name}" quota warning: column "${colKey}" contains ${count} "${tag.toUpperCase()}" headings (maximum allowed: ${max}).`
+                  });
+                }
+              }
             }
           }
-          try {
-            await recordContentHistoryVersion(strapi, {
-              uid,
-              documentId: newDocId,
-              userId: user?.id,
-              statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
-            });
-          } catch {
-          }
-          stats.created++;
-          if (!docId) {
-            stats.newWithoutDocId++;
-          }
-          for (const attrKey of Object.keys(payload)) {
-            stats.diffs.push({
-              uid,
-              collectionName: ct.info?.displayName || uid,
-              documentId: newDocId,
-              label: created?.title || created?.name || `New Entry #${newDocId}`,
-              attribute: attrKey,
-              oldValue: null,
-              newValue: payload[attrKey],
-              status: "created",
-              message: docId ? `Created "${attrKey}" as new entry (documentId "${docId}" not found in database - row ${rowNumber})` : `Created "${attrKey}" as new entry (no documentId provided in CSV - row ${rowNumber})`
-            });
-          }
         }
-      } catch (err) {
-        stats.errors.push({
-          row: rowNumber,
-          documentId: docId || void 0,
-          error: extractDetailedErrorMessage(err)
-        });
       }
-    }
-    try {
-      const bulkService = strapi.plugin("bulk-updater").service("bulkUpdater");
-      if (bulkService && bulkService.invalidateCollectionCache) {
-        bulkService.invalidateCollectionCache(uid);
+      if (!rowHasError) {
+        validRows++;
       }
-    } catch {
     }
-    if (stats.updated > 0 || stats.created > 0) {
-      try {
-        const auditService2 = strapi.plugin("bulk-updater").service("audit");
-        if (auditService2) {
-          const isEnabled = typeof auditService2.isAuditEnabled === "function" ? auditService2.isAuditEnabled() : Boolean(auditService2.getAuditConfig?.().enabled ?? true);
-          if (isEnabled) {
-            const collectionDisplayName = ct.info?.displayName || uid;
-            const updatedDiffs = stats.diffs.filter(
-              (d) => d.status === "updated" || d.status === "created"
-            );
-            const uniqueAttributes = Array.from(
-              new Set(updatedDiffs.map((d) => d.attribute))
-            ).filter(Boolean);
-            const attrListStr = uniqueAttributes.length > 0 ? uniqueAttributes.join(", ") : "fields";
-            const batchAttribute = `CSV [${collectionDisplayName}]: ${attrListStr}`;
-            let batchValue = "";
-            if (updatedDiffs.length === 1) {
-              const d = updatedDiffs[0];
-              const newStr = d.newValue !== null && d.newValue !== void 0 ? String(d.newValue) : "(empty)";
-              batchValue = `"${d.label}": ${d.attribute} → "${newStr}"`;
-            } else if (updatedDiffs.length > 1 && stats.updated === 1 && stats.created === 0) {
-              const d = updatedDiffs[0];
-              const changes = updatedDiffs.map((ud) => `${ud.attribute}: "${ud.newValue ?? ""}"`).join(", ");
-              batchValue = `"${d.label}": ${changes}`;
-            } else {
-              const sampleVal = updatedDiffs[0] ? ` (e.g. ${updatedDiffs[0].attribute}: "${updatedDiffs[0].newValue ?? ""}")` : "";
-              batchValue = `${stats.updated} updated, ${stats.created} created in ${collectionDisplayName}${sampleVal}`;
-            }
-            const batchSummary = {
-              batchId,
-              attribute: batchAttribute,
-              value: batchValue,
-              updatedCount: stats.updated + stats.created,
-              skippedCount: stats.skipped,
-              totalTargets: stats.total
-            };
-            const userObj = {
-              email: userEmail || "admin@strapi.io",
-              firstname: userName || "Admin"
-            };
-            if (typeof auditService2.recordBatch === "function") {
-              await auditService2.recordBatch(batchSummary, stats.diffs, userObj);
-            } else if (typeof auditService2.logOperation === "function") {
-              await auditService2.logOperation({
-                ...batchSummary,
-                userEmail,
-                userName,
-                diffs: stats.diffs
-              });
-            }
-          }
-        }
-      } catch (auditErr) {
-        strapi.log.warn("[bulk-updater] Failed logging CSV import audit:", auditErr);
-      }
+    return {
+      success: true,
+      totalRows: rows.length,
+      validRows,
+      estimatedUpdates,
+      estimatedCreates,
+      hasErrors: errors2.length > 0,
+      hasWarnings: warnings.length > 0,
+      errors: errors2.slice(0, 100),
+      warnings: warnings.slice(0, 100),
+      totalErrorCount: errors2.length,
+      totalWarningCount: warnings.length
+    };
+  },
+  /**
+   * Submits a CSV batch with Guardrails: Maker-Checker (4-Eyes), Execution Windows, Off-Peak Scheduling
+   */
+  async submitBatch(uid, rows, options = {}) {
+    const ct = strapi.contentTypes[uid];
+    if (!ct) {
+      throw new Error(`Content type ${uid} not found`);
+    }
+    if (!rows || rows.length === 0) {
+      throw new Error("No CSV records provided for batch submission.");
+    }
+    const {
+      executionMode = "immediate",
+      makerNotes = "",
+      forceImmediate = false,
+      mode = "auto",
+      publish = true,
+      user
+    } = options;
+    const executionConfig = getExecutionWindowConfig(strapi);
+    const { isBusinessHours, policyMessage } = checkBusinessHours(executionConfig);
+    const collectionDisplayName = ct.info?.displayName || uid;
+    if (executionMode === "maker_checker") {
+      const batchId = `csv_batch_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+      const batch = {
+        id: batchId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        createdBy: user ? {
+          id: user.id,
+          email: user.email,
+          firstname: user.firstname,
+          lastname: user.lastname,
+          username: user.username
+        } : { email: "admin@system.local" },
+        payload: {
+          action: "csv_import",
+          uid,
+          rows,
+          options: {
+            mode,
+            publish,
+            user
+          },
+          attribute: `CSV Import: ${collectionDisplayName}`,
+          value: `${rows.length} rows (${mode} mode)`,
+          publishOnApproval: publish
+        },
+        summary: {
+          attribute: `CSV Import: ${collectionDisplayName}`,
+          value: `${rows.length} rows (${mode} mode)`,
+          totalTargets: rows.length,
+          collectionBreakdown: { [collectionDisplayName]: rows.length },
+          publishOnApproval: publish
+        },
+        status: "pending_approval",
+        executionMode: "maker_checker",
+        makerNotes
+      };
+      registerPendingBatch(batch, {
+        id: batchId,
+        createdAt: batch.createdAt,
+        createdBy: batch.createdBy,
+        status: "pending_approval",
+        executionMode: "maker_checker",
+        attribute: `CSV Import: ${collectionDisplayName}`,
+        value: `${rows.length} rows (${mode} mode)`,
+        totalTargets: rows.length,
+        processedCount: 0,
+        updatedCount: 0,
+        skippedCount: 0,
+        failedCount: 0,
+        isLive: false,
+        publishOnApproval: publish,
+        makerNotes,
+        results: []
+      });
+      return {
+        success: true,
+        pending: true,
+        batchId,
+        status: "pending_approval",
+        message: "CSV batch submitted for Checker authorization (4-Eyes Maker-Checker Workflow).",
+        batch
+      };
+    }
+    if (executionMode === "queue_offpeak") {
+      const batchId = `csv_batch_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+      const batch = {
+        id: batchId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        createdBy: user ? {
+          id: user.id,
+          email: user.email,
+          firstname: user.firstname,
+          lastname: user.lastname,
+          username: user.username
+        } : { email: "admin@system.local" },
+        payload: {
+          action: "csv_import",
+          uid,
+          rows,
+          options: {
+            mode,
+            publish,
+            user
+          },
+          attribute: `CSV Import: ${collectionDisplayName}`,
+          value: `${rows.length} rows (${mode} mode)`,
+          publishOnApproval: publish
+        },
+        summary: {
+          attribute: `CSV Import: ${collectionDisplayName}`,
+          value: `${rows.length} rows (${mode} mode)`,
+          totalTargets: rows.length,
+          collectionBreakdown: { [collectionDisplayName]: rows.length },
+          publishOnApproval: publish
+        },
+        status: "queued_offpeak",
+        executionMode: "queue_offpeak",
+        scheduledFor: executionConfig.offPeakStartTime,
+        makerNotes
+      };
+      registerPendingBatch(batch, {
+        id: batchId,
+        createdAt: batch.createdAt,
+        createdBy: batch.createdBy,
+        status: "queued_offpeak",
+        executionMode: "queue_offpeak",
+        scheduledFor: executionConfig.offPeakStartTime,
+        attribute: `CSV Import: ${collectionDisplayName}`,
+        value: `${rows.length} rows (${mode} mode)`,
+        totalTargets: rows.length,
+        processedCount: 0,
+        updatedCount: 0,
+        skippedCount: 0,
+        failedCount: 0,
+        isLive: false,
+        publishOnApproval: publish,
+        makerNotes,
+        results: []
+      });
+      return {
+        success: true,
+        pending: true,
+        batchId,
+        status: "queued_offpeak",
+        scheduledFor: executionConfig.offPeakStartTime,
+        message: `CSV batch queued for server off-peak maintenance window (${executionConfig.offPeakStartTime}).`,
+        batch
+      };
+    }
+    if (executionConfig.enabled && executionConfig.autoQueueDuringBusinessHours && isBusinessHours && !forceImmediate) {
+      const batchId = `csv_batch_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+      const batch = {
+        id: batchId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        createdBy: user ? {
+          id: user.id,
+          email: user.email,
+          firstname: user.firstname,
+          lastname: user.lastname,
+          username: user.username
+        } : { email: "admin@system.local" },
+        payload: {
+          action: "csv_import",
+          uid,
+          rows,
+          options: {
+            mode,
+            publish,
+            user
+          },
+          attribute: `CSV Import: ${collectionDisplayName}`,
+          value: `${rows.length} rows (${mode} mode)`,
+          publishOnApproval: publish
+        },
+        summary: {
+          attribute: `CSV Import: ${collectionDisplayName}`,
+          value: `${rows.length} rows (${mode} mode)`,
+          totalTargets: rows.length,
+          collectionBreakdown: { [collectionDisplayName]: rows.length },
+          publishOnApproval: publish
+        },
+        status: "queued_offpeak",
+        executionMode: "queue_offpeak",
+        scheduledFor: executionConfig.offPeakStartTime,
+        makerNotes: "Automatically queued due to peak business hours restriction."
+      };
+      registerPendingBatch(batch, {
+        id: batchId,
+        createdAt: batch.createdAt,
+        createdBy: batch.createdBy,
+        status: "queued_offpeak",
+        executionMode: "queue_offpeak",
+        scheduledFor: executionConfig.offPeakStartTime,
+        attribute: `CSV Import: ${collectionDisplayName}`,
+        value: `${rows.length} rows (${mode} mode)`,
+        totalTargets: rows.length,
+        processedCount: 0,
+        updatedCount: 0,
+        skippedCount: 0,
+        failedCount: 0,
+        isLive: false,
+        publishOnApproval: publish,
+        policyMessage,
+        makerNotes: "Automatically queued due to peak business hours restriction.",
+        results: []
+      });
+      return {
+        success: true,
+        pending: true,
+        batchId,
+        status: "queued_offpeak",
+        scheduledFor: executionConfig.offPeakStartTime,
+        message: policyMessage,
+        batch
+      };
     }
     return {
       success: true,
-      batchId,
-      stats
+      pending: false,
+      executeNow: true
     };
   }
 });