strapi-plugin-bulk-updater 1.4.2 → 1.4.6

package/dist/server/index.js

@@ -214,6 +214,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: []
+        }
       }
     ]
   }
@@ -666,6 +690,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 = [
@@ -911,9 +1015,74 @@ function discoverComponentAttributes(strapi, compUid, prefix, currentDepth, maxD
   }
   return Array.from(new Set(discoveredAttrs));
 }
+function parseDynamicZonePath(path) {
+  if (!path) return { cleanPath: "", rootKey: "", subPath: "" };
+  const bracketMatch = path.match(/^([^.[]+)\[([^\]]+)\]\.(.+)$/);
+  if (bracketMatch) {
+    const rootKey = bracketMatch[1];
+    const selector = bracketMatch[2];
+    const subPath = bracketMatch[3];
+    const cleanPath = `${rootKey}.${subPath}`;
+    if (/^\d+$/.test(selector)) {
+      return { cleanPath, rootKey, subPath, targetIndex: parseInt(selector, 10) };
+    }
+    return { cleanPath, rootKey, subPath, targetComponentUid: selector };
+  }
+  const parts = path.split(".");
+  return {
+    cleanPath: path,
+    rootKey: parts[0] || "",
+    subPath: parts.slice(1).join(".")
+  };
+}
+function formatComponentName(compUid) {
+  if (!compUid) return "Component";
+  const name = compUid.includes(".") ? compUid.split(".")[1] : compUid;
+  return name.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function getAllNestedValues(obj, path) {
+  if (!obj || !path) return [];
+  const parsed = parseDynamicZonePath(path);
+  const parts = parsed.cleanPath.split(".");
+  const [head, ...tail] = parts;
+  const rootTarget = obj[head];
+  if (Array.isArray(rootTarget)) {
+    const results = [];
+    rootTarget.forEach((item, idx) => {
+      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 || fieldInSchema) {
+        results.push({
+          index: idx,
+          componentUid: item.__component,
+          componentName: formatComponentName(item.__component),
+          value: subVal !== void 0 ? subVal : null,
+          path: `${head}[#${idx}${item.__component ? ` ${formatComponentName(item.__component)}` : ""}].${tail.join(".")}`
+        });
+      }
+    });
+    return results;
+  }
+  const singleVal = getDeepProperty(obj, parsed.cleanPath);
+  if (singleVal !== void 0) {
+    return [
+      {
+        index: 0,
+        value: singleVal,
+        path: parsed.cleanPath
+      }
+    ];
+  }
+  return [];
+}
 function isDeepComponentField(contentType, allComponents, attribute) {
-  if (!attribute || !attribute.includes(".")) return false;
-  const parts = attribute.split(".");
+  if (!attribute || !attribute.includes(".") && !attribute.includes("[")) return false;
+  const parsed = parseDynamicZonePath(attribute);
+  const parts = parsed.cleanPath.split(".");
   function checkPath(currentSchema, pathParts) {
     if (pathParts.length === 0) return true;
     if (!currentSchema || !currentSchema.attributes) return false;
@@ -929,6 +1098,10 @@ function isDeepComponentField(contentType, allComponents, attribute) {
     }
     if (attrDef.type === "dynamiczone") {
       const compUids = Array.isArray(attrDef.components) ? attrDef.components : [];
+      if (parsed.targetComponentUid) {
+        const comp = allComponents[parsed.targetComponentUid];
+        return comp ? checkPath(comp, tail) : false;
+      }
       return compUids.some((compUid) => {
         const comp = allComponents[compUid];
         return checkPath(comp, tail);
@@ -940,8 +1113,9 @@ function isDeepComponentField(contentType, allComponents, attribute) {
 }
 function getLeafAttributeSchema(contentType, allComponents, attribute) {
   if (!attribute) return null;
-  if (!attribute.includes(".")) return contentType?.attributes?.[attribute] || null;
-  const parts = attribute.split(".");
+  const parsed = parseDynamicZonePath(attribute);
+  if (!parsed.cleanPath.includes(".")) return contentType?.attributes?.[parsed.cleanPath] || null;
+  const parts = parsed.cleanPath.split(".");
   function resolveLeaf(currentSchema, pathParts) {
     if (!currentSchema || !currentSchema.attributes) return null;
     const [head, ...tail] = pathParts;
@@ -955,6 +1129,9 @@ function getLeafAttributeSchema(contentType, allComponents, attribute) {
     }
     if (attrDef.type === "dynamiczone") {
       const compUids = Array.isArray(attrDef.components) ? attrDef.components : [];
+      if (parsed.targetComponentUid) {
+        return resolveLeaf(allComponents[parsed.targetComponentUid], tail);
+      }
       for (const compUid of compUids) {
         const found = resolveLeaf(allComponents[compUid], tail);
         if (found) return found;
@@ -964,22 +1141,30 @@ function getLeafAttributeSchema(contentType, allComponents, attribute) {
   }
   return resolveLeaf(contentType, parts);
 }
-function setDeepProperty(obj, pathParts, value) {
+function setDeepProperty(obj, pathParts, value, options) {
   if (pathParts.length === 0) return value;
   const [head, ...tail] = pathParts;
   if (Array.isArray(obj)) {
     if (/^\d+$/.test(head)) {
       const idx = parseInt(head, 10);
       const copy = [...obj];
-      copy[idx] = setDeepProperty(copy[idx] || {}, tail, value);
+      copy[idx] = setDeepProperty(copy[idx] || {}, tail, value, options);
       return copy;
     }
-    return obj.map((item) => {
+    return obj.map((item, idx) => {
       if (!item || typeof item !== "object") return item;
-      if (head in item || tail.length > 0 && typeof item[head] === "object") {
+      if (options?.targetIndexes && options.targetIndexes.length > 0) {
+        if (!options.targetIndexes.includes(idx)) return item;
+      }
+      if (options?.targetComponentUid) {
+        if (item.__component !== options.targetComponentUid) return item;
+      }
+      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)
+          [head]: setDeepProperty(item[head], tail, value, options)
         };
       }
       return item;
@@ -991,16 +1176,17 @@ function setDeepProperty(obj, pathParts, value) {
   } else {
     const subTarget = current[head];
     if (Array.isArray(subTarget)) {
-      current[head] = setDeepProperty(subTarget, tail, value);
+      current[head] = setDeepProperty(subTarget, tail, value, options);
     } else {
-      current[head] = setDeepProperty(subTarget || {}, tail, value);
+      current[head] = setDeepProperty(subTarget || {}, tail, value, options);
     }
   }
   return current;
 }
 function getDeepProperty(obj, path) {
   if (!obj || !path) return void 0;
-  const parts = path.split(".");
+  const parsed = parseDynamicZonePath(path);
+  const parts = parsed.cleanPath.split(".");
   function extract(current, remainingParts) {
     if (current === void 0 || current === null) return void 0;
     if (remainingParts.length === 0) return current;
@@ -1009,7 +1195,10 @@ function getDeepProperty(obj, path) {
       if (/^\d+$/.test(head)) {
         return extract(current[parseInt(head, 10)], tail);
       }
-      for (const item of current) {
+      for (let idx = 0; idx < current.length; idx++) {
+        const item = current[idx];
+        if (parsed.targetIndex !== void 0 && idx !== parsed.targetIndex) continue;
+        if (parsed.targetComponentUid && item?.__component !== parsed.targetComponentUid) continue;
         const found = extract(item?.[head], tail);
         if (found !== void 0 && found !== null) return found;
       }
@@ -1086,6 +1275,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()) {
@@ -1174,7 +1369,12 @@ async function executeBatchInternal(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 update.");
@@ -1233,10 +1433,13 @@ async function executeBatchInternal(strapi, {
       try {
         const currentEntry = await getDocumentDeduplicated(target.uid, target.documentId);
         const entryLabel = currentEntry?.name || currentEntry?.title || currentEntry?.email || `Entry #${target.documentId}`;
-        const isNested = attribute.includes(".");
+        const parsed = parseDynamicZonePath(attribute);
+        const isNested = attribute.includes(".") || attribute.includes("[");
         const isComponentNested = isNested && isDeepComponentField(contentType, strapi.components, attribute);
-        const parts = isNested ? attribute.split(".") : [];
-        const rootKey = isNested ? parts[0] : "";
+        const parts = isNested ? parsed.cleanPath.split(".") : [];
+        const rootKey = parsed.rootKey;
+        const targetComponentUid = target.targetComponentUid || parsed.targetComponentUid;
+        const targetIndexes = target.dynamicZoneIndexes;
         const attrDef = contentType?.attributes?.[attribute];
         const hasAttribute = Boolean(attrDef) || isComponentNested;
         if (hasAttribute) {
@@ -1249,12 +1452,25 @@ async function executeBatchInternal(strapi, {
             const currentEntryWithPopulate = await strapi.documents(target.uid).findOne(findOneArgs);
             const isRootDz = contentType?.attributes?.[rootKey]?.type === "dynamiczone";
             const existingRoot = currentEntryWithPopulate?.[rootKey] || (isRootDz ? [] : {});
-            const currentVal2 = getDeepProperty(existingRoot, parts.slice(1).join("."));
+            let affectedMatches = [];
+            if (isRootDz && Array.isArray(existingRoot)) {
+              affectedMatches = getAllNestedValues({ [rootKey]: existingRoot }, attribute);
+              if (targetIndexes && targetIndexes.length > 0) {
+                affectedMatches = affectedMatches.filter((m) => targetIndexes.includes(m.index));
+              }
+              if (targetComponentUid) {
+                affectedMatches = affectedMatches.filter((m) => m.componentUid === targetComponentUid);
+              }
+            }
+            const currentVal2 = isRootDz ? affectedMatches.length > 0 ? affectedMatches.map((m) => m.value).join(", ") : getDeepProperty(existingRoot, parts.slice(1).join(".")) : getDeepProperty(existingRoot, parts.slice(1).join("."));
             let newValue2 = value;
             if (regexObj && typeof currentVal2 === "string") {
               newValue2 = currentVal2.replace(regexObj, value);
             }
-            const updatedRoot = setDeepProperty(existingRoot, parts.slice(1), newValue2);
+            const updatedRoot = setDeepProperty(existingRoot, parts.slice(1), newValue2, {
+              targetIndexes,
+              targetComponentUid
+            });
             await strapi.documents(target.uid).update({
               documentId: target.documentId,
               data: {
@@ -1278,6 +1494,14 @@ async function executeBatchInternal(strapi, {
               userId: currentUser?.id,
               statusOverride: publishOnApproval && isDraftAndPublishComp ? "published" : void 0
             });
+            const dzDiffs = isRootDz && affectedMatches.length > 0 ? affectedMatches.map((m) => ({
+              index: m.index,
+              componentUid: m.componentUid,
+              componentName: m.componentName,
+              attribute: `${rootKey}[#${m.index} ${m.componentName}].${parts.slice(1).join(".")}`,
+              oldValue: m.value,
+              newValue: regexObj && typeof m.value === "string" ? m.value.replace(regexObj, value) : value
+            })) : [];
             return {
               uid: target.uid,
               collectionName: displayName,
@@ -1287,7 +1511,8 @@ async function executeBatchInternal(strapi, {
               oldValue: currentVal2 ?? null,
               newValue: newValue2,
               status: "updated",
-              message: `Successfully updated nested field ${attribute}`
+              message: isRootDz ? `Successfully updated ${affectedMatches.length} dynamic zone item(s) in ${attribute}` : `Successfully updated nested field ${attribute}`,
+              dynamicZoneDiffs: dzDiffs
             };
           }
           if (attrDef.type === "relation") {
@@ -1316,13 +1541,13 @@ async function executeBatchInternal(strapi, {
               newDisplay = "(cleared / unlinked)";
             } else {
               try {
-                const parsed = JSON.parse(value);
-                if (parsed && typeof parsed === "object" && parsed.mode) {
-                  mode = parsed.mode;
-                  targetDocIds = Array.isArray(parsed.documentIds) ? parsed.documentIds : parsed.documentId ? [parsed.documentId] : [];
-                  newDisplay = parsed.label || targetDocIds.join(", ") || `[${mode}]`;
-                } else if (Array.isArray(parsed)) {
-                  targetDocIds = parsed;
+                const parsed2 = JSON.parse(value);
+                if (parsed2 && typeof parsed2 === "object" && parsed2.mode) {
+                  mode = parsed2.mode;
+                  targetDocIds = Array.isArray(parsed2.documentIds) ? parsed2.documentIds : parsed2.documentId ? [parsed2.documentId] : [];
+                  newDisplay = parsed2.label || targetDocIds.join(", ") || `[${mode}]`;
+                } else if (Array.isArray(parsed2)) {
+                  targetDocIds = parsed2;
                   newDisplay = targetDocIds.join(", ");
                 } else {
                   targetDocIds = [value];
@@ -1466,6 +1691,26 @@ async function executeBatchInternal(strapi, {
     ...r,
     isLive: r.status === "updated"
   }));
+  const flattenedDiffs = [];
+  for (const r of results) {
+    if (r.dynamicZoneDiffs && r.dynamicZoneDiffs.length > 0) {
+      for (const dz of r.dynamicZoneDiffs) {
+        flattenedDiffs.push({
+          uid: r.uid,
+          collectionName: r.collectionName,
+          documentId: r.documentId,
+          label: `${r.label} [Block #${dz.index} (${dz.componentName})]`,
+          attribute: dz.attribute,
+          oldValue: dz.oldValue,
+          newValue: dz.newValue,
+          status: "updated",
+          message: `Updated ${dz.attribute}`
+        });
+      }
+    } else {
+      flattenedDiffs.push(r);
+    }
+  }
   const batchSummary = {
     batchId,
     attribute,
@@ -1477,7 +1722,7 @@ async function executeBatchInternal(strapi, {
   };
   await strapi.plugin("bulk-updater").service("audit").recordBatch(
     batchSummary,
-    results,
+    flattenedDiffs,
     currentUser
   );
   return {
@@ -1658,6 +1903,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 () => {
@@ -1669,7 +1930,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;
           }
@@ -1745,6 +2006,19 @@ const bulkUpdaterService = ({ strapi }) => {
                   colAttributesMeta
                 );
                 nestedComponentAttrs.push(...compAttrs);
+                const scopedAttrs = discoverComponentAttributes(
+                  strapi,
+                  compUid,
+                  `${attrKey}[${compUid}]`,
+                  1,
+                  5,
+                  systemFields,
+                  allContentTypes,
+                  relationsByAttr,
+                  allRelationsMeta,
+                  colAttributesMeta
+                );
+                nestedComponentAttrs.push(...scopedAttrs);
               }
               return false;
             }
@@ -1959,13 +2233,20 @@ const bulkUpdaterService = ({ strapi }) => {
       const attrs = contentType.attributes || {};
       let colHasAttribute = false;
       let isNestedAttr = false;
+      let isRootDz = false;
       let parts = [];
       if (targetFilterAttr) {
-        if (targetFilterAttr.includes(".")) {
+        const parsed = parseDynamicZonePath(targetFilterAttr);
+        if (parsed.rootKey && contentType.attributes?.[parsed.rootKey]?.type === "dynamiczone") {
+          isRootDz = true;
+          colHasAttribute = true;
+          isNestedAttr = true;
+          parts = parsed.cleanPath.split(".");
+        } else if (targetFilterAttr.includes(".") || targetFilterAttr.includes("[")) {
           isNestedAttr = isDeepComponentField(contentType, strapi.components, targetFilterAttr);
           if (isNestedAttr) {
             colHasAttribute = true;
-            parts = targetFilterAttr.split(".");
+            parts = parsed.cleanPath.split(".");
           }
         } else if (attrs[targetFilterAttr]) {
           colHasAttribute = true;
@@ -2022,8 +2303,11 @@ const bulkUpdaterService = ({ strapi }) => {
         }
         if (condition !== void 0) {
           if (isNestedAttr) {
-            const deepFilter = buildDeepFilter(parts, condition);
-            Object.assign(filters, deepFilter);
+            if (isRootDz) ;
+            else {
+              const deepFilter = buildDeepFilter(parts, condition);
+              Object.assign(filters, deepFilter);
+            }
           } else {
             if (normOp === "empty" && isStringLike) {
               filters.$or = [
@@ -2097,39 +2381,100 @@ const bulkUpdaterService = ({ strapi }) => {
         } else {
           sortClause["createdAt"] = "desc";
         }
-        const findManyArgs = {
-          start,
-          limit,
-          filters: Object.keys(filters).length > 0 ? filters : void 0,
-          sort: sortClause
-        };
-        if (populateOption) {
-          findManyArgs.populate = populateOption;
-        }
-        const [entries, totalEntries] = await Promise.all([
-          strapi.documents(uid).findMany(findManyArgs),
-          strapi.documents(uid).count({
-            filters: Object.keys(filters).length > 0 ? filters : void 0
-          })
-        ]);
-        const totalPages = Math.ceil(totalEntries / limit);
-        result = {
-          uid,
-          displayName: contentType.info?.displayName || uid,
-          isSingleType: false,
-          draftAndPublish: Boolean(contentType.options?.draftAndPublish),
-          entries: (entries || []).map((entry) => ({
-            id: entry.id,
-            documentId: entry.documentId,
-            ...entry
-          })),
-          pagination: {
-            page: currentPage,
-            pageSize: limit,
-            total: totalEntries,
-            pageCount: totalPages
+        if (isRootDz && normOp && normOp !== "none") {
+          const findManyArgs = {
+            limit: 500,
+            filters: Object.keys(filters).length > 0 ? filters : void 0,
+            sort: sortClause
+          };
+          if (populateOption) {
+            findManyArgs.populate = populateOption;
           }
-        };
+          const rawEntries = await strapi.documents(uid).findMany(findManyArgs);
+          const qVal = (filterQuery || "").trim().toLowerCase();
+          const passesDzFilter = (entry) => {
+            const matches = getAllNestedValues(entry, targetFilterAttr);
+            if (normOp === "empty") {
+              return matches.length === 0 || matches.every((m) => m.value === void 0 || m.value === null || String(m.value).trim() === "");
+            }
+            if (normOp === "notempty") {
+              return matches.some((m) => m.value !== void 0 && m.value !== null && String(m.value).trim() !== "");
+            }
+            return matches.some((m) => {
+              if (m.value === void 0 || m.value === null) return false;
+              const valStr = String(m.value).toLowerCase();
+              switch (normOp) {
+                case "equals":
+                  return valStr === qVal;
+                case "notequals":
+                  return valStr !== qVal;
+                case "contains":
+                  return valStr.includes(qVal);
+                case "notcontains":
+                  return !valStr.includes(qVal);
+                case "startswith":
+                  return valStr.startsWith(qVal);
+                case "endswith":
+                  return valStr.endsWith(qVal);
+                default:
+                  return true;
+              }
+            });
+          };
+          const matchedEntries = (rawEntries || []).filter(passesDzFilter);
+          const totalEntries = matchedEntries.length;
+          const paginatedEntries = matchedEntries.slice(start, start + limit);
+          result = {
+            uid,
+            displayName: contentType.info?.displayName || uid,
+            isSingleType: false,
+            draftAndPublish: Boolean(contentType.options?.draftAndPublish),
+            entries: paginatedEntries.map((entry) => ({
+              id: entry.id,
+              documentId: entry.documentId,
+              ...entry
+            })),
+            pagination: {
+              page: currentPage,
+              pageSize: limit,
+              total: totalEntries,
+              pageCount: Math.ceil(totalEntries / limit) || 1
+            }
+          };
+        } else {
+          const findManyArgs = {
+            start,
+            limit,
+            filters: Object.keys(filters).length > 0 ? filters : void 0,
+            sort: sortClause
+          };
+          if (populateOption) {
+            findManyArgs.populate = populateOption;
+          }
+          const [entries, totalEntries] = await Promise.all([
+            strapi.documents(uid).findMany(findManyArgs),
+            strapi.documents(uid).count({
+              filters: Object.keys(filters).length > 0 ? filters : void 0
+            })
+          ]);
+          result = {
+            uid,
+            displayName: contentType.info?.displayName || uid,
+            isSingleType: false,
+            draftAndPublish: Boolean(contentType.options?.draftAndPublish),
+            entries: (entries || []).map((entry) => ({
+              id: entry.id,
+              documentId: entry.documentId,
+              ...entry
+            })),
+            pagination: {
+              page: currentPage,
+              pageSize: limit,
+              total: totalEntries,
+              pageCount: Math.ceil(totalEntries / limit) || 1
+            }
+          };
+        }
       }
       if (queryCache.size >= MAX_QUERY_CACHE_SIZE) {
         const toDelete = Array.from(queryCache.keys()).slice(0, 100);
@@ -2198,7 +2543,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.");
@@ -2262,6 +2612,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") {
@@ -2841,7 +3234,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 {
@@ -2902,7 +3295,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 {
@@ -3149,6 +3542,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);
     }
   };
 };
@@ -4355,36 +4762,589 @@ 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":
+          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;
+      }
+    }
+    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";
@@ -4478,40 +5438,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)
     };
   },
@@ -4572,7 +5556,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 = [
@@ -4623,7 +5607,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];
@@ -4634,560 +5688,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 errors = [];
+    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) {
+          errors.push({
+            row: rowNumber,
+            error: "Missing or invalid documentId for Update Only mode."
+          });
+          rowHasError = true;
+        } else if (!existing) {
+          errors.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)) {
+              errors.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)) {
+              errors.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: errors.length > 0,
+      hasWarnings: warnings.length > 0,
+      errors: errors.slice(0, 100),
+      warnings: warnings.slice(0, 100),
+      totalErrorCount: errors.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
     };
   }
 });