@salesforce/plugin-omnistudio-migration-tool 2.0.0-preview.27 → 2.0.0-preview.28

package/lib/migration/omniscript.js

@@ -329,7 +329,7 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                 }
             }
             // Check for Integration Procedure Action dependencies
-            if (type === 'Integration Procedure Action') {
+            if (type === stringContants_1.Constants.IntegrationProcedureAction) {
                 const nameVal = `${elemName}`;
                 dependencyIP.push({ name: propertySet['integrationProcedureKey'], location: nameVal });
                 if (!existingOmniscriptNames.has(nameVal) && !existingFlexCardNames.has(nameVal)) {
@@ -338,10 +338,10 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
             }
             // Check for DataRaptor dependencies
             if ([
-                'DataRaptor Extract Action',
-                'DataRaptor Turbo Action',
-                'DataRaptor Transform Action',
-                'DataRaptor Post Action',
+                stringContants_1.Constants.DataRaptorExtractAction,
+                stringContants_1.Constants.DataRaptorTurboAction,
+                stringContants_1.Constants.DataRaptorTransformAction,
+                stringContants_1.Constants.DataRaptorPostAction,
             ].includes(type)) {
                 const nameVal = `${elemName}`;
                 dependencyDR.push({ name: propertySet['bundle'], location: nameVal });
@@ -349,7 +349,18 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                     missingDR.push(nameVal);
                 }
             }
-            if (type === 'Remote Action') {
+            // Check for DataRaptor transform bundle dependencies in various action types
+            // These bundles are used for pre/post transformation in HTTP, Remote, Decision Matrix, Expression Set, PDF, and Step actions
+            this.collectTransformBundleDependencies(propertySet, elemName, dependencyDR, existingDataRaptorNames, missingDR);
+            // Check for DocuSign Envelope Action transform bundle dependencies
+            if (type === stringContants_1.Constants.DocuSignEnvelopeAction) {
+                this.collectDocuSignBundleDependencies(propertySet, elemName, dependencyDR, existingDataRaptorNames, missingDR);
+            }
+            // Check for DocuSign Signature Action transform bundle dependencies
+            if (type === stringContants_1.Constants.DocuSignSignatureAction) {
+                this.collectDocuSignSignatureBundleDependencies(propertySet, elemName, dependencyDR, existingDataRaptorNames, missingDR);
+            }
+            if (type === stringContants_1.Constants.RemoteAction) {
                 const nameVal = `${elemName}`;
                 const className = propertySet['remoteClass'];
                 const methodName = propertySet['remoteMethod'];
@@ -361,7 +372,7 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                 const nameVal = `${elemName}`;
                 dependenciesRA.push({ name: propertySet['optionSource']['source'], location: nameVal });
             }
-            if (type === 'Custom Lightning Web Component') {
+            if (type === stringContants_1.Constants.CustomLightningWebComponent) {
                 const nameVal = `${elemName}`;
                 const lwcName = propertySet['lwcName'];
                 dependenciesLWC.push({ name: lwcName, location: nameVal });
@@ -373,6 +384,8 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                 dependenciesLWC.push({ name: lwcName, location: nameVal });
             }
         }
+        // Collect persistent component bundle dependencies from OmniProcess PropertySetConfig
+        this.collectPersistentComponentBundleDependencies(omniscript, dependencyDR, existingDataRaptorNames, missingDR);
         const omniProcessType = omniscript[this.getFieldKey('IsProcedure__c')] ? 'Integration Procedure' : 'OmniScript';
         const existingType = omniscript[this.getFieldKey('Type__c')];
         const existingTypeVal = new stringval_1.StringVal(existingType, 'type');
@@ -510,23 +523,34 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                 assessmentStatus = 'Needs manual intervention';
             }
         }
