diff --git a/api/src/services/wordpress.service.ts b/api/src/services/wordpress.service.ts
index 293899b3..5bd6058d 100644
--- a/api/src/services/wordpress.service.ts
+++ b/api/src/services/wordpress.service.ts
@@ -124,7 +124,7 @@ function getLastUid(uid : string) {
   return uid?.split?.('.')?.[uid?.split?.('.')?.length - 1];
 }
 
-async function createSchema(fields: any, blockJson : any, title: string, uid: string, assetData: any) {
+async function createSchema(fields: any, blockJson : any, title: string, uid: string, assetData: any, duplicateBlockMappings?: Record<string, string>) {
   const schema : any = {
     title: title,
     uid: uid,
@@ -162,16 +162,37 @@ async function createSchema(fields: any, blockJson : any, title: string, uid: st
             const blockName = (block?.attrs?.metadata?.name?.toLowerCase() || getFieldName(block?.blockName?.toLowerCase()));
             
             // Find which modular block child this block matches
-            const matchingChildField = fields.find((childField: any) => {
+            let matchingChildField = fields.find((childField: any) => {
               const fieldName = childField?.otherCmsField?.toLowerCase() ;
               
               return (childField?.contentstackFieldType !== 'modular_blocks_child') && (blockName === fieldName) 
             });
    
-            const matchingModularBlockChild = modularBlockChildren.find((childField: any) => {
+            let matchingModularBlockChild = modularBlockChildren.find((childField: any) => {
               const fieldName = childField?.otherCmsField?.toLowerCase() ;
               return  blockName === fieldName 
             });
+
+            // Fallback: if no direct match, check duplicate block mappings
+            if (!matchingModularBlockChild && duplicateBlockMappings) {
+              const mappedName = duplicateBlockMappings[blockName];
+              
+              if (mappedName) {
+                
+                matchingModularBlockChild = modularBlockChildren.find((childField: any) => {
+                  const fieldName = childField?.otherCmsField?.toLowerCase();
+                  return mappedName === fieldName;
+                });
+                
+                //if (!matchingChildField) {
+                  matchingChildField = fields.find((childField: any) => {
+                    const fieldName = childField?.otherCmsField?.toLowerCase();
+                    return (childField?.contentstackFieldType !== 'modular_blocks_child') && (mappedName === fieldName);
+                  });
+                 
+               // }
+              }
+            }
             
             //if (matchingChildField) {
               // Process innerBlocks (children) if they exist
@@ -186,12 +207,13 @@ async function createSchema(fields: any, blockJson : any, title: string, uid: st
                     const childField = fields.find((f: any) => {
                       const fUid = f?.contentstackFieldUid || '';
                       const fOtherCmsField = f?.otherCmsType?.toLowerCase();
-                      const childBlockName = (child?.attrs?.metadata?.name?.toLowerCase() || getFieldName(child?.blockName?.toLowerCase()));
-                      // Check if this field belongs to the modular_blocks_child and matches the block name
+                      const childBlockName = matchingChildField ? matchingChildField?.otherCmsField?.toLowerCase() :  (child?.attrs?.metadata?.name?.toLowerCase() || getFieldName(child?.blockName?.toLowerCase()));
+                      const childKey = getLastUid(f?.contentstackFieldUid);
+                      const alreadyPopulated = childrenObject[childKey] !== undefined && childrenObject[childKey] !== null;
                       return fUid.startsWith(childFieldUid + '.') &&
-                        (fOtherCmsField === childBlockName) && !childrenObject[getLastUid(f?.contentstackFieldUid)]?.length;
+                        (fOtherCmsField === childBlockName) && (!alreadyPopulated || f?.advanced?.multiple === true);
                     });
-                    
+                   
                     if (childField) {
                       const childKey = getLastUid(childField?.contentstackFieldUid);
                       
@@ -218,6 +240,7 @@ async function createSchema(fields: any, blockJson : any, title: string, uid: st
                             childrenObject[childKey] = [formattedChild];
                           }
                         } else {
+                          
                           formattedChild && (childrenObject[childKey] = formattedChild);
                         }
                       }
@@ -228,7 +251,13 @@ async function createSchema(fields: any, blockJson : any, title: string, uid: st
                 });
                 
                 // Add the block to the modular blocks array with the child field's UID as the key
-                Object.keys(childrenObject).length > 0 && modularBlocksArray.push({[getLastUid(matchingModularBlockChild?.contentstackFieldUid)] : childrenObject });
+                if (Object?.keys(childrenObject)?.length > 0) {
+                  modularBlocksArray.push({[getLastUid(matchingModularBlockChild?.contentstackFieldUid)] : childrenObject });
+                } else if (getLastUid(matchingModularBlockChild?.contentstackFieldUid) && matchingChildField) {
+                  // Fallback: inner blocks didn't match child fields (e.g., duplicate-mapped block with different inner block types)
+                  const formattedBlock = formatChildByType(block, matchingChildField, assetData);
+                  formattedBlock && modularBlocksArray.push({[getLastUid(matchingModularBlockChild?.contentstackFieldUid)] : { [getLastUid(matchingChildField?.contentstackFieldUid)]: formattedBlock }});
+                }
               } else if(getLastUid(matchingModularBlockChild?.contentstackFieldUid) && matchingChildField){
                 // Handle blocks with no inner blocks - format the block itself
                 const formattedBlock = formatChildByType(block, matchingChildField, assetData);
@@ -389,9 +418,17 @@ function formatChildByType(child: any, field: any, assetData: any) {
               formatted = Boolean(child?.attrs[attrKey]);
               break;
 
-            case 'json':
-              formatted = child?.blockName ? RteJsonConverter(formatted ?? child?.innerHTML) : RteJsonConverter(formatted ?? child);
+            case 'json': {
+              let htmlContent = formatted;
+              if (!htmlContent && child?.innerBlocks?.length > 0) {
+                htmlContent = collectHtmlFromInnerBlocks(child);
+              }
+              if (!htmlContent) {
+                htmlContent = child?.blockName ? child?.innerHTML : child;
+              }
+              formatted = RteJsonConverter(htmlContent);
               break;
+            }
 
             case 'html':
               formatted = child?.blockName ? formatted ?? child?.innerHTML : `<p>${child}</p>`;
@@ -471,7 +508,7 @@ const extractTermsReference = (terms: any) => {
   const termReference = termArray?.filter((term: any) => term?.attributes?.domain !== 'category');
   return termReference;
 }
-async function saveEntry(fields: any, entry: any,  file_path: string, assetData : any, categories: any, master_locale: string, destinationStackId: string, project: any, allTerms: any) {
+async function saveEntry(fields: any, entry: any,  file_path: string, assetData : any, categories: any, master_locale: string, destinationStackId: string, project: any, allTerms: any, duplicateBlockMappings?: Record<string, string>) {
   const locale = getLocale(master_locale, project);
   const mapperKeys = project?.mapperKeys || {};
   const authorsCtName = mapperKeys[MIGRATION_DATA_CONFIG.AUTHORS_DIR_NAME] ? mapperKeys[MIGRATION_DATA_CONFIG.AUTHORS_DIR_NAME] : MIGRATION_DATA_CONFIG.AUTHORS_DIR_NAME;
@@ -544,10 +581,11 @@ async function saveEntry(fields: any, entry: any,  file_path: string, assetData
           const contentEncoded = $(xmlItem)?.find("content\\:encoded")?.text() || '';
           const blocksJson = await setupWordPressBlocks(contentEncoded);
           customLogger(project?.id, destinationStackId,'info', `Processed blocks for entry ${uid}`);
-          //await writeFileAsync(`${uid}.json`, JSON.stringify(blocksJson, null, 4), 4);
+
+          
 
           // Pass individual content to createSchema
-          entryData[uid] = await createSchema(fields, blocksJson, item?.title, uid, assetData);
+          entryData[uid] = await createSchema(fields, blocksJson, item?.title, uid, assetData, duplicateBlockMappings);
           const categoryReference = extractCategoryReference(item?.['category']);
           if (categoryReference?.length > 0) {
             entryData[uid]['taxonomies'] = taxonomies;
@@ -586,6 +624,7 @@ async function createEntry(file_path: string, packagePath: string, destinationSt
   const entriesJsonData = JSON.parse(Jsondata);
   const entries = entriesJsonData?.rss?.channel?.["item"];
   const categories = entriesJsonData?.rss?.channel?.["wp:category"];
+  const allCategories = Array?.isArray(categories) ? categories : (categories ? [categories] : []);
 
   const authorsData = entriesJsonData?.rss?.channel?.["wp:author"];
   const authors = Array?.isArray(authorsData) ? authorsData : [authorsData];
@@ -669,15 +708,8 @@ async function createEntry(file_path: string, packagePath: string, destinationSt
     const entry = entries?.filter((entry: any) => {
       return entry?.['wp:post_type']?.toLowerCase() === contentTypeUid;
     });
-    
-      // for (const [type, items] of Object.entries(groupedByType)) {
-      //   if (Array.isArray(items) && items.length > 0) {
-      //     await extractItems(items,file_path);
-      //   } else {
-      //     console.log(`No ${type} found to extract`);
-      //   }
-      // }
-      const content = await saveEntry(contentType?.fieldMapping, entry,file_path, assetData, categories, master_locale, destinationStackId, project, allTerms) || {};
+
+      const content = await saveEntry(contentType?.fieldMapping, entry,file_path, assetData, allCategories, master_locale, destinationStackId, project, allTerms, contentType?.duplicateBlockMappings) || {};
       
       const filePath = path.join(postFolderPath,  `${locale}.json`);
       await writeFileAsync(filePath, content, 4);
@@ -696,7 +728,9 @@ async function createTaxonomy(file_path: string, packagePath: string, destinatio
 
   const Jsondata = await fs.promises.readFile(packagePath, "utf8");
   const xmlData = await fs.promises.readFile(file_path, "utf8");
-  const categoriesJsonData = JSON.parse(Jsondata)?.rss?.channel?.["wp:category"] || JSON.parse(Jsondata)?.channel?.["wp:category"] || [];
+  const categoriesData = JSON.parse(Jsondata)?.rss?.channel?.["wp:category"] || JSON.parse(Jsondata)?.channel?.["wp:category"];
+  const categoriesJsonData = Array?.isArray(categoriesData) ? categoriesData : (categoriesData ? [categoriesData] : []);
+
   if(categoriesJsonData?.length > 0){
     const allTaxonomies : any = {}
     for(const category of categoriesJsonData){
diff --git a/ui/src/components/AdvancePropertise/index.tsx b/ui/src/components/AdvancePropertise/index.tsx
index 605020e6..18165480 100644
--- a/ui/src/components/AdvancePropertise/index.tsx
+++ b/ui/src/components/AdvancePropertise/index.tsx
@@ -805,7 +805,7 @@ const AdvancePropertise = (props: SchemaProps) => {
               <Select
                 value={referencedTaxonomies}
                 isMulti={true}
-                isDisabled={isTaxonomiesLoading}
+                //isDisabled={isTaxonomiesLoading}
                 onChange={(selectedOptions: ContentTypeOption[]) => {
                   
                   setReferencedTaxonomies(selectedOptions);
@@ -858,15 +858,7 @@ const AdvancePropertise = (props: SchemaProps) => {
                 width="350px"
                 maxMenuHeight={200}
               />
-              {isTaxonomiesLoading ? (
-                <InstructionText>
-                  Loading taxonomies...
-                </InstructionText>
-              ) : sourceTaxonomies?.length === 0 && destinationTaxonomies?.length === 0 ? (
-                <InstructionText>
-                  No taxonomies found. Please upload source data or create taxonomies in your destination stack.
-                </InstructionText>
-              ) : null}
+           
             </Field>
           )}
 
diff --git a/ui/src/components/ContentMapper/index.tsx b/ui/src/components/ContentMapper/index.tsx
index 4ea40ccc..3f03cdae 100644
--- a/ui/src/components/ContentMapper/index.tsx
+++ b/ui/src/components/ContentMapper/index.tsx
@@ -1611,21 +1611,38 @@ const ContentMapper = forwardRef(({ handleStepChange }: contentMapperProps, ref:
     let groupId = '';
     let modularBlockId = '';
     let modularBlockChildId = '';
-    let nestedGroupId = '';
     const data: FieldMapType[] = [];
+
+    const findDeepestParentGroup = (children: FieldMapType[], fieldUid: string): FieldMapType | null => {
+      for (let i = children?.length - 1; i >= 0; i--) {
+        const child = children[i];
+        if (child?.contentstackFieldType === 'group' && fieldUid?.startsWith(child?.uid + '.')) {
+          const deeperMatch = findDeepestParentGroup(child?.child || [], fieldUid);
+          return deeperMatch || child;
+        }
+      }
+      return null;
+    };
+
+    const addFieldToParent = (parent: FieldMapType, field: FieldMapType) => {
+      const fieldToAdd = field?.contentstackFieldType === 'group' ? { ...field, child: [] } : field;
+      if (Object.hasOwn(parent, 'child')) {
+        parent?.child?.push(fieldToAdd);
+      } else {
+        parent.child = [fieldToAdd];
+      }
+    };
     
     schema?.forEach((field: FieldMapType) => {
       // Handle modular blocks parent
       if (field?.contentstackFieldType === 'modular_blocks') {
         modularBlockId = field?.uid;
         modularBlockChildId = '';
-        nestedGroupId = '';
         data?.push({ ...field, child: [] });
       }
       // Handle modular blocks child
       else if (field?.contentstackFieldType === 'modular_blocks_child' && field?.uid?.startsWith(modularBlockId + '.')) {
         modularBlockChildId = field?.uid;
-        nestedGroupId = '';
         const parentBlock = data[data?.length - 1];
         
         if (!parentBlock) {
@@ -1684,29 +1701,12 @@ const ContentMapper = forwardRef(({ handleStepChange }: contentMapperProps, ref:
             console.warn(
               `Child block exists but missing 'child' property: ${childBlock?.uid}`
             );
-          } else if (nestedGroupId && field?.uid?.startsWith(nestedGroupId + '.')) {
-            const nestedGroup = childBlock?.child?.find(
-              (c: FieldMapType) => c?.uid === nestedGroupId && c?.contentstackFieldType === 'group'
-            );
-            if (nestedGroup) {
-              if (Object.hasOwn(nestedGroup, 'child')) {
-                nestedGroup?.child?.push(field);
-              } else {
-                nestedGroup.child = [field];
-              }
-            } else {
-              console.warn(
-                `No nested group found for field: ${field?.uid}. ` +
-                `Expected group UID: ${nestedGroupId}`
-              );
-            }
           } else {
-            if (field?.contentstackFieldType === 'group') {
-              nestedGroupId = field?.uid;
-              childBlock?.child?.push({ ...field, child: [] });
+            const parentGroup = findDeepestParentGroup(childBlock?.child || [], field?.uid);
+            if (parentGroup) {
+              addFieldToParent(parentGroup, field);
             } else {
-              nestedGroupId = '';
-              childBlock?.child?.push(field);
+              addFieldToParent(childBlock, field);
             }
           }
         }
@@ -1715,16 +1715,16 @@ const ContentMapper = forwardRef(({ handleStepChange }: contentMapperProps, ref:
       else if (field?.contentstackFieldType === 'group') {
         groupId = field?.uid;
         modularBlockChildId = '';
-        nestedGroupId = '';
         data?.push({ ...field, child: [] });
       }
       // Handle fields within top-level groups
       else if (field?.uid?.startsWith(groupId + '.')) {
         const obj = data[data?.length - 1];
-        if (Object.hasOwn(obj, 'child')) {
-          obj?.child?.push(field);
+        const parentGroup = findDeepestParentGroup(obj?.child || [], field?.uid);
+        if (parentGroup) {
+          addFieldToParent(parentGroup, field);
         } else {
-          obj.child = [field];
+          addFieldToParent(obj, field);
         }
       }
       // Handle standalone fields
@@ -2017,21 +2017,31 @@ const ContentMapper = forwardRef(({ handleStepChange }: contentMapperProps, ref:
     else if (value?.data_type === 'group') {
 
         if (data?.backupFieldType === 'group' && checkConditions('Group', value, data) ) {
-          OptionsForRow.push(getMatchingOption(value, true, updatedDisplayName, uid ?? ''));
+          const newOption = getMatchingOption(value, true, updatedDisplayName, uid ?? '');
+          const isDuplicate = OptionsForRow?.some(
+            (opt: any) => opt?.label === newOption?.label && opt?.uid === newOption?.uid
+          );
+          if (!isDuplicate) {
+            OptionsForRow.push(newOption);
+          }
         }
       
           const existingLabel = existingField[groupArray?.[0]?.backupFieldUid]?.label ?? '';
          
-          const lastLabelSegment = existingLabel.includes('>')
+          const lastLabelSegment = existingLabel?.includes('>')
             ? existingLabel?.split('>')?.pop()?.trim()
             : existingLabel;
-      
+          
           if (value?.display_name === lastLabelSegment) {
-            // Process nested schemas within the current group
-            for (const item of array) {
-             
+            const groupUid = groupArray?.[0]?.uid ?? '';
+            const groupDepth = groupUid?.split('.')?.length ?? 0;
+
+            for (const item of groupArray?.[0]?.child || []) {
               const fieldTypeToMatch = Fields[item?.backupFieldType as keyof Mapping]?.type;
-              if (item?.id === data?.id) {
+              const itemDepth = item?.uid?.split('.')?.length ?? 0;
+              const isRootLevelChild = itemDepth === groupDepth + 1;
+
+              if (item?.id === data?.id && isRootLevelChild) {
                 for (const key of existingField[groupArray?.[0]?.backupFieldUid]?.value?.schema || []) {
                   if (checkConditions(fieldTypeToMatch, key, item)) {
                     OptionsForRow.push(getMatchingOption(
@@ -2041,18 +2051,28 @@ const ContentMapper = forwardRef(({ handleStepChange }: contentMapperProps, ref:
                       `${uid}.${key?.uid}`
                     ));
                   }
-
-                  // Recursively process nested groups
-                  if (key?.data_type === 'group') {
-                    processSchema(key, data, array, groupArray, OptionsForRow, fieldsOfContentstack, updatedDisplayName, uid);
-                  }
                 }
               }
             }
 
+            for (const key of existingField[groupArray?.[0]?.backupFieldUid]?.value?.schema || []) {
+              if (key?.data_type === 'group') {
+           
+                const nestedGroupUid = data?.uid?.split('.')?.slice(0, groupDepth + 1)?.join('.');
+       
+                const nestedGroupField = groupArray?.[0]?.child?.find(
+                  (c: FieldMapType) => c?.uid === nestedGroupUid && c?.contentstackFieldType === 'group'
+                );
+                const nestedGroupChildren = nestedGroupField?.child || [];
+                const nestedGroupArr = nestedGroupField ? [nestedGroupField] : [];
+                
+                processSchema(key, data, nestedGroupChildren, nestedGroupArr, OptionsForRow, fieldsOfContentstack, updatedDisplayName, uid);
+              }
+            }
+
           }
           else {
-            for (const key of value.schema || []) {
+            for (const key of value?.schema || []) {
               if (key?.data_type === 'group') {
                 processSchema(key, data, array, groupArray, OptionsForRow, fieldsOfContentstack, updatedDisplayName, uid);
               }
@@ -2064,15 +2084,18 @@ const ContentMapper = forwardRef(({ handleStepChange }: contentMapperProps, ref:
           const fieldTypeToMatch = Fields[data?.backupFieldType as keyof Mapping]?.type;
          
           if (!array.some((item: FieldMapType) => item?.id === data?.id) && checkConditions(fieldTypeToMatch, value, data)) {
+        
             OptionsForRow.push(getMatchingOption(value, true, updatedDisplayName || '', uid ?? ''));
           }
 
           // Process nested schemas if value is not a group
           for (const item of array) {
             if (item?.id === data?.id) {
+            
               for (const key of value?.schema || []) {
                
                 if (checkConditions(fieldTypeToMatch, key, item)) {
+                  
                   OptionsForRow.push(getMatchingOption(
                     key,
                     true,
@@ -2161,21 +2184,30 @@ const ContentMapper = forwardRef(({ handleStepChange }: contentMapperProps, ref:
           const array = groupArray?.[0]?.child || [];
          
   
-          const parentBlockUid = data?.uid?.split('.')?.slice(0, -1)?.join('.');
-          const parentBlock = nestedList.filter(item =>
-            item?.child?.some(e => e?.uid === parentBlockUid)
-          );
+          const uidSegments = data?.uid?.split('.') || [];
+          let parentBlock: FieldMapType[] = [];
+          for (let i = uidSegments?.length - 1; i >= 1; i--) {
+            const ancestorUid = uidSegments?.slice(0, i)?.join('.');
+            parentBlock = nestedList?.filter(item =>
+              item?.child?.some(e => e?.uid === ancestorUid)
+            );
+            if (parentBlock?.length) break;
+          }
+       
          
           // Process modular blocks
           if (value?.data_type === 'blocks') {
+    
             processSchema(value, data, parentBlock[0]?.child || [], groupArray, OptionsForRow, fieldsOfContentstack);
           }
           // Process groups
-          else if (value?.data_type === 'group') {        
+          else if (value?.data_type === 'group') {  
+            
             processSchema(value, data, array, groupArray, OptionsForRow, fieldsOfContentstack);
           }
           // Process leaf fields
           else if (!array?.some(item => item?.id === data?.id) && checkConditions(fieldTypeToMatch, value, data) && !parentBlock?.length) {
+          
             OptionsForRow.push(getMatchingOption(value, true, value?.display_name || '', value?.uid ?? ''));
           }
         }
@@ -2324,7 +2356,8 @@ const ContentMapper = forwardRef(({ handleStepChange }: contentMapperProps, ref:
           (data?.backupFieldType !== 'extension' &&
             data?.backupFieldType !== 'app' &&
             data?.backupFieldUid !== 'title' &&
-            data?.backupFieldUid !== 'url')) && (
+            data?.backupFieldUid !== 'url' &&
+            data?.backupFieldType !== 'modular_blocks_child')) && (
             <div className='advanced-setting-button'>
               <Tooltip
                 content="Advanced properties"
diff --git a/upload-api/migration-wordpress/libs/extractItems.ts b/upload-api/migration-wordpress/libs/extractItems.ts
index 90eeda3f..e368720e 100644
--- a/upload-api/migration-wordpress/libs/extractItems.ts
+++ b/upload-api/migration-wordpress/libs/extractItems.ts
@@ -11,9 +11,18 @@ import config from '../config/index.json';
 import extractTaxonomy from './extractTaxonomy';
 import { DataConfig, Field, CT } from '../interface/interface';
 
-const { contentTypes: contentTypesConfig } = config.modules;
+const MEDIA_BLOCK_NAMES = ['core/image', 'core/video', 'core/audio', 'core/file'];
 
-const contentTypeFolderPath = path.resolve(config.data, contentTypesConfig.dirName);
+function resolveBlockName(field: any): string {
+  if (field?.attributes?.metadata?.name) return field.attributes.metadata.name;
+  if (field?.name === 'core/missing') return 'body';
+  if (MEDIA_BLOCK_NAMES.includes(field?.name)) return 'media';
+  return field?.name;
+}
+
+const { contentTypes: contentTypesConfig } = config?.modules;
+
+const contentTypeFolderPath = path.resolve(config?.data, contentTypesConfig?.dirName);
 
 function findSimilarBlocks(data: any[][], targetId: string) {
   for (const group of data) {
@@ -183,12 +192,13 @@ function getLastUid(uid : string) {
 }
 
 const extractItems = async (item: any, config: DataConfig, type: string, affix: string, categories: any, terms: any) => {
-    const localPath = config.localPath;
+    const localPath = config?.localPath;
     const xmlData = await fs.promises.readFile(localPath, "utf8");
     const $ = cheerio.load(xmlData, { xmlMode: true });
     const items = $('item');
     const authorsData = $('wp\\author');
     const CT: CT = [];
+    const duplicateBlockMappings: Record<string, string> = {};
     let isCategories : boolean = false;
     let isTermReffered : boolean = false;
 
@@ -288,7 +298,7 @@ const extractItems = async (item: any, config: DataConfig, type: string, affix:
 
         const contentEncoded = targetItem?.find("content\\:encoded")?.text() || '';
         const blocksJson = await setupWordPressBlocks(contentEncoded);
-        //await helper?.writeFileAsync(`${data?.title || 'undefined'}.json`, JSON.stringify({blocks : blocksJson, count :blocksJson?.length}, null, 4), 4);
+      
 
   
         // Example usage
@@ -300,7 +310,7 @@ const extractItems = async (item: any, config: DataConfig, type: string, affix:
         
         for (const field of blocksJson) {
             const fieldUid = getFieldUid(`${field?.name}_${field?.clientId}`|| '', affix || '');
-            const contentstackFieldName = getFieldName(field?.attributes?.metadata?.name ?? (field?.name === 'core/missing' ? 'body' : field?.name));
+            const contentstackFieldName = getFieldName(resolveBlockName(field));
 
             const similarBlocks = findSimilarBlocks(result, field?.clientId);
 
@@ -310,8 +320,8 @@ const extractItems = async (item: any, config: DataConfig, type: string, affix:
             .filter((name, index, array) => name && array?.indexOf(name) === index) // Remove duplicates
             .sort(); // Sort for consistency
      
-            const filterOutBlock = allBlockNames?.filter((item)=> item !== (field?.attributes?.metadata?.name ?? (field?.name === 'core/missing' ? 'body' : field?.name)));
-            const fieldDisplayName = getFieldName( field?.attributes?.metadata?.name ?? (field?.name === 'core/missing' ? 'body' : field?.name));
+            const filterOutBlock = allBlockNames?.filter((item)=> item !== resolveBlockName(field));
+            const fieldDisplayName = getFieldName(resolveBlockName(field));
             const firstFilterBlock = filterOutBlock?.[0] ? `Modular Blocks > ${filterOutBlock?.[0]}` : null;
             
             const generatedFieldName = `Modular Blocks > ${fieldDisplayName}`;
@@ -334,7 +344,7 @@ const extractItems = async (item: any, config: DataConfig, type: string, affix:
             // If this block has similar structures
             if (similarBlocks?.length > 0) {
               // Create a unique key based on the structure/name to track processed groups
-              const groupKey = field?.attributes?.metadata?.name ?? (field?.name === 'core/missing' ? 'body' : field?.name);
+              const groupKey = resolveBlockName(field);
               // Skip if we've already processed this group of similar blocks
               if (processedSimilarBlocks?.has?.(groupKey) || existingBlock) {
                   continue;
@@ -354,8 +364,8 @@ const extractItems = async (item: any, config: DataConfig, type: string, affix:
                 const duplicateBlock = findDuplicateModularBlockChild(Schema, CT);
                 
                 if (duplicateBlock) {
-                  // Duplicate found - skip adding this modular block child and its Fieldschema
                   console.log(`Skipping duplicate modular block child: "${groupedContentstackField}" (duplicate of "${duplicateBlock.contentstackField}")`);
+                  duplicateBlockMappings[contentstackFieldName?.toLowerCase()] = duplicateBlock.otherCmsField?.toLowerCase();
                   continue;
                 }
                 
@@ -398,10 +408,10 @@ const extractItems = async (item: any, config: DataConfig, type: string, affix:
             } 
             else {
               // Handle single blocks (no similar structures found)
-              const singleBlockName = getFieldName(field?.attributes?.metadata?.name ?? (field?.name === 'core/missing' ? 'body' : field?.name));
+              const singleBlockName = getFieldName(resolveBlockName(field));
              
-              if(!existingBlock && ! processedSimilarBlocks?.has?.(field?.attributes?.metadata?.name ?? getFieldName(field?.name === 'core/missing' ? 'body' : field?.name) )){
-                processedSimilarBlocks?.add?.(field?.attributes?.metadata?.name ?? (field?.name === 'core/missing' ? 'body' : field?.name));
+              if(!existingBlock && ! processedSimilarBlocks?.has?.(resolveBlockName(field))){
+                processedSimilarBlocks?.add?.(resolveBlockName(field));
                 
                 // Generate Fieldschema first to check for duplicates
                 const Fieldschema: Field[] | Field = await schemaMapper(field?.innerBlocks?.length > 0 ? field?.innerBlocks : field, `modular_blocks.${fieldUid}`, groupedContentstackField, affix || '');
@@ -410,8 +420,8 @@ const extractItems = async (item: any, config: DataConfig, type: string, affix:
                 const duplicateBlock = findDuplicateModularBlockChild(Schema, CT);
                 
                 if (duplicateBlock) {
-                  // Duplicate found - skip adding this modular block child and its Fieldschema
                   console.log(`Skipping duplicate modular block child: "Modular Blocks > ${singleBlockName}" (duplicate of "${duplicateBlock.contentstackField}")`);
+                  duplicateBlockMappings[singleBlockName?.toLowerCase()] = duplicateBlock.otherCmsField?.toLowerCase();
                   continue;
                 }
                 
@@ -501,7 +511,7 @@ const extractItems = async (item: any, config: DataConfig, type: string, affix:
     }
 
     const filePath = path.join(contentTypeFolderPath, `${type?.toLowerCase()}.json`);
-        const contentType = {
+        const contentType: Record<string, any> = {
             "status": 1,
             "isUpdated": false,
             "updateAt": "",
@@ -512,6 +522,9 @@ const extractItems = async (item: any, config: DataConfig, type: string, affix:
             "type": "content_type",
             "fieldMapping": CT
         };
+        if (Object?.keys(duplicateBlockMappings)?.length > 0) {
+          contentType.duplicateBlockMappings = duplicateBlockMappings;
+        }
 
     try {
         await helper.writeFileAsync(
diff --git a/upload-api/migration-wordpress/libs/schemaMapper.ts b/upload-api/migration-wordpress/libs/schemaMapper.ts
index 801ab96d..6fe01300 100644
--- a/upload-api/migration-wordpress/libs/schemaMapper.ts
+++ b/upload-api/migration-wordpress/libs/schemaMapper.ts
@@ -2,6 +2,15 @@ import { Field, WordPressBlock } from '../interface/interface';
 import restrictedUid from '../utils/index';
 import GenerateSchema from 'generate-schema';
 
+const MEDIA_BLOCK_NAMES = ['core/image', 'core/video', 'core/audio', 'core/file'];
+
+function resolveBlockName(key: any): string {
+  if (key?.attributes?.metadata?.name) return key.attributes.metadata.name;
+  if (key?.name === 'core/missing') return 'body';
+  if (MEDIA_BLOCK_NAMES.includes(key?.name)) return 'media';
+  return key?.name;
+}
+
 const getFieldName = (key: string   ) => {
     if(key?.includes('/')){
         return key?.split('/')?.[1];
@@ -152,13 +161,16 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
         const schemas: Field[] = [];
         for (const item of key) {
             const result = await schemaMapper(item, parentUid, parentFieldName, affix);
-            const existingBlock: Field | undefined = schemas.find((schemaItem: Field) => 
-                result?.otherCmsField === schemaItem?.otherCmsField && 
-                schemaItem?.contentstackFieldType === result?.contentstackFieldType && 
-                schemaItem?.contentstackField === result?.contentstackField &&
-                result?.contentstackFieldUid?.includes(parentUid)
-            );
-                item?.contentstackFieldUid?.includes(parentUid) ; 
+
+            const compareField = Array.isArray(result) ? result[0] : result;
+            const existingBlock: Field | undefined = compareField ? schemas.find((schemaItem: Field) => 
+                compareField?.otherCmsField === schemaItem?.otherCmsField && 
+                schemaItem?.contentstackFieldType === compareField?.contentstackFieldType && 
+                schemaItem?.contentstackField === compareField?.contentstackField &&
+                parentUid && compareField?.contentstackFieldUid?.includes(parentUid) &&
+                parentUid && schemaItem?.contentstackFieldUid?.includes(parentUid)
+            ) : undefined;
+
             if (existingBlock && typeof existingBlock === 'object' && 'advanced' in existingBlock) {
                 existingBlock.advanced = {
                   ...(existingBlock.advanced as object),
@@ -175,7 +187,7 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
         return schemas;
     }
     
-    const fieldName = parentFieldName ? `${parentFieldName} > ${getFieldName(key?.attributes?.metadata?.name ?? (key?.name === 'core/missing' ? 'body' : key?.name))}` : getFieldName(key?.attributes?.metadata?.name ?? (key?.name === 'core/missing' ? 'body' : key?.name));
+    const fieldName = parentFieldName ? `${parentFieldName} > ${getFieldName(resolveBlockName(key))}` : getFieldName(resolveBlockName(key));
     
     switch (key?.name) {
         case 'core/paragraph':
@@ -184,6 +196,7 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
         case 'core/table':
         case 'core/columns':
         case 'core/missing':
+        case 'core/verse':
         case 'core/code': {
             const rteUid = parentUid ?
             `${parentUid}.${getFieldUid(`${key?.name}_${key?.clientId}`, affix)}`
@@ -200,7 +213,6 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
                 advanced: {}
             };
         }
-        break;
         case 'core/image':
         case 'core/audio':
         case 'core/video':
@@ -209,9 +221,9 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
             
             return {
                 uid: fileUid,
-                otherCmsField: getFieldName(key?.name),
+                otherCmsField: 'media',
                 otherCmsType: getFieldName(key?.attributes?.metadata?.name ?? key?.name),
-                contentstackField: fieldName,
+                contentstackField: 'media',
                 contentstackFieldUid: fileUid,
                 contentstackFieldType: 'file',
                 backupFieldType: 'file',
@@ -219,9 +231,9 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
                 advanced: {}
             };
         }
-        break;
-            
+
         case 'core/heading':
+        case 'core/accordion-heading':
         case 'core/list-item': {
             const textUid = parentUid ? `${parentUid}.${getFieldUid(`${key?.name}_${key?.clientId}`, affix)}` : getFieldUid(`${key?.name}_${key?.clientId}`, affix);
             return {
@@ -236,7 +248,7 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
                 advanced: {}
             };
         }
-        break;
+
         case 'core/social-link':
         case 'core/navigation-link': {
            
@@ -253,13 +265,15 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
                 advanced: {}
             };
         }
-        break;
+        
         case 'core/list':
         case 'core/quote':
         case 'core/cover':
         case 'core/social-links':
         case 'core/details':
         case 'core/group':
+        case 'core/accordion-item':
+        case 'core/accordion-panel':
         case 'core/navigation': {
             const groupSchema: Field[] = [];
             const groupUid = parentUid ? `${parentUid}.${getFieldUid(`${key?.name}_${key?.clientId}`, affix)}` : getFieldUid(`${key?.name}_${key?.clientId}`, affix);
@@ -298,7 +312,7 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
             }
             
         }
-        break;
+        
         case 'core/search': {
             const searchEleUid = parentUid ? `${parentUid}.${getFieldUid(`${key?.name}_${key?.clientId}`, affix)}` : getFieldUid(`${key?.name}_${key?.clientId}`, affix);
             const searchEle = await processAttributes(key, searchEleUid,fieldName, affix);
@@ -314,15 +328,26 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
             });
             return searchEle;
         }
-        break;
+        
            
         case 'core/button': {
-            const parentName = parentFieldName ? `${parentFieldName}` :  `${getFieldName(key?.attributes?.metadata?.name ?? key?.name)}` ;
-            const buttonUid = parentUid ? `${parentUid}` : getFieldUid(`${key?.name}_${key?.clientId}`, affix);
-            const button = await processAttributes(key, buttonUid, parentName, affix);
-            return button;
+            const fieldName = parentFieldName ? `${parentFieldName} > ${getFieldName(key?.attributes?.metadata?.name ?? key?.name)}` :  `${getFieldName(key?.attributes?.metadata?.name ?? key?.name)}` ;
+            const buttonUid = parentUid ? `${parentUid}.${getFieldUid(`${key?.name}_${key?.clientId}`, affix)}` : getFieldUid(`${key?.name}_${key?.clientId}`, affix);
+
+            return { 
+                uid: buttonUid,
+                otherCmsField: getFieldName(key?.name),
+                otherCmsType: getFieldName(key?.attributes?.metadata?.name ?? key?.name),
+                contentstackField: fieldName,
+                contentstackFieldUid: buttonUid,
+                contentstackFieldType: 'link',
+                backupFieldType: 'link',
+                backupFieldUid: buttonUid,
+
+            };
+            
         }
-        break;
+        
         case 'core/buttons': { 
             const groupSchema: Field[] = [];
             const groupUid = parentUid ? `${parentUid}.${getFieldUid(`${key?.name}_${key?.clientId}`, affix)}` : getFieldUid(`${key?.name}_${key?.clientId}`, affix);
@@ -333,19 +358,30 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
                 fieldName,
                 affix
             );
-            innerBlocks?.length > 0 && groupSchema.push({
-                uid: groupUid,
-                otherCmsField: getFieldName(key?.name),
-                otherCmsType: getFieldName(key?.attributes?.metadata?.name ?? key?.name),
-                contentstackField: fieldName,
-                contentstackFieldUid: groupUid,
-                contentstackFieldType: 'group',
-                backupFieldType: 'group',
-                backupFieldUid: groupUid,
-                advanced: {}
-            });
-        
-            if(innerBlocks?.length > 0 ){
+            if (innerBlocks?.length === 1) {
+                const items = Array.isArray(innerBlocks[0]) ? innerBlocks[0] : [innerBlocks[0]];
+                items.forEach((item: Field) => {
+                    item.uid = `${parentUid}.${getFieldUid(`${key?.name}_${key?.clientId}`, affix)}`,
+                    item.contentstackField = `${parentFieldName} > ${getFieldName(resolveBlockName(key))}`;
+                    item.contentstackFieldUid = `${parentUid}.${getFieldUid(`${key?.name}_${key?.clientId}`, affix)}`,
+                    item.backupFieldUid = `${parentUid}.${getFieldUid(`${key?.name}_${key?.clientId}`, affix)}`
+                });
+                return items;
+            }
+
+            if (innerBlocks?.length > 1) {
+                groupSchema.push({
+                    uid: groupUid,
+                    otherCmsField: getFieldName(key?.name),
+                    otherCmsType: getFieldName(key?.attributes?.metadata?.name ?? key?.name),
+                    contentstackField: fieldName,
+                    contentstackFieldUid: groupUid,
+                    contentstackFieldType: 'group',
+                    backupFieldType: 'group',
+                    backupFieldUid: groupUid,
+                    advanced: {}
+                });
+
                 innerBlocks.forEach(schemaObj => {
                     if (schemaObj) {
                         if (Array.isArray(schemaObj)) {
@@ -356,12 +392,11 @@ async function schemaMapper (key: WordPressBlock | WordPressBlock[], parentUid:
                     }
                 }); 
             
-                return groupSchema;   
-
+                return groupSchema;
             }
            
         }
-        break;
+        
 
     }
     return [];
diff --git a/upload-api/tests/unit/migration-wordpress/schemaMapper.test.ts b/upload-api/tests/unit/migration-wordpress/schemaMapper.test.ts
new file mode 100644
index 00000000..38f41ccf
--- /dev/null
+++ b/upload-api/tests/unit/migration-wordpress/schemaMapper.test.ts
@@ -0,0 +1,326 @@
+import { describe, it, expect, vi } from 'vitest';
+import { schemaMapper, getFieldName, getFieldUid, handleAttributesSchema } from '../../../migration-wordpress/libs/schemaMapper';
+import { WordPressBlock } from '../../../migration-wordpress/interface/interface';
+
+function makeBlock(overrides: Partial<WordPressBlock> & { name: string }): WordPressBlock {
+  return {
+    clientId: 'c1',
+    attributes: {},
+    innerBlocks: [],
+    ...overrides,
+  };
+}
+
+const affix = 'wp';
+
+describe('getFieldName', () => {
+  it('returns the part after "/" for slash-separated names', () => {
+    expect(getFieldName('core/paragraph')).toBe('paragraph');
+  });
+
+  it('returns the original key when no "/" or "wp:" prefix', () => {
+    expect(getFieldName('title')).toBe('title');
+  });
+
+  it('strips "wp:" prefix and joins remaining parts', () => {
+    expect(getFieldName('wp:post_title')).toBe('title');
+    expect(getFieldName('wp:post_author_name')).toBe('author name');
+  });
+});
+
+describe('getFieldUid', () => {
+  it('returns the part after "/" lowercased with hyphens replaced', () => {
+    expect(getFieldUid('core/my-block', affix)).toBe('my_block');
+  });
+
+  it('returns the key as-is (lowercased) when no special prefix', () => {
+    expect(getFieldUid('MyField', affix)).toBe('myfield');
+  });
+
+  it('strips "wp:" prefix', () => {
+    expect(getFieldUid('wp:meta_value', affix)).toBe('meta_value');
+  });
+
+  it('returns falsy input unchanged', () => {
+    expect(getFieldUid('', affix)).toBe('');
+  });
+
+  it('prefixes with affix when uid is a restricted keyword', () => {
+    expect(getFieldUid('core/tags', affix)).toBe('wp_tags');
+    expect(getFieldUid('core/locale', affix)).toBe('wp_locale');
+  });
+});
+
+describe('handleAttributesSchema', () => {
+  it('maps string properties to single_line_text', async () => {
+    const schema = { title: { type: 'string' } };
+    const result = await handleAttributesSchema(schema, null, 'root', affix);
+    expect(result).toHaveLength(1);
+    expect(result[0].contentstackFieldType).toBe('single_line_text');
+    expect(result[0].otherCmsField).toBe('title');
+  });
+
+  it('maps boolean properties', async () => {
+    const schema = { isActive: { type: 'boolean' } };
+    const result = await handleAttributesSchema(schema, null, 'root', affix);
+    expect(result[0].contentstackFieldType).toBe('boolean');
+  });
+
+  it('maps number properties', async () => {
+    const schema = { count: { type: 'number' } };
+    const result = await handleAttributesSchema(schema, null, 'root', affix);
+    expect(result[0].contentstackFieldType).toBe('number');
+  });
+
+  it('excludes the "id" field', async () => {
+    const schema = { id: { type: 'string' }, name: { type: 'string' } };
+    const result = await handleAttributesSchema(schema, null, 'root', affix);
+    expect(result).toHaveLength(1);
+    expect(result[0].otherCmsField).toBe('name');
+  });
+
+  it('prefixes uid with parentUid when provided', async () => {
+    const schema = { title: { type: 'string' } };
+    const result = await handleAttributesSchema(schema, 'parent_group', 'root', affix);
+    expect(result[0].contentstackFieldUid).toBe('parent_group.title');
+    expect(result[0].contentstackField).toBe('root > title');
+  });
+});
+
+describe('schemaMapper', () => {
+  describe('core/paragraph and RTE blocks', () => {
+    const rteBlockNames = ['core/paragraph', 'core/html', 'core/pullquote', 'core/table', 'core/columns', 'core/verse', 'core/code'];
+
+    rteBlockNames.forEach((blockName) => {
+      it(`maps ${blockName} to json type`, async () => {
+        const block = makeBlock({ name: blockName });
+        const result = await schemaMapper(block, null, null, affix);
+        expect(result).toMatchObject({
+          otherCmsField: getFieldName(blockName),
+          contentstackFieldType: 'json',
+          backupFieldType: 'json',
+        });
+      });
+    });
+
+    it('maps core/missing to json type with "body" fieldName', async () => {
+      const block = makeBlock({ name: 'core/missing' });
+      const result = await schemaMapper(block, null, null, affix);
+      expect(result.contentstackFieldType).toBe('json');
+      expect(result.contentstackField).toBe('body');
+    });
+  });
+
+  describe('media blocks', () => {
+    const mediaBlockNames = ['core/image', 'core/audio', 'core/video', 'core/file'];
+
+    mediaBlockNames.forEach((blockName) => {
+      it(`maps ${blockName} to file type`, async () => {
+        const block = makeBlock({ name: blockName });
+        const result = await schemaMapper(block, null, null, affix);
+        expect(result).toMatchObject({
+          otherCmsField: 'media',
+          contentstackField: 'media',
+          contentstackFieldType: 'file',
+          backupFieldType: 'file',
+        });
+      });
+    });
+  });
+
+  describe('text blocks (heading, list-item)', () => {
+    const textBlockNames = ['core/heading', 'core/accordion-heading', 'core/list-item'];
+
+    textBlockNames.forEach((blockName) => {
+      it(`maps ${blockName} to single_line_text`, async () => {
+        const block = makeBlock({ name: blockName });
+        const result = await schemaMapper(block, null, null, affix);
+        expect(result).toMatchObject({
+          otherCmsField: getFieldName(blockName),
+          contentstackFieldType: 'single_line_text',
+          backupFieldType: 'single_line_text',
+        });
+      });
+    });
+  });
+
+  describe('link blocks', () => {
+    it('maps core/social-link to link type', async () => {
+      const block = makeBlock({ name: 'core/social-link' });
+      const result = await schemaMapper(block, null, null, affix);
+      expect(result.contentstackFieldType).toBe('link');
+    });
+
+    it('maps core/navigation-link to link type', async () => {
+      const block = makeBlock({ name: 'core/navigation-link' });
+      const result = await schemaMapper(block, null, null, affix);
+      expect(result.contentstackFieldType).toBe('link');
+    });
+  });
+
+  describe('core/button', () => {
+    it('returns a link field for a button block', async () => {
+      const block = makeBlock({ name: 'core/button', clientId: 'btn1' });
+      const result = await schemaMapper(block, null, null, affix);
+      expect(result).toMatchObject({
+        otherCmsField: 'button',
+        contentstackFieldType: 'link',
+        backupFieldType: 'link',
+      });
+    });
+
+    it('uses metadata name when available', async () => {
+      const block = makeBlock({
+        name: 'core/button',
+        clientId: 'btn1',
+        attributes: { metadata: { name: 'cta_button' } },
+      });
+      const result = await schemaMapper(block, null, null, affix);
+      expect(result.otherCmsType).toBe('cta_button');
+      expect(result.contentstackField).toBe('cta_button');
+    });
+
+    it('nests uid under parentUid when provided', async () => {
+      const block = makeBlock({ name: 'core/button', clientId: 'btn1' });
+      const result = await schemaMapper(block, 'parent', 'Parent', affix);
+      expect(result.uid).toContain('parent.');
+      expect(result.contentstackField).toContain('Parent > ');
+    });
+  });
+
+  describe('core/buttons', () => {
+    it('returns [] when there are no inner blocks', async () => {
+      const block = makeBlock({ name: 'core/buttons', clientId: 'btns1', innerBlocks: [] });
+      const result = await schemaMapper(block, null, null, affix);
+      expect(result).toEqual([]);
+    });
+
+    it('returns inner block fields directly (no group wrapper) for 1 inner block', async () => {
+      const innerButton = makeBlock({ name: 'core/button', clientId: 'btn1' });
+      const block = makeBlock({ name: 'core/buttons', clientId: 'btns1', innerBlocks: [innerButton] });
+      const result = await schemaMapper(block, 'page', 'Page', affix);
+
+      expect(Array.isArray(result)).toBe(true);
+      const groupFields = result.filter((f: any) => f.contentstackFieldType === 'group');
+      expect(groupFields).toHaveLength(0);
+      expect(result.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('overwrites uid/contentstackField/contentstackFieldUid/backupFieldUid for single inner block', async () => {
+      const innerButton = makeBlock({ name: 'core/button', clientId: 'btn1' });
+      const block = makeBlock({ name: 'core/buttons', clientId: 'btns1', innerBlocks: [innerButton] });
+      const result = await schemaMapper(block, 'page', 'Page', affix);
+
+      result.forEach((field: any) => {
+        expect(field.contentstackFieldUid).toBe(`page.${getFieldUid('core/buttons_btns1', affix)}`);
+        expect(field.uid).toBe(`page.${getFieldUid('core/buttons_btns1', affix)}`);
+        expect(field.backupFieldUid).toBe(`page.${getFieldUid('core/buttons_btns1', affix)}`);
+        expect(field.contentstackField).toContain('Page > ');
+      });
+    });
+
+    it('returns group wrapper + inner block fields for >1 inner blocks', async () => {
+      const btn1 = makeBlock({
+        name: 'core/button', clientId: 'btn1',
+        attributes: { metadata: { name: 'primary_cta' } },
+      });
+      const btn2 = makeBlock({
+        name: 'core/button', clientId: 'btn2',
+        attributes: { metadata: { name: 'secondary_cta' } },
+      });
+      const block = makeBlock({ name: 'core/buttons', clientId: 'btns1', innerBlocks: [btn1, btn2] });
+      const result = await schemaMapper(block, null, null, affix);
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result[0].contentstackFieldType).toBe('group');
+      expect(result[0].otherCmsField).toBe('buttons');
+
+      const nonGroupFields = result.filter((f: any) => f.contentstackFieldType !== 'group');
+      expect(nonGroupFields.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe('group blocks (core/group, core/list, etc.)', () => {
+    it('returns group wrapper + inner block fields when inner blocks exist', async () => {
+      const innerParagraph = makeBlock({ name: 'core/paragraph', clientId: 'p1' });
+      const block = makeBlock({ name: 'core/group', clientId: 'g1', innerBlocks: [innerParagraph] });
+      const result = await schemaMapper(block, null, null, affix);
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result[0].contentstackFieldType).toBe('group');
+      expect(result.length).toBeGreaterThan(1);
+    });
+
+    it('marks duplicate inner blocks as multiple', async () => {
+      const p1 = makeBlock({ name: 'core/paragraph', clientId: 'p1' });
+      const p2 = makeBlock({ name: 'core/paragraph', clientId: 'p2' });
+      const block = makeBlock({ name: 'core/group', clientId: 'g1', innerBlocks: [p1, p2] });
+      const result = await schemaMapper(block, null, null, affix);
+
+      const innerFields = result.filter((f: any) => f.contentstackFieldType !== 'group');
+      const multipleField = innerFields.find((f: any) => f.advanced?.multiple);
+      expect(multipleField).toBeDefined();
+    });
+  });
+
+  describe('parentUid propagation', () => {
+    it('prefixes uid with parentUid for nested blocks', async () => {
+      const block = makeBlock({ name: 'core/paragraph', clientId: 'p1' });
+      const result = await schemaMapper(block, 'parent_group', null, affix);
+      expect(result.uid).toMatch(/^parent_group\./);
+      expect(result.contentstackFieldUid).toMatch(/^parent_group\./);
+    });
+
+    it('builds fieldName chain with parentFieldName', async () => {
+      const block = makeBlock({ name: 'core/heading', clientId: 'h1' });
+      const result = await schemaMapper(block, null, 'Section', affix);
+      expect(result.contentstackField).toBe('Section > heading');
+    });
+  });
+
+  describe('array input', () => {
+    it('processes an array of blocks and returns flat schema', async () => {
+      const blocks = [
+        makeBlock({ name: 'core/paragraph', clientId: 'p1' }),
+        makeBlock({ name: 'core/heading', clientId: 'h1' }),
+      ];
+      const result = await schemaMapper(blocks, null, null, affix);
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(2);
+      expect(result[0].contentstackFieldType).toBe('json');
+      expect(result[1].contentstackFieldType).toBe('single_line_text');
+    });
+
+    it('deduplicates matching blocks and marks as multiple', async () => {
+      const blocks = [
+        makeBlock({ name: 'core/paragraph', clientId: 'p1' }),
+        makeBlock({ name: 'core/paragraph', clientId: 'p2' }),
+      ];
+      const result = await schemaMapper(blocks, 'root', null, affix);
+      const paragraphs = result.filter((f: any) => f.otherCmsField === 'paragraph');
+      expect(paragraphs).toHaveLength(1);
+      expect(paragraphs[0].advanced?.multiple).toBe(true);
+    });
+  });
+
+  describe('unknown block types', () => {
+    it('returns empty array for unrecognized block names', async () => {
+      const block = makeBlock({ name: 'custom/unknown-block', clientId: 'u1' });
+      const result = await schemaMapper(block, null, null, affix);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('metadata name override', () => {
+    it('uses attributes.metadata.name for otherCmsType when available', async () => {
+      const block = makeBlock({
+        name: 'core/paragraph',
+        clientId: 'p1',
+        attributes: { metadata: { name: 'intro_text' } },
+      });
+      const result = await schemaMapper(block, null, null, affix);
+      expect(result.otherCmsType).toBe('intro_text');
+      expect(result.contentstackField).toBe('intro_text');
+    });
+  });
+});