+        // Deduplicate all dependency arrays to ensure no duplicates
+        // For Remote Actions and LWCs, deduplicate by name property
+        const uniqueRA = Array.from(new Map(dependenciesRA.map((item) => [item.name, item])).values());
+        const uniqueLWC = Array.from(new Map(dependenciesLWC.map((item) => [item.name, item])).values());
+        const uniqueIP = Array.from(new Map(dependencyIP.map((item) => [item.name, item])).values());
+        const uniqueDR = Array.from(new Map(dependencyDR.map((item) => [item.name, item])).values());
+        const uniqueOS = Array.from(new Map(dependencyOS.map((item) => [item.name, item])).values());
+        // Deduplicate missing dependency arrays (simple string arrays)
+        const uniqueMissingDR = [...new Set(missingDR)];
+        const uniqueMissingIP = [...new Set(missingIP)];
+        const uniqueMissingOS = [...new Set(missingOS)];
         const result = {
             name: recordName,
             id: omniscript['Id'],
             oldName: oldName,
-            dependenciesIP: dependencyIP,
-            dependenciesDR: dependencyDR,
-            dependenciesOS: dependencyOS,
-            dependenciesRemoteAction: dependenciesRA,
-            dependenciesLWC: dependenciesLWC,
+            dependenciesIP: uniqueIP,
+            dependenciesDR: uniqueDR,
+            dependenciesOS: uniqueOS,
+            dependenciesRemoteAction: uniqueRA,
+            dependenciesLWC: uniqueLWC,
             infos: [],
             warnings: warnings,
             errors: [],
             migrationStatus: assessmentStatus,
             type: omniProcessType,
-            missingDR: missingDR,
-            missingIP: missingIP,
-            missingOS: missingOS,
+            missingDR: uniqueMissingDR,
+            missingIP: uniqueMissingIP,
+            missingOS: uniqueMissingOS,
         };
         if (omniProcessType === this.OMNISCRIPT) {
             const nameMapping = {
@@ -1362,6 +1386,18 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
             mappedObject = { ...omniScriptRecord };
         }
         mappedObject['Name'] = this.cleanName(mappedObject['Name']);
+        // Process PropertySetConfig to update persistentComponent transform bundle references
+        const propertySetConfig = mappedObject[OmniScript_1.default.PropertySet__c];
+        if (propertySetConfig) {
+            try {
+                const parsedConfig = JSON.parse(propertySetConfig);
+                this.processPersistentComponents(parsedConfig);
+                mappedObject[OmniScript_1.default.PropertySet__c] = JSON.stringify(parsedConfig);
+            }
+            catch (ex) {
+                logger_1.Logger.error(`Failed to parse PropertySetConfig for OmniScript: ${mappedObject['Name']}`);
+            }
+        }
         // BATCH framework requires that each record has an "attributes" property
         mappedObject['attributes'] = {
             type: OmniScriptMigrationTool.OMNIPROCESS_NAME,
@@ -1369,9 +1405,40 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
         };
         return mappedObject;
     }
+    /**
+     * Processes persistentComponent array in OmniProcess PropertySetConfig to update transform bundle references
+     * Handles: persistentComponent[].remoteOptions.preTransformBundle, persistentComponent[].remoteOptions.postTransformBundle,
+     *          persistentComponent[].preTransformBundle, persistentComponent[].postTransformBundle
+     * @param propertySetConfig The parsed PropertySetConfig object
+     */
+    processPersistentComponents(propertySetConfig) {
+        if (!propertySetConfig || !Array.isArray(propertySetConfig.persistentComponent)) {
+            return;
+        }
+        propertySetConfig.persistentComponent.forEach((component) => {
+            if (!component) {
+                return;
+            }
+            // Handle remoteOptions pre/post transform bundles
+            if (component.remoteOptions) {
+                if (component.remoteOptions.preTransformBundle) {
+                    component.remoteOptions.preTransformBundle = this.cleanBundleName(component.remoteOptions.preTransformBundle);
+                }
+                if (component.remoteOptions.postTransformBundle) {
+                    component.remoteOptions.postTransformBundle = this.cleanBundleName(component.remoteOptions.postTransformBundle);
+                }
+            }
+            // Handle direct pre/post transform bundles
+            if (component.preTransformBundle) {
+                component.preTransformBundle = this.cleanBundleName(component.preTransformBundle);
+            }
+            if (component.postTransformBundle) {
+                component.postTransformBundle = this.cleanBundleName(component.postTransformBundle);
+            }
+        });
+    }
     // Maps an individual Element into an OmniProcessElement record
     mapElementData(elementRecord, omniProcessId, parentElementUploadResponse, invalidIpReferences) {
-        var _a, _b;
         // Transformed object
         let mappedObject = {};
         if (!this.IS_STANDARD_DATA_MODEL) {
@@ -1397,128 +1464,9 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
         // We need to fix the child references
         const elementType = mappedObject[Element_1.default.Type__c];
         const propertySet = JSON.parse(mappedObject[Element_1.default.PropertySet__c] || '{}');
-        // Use NameMappingRegistry to update all dependency references
-        const updatedPropertySet = this.nameRegistry.updateDependencyReferences(propertySet);
-        switch (elementType) {
-            case 'OmniScript':
-                // Use registry for OmniScript references with explicit fallback
-                const osType = propertySet['Type'] || '';
-                const osSubType = propertySet['Sub Type'] || '';
-                const osLanguage = propertySet['Language'] || 'English';
-                // Construct full OmniScript name to check registry
-                const fullOmniScriptName = `${osType}_${osSubType}_${osLanguage}`;
-                if (this.nameRegistry.isAngularOmniScript(fullOmniScriptName)) {
-                    // Referenced OmniScript is Angular - add warning and keep original reference
-                    logger_1.Logger.logVerbose(`\n${this.messages.getMessage('angularOmniScriptDependencyWarning', [
-                        'OmniScript element',
-                        fullOmniScriptName,
-                    ])}`);
-                    // Keep original reference as-is since Angular OmniScript won't be migrated
-                    updatedPropertySet['Type'] = osType;
-                    updatedPropertySet['Sub Type'] = osSubType;
-                    updatedPropertySet['Language'] = osLanguage;
-                }
-                else if (this.nameRegistry.hasOmniScriptMapping(fullOmniScriptName)) {
-                    // Registry has mapping for this LWC OmniScript - extract cleaned parts
-                    const cleanedFullName = this.nameRegistry.getCleanedName(fullOmniScriptName, 'OmniScript');
-                    const parts = cleanedFullName.split('_');
-                    if (parts.length >= 2) {
-                        updatedPropertySet['Type'] = parts[0];
-                        updatedPropertySet['Sub Type'] = parts[1];
-                        // Language doesn't typically change, but update if provided
-                        if (parts.length >= 3) {
-                            updatedPropertySet['Language'] = parts[2];
-                        }
-                    }
-                }
-                else {
-                    // No registry mapping - use original fallback approach
-                    logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['OmniScript', fullOmniScriptName])}`);
-                    updatedPropertySet['Type'] = this.cleanName(osType);
-                    updatedPropertySet['Sub Type'] = this.cleanName(osSubType);
-                }
-                break;
-            case 'Integration Procedure Action':
-                const remoteOptions = updatedPropertySet['remoteOptions'] || {};
-                // Use registry for DataMapper references with explicit fallback
-                const preTransformBundle = (_a = propertySet['remoteOptions']) === null || _a === void 0 ? void 0 : _a['preTransformBundle'];
-                if (preTransformBundle) {
-                    if (this.nameRegistry.hasDataMapperMapping(preTransformBundle)) {
-                        remoteOptions['preTransformBundle'] = this.nameRegistry.getDataMapperCleanedName(preTransformBundle);
-                    }
-                    else {
-                        logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', preTransformBundle])}`);
-                        remoteOptions['preTransformBundle'] = this.cleanName(preTransformBundle);
-                    }
-                }
-                const postTransformBundle = (_b = propertySet['remoteOptions']) === null || _b === void 0 ? void 0 : _b['postTransformBundle'];
-                if (postTransformBundle) {
-                    if (this.nameRegistry.hasDataMapperMapping(postTransformBundle)) {
-                        remoteOptions['postTransformBundle'] = this.nameRegistry.getDataMapperCleanedName(postTransformBundle);
-                    }
-                    else {
-                        logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', postTransformBundle])}`);
-                        remoteOptions['postTransformBundle'] = this.cleanName(postTransformBundle);
-                    }
-                }
-                updatedPropertySet['remoteOptions'] = remoteOptions;
-                const preBundle = propertySet['preTransformBundle'];
-                if (preBundle) {
-                    if (this.nameRegistry.hasDataMapperMapping(preBundle)) {
-                        updatedPropertySet['preTransformBundle'] = this.nameRegistry.getDataMapperCleanedName(preBundle);
-                    }
-                    else {
-                        logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', preBundle])}`);
-                        updatedPropertySet['preTransformBundle'] = this.cleanName(preBundle);
-                    }
-                }
-                const postBundle = propertySet['postTransformBundle'];
-                if (postBundle) {
-                    if (this.nameRegistry.hasDataMapperMapping(postBundle)) {
-                        updatedPropertySet['postTransformBundle'] = this.nameRegistry.getDataMapperCleanedName(postBundle);
-                    }
-                    else {
-                        logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', postBundle])}`);
-                        updatedPropertySet['postTransformBundle'] = this.cleanName(postBundle);
-                    }
-                }
-                // Use registry for Integration Procedure references
-                const key = propertySet['integrationProcedureKey'] || '';
-                if (key) {
-                    const hasRegistryMapping = this.nameRegistry.hasIntegrationProcedureMapping(key);
-                    if (hasRegistryMapping) {
-                        const cleanedIpName = this.nameRegistry.getIntegrationProcedureCleanedName(key);
-                        updatedPropertySet['integrationProcedureKey'] = cleanedIpName;
-                    }
-                    else {
-                        logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['IntegrationProcedure', key])}`);
-                        const parts = key.split('_');
-                        const newKey = parts.map((p) => this.cleanName(p, true)).join('_');
-                        if (parts.length > 2) {
-                            invalidIpReferences.set(mappedObject[Element_1.default.Name], key);
-                        }
-                        updatedPropertySet['integrationProcedureKey'] = newKey;
-                    }
-                }
-                break;
-            case 'DataRaptor Turbo Action':
-            case 'DataRaptor Transform Action':
-            case 'DataRaptor Post Action':
-            case 'DataRaptor Extract Action':
-                // Use registry for DataMapper references with explicit fallback
-                const bundleName = propertySet['bundle'];
-                if (bundleName) {
-                    if (this.nameRegistry.hasDataMapperMapping(bundleName)) {
-                        updatedPropertySet['bundle'] = this.nameRegistry.getDataMapperCleanedName(bundleName);
-                    }
-                    else {
-                        logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', bundleName])}`);
-                        updatedPropertySet['bundle'] = this.cleanName(bundleName);
-                    }
-                }
-                break;
-        }
-        mappedObject[Element_1.default.PropertySet__c] = JSON.stringify(updatedPropertySet);
+        // Use shared method to process element types
+        this.processElementByType(elementType, propertySet, invalidIpReferences, mappedObject[Element_1.default.Name]);
+        mappedObject[Element_1.default.PropertySet__c] = JSON.stringify(propertySet);
         // BATCH framework requires that each record has an "attributes" property
         mappedObject['attributes'] = {
             type: OmniScriptMigrationTool.OMNIPROCESSELEMENT_NAME,
@@ -1558,6 +1506,10 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                 if (content && content['children']) {
                     this.processContentChildren(content['children']);
                 }
+                // Process persistentComponent array in OmniProcessCompilation Content (inside propSetMap)
+                if (content && content['propSetMap']) {
+                    this.processPersistentComponents(content['propSetMap']);
+                }
                 mappedObject[OmniScriptDefinition_1.default.Content__c] = JSON.stringify(content);
             }
             catch (ex) {
@@ -1571,6 +1523,59 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
         };
         return mappedObject;
     }
+    /**
+     * Shared helper method to process element types and update references
+     * Handles the switch statement logic for different element types
+     * @param elementType Type of the element
+     * @param propSet Property set map from the element
+     * @param invalidIpReferences Optional map to track invalid IP references
+     * @param elementName Optional element name for logging
+     */
+    processElementByType(elementType, propSet, invalidIpReferences, elementName) {
+        switch (elementType) {
+            case stringContants_1.Constants.OmniScriptComponentName:
+                this.processOmniScriptAction(propSet);
+                break;
+            case stringContants_1.Constants.IntegrationProcedureAction:
+                this.processIntegrationProcedureAction(propSet, invalidIpReferences, elementName);
+                break;
+            case stringContants_1.Constants.DataRaptorTurboAction:
+            case stringContants_1.Constants.DataRaptorTransformAction:
+            case stringContants_1.Constants.DataRaptorPostAction:
+            case stringContants_1.Constants.DataRaptorExtractAction:
+                this.processDataRaptorAction(propSet);
+                break;
+            case stringContants_1.Constants.StepElement:
+                this.processStepAction(propSet);
+                break;
+            case stringContants_1.Constants.DocuSignEnvelopeAction:
+                this.processDocuSignEnvelopeAction(propSet);
+                break;
+            case stringContants_1.Constants.DocuSignSignatureAction:
+                this.processDocuSignSignatureAction(propSet);
+                break;
+            case stringContants_1.Constants.DecisionMatrixAction:
+                this.processDecisionMatrixAction(propSet);
+                break;
+            case stringContants_1.Constants.ExpressionSetAction:
+                this.processExpressionSetAction(propSet);
+                break;
+            case stringContants_1.Constants.HTTPAction:
+                this.processHttpAction(propSet);
+                break;
+            case stringContants_1.Constants.PDFAction:
+                this.processPdfAction(propSet);
+                break;
+            case stringContants_1.Constants.RemoteAction:
+                this.processRemoteAction(propSet);
+                break;
+            default:
+                // Handle other element types if needed
+                break;
+        }
+        // Process lwcComponentOverride for all element types (FlexCard reference)
+        this.processLwcComponentOverride(propSet);
+    }
     /**
      * Recursively processes children elements in the content JSON to update bundle/reference names
      * @param children Array of child elements from the content JSON
@@ -1607,32 +1612,58 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
         if (!elementType || !propSetMap) {
             return;
         }
-        switch (elementType) {
-            case 'Integration Procedure Action':
-                this.processIntegrationProcedureAction(propSetMap);
-                break;
-            case 'DataRaptor Turbo Action':
-            case 'DataRaptor Transform Action':
-            case 'DataRaptor Post Action':
-            case 'DataRaptor Extract Action':
-                this.processDataRaptorAction(propSetMap);
-                break;
-            case 'OmniScript':
-                this.processOmniScriptAction(propSetMap);
-                break;
-            case 'Step':
-                this.processStepAction(propSetMap);
-                break;
-            default:
-                // Handle other element types if needed
-                break;
+        // Use shared method to process element types
+        this.processElementByType(elementType, propSetMap);
+    }
+    /**
+     * Processes DocuSign Envelope Action elements to update transformBundle references
+     * @param propSetMap Property set map from the element
+     */
+    processDocuSignEnvelopeAction(propSetMap) {
+        // Handle docuSignTemplatesGroup[].transformBundle
+        if (Array.isArray(propSetMap.docuSignTemplatesGroup)) {
+            propSetMap.docuSignTemplatesGroup.forEach((template) => {
+                if (template && template.transformBundle) {
+                    const bundleName = template.transformBundle;
+                    if (this.nameRegistry.hasDataMapperMapping(bundleName)) {
+                        template.transformBundle = this.nameRegistry.getDataMapperCleanedName(bundleName);
+                    }
+                    else {
+                        logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', bundleName])}`);
+                        template.transformBundle = this.cleanName(bundleName);
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Processes DocuSign Signature Action elements to update transformBundle references
+     * @param propSetMap Property set map from the element
+     */
+    processDocuSignSignatureAction(propSetMap) {
+        // Handle docuSignTemplatesGroupSig[].transformBundle
+        if (Array.isArray(propSetMap.docuSignTemplatesGroupSig)) {
+            propSetMap.docuSignTemplatesGroupSig.forEach((template) => {
+                if (template && template.transformBundle) {
+                    const bundleName = template.transformBundle;
+                    if (this.nameRegistry.hasDataMapperMapping(bundleName)) {
+                        template.transformBundle = this.nameRegistry.getDataMapperCleanedName(bundleName);
+                    }
+                    else {
+                        logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', bundleName])}`);
+                        template.transformBundle = this.cleanName(bundleName);
+                    }
+                }
+            });
         }
     }
     /**
      * Processes Integration Procedure Action elements to update reference names
      * @param propSetMap Property set map from the element
+     * @param invalidIpReferences Optional map to track invalid IP references for reporting
+     * @param elementName Optional element name for tracking invalid references
      */
-    processIntegrationProcedureAction(propSetMap) {
+    processIntegrationProcedureAction(propSetMap, invalidIpReferences, elementName) {
         // Handle remoteOptions pre/post transform bundles
         if (propSetMap.remoteOptions) {
             if (propSetMap.remoteOptions.preTransformBundle) {
@@ -1641,6 +1672,7 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                     propSetMap.remoteOptions.preTransformBundle = this.nameRegistry.getDataMapperCleanedName(bundleName);
                 }
                 else {
+                    logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', bundleName])}`);
                     propSetMap.remoteOptions.preTransformBundle = this.cleanName(bundleName);
                 }
             }
@@ -1650,6 +1682,7 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                     propSetMap.remoteOptions.postTransformBundle = this.nameRegistry.getDataMapperCleanedName(bundleName);
                 }
                 else {
+                    logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', bundleName])}`);
                     propSetMap.remoteOptions.postTransformBundle = this.cleanName(bundleName);
                 }
             }
@@ -1661,6 +1694,7 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                 propSetMap.preTransformBundle = this.nameRegistry.getDataMapperCleanedName(bundleName);
             }
             else {
+                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', bundleName])}`);
                 propSetMap.preTransformBundle = this.cleanName(bundleName);
             }
         }
@@ -1670,6 +1704,7 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                 propSetMap.postTransformBundle = this.nameRegistry.getDataMapperCleanedName(bundleName);
             }
             else {
+                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', bundleName])}`);
                 propSetMap.postTransformBundle = this.cleanName(bundleName);
             }
         }
@@ -1680,13 +1715,19 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                 propSetMap.integrationProcedureKey = this.nameRegistry.getIntegrationProcedureCleanedName(key);
             }
             else {
+                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['IntegrationProcedure', key])}`);
                 const parts = key.split('_');
+                const newKey = parts.map((p) => this.cleanName(p, true)).join('_');
                 // Integration Procedures should have Type_SubType format (2 parts)
                 if (parts.length > 2) {
-                    logger_1.Logger.logVerbose(this.messages.getMessage('integrationProcedureInvalidUnderscoreFormat', [key]));
-                    return;
+                    if (invalidIpReferences && elementName) {
+                        invalidIpReferences.set(elementName, key);
+                    }
+                    else {
+                        logger_1.Logger.logVerbose(this.messages.getMessage('integrationProcedureInvalidUnderscoreFormat', [key]));
+                    }
                 }
-                propSetMap.integrationProcedureKey = parts.map((p) => this.cleanName(p, true)).join('_');
+                propSetMap.integrationProcedureKey = newKey;
             }
         }
     }
@@ -1701,9 +1742,12 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                 propSetMap.bundle = this.nameRegistry.getDataMapperCleanedName(bundleName);
             }
             else {
+                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', bundleName])}`);
                 propSetMap.bundle = this.cleanName(bundleName);
             }
         }
+        // Handle postTransformBundle for DataRaptor Post Action
+        this.processTransformBundles(propSetMap);
     }
     /**
      * Processes OmniScript Action elements to update reference names
@@ -1716,6 +1760,11 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
         // Construct full OmniScript name to check registry
         const fullOmniScriptName = `${osType}_${osSubType}_${osLanguage}`;
         if (this.nameRegistry.isAngularOmniScript(fullOmniScriptName)) {
+            // Referenced OmniScript is Angular - add warning and keep original reference
+            logger_1.Logger.logVerbose(`\n${this.messages.getMessage('angularOmniScriptDependencyWarning', [
+                'OmniScript element',
+                fullOmniScriptName,
+            ])}`);
             // Keep original reference as-is since Angular OmniScript won't be migrated
             return;
         }
@@ -1734,6 +1783,7 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
         }
         else {
             // No registry mapping - use original fallback approach
+            logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['OmniScript', fullOmniScriptName])}`);
             propSetMap['Type'] = this.cleanName(osType);
             propSetMap['Sub Type'] = this.cleanName(osSubType);
         }
@@ -1752,6 +1802,7 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                     propSetMap.remoteOptions.preTransformBundle = this.nameRegistry.getDataMapperCleanedName(bundleName);
                 }
                 else {
+                    logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', bundleName])}`);
                     propSetMap.remoteOptions.preTransformBundle = this.cleanName(bundleName);
                 }
             }
@@ -1761,11 +1812,119 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
                     propSetMap.remoteOptions.postTransformBundle = this.nameRegistry.getDataMapperCleanedName(bundleName);
                 }
                 else {
+                    logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', bundleName])}`);
                     propSetMap.remoteOptions.postTransformBundle = this.cleanName(bundleName);
                 }
             }
         }
     }
+    /**
+     * Generic helper to process common transform bundle properties
+     * Handles: preTransformBundle, postTransformBundle, remoteOptions.preTransformBundle, remoteOptions.postTransformBundle
+     * @param propSetMap Property set map from the element
+     */
+    processTransformBundles(propSetMap) {
+        // Handle remoteOptions pre/post transform bundles
+        if (propSetMap.remoteOptions) {
+            if (propSetMap.remoteOptions.preTransformBundle) {
+                propSetMap.remoteOptions.preTransformBundle = this.cleanBundleName(propSetMap.remoteOptions.preTransformBundle);
+            }
+            if (propSetMap.remoteOptions.postTransformBundle) {
+                propSetMap.remoteOptions.postTransformBundle = this.cleanBundleName(propSetMap.remoteOptions.postTransformBundle);
+            }
+        }
+        // Handle direct pre/post transform bundles
+        if (propSetMap.preTransformBundle) {
+            propSetMap.preTransformBundle = this.cleanBundleName(propSetMap.preTransformBundle);
+        }
+        if (propSetMap.postTransformBundle) {
+            propSetMap.postTransformBundle = this.cleanBundleName(propSetMap.postTransformBundle);
+        }
+    }
+    /**
+     * Helper to clean a single bundle name using registry or fallback
+     * @param bundleName The bundle name to clean
+     * @returns The cleaned bundle name
+     */
+    cleanBundleName(bundleName) {
+        if (!bundleName) {
+            return bundleName;
+        }
+        if (this.nameRegistry.hasDataMapperMapping(bundleName)) {
+            return this.nameRegistry.getDataMapperCleanedName(bundleName);
+        }
+        else {
+            logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', bundleName])}`);
+            return this.cleanName(bundleName);
+        }
+    }
+    /**
+     * Processes Decision Matrix Action elements to update transform bundle references
+     * @param propSetMap Property set map from the element
+     */
+    processDecisionMatrixAction(propSetMap) {
+        this.processTransformBundles(propSetMap);
+    }
+    /**
+     * Processes Expression Set Action elements to update transform bundle references
+     * @param propSetMap Property set map from the element
+     */
+    processExpressionSetAction(propSetMap) {
+        this.processTransformBundles(propSetMap);
+    }
+    /**
+     * Processes HTTP Action elements to update transform bundle references
+     * Handles: preTransformBundle, postTransformBundle, xmlPreTransformBundle, xmlPostTransformBundle
+     * @param propSetMap Property set map from the element
+     */
+    processHttpAction(propSetMap) {
+        this.processTransformBundles(propSetMap);
+        // Handle XML-specific transform bundles
+        if (propSetMap.xmlPreTransformBundle) {
+            propSetMap.xmlPreTransformBundle = this.cleanBundleName(propSetMap.xmlPreTransformBundle);
+        }
+        if (propSetMap.xmlPostTransformBundle) {
+            propSetMap.xmlPostTransformBundle = this.cleanBundleName(propSetMap.xmlPostTransformBundle);
+        }
+    }
+    /**
+     * Processes PDF Action elements to update transform bundle references
+     * @param propSetMap Property set map from the element
+     */
+    processPdfAction(propSetMap) {
+        if (propSetMap.preTransformBundle) {
+            propSetMap.preTransformBundle = this.cleanBundleName(propSetMap.preTransformBundle);
+        }
+    }
+    /**
+     * Processes Remote Action elements to update transform bundle references
+     * @param propSetMap Property set map from the element
+     */
+    processRemoteAction(propSetMap) {
+        this.processTransformBundles(propSetMap);
+    }
+    /**
+     * Processes lwcComponentOverride property to update FlexCard reference names
+     * @param propSetMap Property set map from the element
+     */
+    processLwcComponentOverride(propSetMap) {
+        if (propSetMap.lwcComponentOverride) {
+            const lwcOverride = propSetMap.lwcComponentOverride;
+            // lwcComponentOverride has 'cf' prefix (e.g., 'cfEventManagementBudgetCard')
+            // Registry stores FlexCard names without prefix (e.g., 'EventManagementBudgetCard')
+            if (lwcOverride.startsWith('cf')) {
+                const flexCardName = lwcOverride.substring(2); // Remove 'cf' prefix
+                if (this.nameRegistry.hasFlexCardMapping(flexCardName)) {
+                    const cleanedName = this.nameRegistry.getFlexCardCleanedName(flexCardName);
+                    propSetMap.lwcComponentOverride = 'cf' + cleanedName;
+                }
+                else {
+                    logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['FlexCard', flexCardName])}`);
+                    propSetMap.lwcComponentOverride = 'cf' + this.cleanName(flexCardName);
+                }
+            }
+        }
+    }
     getOmniScriptFields() {
         return this.IS_STANDARD_DATA_MODEL ? Object.values(OmniScript_1.default) : Object.keys(OmniScript_1.default);
     }
@@ -1822,6 +1981,162 @@ class OmniScriptMigrationTool extends base_1.BaseMigrationTool {
             }
         }
     }
+    /**
+     * Collects DataRaptor transform bundle dependencies from PropertySet
+     * Handles: preTransformBundle, postTransformBundle, xmlPreTransformBundle, xmlPostTransformBundle,
+     * and remoteOptions.preTransformBundle, remoteOptions.postTransformBundle
+     * Used by: HTTP Action, Remote Action, Decision Matrix Action, Expression Set Action, PDF Action, Step
+     * @param propertySet - The PropertySet JSON object
+     * @param elemName - Element name for location tracking
+     * @param dependencyDR - Array to collect DataRaptor dependencies
+     * @param existingDataRaptorNames - Set of existing DataRaptor names
+     * @param missingDR - Array to collect missing DataRaptor names
+     */
+    collectTransformBundleDependencies(propertySet, elemName, dependencyDR, existingDataRaptorNames, missingDR) {
+        const bundleFields = [
+            'preTransformBundle',
+            'postTransformBundle',
+            'xmlPreTransformBundle',
+            'xmlPostTransformBundle',
+        ];
+        // Check direct transform bundle fields
+        for (const field of bundleFields) {
+            if (propertySet[field]) {
+                const bundleName = propertySet[field];
+                dependencyDR.push({ name: bundleName, location: `${elemName} (${field})` });
+                if (!existingDataRaptorNames.has(bundleName)) {
+                    missingDR.push(bundleName);
+                }
+            }
+        }
+        // Check remoteOptions transform bundle fields
+        if (propertySet.remoteOptions) {
+            if (propertySet.remoteOptions.preTransformBundle) {
+                const bundleName = propertySet.remoteOptions.preTransformBundle;
+                dependencyDR.push({ name: bundleName, location: `${elemName} (remoteOptions.preTransformBundle)` });
+                if (!existingDataRaptorNames.has(bundleName)) {
+                    missingDR.push(bundleName);
+                }
+            }
+            if (propertySet.remoteOptions.postTransformBundle) {
+                const bundleName = propertySet.remoteOptions.postTransformBundle;
+                dependencyDR.push({ name: bundleName, location: `${elemName} (remoteOptions.postTransformBundle)` });
+                if (!existingDataRaptorNames.has(bundleName)) {
+                    missingDR.push(bundleName);
+                }
+            }
+        }
+    }
+    /**
+     * Collects DataRaptor transform bundle dependencies from DocuSign Envelope Action
+     * Handles: docuSignTemplatesGroup[].transformBundle
+     * @param propertySet - The PropertySet JSON object
+     * @param elemName - Element name for location tracking
+     * @param dependencyDR - Array to collect DataRaptor dependencies
+     * @param existingDataRaptorNames - Set of existing DataRaptor names
+     * @param missingDR - Array to collect missing DataRaptor names
+     */
+    collectDocuSignBundleDependencies(propertySet, elemName, dependencyDR, existingDataRaptorNames, missingDR) {
+        if (Array.isArray(propertySet.docuSignTemplatesGroup)) {
+            propertySet.docuSignTemplatesGroup.forEach((template, index) => {
+                if (template && template.transformBundle) {
+                    const bundleName = template.transformBundle;
+                    dependencyDR.push({
+                        name: bundleName,
+                        location: `${elemName} (docuSignTemplatesGroup[${index}].transformBundle)`,
+                    });
+                    if (!existingDataRaptorNames.has(bundleName)) {
+                        missingDR.push(bundleName);
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Collects DataRaptor transform bundle dependencies from DocuSign Signature Action
+     * Handles: docuSignTemplatesGroupSig[].transformBundle
+     * @param propertySet - The PropertySet JSON object
+     * @param elemName - Element name for location tracking
+     * @param dependencyDR - Array to collect DataRaptor dependencies
+     * @param existingDataRaptorNames - Set of existing DataRaptor names
+     * @param missingDR - Array to collect missing DataRaptor names
+     */
+    collectDocuSignSignatureBundleDependencies(propertySet, elemName, dependencyDR, existingDataRaptorNames, missingDR) {
+        if (Array.isArray(propertySet.docuSignTemplatesGroupSig)) {
+            propertySet.docuSignTemplatesGroupSig.forEach((template, index) => {
+                if (template && template.transformBundle) {
+                    const bundleName = template.transformBundle;
+                    dependencyDR.push({
+                        name: bundleName,
+                        location: `${elemName} (docuSignTemplatesGroupSig[${index}].transformBundle)`,
+                    });
+                    if (!existingDataRaptorNames.has(bundleName)) {
+                        missingDR.push(bundleName);
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Collects DataRaptor transform bundle dependencies from OmniProcess PropertySetConfig persistentComponent array
+     * Handles: persistentComponent[].remoteOptions.preTransformBundle, persistentComponent[].remoteOptions.postTransformBundle,
+     *          persistentComponent[].preTransformBundle, persistentComponent[].postTransformBundle
+     * @param omniscript - The OmniScript/Integration Procedure record
+     * @param dependencyDR - Array to collect DataRaptor dependencies
+     * @param existingDataRaptorNames - Set of existing DataRaptor names
+     * @param missingDR - Array to collect missing DataRaptor names
+     */
+    collectPersistentComponentBundleDependencies(omniscript, dependencyDR, existingDataRaptorNames, missingDR) {
+        const propertySetConfigStr = omniscript[this.getFieldKey('PropertySet__c')];
+        if (!propertySetConfigStr) {
+            return;
+        }
+        let propertySetConfig;
+        try {
+            propertySetConfig = JSON.parse(propertySetConfigStr);
+        }
+        catch (ex) {
+            logger_1.Logger.error(`Failed to parse PropertySetConfig for assessment: ${omniscript['Name']}`);
+            return;
+        }
+        if (!propertySetConfig || !Array.isArray(propertySetConfig.persistentComponent)) {
+            return;
+        }
+        const bundleFields = ['preTransformBundle', 'postTransformBundle'];
+        propertySetConfig.persistentComponent.forEach((component, index) => {
+            if (!component) {
+                return;
+            }
+            // Check remoteOptions transform bundle fields
+            if (component.remoteOptions) {
+                bundleFields.forEach((field) => {
+                    if (component.remoteOptions[field]) {
+                        const bundleName = component.remoteOptions[field];
+                        dependencyDR.push({
+                            name: bundleName,
+                            location: `persistentComponent[${index}].remoteOptions.${field}`,
+                        });
+                        if (!existingDataRaptorNames.has(bundleName)) {
+                            missingDR.push(bundleName);
+                        }
+                    }
+                });
+            }
+            // Check direct transform bundle fields
+            bundleFields.forEach((field) => {
+                if (component[field]) {
+                    const bundleName = component[field];
+                    dependencyDR.push({
+                        name: bundleName,
+                        location: `persistentComponent[${index}].${field}`,
+                    });
+                    if (!existingDataRaptorNames.has(bundleName)) {
+                        missingDR.push(bundleName);
+                    }
+                }
+            });
+        });
+    }
     getElementFieldKey(fieldName) {
         return this.IS_STANDARD_DATA_MODEL ? Element_1.default[fieldName] : this.namespacePrefix + fieldName;
     }