@salesforce/plugin-omnistudio-migration-tool 2.0.0-rc.6 → 2.0.0-rc.61

package/lib/migration/flexcard.js

@@ -8,22 +8,30 @@ const VlocityCard_1 = __importDefault(require("../mappings/VlocityCard"));
 const utils_1 = require("../utils");
 const net_1 = require("../utils/net");
 const base_1 = require("./base");
+const CustomCssRegistry_1 = require("./CustomCssRegistry");
 const interfaces_1 = require("./interfaces");
 const logger_1 = require("../utils/logger");
 const base_2 = require("./base");
 const stringContants_1 = require("../utils/constants/stringContants");
 const storageUtil_1 = require("../utils/storageUtil");
+const stringUtils_1 = require("../utils/stringUtils");
+const dataModelService_1 = require("../utils/dataModelService");
+const recordPrioritization_1 = require("../utils/recordPrioritization");
+const ApexNamespaceRegistry_1 = require("./ApexNamespaceRegistry");
 class CardMigrationTool extends base_1.BaseMigrationTool {
     constructor(namespace, connection, logger, messages, ux, allVersions) {
         super(namespace, connection, logger, messages, ux);
+        this.apexNamespaceRegistry = ApexNamespaceRegistry_1.ApexNamespaceRegistry.getInstance();
+        this.IS_STANDARD_DATA_MODEL = (0, dataModelService_1.isStandardDataModel)();
         this.allVersions = allVersions;
+        CustomCssRegistry_1.CustomCssRegistry.getInstance().init(connection, namespace, messages);
     }
     getName() {
-        return 'FlexCards';
+        return 'Flexcards';
     }
     getRecordName(record) {
         return this.allVersions
-            ? `${record['Name']}_${record[this.namespacePrefix + CardMigrationTool.VERSION_PROP]}`
+            ? `${record['Name']}_${record[this.getFieldKey(CardMigrationTool.VERSION_PROP)]}`
             : record['Name'];
     }
     getMappings() {
@@ -36,6 +44,10 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
     }
     // Perform Delete of OmniUiCard Records to start migration from scratch
     async truncate() {
+        if (this.IS_STANDARD_DATA_MODEL) {
+            logger_1.Logger.logVerbose(this.messages.getMessage('skippingTruncation'));
+            return;
+        }
         const objectName = CardMigrationTool.OMNIUICARD_NAME;
         utils_1.DebugTimer.getInstance().lap('Truncating ' + objectName);
         const ids = await utils_1.QueryTools.queryIds(this.connection, objectName);
@@ -57,19 +69,53 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
     }
     // Perform Records Migration from VlocityCard__c to OmniUiCard
     async migrate() {
-        // Get All the Active VlocityCard__c records
-        const cards = await this.getAllActiveCards();
-        logger_1.Logger.log(this.messages.getMessage('foundFlexCardsToMigrate', [cards.length]));
-        const progressBar = (0, base_2.createProgressBar)('Migrating', 'Flexcard');
+        const allCards = await this.getAllCards();
+        if ((0, dataModelService_1.isStandardDataModelWithMetadataAPIEnabled)()) {
+            return this.handleMigrationForStdDataModelOrgsWithMetadataAPIEnabled(allCards);
+        }
+        logger_1.Logger.log(this.messages.getMessage('foundFlexCardsToMigrate', [allCards.length]));
+        // Filter out FlexCards with Angular OmniScript dependencies
+        const cards = [];
+        const skippedCards = new Map();
+        for (const card of allCards) {
+            if (this.hasAngularOmniScriptDependencies(card)) {
+                // Skip FlexCard with Angular dependencies
+                logger_1.Logger.logVerbose(`${this.messages.getMessage('skipFlexcardAngularOmniScriptDependencyWarning', [card['Name']])}`);
+                skippedCards.set(card['Id'], {
+                    referenceId: card['Id'],
+                    id: '',
+                    success: false,
+                    hasErrors: false,
+                    errors: [],
+                    warnings: [this.messages.getMessage('flexCardWithAngularOmniScriptWarning')],
+                    newName: '',
+                    skipped: true,
+                });
+            }
+            else {
+                cards.push(card);
+            }
+        }
+        if (this.IS_STANDARD_DATA_MODEL) {
+            logger_1.Logger.log(`${this.messages.getMessage('flexCardMigrationProcessingMessage', [cards.length])}`);
+        }
+        else {
+            logger_1.Logger.log(`${this.messages.getMessage('flexCardMigrationProcessingMessage', [cards.length])} ${this.messages.getMessage('skippingAsAngularDependencies', [skippedCards.size])}`);
+        }
+        const progressBar = (0, base_2.createProgressBar)('Migrating', 'Flexcards');
         // Save the Vlocity Cards in OmniUiCard
         const cardUploadResponse = await this.uploadAllCards(cards, progressBar);
+        // Add skipped cards to the response
+        for (const [cardId, skippedResult] of skippedCards.entries()) {
+            cardUploadResponse.set(cardId, skippedResult);
+        }
         const records = new Map();
-        for (let i = 0; i < cards.length; i++) {
-            records.set(cards[i]['Id'], cards[i]);
+        for (let i = 0; i < allCards.length; i++) {
+            records.set(allCards[i]['Id'], allCards[i]);
         }
         return [
             {
-                name: 'FlexCards',
+                name: 'Flexcards',
                 records: records,
                 results: cardUploadResponse,
             },
@@ -77,10 +123,14 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
     }
     async assess() {
         try {
+            const flexCards = await this.getAllCards();
+            if ((0, dataModelService_1.isStandardDataModelWithMetadataAPIEnabled)()) {
+                return this.handleAssessmentForStdDataModelOrgsWithMetadataAPIEnabled(flexCards);
+            }
             logger_1.Logger.log(this.messages.getMessage('startingFlexCardAssessment'));
-            const flexCards = await this.getAllActiveCards();
             logger_1.Logger.log(this.messages.getMessage('foundFlexCardsToAssess', [flexCards.length]));
-            const flexCardsAssessmentInfos = this.processCardComponents(flexCards);
+            const flexCardsAssessmentInfos = await this.processCardComponents(flexCards);
+            this.prepareAssessmentStorageForFlexcards(flexCardsAssessmentInfos);
             return flexCardsAssessmentInfos;
         }
         catch (err) {
@@ -93,13 +143,14 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
     async processCardComponents(flexCards) {
         const flexCardAssessmentInfos = [];
         let progressCounter = 0;
-        const progressBar = (0, base_2.createProgressBar)('Assessing', 'Flexcard');
+        const progressBar = (0, base_2.createProgressBar)('Assessing', 'Flexcards');
         progressBar.start(flexCards.length, progressCounter);
         const uniqueNames = new Set();
+        const dupFlexCardNames = new Map();
         // Now process each OmniScript and its elements
         for (const flexCard of flexCards) {
             try {
-                const flexCardAssessmentInfo = await this.processFlexCard(flexCard, uniqueNames);
+                const flexCardAssessmentInfo = await this.processFlexCard(flexCard, uniqueNames, dupFlexCardNames);
                 flexCardAssessmentInfos.push(flexCardAssessmentInfo);
             }
             catch (e) {
@@ -113,6 +164,7 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                     dependenciesOS: [],
                     dependenciesLWC: [],
                     dependenciesApexRemoteAction: [],
+                    dependenciesVlocityAction: [],
                     infos: [],
                     warnings: [],
                     errors: [this.messages.getMessage('unexpectedError')],
@@ -126,10 +178,10 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
         progressBar.stop();
         return flexCardAssessmentInfos;
     }
-    async processFlexCard(flexCard, uniqueNames) {
+    async processFlexCard(flexCard, uniqueNames, dupFlexCardNames) {
         const flexCardName = flexCard['Name'];
         logger_1.Logger.info(this.messages.getMessage('processingFlexCard', [flexCardName]));
-        const version = flexCard[this.namespacePrefix + CardMigrationTool.VERSION_PROP];
+        const version = flexCard[this.getFieldKey(CardMigrationTool.VERSION_PROP)];
         const flexCardAssessmentInfo = {
             name: this.allVersions ? `${flexCardName}_${version}` : flexCardName,
             oldName: this.allVersions ? `${flexCardName}_${version}` : flexCardName,
@@ -140,101 +192,196 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
             dependenciesFC: [],
             dependenciesLWC: [],
             dependenciesApexRemoteAction: [],
+            dependenciesVlocityAction: [],
             infos: [],
             warnings: [],
             errors: [],
-            migrationStatus: '',
+            migrationStatus: 'Ready for migration',
         };
         // Check for name changes due to API naming requirements
         const originalName = flexCardName;
         const cleanedName = this.cleanName(originalName);
-        let assessmentStatus = 'Can be Automated';
+        let assessmentStatus = 'Ready for migration';
         flexCardAssessmentInfo.name = this.allVersions ? `${cleanedName}_${version}` : cleanedName;
         if (cleanedName !== originalName) {
             flexCardAssessmentInfo.warnings.push(this.messages.getMessage('cardNameChangeMessage', [originalName, cleanedName]));
-            assessmentStatus = 'Has Warnings';
+            assessmentStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(assessmentStatus, 'Warnings');
+        }
+        // Check for duplicate names (include version when allVersions is true)
+        const uniqueCleanedName = this.allVersions ? `${cleanedName}_${version}` : cleanedName;
+        // Check for exact duplicate (same name + same version)
+        if (uniqueNames.has(uniqueCleanedName)) {
+            flexCardAssessmentInfo.warnings.push(this.messages.getMessage('duplicateCardNameMessage', [uniqueCleanedName]));
+            assessmentStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(assessmentStatus, 'Needs manual intervention');
+        }
+        // Check for naming conflict: different original names cleaning to same name
+        else if (this.allVersions && dupFlexCardNames.has(cleanedName)) {
+            const existingOriginalName = dupFlexCardNames.get(cleanedName);
+            // Only flag if the original names are different (indicates a naming conflict)
+            if (existingOriginalName !== originalName) {
+                flexCardAssessmentInfo.warnings.push(this.messages.getMessage('lowerVersionDuplicateCardNameMessage', [uniqueCleanedName]));
+                assessmentStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(assessmentStatus, 'Needs manual intervention');
+            }
         }
-        // Check for duplicate names
-        if (uniqueNames.has(cleanedName)) {
-            flexCardAssessmentInfo.warnings.push(this.messages.getMessage('duplicateCardNameMessage', [cleanedName]));
-            assessmentStatus = 'Need Manual Intervention';
+        // Add to tracking structures
+        uniqueNames.add(uniqueCleanedName);
+        if (this.allVersions && !dupFlexCardNames.has(cleanedName)) {
+            dupFlexCardNames.set(cleanedName, originalName);
         }
-        uniqueNames.add(cleanedName);
-        this.addToAssessmentStorage(originalName, cleanedName);
         // Check for author name changes
-        const originalAuthor = flexCard[this.namespacePrefix + 'Author__c'];
+        const originalAuthor = flexCard[this.getFieldKey('Author__c')];
         if (originalAuthor) {
             const cleanedAuthor = this.cleanName(originalAuthor);
             if (cleanedAuthor !== originalAuthor) {
                 flexCardAssessmentInfo.warnings.push(this.messages.getMessage('authordNameChangeMessage', [originalAuthor, cleanedAuthor]));
-                assessmentStatus = 'Has Warnings';
+                assessmentStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(assessmentStatus, 'Warnings');
             }
         }
+        flexCardAssessmentInfo.nameMapping = {
+            oldName: flexCardName,
+            newName: cleanedName,
+        };
         flexCardAssessmentInfo.migrationStatus = assessmentStatus;
         this.updateDependencies(flexCard, flexCardAssessmentInfo);
+        // Scan custom CSS (both StaticResource-backed and inline) for managed-package
+        // namespace references. The helper updates `migrationStatus` itself via
+        // `getUpdatedAssessmentStatus`, so it never downgrades a stricter status.
+        await this.collectStylesheetNamespaceDependencies(flexCard, flexCardAssessmentInfo);
+        if (flexCardAssessmentInfo.errors.length > 0) {
+            flexCardAssessmentInfo.migrationStatus = 'Needs manual intervention';
+        }
+        else if (flexCardAssessmentInfo.warnings.length > 0 &&
+            flexCardAssessmentInfo.migrationStatus === 'Ready for migration') {
+            flexCardAssessmentInfo.migrationStatus = 'Warnings';
+        }
+        // Deduplicate all dependency arrays to ensure no duplicates
+        flexCardAssessmentInfo.dependenciesIP = [...new Set(flexCardAssessmentInfo.dependenciesIP)];
+        flexCardAssessmentInfo.dependenciesDR = [...new Set(flexCardAssessmentInfo.dependenciesDR)];
+        flexCardAssessmentInfo.dependenciesFC = [...new Set(flexCardAssessmentInfo.dependenciesFC)];
+        flexCardAssessmentInfo.dependenciesOS = [...new Set(flexCardAssessmentInfo.dependenciesOS)];
+        flexCardAssessmentInfo.dependenciesLWC = [...new Set(flexCardAssessmentInfo.dependenciesLWC)];
+        flexCardAssessmentInfo.dependenciesApexRemoteAction = [
+            ...new Set(flexCardAssessmentInfo.dependenciesApexRemoteAction),
+        ];
+        flexCardAssessmentInfo.dependenciesVlocityAction = [...new Set(flexCardAssessmentInfo.dependenciesVlocityAction)];
         return flexCardAssessmentInfo;
     }
+    /**
+     * Scan a FlexCard for two distinct kinds of namespace-bound custom CSS:
+     *
+     *  1. **StaticResource-backed stylesheet** — `Definition__c.customStyleSheet`
+     *     stores the *Name* of a Static Resource. We look it up, fetch its body,
+     *     and substring-check for the org's managed-package namespace. Same flow
+     *     and same warning message as the OmniScript implementation; resource
+     *     scans are cached by name in {@link CustomCssRegistry}, so a stylesheet
+     *     shared between OmniScripts and FlexCards is only fetched once per run.
+     *
+     *  2. **Inline CSS** — `Styles__c.customStyles` stores raw CSS text. We
+     *     substring-check the namespace directly against that string. No
+     *     SOQL/REST traffic and no caching (the CSS is per-FlexCard and not
+     *     shared across records).
+     *
+     * Both checks emit a warning into `flexCardAssessmentInfo.warnings` and bump
+     * `migrationStatus` to 'Needs manual intervention' (via
+     * `getUpdatedAssessmentStatus`, which never downgrades a stricter status).
+     */
+    async collectStylesheetNamespaceDependencies(flexCard, flexCardAssessmentInfo) {
+        const registry = CustomCssRegistry_1.CustomCssRegistry.getInstance();
+        if (!registry.isEnabled()) {
+            return;
+        }
+        // ---- 1. Definition__c.customStyleSheet (StaticResource name) ----
+        const definitionRaw = flexCard[this.getFieldKey('Definition__c')];
+        if (definitionRaw) {
+            let definition;
+            try {
+                definition = JSON.parse(definitionRaw);
+            }
+            catch (ex) {
+                logger_1.Logger.error(`Failed to parse Definition__c for stylesheet scan: ${flexCard['Name']}`);
+                definition = null;
+            }
+            const resourceName = ((definition === null || definition === void 0 ? void 0 : definition.customStyleSheet) || '').toString().trim();
+            if (resourceName) {
+                const verdict = await registry.scanResource(resourceName);
+                if (verdict === 'namespaceFound') {
+                    const message = registry.buildFlexCardNamespaceWarning(resourceName);
+                    if (message) {
+                        flexCardAssessmentInfo.warnings.push(message);
+                        flexCardAssessmentInfo.migrationStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(flexCardAssessmentInfo.migrationStatus, 'Needs manual intervention');
+                    }
+                }
+            }
+        }
+        // ---- 2. Styles__c.customStyles (raw inline CSS) ----
+        const stylesRaw = flexCard[this.getFieldKey('Styles__c')];
+        if (stylesRaw) {
+            let styles;
+            try {
+                styles = JSON.parse(stylesRaw);
+            }
+            catch (ex) {
+                logger_1.Logger.error(`Failed to parse Styles__c for stylesheet scan: ${flexCard['Name']}`);
+                styles = null;
+            }
+            const inlineCss = styles === null || styles === void 0 ? void 0 : styles.customStyles;
+            if (registry.containsNamespaceInText(inlineCss)) {
+                const message = registry.buildInlineCssNamespaceWarning();
+                if (message) {
+                    flexCardAssessmentInfo.warnings.push(message);
+                    flexCardAssessmentInfo.migrationStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(flexCardAssessmentInfo.migrationStatus, 'Needs manual intervention');
+                }
+            }
+        }
+    }
     updateDependencies(flexCard, flexCardAssessmentInfo) {
         var _a, _b, _c, _d;
-        let dataSource = JSON.parse(flexCard[this.namespacePrefix + 'Datasource__c'] || '{}');
-        // Handle both camelCase and lowercase variants
-        if (dataSource === null || dataSource === void 0 ? void 0 : dataSource.dataSource) {
-            dataSource = dataSource.dataSource;
-        }
-        else if (dataSource === null || dataSource === void 0 ? void 0 : dataSource.datasource) {
-            dataSource = dataSource.datasource;
-        }
-        // Check if it's a DataRaptor source
-        if (dataSource.type === stringContants_1.Constants.DataRaptorComponentName) {
-            const originalBundle = (_a = dataSource.value) === null || _a === void 0 ? void 0 : _a.bundle;
-            if (originalBundle) {
-                const cleanedBundle = this.cleanName(originalBundle);
-                flexCardAssessmentInfo.dependenciesDR.push(cleanedBundle);
-                // Add warning if DataRaptor name will change
-                if (originalBundle !== cleanedBundle) {
-                    flexCardAssessmentInfo.warnings.push(this.messages.getMessage('dataRaptorNameChangeMessage', [originalBundle, cleanedBundle]));
-                    flexCardAssessmentInfo.migrationStatus = 'Has Warnings';
-                }
-            }
-        }
-        else if (dataSource.type === stringContants_1.Constants.IntegrationProcedurePluralName) {
-            const originalIpMethod = (_b = dataSource.value) === null || _b === void 0 ? void 0 : _b.ipMethod;
-            if (originalIpMethod) {
-                const parts = originalIpMethod.split('_');
-                const cleanedParts = parts.map((p) => this.cleanName(p, true));
-                const cleanedIpMethod = cleanedParts.join('_');
-                flexCardAssessmentInfo.dependenciesIP.push(cleanedIpMethod);
-                // Add warning if IP name will change
-                if (originalIpMethod !== cleanedIpMethod) {
-                    flexCardAssessmentInfo.warnings.push(this.messages.getMessage('integrationProcedureNameChangeMessage', [originalIpMethod, cleanedIpMethod]));
-                    flexCardAssessmentInfo.migrationStatus = 'Has Warnings';
-                }
-                // Add warning for IP references with more than 2 parts (which potentially need manual updates)
-                if (parts.length > 2) {
-                    flexCardAssessmentInfo.warnings.push(this.messages.getMessage('integrationProcedureManualUpdateMessage', [originalIpMethod]));
-                    flexCardAssessmentInfo.migrationStatus = 'Need Manual Intervention';
+        const dataSourceConfig = JSON.parse(flexCard[this.getFieldKey('Datasource__c')] || '{}');
+        // Collect all data sources - any nested object with a 'type' property is a data source
+        // This handles: dataSource, datasource, event-0_0, event-1_0, etc.
+        const dataSources = Object.values(dataSourceConfig).filter((value) => value && typeof value === 'object' && value.type);
+        for (const ds of dataSources) {
+            // Check if it's a DataRaptor source
+            if (ds.type === stringContants_1.Constants.DataRaptorComponentName) {
+                const originalBundle = (_a = ds.value) === null || _a === void 0 ? void 0 : _a.bundle;
+                if (originalBundle) {
+                    this.addDataRaptorDependency(originalBundle, flexCardAssessmentInfo);
                 }
             }
-        }
-        else if (dataSource.type === stringContants_1.Constants.ApexRemoteComponentName) {
-            const remoteClass = (_c = dataSource.value) === null || _c === void 0 ? void 0 : _c.remoteClass;
-            const remoteMethod = (_d = dataSource.value) === null || _d === void 0 ? void 0 : _d.remoteMethod;
-            logger_1.Logger.info(`Remote Action name: ${remoteClass}.${remoteMethod}`);
-            // Avoid duplicates
-            if (!flexCardAssessmentInfo.dependenciesApexRemoteAction.includes(`${remoteClass}.${remoteMethod}`)) {
-                flexCardAssessmentInfo.dependenciesApexRemoteAction.push(`${remoteClass}.${remoteMethod}`);
+            else if (ds.type === stringContants_1.Constants.IntegrationProcedurePluralName) {
+                const originalIpMethod = (_b = ds.value) === null || _b === void 0 ? void 0 : _b.ipMethod;
+                if (originalIpMethod) {
+                    this.addIntegrationProcedureDependency(originalIpMethod, flexCardAssessmentInfo);
+                }
+            }
+            else if (ds.type === stringContants_1.Constants.ApexRemoteComponentName) {
+                const remoteClass = (_c = ds.value) === null || _c === void 0 ? void 0 : _c.remoteClass;
+                const remoteMethod = (_d = ds.value) === null || _d === void 0 ? void 0 : _d.remoteMethod;
+                if (remoteClass && remoteMethod) {
+                    const status = this.apexNamespaceRegistry.resolveStatus(remoteClass);
+                    const qualifiedClass = this.apexNamespaceRegistry.getQualifiedClassName(remoteClass);
+                    const qualifiedEntry = `${qualifiedClass}.${remoteMethod}`;
+                    if (!flexCardAssessmentInfo.dependenciesApexRemoteAction.includes(qualifiedEntry)) {
+                        flexCardAssessmentInfo.dependenciesApexRemoteAction.push(qualifiedEntry);
+                    }
+                    if (status === ApexNamespaceRegistry_1.ApexResolveStatus.NAMESPACED) {
+                        flexCardAssessmentInfo.warnings.push(this.messages.getMessage('apexRemoteDatasourceNamespaceWarning', [remoteClass, qualifiedClass]));
+                    }
+                    else if (status === ApexNamespaceRegistry_1.ApexResolveStatus.NOT_FOUND) {
+                        flexCardAssessmentInfo.errors.push(this.messages.getMessage('apexClassNotFound', [remoteClass, flexCardAssessmentInfo.name]));
+                    }
+                }
             }
         }
-        // Check for OmniScript dependencies in the card's definition
+        // Check for Omniscript dependencies in the card's definition
         try {
-            const definition = JSON.parse(flexCard[this.namespacePrefix + 'Definition__c'] || '{}');
+            const definition = JSON.parse(flexCard[this.getFieldKey('Definition__c')] || '{}');
             if (definition && definition.states) {
                 for (const state of definition.states) {
                     if (state.omniscripts && Array.isArray(state.omniscripts)) {
                         for (const os of state.omniscripts) {
                             if (os.type && os.subtype) {
-                                const osRef = `${os.type}_${os.subtype}_${os.language || 'English'}`;
-                                flexCardAssessmentInfo.dependenciesOS.push(osRef);
+                                this.addOmniScriptDependencyFromParts(os.type, os.subtype, os.language, flexCardAssessmentInfo);
                             }
                         }
                     }
@@ -250,16 +397,281 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                 }
             }
             let childCards = this.readChildCardsFromDefinition(flexCard);
-            flexCardAssessmentInfo.dependenciesFC.push(...childCards);
+            // Add warnings for child card name changes
+            for (const childCardName of childCards) {
+                this.addFlexCardDependency(childCardName, flexCardAssessmentInfo);
+            }
+            // Check for dependencies in events[] array
+            if (definition.events && Array.isArray(definition.events)) {
+                this.checkEventsForDependencies(definition.events, flexCardAssessmentInfo);
+            }
         }
         catch (err) {
             // Log the error but continue processing
             logger_1.Logger.error(`Error parsing definition for card ${flexCard.Name}: ${err.message}`);
         }
     }
+    /**
+     * Check events array for dependencies (Assessment)
+     * Handles: events[].actionList[].stateAction references
+     */
+    checkEventsForDependencies(events, flexCardAssessmentInfo) {
+        for (const event of events) {
+            if (!event.actionList || !Array.isArray(event.actionList)) {
+                continue;
+            }
+            for (const action of event.actionList) {
+                if (!action.stateAction) {
+                    continue;
+                }
+                const stateAction = action.stateAction;
+                // Detect Vlocity Action (not supported in standard runtime FlexCards)
+                if (stateAction.type === stringContants_1.Constants.VlocityAction) {
+                    this.addVlocityActionDependency(stateAction, flexCardAssessmentInfo);
+                }
+                // 1-2. Handle message.value.bundle (DataRaptor) and message.value.ipMethod (Integration Procedure)
+                this.processStateActionMessageForDependencies(stateAction, flexCardAssessmentInfo);
+                // 3. Handle cardName (FlexCard - Flyout childCard)
+                if (stateAction.cardName) {
+                    this.addFlexCardDependency(stateAction.cardName, flexCardAssessmentInfo);
+                }
+                // 4. Handle flyoutLwc - FlexCard child cards
+                if (this.hasFlexCardFlyoutDependency(stateAction)) {
+                    this.addFlexCardDependency(stateAction.flyoutLwc, flexCardAssessmentInfo);
+                }
+                // Handle flyoutLwc - CustomLwc with potential "cf" prefix for FlexCard reference
+                else if (this.hasCustomLwcFlyoutDependency(stateAction)) {
+                    this.addCfPrefixedFlexCardDependency(stateAction.flyoutLwc, flexCardAssessmentInfo);
+                }
+                // 5. Handle osName
+                else if (this.hasOmniscriptFlyoutDependency(stateAction)) {
+                    this.addOmniScriptDependency(stateAction.osName, flexCardAssessmentInfo);
+                }
+                // 6. Handle omniType.Name (OmniScript)
+                if (stateAction.omniType && stateAction.omniType.Name) {
+                    this.addOmniScriptDependency(stateAction.omniType.Name, flexCardAssessmentInfo);
+                }
+            }
+        }
+    }
+    /**
+     * Shared helper to check if a "cf" prefixed LWC name references a FlexCard and add dependency (assessment phase)
+     * @param cfPrefixedLwcName LWC name with "cf" prefix (e.g., "cfMyFlexCard")
+     * @param flexCardAssessmentInfo Assessment info to add dependencies and warnings
+     */
+    addCfPrefixedFlexCardDependency(cfPrefixedLwcName, flexCardAssessmentInfo) {
+        if (cfPrefixedLwcName.startsWith('cf')) {
+            // Remove "cf" prefix to get the original FlexCard name
+            const originalFlexCardName = cfPrefixedLwcName.substring(2);
+            // Check if the FlexCard name will change and add warning
+            const cleanedFlexCardName = this.cleanName(originalFlexCardName);
+            this.addFlexCardDependency(originalFlexCardName, flexCardAssessmentInfo);
+            if (originalFlexCardName !== cleanedFlexCardName) {
+                flexCardAssessmentInfo.warnings.push(this.messages.getMessage('cardLWCNameChangeMessage', [originalFlexCardName, cleanedFlexCardName]));
+                flexCardAssessmentInfo.migrationStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(flexCardAssessmentInfo.migrationStatus, 'Warnings');
+            }
+        }
+    }
+    /**
+     * Shared helper to update a "cf" prefixed LWC name with registry (migration phase)
+     * @param cfPrefixedLwcName LWC name with "cf" prefix (e.g., "cfMyFlexCard")
+     * @returns Updated LWC name with "cf" prefix
+     */
+    updateCfPrefixedFlexCardName(cfPrefixedLwcName) {
+        if (cfPrefixedLwcName.startsWith('cf')) {
+            // Remove "cf" prefix to get the original FlexCard name
+            const originalFlexCardName = cfPrefixedLwcName.substring(2);
+            // Look up the cleaned name from registry
+            let cleanedFlexCardName;
+            if (this.nameRegistry.hasFlexCardMapping(originalFlexCardName)) {
+                cleanedFlexCardName = this.nameRegistry.getFlexCardCleanedName(originalFlexCardName);
+            }
+            else {
+                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['Flexcard', originalFlexCardName])}`);
+                cleanedFlexCardName = this.cleanName(originalFlexCardName);
+            }
+            return `cf${cleanedFlexCardName}`;
+        }
+        return cfPrefixedLwcName;
+    }
+    /**
+     * Shared helper to check Custom LWC component for FlexCard dependencies (assessment phase)
+     * Handles customlwcname with "cf" prefix indicating FlexCard reference
+     */
+    checkCustomLwcForDependencies(component, flexCardAssessmentInfo) {
+        if (component.element === stringContants_1.Constants.CustomLwc && component.property) {
+            if (component.property.customlwcname) {
+                const customLwcName = component.property.customlwcname;
+                logger_1.Logger.info(`Custom LWC name: ${customLwcName}`);
+                // Check if this is a FlexCard reference (starts with "cf" prefix)
+                this.addCfPrefixedFlexCardDependency(customLwcName, flexCardAssessmentInfo);
+                // Add to LWC dependencies for tracking (avoid duplicates)
+                if (!flexCardAssessmentInfo.dependenciesLWC.includes(customLwcName)) {
+                    flexCardAssessmentInfo.dependenciesLWC.push(customLwcName);
+                }
+            }
+            // "action" is a reserved keyword in the core runtime; flag any Custom LWC
+            // that defines it as a property so the user removes/renames it pre-migration.
+            if (Object.prototype.hasOwnProperty.call(component.property, 'action')) {
+                const lwcLabel = component.property.customlwcname || component.elementLabel || stringContants_1.Constants.CustomLwc;
+                const reservedActionMessage = this.messages.getMessage('customLwcReservedActionKey', [lwcLabel]);
+                flexCardAssessmentInfo.errors.push(reservedActionMessage);
+                flexCardAssessmentInfo.warnings.push(reservedActionMessage);
+                flexCardAssessmentInfo.migrationStatus = 'Needs manual intervention';
+            }
+        }
+    }
+    /**
+     * Shared helper to update Custom LWC component with registry (migration phase)
+     * Handles customlwcname with "cf" prefix indicating FlexCard reference
+     */
+    updateCustomLwcWithRegistry(component) {
+        if (component.element === stringContants_1.Constants.CustomLwc && component.property) {
+            if (component.property.customlwcname) {
+                const customLwcName = component.property.customlwcname;
+                // Check if this is a FlexCard reference (starts with "cf" prefix) and update it
+                if (customLwcName === null || customLwcName === void 0 ? void 0 : customLwcName.startsWith('cf')) {
+                    const updatedLwcName = this.updateCfPrefixedFlexCardName(customLwcName);
+                    component.property.customlwcname = updatedLwcName;
+                    if (customLwcName !== updatedLwcName) {
+                        const cleanedFlexCardName = updatedLwcName.substring(2);
+                        logger_1.Logger.logVerbose(this.messages.getMessage('customLWCFlexCardReferenceUpdated', [customLwcName, cleanedFlexCardName]));
+                    }
+                }
+                // Note: Other custom LWC names (not starting with "cf") typically don't need cleaning
+            }
+        }
+    }
+    /**
+     * Shared helper to update flyoutLwc value with registry (migration phase)
+     * Handles FlexCard child cards references
+     */
+    updateFlyoutLwcValue(stateAction) {
+        if (stateAction.flyoutLwc) {
+            if (stateAction.flyoutType === stringContants_1.Constants.ChildCard) {
+                // flyoutLwc is a direct FlexCard name reference
+                const lwcName = stateAction.flyoutLwc;
+                if (this.nameRegistry.hasFlexCardMapping(lwcName)) {
+                    stateAction.flyoutLwc = this.nameRegistry.getFlexCardCleanedName(lwcName);
+                }
+                else {
+                    logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['Flexcard', lwcName])}`);
+                    stateAction.flyoutLwc = this.cleanName(lwcName);
+                }
+            }
+            else if (stateAction.flyoutType === stringContants_1.Constants.CustomLwc) {
+                // flyoutType is customLwc - update if it's a FlexCard reference with "cf" prefix
+                stateAction.flyoutLwc = this.updateCfPrefixedFlexCardName(stateAction.flyoutLwc);
+                // Note: Non-"cf" prefixed names are returned unchanged by the helper
+            }
+        }
+    }
+    /**
+     * Shared helper to process stateAction.message JSON for dependencies
+     * Handles DataRaptor bundle and Integration Procedure ipMethod references
+     */
+    processStateActionMessageForDependencies(stateAction, flexCardAssessmentInfo) {
+        // Only parse message for DataAction or cardAction types
+        if (stateAction.message &&
+            typeof stateAction.message === 'string' &&
+            stateAction.message.trim().length > 0 &&
+            (stateAction.type === stringContants_1.Constants.DataAction || stateAction.type === stringContants_1.Constants.CardAction)) {
+            try {
+                const messageObj = JSON.parse(stateAction.message);
+                if (messageObj.value) {
+                    // DataRaptor bundle
+                    if (messageObj.value.bundle) {
+                        this.addDataRaptorDependency(messageObj.value.bundle, flexCardAssessmentInfo);
+                    }
+                    // Integration Procedure ipMethod
+                    if (messageObj.value.ipMethod) {
+                        this.addIntegrationProcedureDependency(messageObj.value.ipMethod, flexCardAssessmentInfo);
+                    }
+                }
+            }
+            catch (e) {
+                // message is not valid JSON, skip
+                logger_1.Logger.error(`Failed to parse stateAction.message as JSON: ${e.message}`);
+            }
+        }
+    }
+    /**
+     * Shared helper to process stateAction.message JSON with registry updates
+     * Handles DataRaptor bundle and Integration Procedure ipMethod references
+     */
+    processStateActionMessageWithRegistry(stateAction, invalidIpNames) {
+        // Only parse message for DataAction or cardAction types
+        if (stateAction.message &&
+            typeof stateAction.message === 'string' &&
+            stateAction.message.trim().length > 0 &&
+            (stateAction.type === stringContants_1.Constants.DataAction || stateAction.type === stringContants_1.Constants.CardAction)) {
+            try {
+                const messageObj = JSON.parse(stateAction.message);
+                let messageUpdated = false;
+                if (messageObj.value) {
+                    // DataRaptor bundle
+                    if (messageObj.value.bundle) {
+                        const originalBundle = messageObj.value.bundle;
+                        if (this.nameRegistry.hasDataMapperMapping(originalBundle)) {
+                            messageObj.value.bundle = this.nameRegistry.getDataMapperCleanedName(originalBundle);
+                        }
+                        else {
+                            logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', originalBundle])}`);
+                            messageObj.value.bundle = this.cleanName(originalBundle);
+                        }
+                        messageUpdated = true;
+                    }
+                    // Integration Procedure ipMethod
+                    if (messageObj.value.ipMethod) {
+                        const ipMethod = messageObj.value.ipMethod;
+                        if (this.nameRegistry.hasIntegrationProcedureMapping(ipMethod)) {
+                            messageObj.value.ipMethod = this.nameRegistry.getIntegrationProcedureCleanedName(ipMethod);
+                        }
+                        else {
+                            logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['IntegrationProcedure', ipMethod])}`);
+                            const parts = ipMethod.split('_');
+                            messageObj.value.ipMethod = parts.map((p) => this.cleanName(p, true)).join('_');
+                            if (parts.length > 2 && invalidIpNames) {
+                                invalidIpNames.set(`event.actionList.stateAction.message`, ipMethod);
+                            }
+                        }
+                        messageUpdated = true;
+                    }
+                }
+                if (messageUpdated) {
+                    stateAction.message = JSON.stringify(messageObj);
+                }
+            }
+            catch (e) {
+                // message is not valid JSON, skip
+                logger_1.Logger.error(`Failed to parse stateAction.message as JSON: ${e.message}`);
+            }
+        }
+    }
+    handleAssessmentForStdDataModelOrgsWithMetadataAPIEnabled(flexCards) {
+        logger_1.Logger.logVerbose(this.messages.getMessage('preparingStorageForMetadataEnabledOrg', [stringContants_1.Constants.Flexcard]));
+        let storage = storageUtil_1.StorageUtil.getOmnistudioAssessmentStorage();
+        this.prepareStorageForRelatedObjectsWhenMetadataAPIEnabled(storage, flexCards);
+        storageUtil_1.StorageUtil.printAssessmentStorage();
+        return [];
+    }
+    handleMigrationForStdDataModelOrgsWithMetadataAPIEnabled(flexcards) {
+        logger_1.Logger.logVerbose(this.messages.getMessage('preparingStorageForMetadataEnabledOrg', [stringContants_1.Constants.Flexcard]));
+        let storage = storageUtil_1.StorageUtil.getOmnistudioMigrationStorage();
+        this.prepareStorageForRelatedObjectsWhenMetadataAPIEnabled(storage, flexcards);
+        storageUtil_1.StorageUtil.printAssessmentStorage();
+        // Return empty result structure for report generation
+        return [
+            {
+                name: this.getName(),
+                results: new Map(),
+                records: new Map(),
+            },
+        ];
+    }
     readChildCardsFromDefinition(card) {
         let childs = [];
-        const definition = JSON.parse(card[this.namespacePrefix + 'Definition__c']);
+        const definition = JSON.parse(card[this.getFieldKey('Definition__c')]);
         if (!definition)
             return childs;
         for (let state of definition.states || []) {
@@ -269,105 +681,205 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
         }
         return childs;
     }
-    checkComponentForDependencies(component, flexCardAssessmentInfo) {
+    checkComponentForDependencies(component, flexCardAssessmentInfo, omniScriptNavigateURLWarningKeys = new Set()) {
         // Check if this component is an action element
         if (component.element === 'action' && component.property && component.property.actionList) {
             // Process each action in the actionList
             for (const action of component.property.actionList) {
                 if (action.stateAction) {
+                    // Detect Vlocity Action (not supported in standard runtime FlexCards)
+                    if (action.stateAction.type === stringContants_1.Constants.VlocityAction) {
+                        this.addVlocityActionDependency(action.stateAction, flexCardAssessmentInfo);
+                    }
+                    // Handle message field (contains DataRaptor/IP references as JSON string)
+                    this.processStateActionMessageForDependencies(action.stateAction, flexCardAssessmentInfo);
                     // Case 1: Direct OmniScript reference
                     if (action.stateAction.type === stringContants_1.Constants.OmniScriptComponentName && action.stateAction.omniType) {
                         const omniType = action.stateAction.omniType;
                         if (omniType.Name && typeof omniType.Name === 'string') {
-                            const originalName = omniType.Name;
-                            const parts = originalName.split('/');
-                            if (parts.length >= 2) {
-                                // Check for name changes in each part
-                                const cleanedParts = parts.map((p) => this.cleanName(p));
-                                const cleanedName = cleanedParts.join('_');
-                                flexCardAssessmentInfo.dependenciesOS.push(cleanedName);
-                                // Add warning if any part of the name will change
-                                for (let i = 0; i < parts.length; i++) {
-                                    if (parts[i] !== cleanedParts[i]) {
-                                        flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [parts[i], cleanedParts[i]]));
-                                        flexCardAssessmentInfo.migrationStatus = 'Has Warnings';
-                                    }
-                                }
-                            }
+                            this.addOmniScriptDependency(omniType.Name, flexCardAssessmentInfo);
+                        }
+                    }
+                    // MISSING PATTERN FIXED: Case 1b: Direct OmniScript reference without type check (for test compatibility)
+                    else if (action.stateAction.omniType && !action.stateAction.type) {
+                        const omniType = action.stateAction.omniType;
+                        // Handle both string omniType and object with Name property
+                        let omniTypeName;
+                        if (typeof omniType === 'string') {
+                            omniTypeName = omniType;
                         }
+                        else if (omniType.Name && typeof omniType.Name === 'string') {
+                            omniTypeName = omniType.Name;
+                        }
+                        else {
+                            continue; // Skip if we can't extract the name
+                        }
+                        this.addOmniScriptDependency(omniTypeName, flexCardAssessmentInfo);
                     }
                     // Case 2: Flyout OmniScript reference
-                    else if (action.stateAction.type === 'Flyout' &&
-                        action.stateAction.flyoutType === stringContants_1.Constants.OmniScriptPluralName &&
-                        action.stateAction.osName) {
+                    else if (this.hasOmniscriptFlyoutDependency(action.stateAction)) {
                         const osName = action.stateAction.osName;
                         if (typeof osName === 'string') {
-                            // osName is typically in format "Omniscript/Testing/English"
-                            const originalName = osName;
-                            const parts = originalName.split('/');
-                            if (parts.length >= 2) {
-                                // Check for name changes in each part
-                                const cleanedParts = parts.map((p) => this.cleanName(p));
-                                const cleanedName = cleanedParts.join('_');
-                                flexCardAssessmentInfo.dependenciesOS.push(cleanedName);
-                                // Add warning if any part of the name will change
-                                for (let i = 0; i < parts.length; i++) {
-                                    if (parts[i] !== cleanedParts[i]) {
-                                        flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [parts[i], cleanedParts[i]]));
-                                        flexCardAssessmentInfo.migrationStatus = 'Has Warnings';
-                                    }
-                                }
-                            }
+                            this.addOmniScriptDependency(osName, flexCardAssessmentInfo);
                         }
                     }
+                    // Case 3: Flyout childCard reference - flyoutLwc is a direct FlexCard name
+                    else if (this.hasFlexCardFlyoutDependency(action.stateAction)) {
+                        this.addFlexCardDependency(action.stateAction.flyoutLwc, flexCardAssessmentInfo);
+                    }
+                    // Case 4: Flyout CustomLwc reference - check for FlexCard reference with "cf" prefix
+                    else if (this.hasCustomLwcFlyoutDependency(action.stateAction)) {
+                        this.addCfPrefixedFlexCardDependency(action.stateAction.flyoutLwc, flexCardAssessmentInfo);
+                    }
+                    else if (this.isCustomWebPageAction(action.stateAction)) {
+                        this.addOmniScriptNavigateURLAssessmentWarning(action.stateAction, flexCardAssessmentInfo, omniScriptNavigateURLWarningKeys);
+                    }
                 }
             }
         }
         // Check for Custom LWC component
-        if (component.element === 'customLwc' && component.property) {
-            // Check customlwcname property first
-            if (component.property.customlwcname) {
-                const customLwcName = component.property.customlwcname;
-                logger_1.Logger.info(`Custom LWC name: ${customLwcName}`);
-                // Avoid duplicates
-                if (!flexCardAssessmentInfo.dependenciesLWC.includes(customLwcName)) {
-                    flexCardAssessmentInfo.dependenciesLWC.push(customLwcName);
-                }
-            }
-        }
+        this.checkCustomLwcForDependencies(component, flexCardAssessmentInfo);
         // Check standard component actions if they exist
         if (component.actions && Array.isArray(component.actions)) {
             for (const action of component.actions) {
                 if (action.stateAction && action.stateAction.omniType) {
                     const omniType = action.stateAction.omniType;
                     if (omniType.Name && typeof omniType.Name === 'string') {
-                        const parts = omniType.Name.split('/');
-                        if (parts.length >= 2) {
-                            const osRef = parts.join('_');
-                            flexCardAssessmentInfo.dependenciesOS.push(osRef);
-                        }
+                        this.addOmniScriptDependency(omniType.Name, flexCardAssessmentInfo);
                     }
                 }
             }
         }
+        // MISSING PATTERN FIXED: Handle direct stateAction on component property
+        if (component.property && component.property.stateAction) {
+            // Case 1: Direct OmniScript reference on component property
+            if (component.property.stateAction.omniType) {
+                const omniType = component.property.stateAction.omniType;
+                if (omniType.Name && typeof omniType.Name === 'string') {
+                    this.addOmniScriptDependency(omniType.Name, flexCardAssessmentInfo);
+                }
+            }
+            // Case 2: Flyout OmniScript reference on component property
+            if (this.hasOmniscriptFlyoutDependency(component.property.stateAction)) {
+                const osName = component.property.stateAction.osName;
+                if (typeof osName === 'string') {
+                    this.addOmniScriptDependency(osName, flexCardAssessmentInfo);
+                }
+            }
+            // Case 3: Flyout childCard reference on component property - flyoutLwc is a direct FlexCard name
+            if (this.hasFlexCardFlyoutDependency(component.property.stateAction)) {
+                this.addFlexCardDependency(component.property.stateAction.flyoutLwc, flexCardAssessmentInfo);
+            }
+            // Case 4: Flyout CustomLwc reference on component property - check for FlexCard reference with "cf" prefix
+            if (this.hasCustomLwcFlyoutDependency(component.property.stateAction)) {
+                this.addCfPrefixedFlexCardDependency(component.property.stateAction.flyoutLwc, flexCardAssessmentInfo);
+            }
+            else if (this.isCustomWebPageAction(component.property.stateAction)) {
+                this.addOmniScriptNavigateURLAssessmentWarning(component.property.stateAction, flexCardAssessmentInfo, omniScriptNavigateURLWarningKeys);
+            }
+        }
+        // MISSING PATTERN FIXED: Handle omni-flyout elements (from tests)
+        if (component.element === stringContants_1.Constants.OmniFlyout && component.property && component.property.flyoutOmniScript) {
+            if (component.property.flyoutOmniScript.osName) {
+                const osName = component.property.flyoutOmniScript.osName;
+                if (typeof osName === 'string') {
+                    this.addOmniScriptDependency(osName, flexCardAssessmentInfo);
+                }
+            }
+        }
+        // MISSING PATTERN FIXED: Handle childCardPreview elements with cardName property
+        if (component.element === stringContants_1.Constants.ChildCardPreview && component.property && component.property.cardName) {
+            this.addFlexCardDependency(component.property.cardName, flexCardAssessmentInfo);
+        }
         // Check child components recursively
         if (component.children && Array.isArray(component.children)) {
-            for (const child of component.children) {
-                this.checkComponentForDependencies(child, flexCardAssessmentInfo);
+            for (let childIndex = 0; childIndex < component.children.length; childIndex++) {
+                const child = component.children[childIndex];
+                this.checkComponentForDependencies(child, flexCardAssessmentInfo, omniScriptNavigateURLWarningKeys);
+            }
+        }
+    }
+    addOmniScriptNavigateURLAssessmentWarning(stateAction, flexCardAssessmentInfo, warningKeys) {
+        if (this.IS_STANDARD_DATA_MODEL) {
+            return;
+        }
+        const rewrite = this.getOmniScriptURLRewrite(stateAction);
+        if (!rewrite) {
+            return;
+        }
+        const { targetName, updatedURL, malformedTokens } = rewrite;
+        const summary = this.formatURLRewriteSummary(targetName, updatedURL);
+        if (warningKeys.has(summary)) {
+            return;
+        }
+        warningKeys.add(summary);
+        // Emit a single warning per URL: when fragment tokens are malformed, the
+        // dedicated malformed-token warning is the authoritative one (it already
+        // contains both the original URL and the "will get replaced with" line,
+        // PLUS the malformed-token list and the verify instruction). For clean
+        // URLs we fall back to the plain rewrite warning. Defense-in-depth: if
+        // the malformed formatter unexpectedly returns empty, fall back to the
+        // plain rewrite warning so the customer still sees something.
+        const hasMalformedTokens = Array.isArray(malformedTokens) && malformedTokens.length > 0;
+        let warningText = '';
+        if (hasMalformedTokens) {
+            warningText = this.formatMalformedFragmentTokenWarning(targetName, updatedURL, malformedTokens);
+        }
+        if (!warningText) {
+            warningText = this.messages.getMessage('webPageOmniScriptNavigationDetected', [
+                this.toReadableURL(targetName),
+                this.toReadableURL(updatedURL),
+            ]);
+        }
+        flexCardAssessmentInfo.warnings.push(warningText);
+        flexCardAssessmentInfo.migrationStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(flexCardAssessmentInfo.migrationStatus, 'Warnings');
+    }
+    /**
+     * Build the customer-facing warning shown when a Web Page action URL contains
+     * fragment tokens that decodeURIComponent couldn't parse. Centralised here so
+     * the assessment and migration paths emit byte-identical text.
+     *
+     * Returns an empty string when the helper is called with no malformed tokens
+     * (defense in depth: callers already guard, but a future caller that forgets
+     * shouldn't be able to produce a degenerate warning with an empty bracket).
+     * Non-string entries are coerced via String() so a misbehaving caller can't
+     * surface "undefined" / "[object Object]" to customers; duplicates are
+     * suppressed so a fragment like `#/Foo%/Bar/Foo%/Baz` doesn't render as
+     * `["Foo%", "Foo%"]`.
+     */
+    formatMalformedFragmentTokenWarning(targetName, updatedURL, malformedTokens) {
+        if (!Array.isArray(malformedTokens) || malformedTokens.length === 0) {
+            return '';
+        }
+        const seen = new Set();
+        const uniqueTokens = [];
+        for (const raw of malformedTokens) {
+            const t = typeof raw === 'string' ? raw : String(raw);
+            if (!seen.has(t)) {
+                seen.add(t);
+                uniqueTokens.push(t);
             }
         }
+        const tokenList = uniqueTokens.map((t) => `"${t}"`).join(', ');
+        return this.messages.getMessage('webPageOmniScriptUrlMalformedToken', [
+            tokenList,
+            this.toReadableURL(targetName),
+            this.toReadableURL(updatedURL),
+        ]);
     }
-    // Query all cards that are active
-    async getAllActiveCards() {
+    async getAllCards() {
         //DebugTimer.getInstance().lap('Query Vlocity Cards');
         const filters = new Map();
-        filters.set(this.namespacePrefix + 'CardType__c', 'flex');
+        if (!this.IS_STANDARD_DATA_MODEL) {
+            filters.set(this.namespacePrefix + 'CardType__c', 'flex');
+        }
+        let flexCards;
         if (this.allVersions) {
             const sortFields = [
                 { field: 'Name', direction: utils_1.SortDirection.ASC },
-                { field: this.namespacePrefix + 'Version__c', direction: utils_1.SortDirection.ASC },
+                { field: this.getFieldKey('Version__c'), direction: utils_1.SortDirection.ASC },
             ];
-            return await utils_1.QueryTools.queryWithFilterAndSort(this.connection, this.namespace, CardMigrationTool.VLOCITYCARD_NAME, this.getCardFields(), filters, sortFields).catch((err) => {
+            flexCards = await utils_1.QueryTools.queryWithFilterAndSort(this.connection, this.getQueryNamespace(), this.getCardObjectName(), this.getCardFields(), filters, sortFields).catch((err) => {
                 if (err.errorCode === 'INVALID_TYPE') {
                     throw new interfaces_1.InvalidEntityTypeError(`${CardMigrationTool.VLOCITYCARD_NAME} type is not found under this namespace`);
                 }
@@ -375,37 +887,44 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
             });
         }
         else {
-            filters.set(this.namespacePrefix + 'Active__c', true);
-            return await utils_1.QueryTools.queryWithFilter(this.connection, this.namespace, CardMigrationTool.VLOCITYCARD_NAME, this.getCardFields(), filters).catch((err) => {
+            filters.set(this.getFieldKey('Active__c'), true);
+            flexCards = await utils_1.QueryTools.queryWithFilter(this.connection, this.getQueryNamespace(), this.getCardObjectName(), this.getCardFields(), filters).catch((err) => {
                 if (err.errorCode === 'INVALID_TYPE') {
-                    throw new interfaces_1.InvalidEntityTypeError(`${CardMigrationTool.VLOCITYCARD_NAME} type is not found under this namespace`);
+                    throw new interfaces_1.InvalidEntityTypeError(`${this.getCardObjectName()} type is not found under this namespace`);
                 }
                 throw err;
             });
         }
+        // Apply prioritization only for standard data model
+        if (this.IS_STANDARD_DATA_MODEL) {
+            return this.prioritizeFlexCardsWithoutSpecialCharacters(flexCards);
+        }
+        return flexCards;
     }
-    // Upload All the VlocityCard__c records to OmniUiCard
+    // Upload All the VlocityCard__c records to OmniUiCard for custom model and update references for standard
     async uploadAllCards(cards, progressBar) {
         const cardsUploadInfo = new Map();
         const originalRecords = new Map();
         const uniqueNames = new Set();
+        // Map to track cleanedName -> originalName for duplicate detection
+        const dupFlexCardNames = new Map();
         let progressCounter = 0;
         progressBar.start(cards.length, progressCounter);
         for (let card of cards) {
-            await this.uploadCard(cards, card, cardsUploadInfo, originalRecords, uniqueNames);
+            await this.uploadCard(cards, card, cardsUploadInfo, originalRecords, uniqueNames, dupFlexCardNames);
             progressBar.update(++progressCounter);
         }
         this.prepareStorageForFlexcards(cardsUploadInfo, originalRecords);
         progressBar.stop();
         return cardsUploadInfo;
     }
-    async uploadCard(allCards, card, cardsUploadInfo, originalRecords, uniqueNames) {
+    async uploadCard(allCards, card, cardsUploadInfo, originalRecords, uniqueNames, dupFlexCardNames) {
         const recordId = card['Id'];
         // If we already uploaded this card, skip
         if (cardsUploadInfo.has(recordId)) {
             return;
         }
-        const isCardActive = card[`${this.namespacePrefix}Active__c`];
+        const isCardActive = card[this.getFieldKey('Active__c')];
         try {
             const childCards = this.getChildCards(card);
             if (childCards.length > 0) {
@@ -413,14 +932,19 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                     // Upload child cards
                     const childCard = allCards.find((c) => c['Name'] === childCardName);
                     if (childCard) {
-                        await this.uploadCard(allCards, childCard, cardsUploadInfo, originalRecords, uniqueNames);
+                        await this.uploadCard(allCards, childCard, cardsUploadInfo, originalRecords, uniqueNames, dupFlexCardNames);
                     }
                 }
                 this.updateChildCards(card);
             }
             // Perform the transformation
             const invalidIpNames = new Map();
-            const transformedCard = this.mapVlocityCardRecord(card, cardsUploadInfo, invalidIpNames);
+            const urlUpdateSummaries = new Set();
+            // Map keyed by rewrite summary so the emission step below can subtract
+            // malformed URLs from the aggregate "Updated URLs:" locations message.
+            // Same key for two actions on the same card => one entry (deduped).
+            const malformedFragmentWarnings = new Map();
+            const transformedCard = this.mapVlocityCardRecord(card, cardsUploadInfo, invalidIpNames, urlUpdateSummaries, malformedFragmentWarnings); // This only has the card structure, card definition is not there
             // Verify duplicated names
             let transformedCardName;
             if (this.allVersions) {
@@ -430,17 +954,50 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                 transformedCardName = transformedCard['Name'];
             }
             const transformedCardAuthorName = transformedCard['AuthorName'];
-            if (uniqueNames.has(transformedCard['Name'])) {
-                this.setRecordErrors(card, this.messages.getMessage('duplicatedCardName'));
+            // Check for duplicates using version-aware name when allVersions is true
+            const uniqueCheckName = this.allVersions
+                ? `${transformedCard['Name']}_${transformedCard['VersionNumber']}`
+                : transformedCard['Name'];
+            const originalCardName = card['Name'];
+            const cleanedCardName = transformedCard['Name'];
+            // Check for exact duplicate (same name + same version)
+            if (uniqueNames.has(uniqueCheckName)) {
+                this.setRecordErrors(card, this.messages.getMessage('duplicatedCardName', [uniqueCheckName]));
                 originalRecords.set(recordId, card);
                 return;
             }
-            // Save the name for duplicated names check
-            uniqueNames.add(transformedCard['Name']);
+            // Check for naming conflict: different original names cleaning to same name
+            else if (this.allVersions && dupFlexCardNames.has(cleanedCardName)) {
+                const existingOriginalName = dupFlexCardNames.get(cleanedCardName);
+                // Only flag if the original names are different (indicates a naming conflict)
+                if (existingOriginalName !== originalCardName) {
+                    this.setRecordErrors(card, this.messages.getMessage('lowerVersionDuplicateCardName', [uniqueCheckName]));
+                    originalRecords.set(recordId, card);
+                    return;
+                }
+            }
+            // Add to tracking structures
+            uniqueNames.add(uniqueCheckName);
+            if (this.allVersions && !dupFlexCardNames.has(cleanedCardName)) {
+                dupFlexCardNames.set(cleanedCardName, originalCardName);
+            }
             // Create a map of the original records
             originalRecords.set(recordId, card);
             // Create card
-            const uploadResult = await net_1.NetUtils.createOne(this.connection, CardMigrationTool.OMNIUICARD_NAME, recordId, transformedCard);
+            let uploadResult;
+            if (!this.IS_STANDARD_DATA_MODEL) {
+                uploadResult = await net_1.NetUtils.createOne(this.connection, CardMigrationTool.OMNIUICARD_NAME, recordId, transformedCard);
+            }
+            else {
+                const standardId = transformedCard['Id'];
+                delete transformedCard['Id'];
+                const deactivationResult = await net_1.NetUtils.updateOne(this.connection, CardMigrationTool.OMNIUICARD_NAME, standardId, standardId, {
+                    ['IsActive']: false,
+                });
+                logger_1.Logger.logVerbose(JSON.stringify(deactivationResult)); // TODO - Add checks here
+                uploadResult = await net_1.NetUtils.updateOne(this.connection, CardMigrationTool.OMNIUICARD_NAME, recordId, recordId, transformedCard);
+                uploadResult['id'] = standardId;
+            }
             if (uploadResult) {
                 // Fix errors
                 uploadResult.errors = uploadResult.errors || [];
@@ -449,13 +1006,33 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
                 }
                 // If name has been changed, add a warning message
                 uploadResult.warnings = uploadResult.warnings || [];
-                if (transformedCardAuthorName !== card[this.namespacePrefix + 'Author__c']) {
+                if (transformedCardAuthorName !== card[this.getFieldKey('Author__c')]) {
                     uploadResult.warnings.unshift(this.messages.getMessage('cardAuthorNameChangeMessage', [transformedCardAuthorName]));
                 }
                 uploadResult.newName = transformedCardName;
+                uploadResult.actualName = transformedCard['Name']; // This is required as storage needs name without version, for replacement in other references
                 if (transformedCard['Name'] !== card['Name']) {
                     uploadResult.warnings.unshift(this.messages.getMessage('cardNameChangeMessage', [transformedCardName]));
                 }
+                // The count summary describes ONLY URLs that were converted cleanly
+                // to the standard URL format. Malformed URLs were rewritten with
+                // their bad tokens kept as-is -- claiming they were "updated to
+                // standard URL format" alongside their own malformed warning would
+                // contradict that warning and confuse the customer. Each malformed
+                // URL is surfaced via its own dedicated bullet below which already
+                // names the original URL, the rewritten URL, and the verify
+                // instruction.
+                const cleanRewriteSummaries = Array.from(urlUpdateSummaries).filter((summary) => !malformedFragmentWarnings.has(summary));
+                if (cleanRewriteSummaries.length > 0) {
+                    uploadResult.warnings.unshift(this.messages.getMessage('flexCardOmniScriptNavigateURLUpdated', [String(cleanRewriteSummaries.length)]));
+                }
+                // Surface malformed-fragment-token warnings (one per affected URL).
+                // These are intentionally emitted *instead of* the count bullet
+                // above so the customer sees a single, actionable bullet per
+                // malformed URL: original URL, rewrite, verify instruction.
+                for (const malformedWarning of malformedFragmentWarnings.values()) {
+                    uploadResult.warnings.push(malformedWarning);
+                }
                 if (uploadResult.id && invalidIpNames.size > 0) {
                     const val = Array.from(invalidIpNames.entries())
                         .map((e) => e[0])
@@ -485,50 +1062,120 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
             });
         }
     }
-    addToAssessmentStorage(originalName, cleanedName) {
+    prepareStorageForRelatedObjectsWhenMetadataAPIEnabled(storage, flexcards) {
+        for (const flexcard of flexcards) {
+            const originalName = flexcard[this.getFieldKey('Name')];
+            let value = {
+                name: originalName,
+                isDuplicate: false,
+                originalName: originalName,
+                migrationSuccess: true, // When metadata API is enabled, assume migration is successful
+            };
+            this.addKeyToStorage(originalName, value, storage);
+        }
+    }
+    prepareAssessmentStorageForFlexcards(flexcardAssessmentInfos) {
         let storage = storageUtil_1.StorageUtil.getOmnistudioAssessmentStorage();
-        if (storage.fcStorage.has(originalName)) {
-            storage.fcStorage.get(originalName).isDuplicate = true;
+        for (let flexCardAssessmentInfo of flexcardAssessmentInfos) {
+            try {
+                if (!(flexCardAssessmentInfo === null || flexCardAssessmentInfo === void 0 ? void 0 : flexCardAssessmentInfo.nameMapping)) {
+                    logger_1.Logger.error(this.messages.getMessage('missingInfo'));
+                    return;
+                }
+                const originalName = flexCardAssessmentInfo.nameMapping.oldName;
+                let value = {
+                    name: flexCardAssessmentInfo.nameMapping.newName,
+                    isDuplicate: false,
+                    originalName: originalName,
+                };
+                if (flexCardAssessmentInfo.errors && flexCardAssessmentInfo.errors.length > 0) {
+                    value.error = flexCardAssessmentInfo.errors;
+                    value.migrationSuccess = false;
+                }
+                else if (flexCardAssessmentInfo.migrationStatus === 'Needs manual intervention') {
+                    // Duplicate name and other critical warnings
+                    value.error = flexCardAssessmentInfo.warnings;
+                    value.migrationSuccess = false;
+                }
+                else {
+                    value.migrationSuccess = true;
+                }
+                this.addKeyToStorage(originalName, value, storage);
+            }
+            catch (error) {
+                logger_1.Logger.logVerbose(this.messages.getMessage('errorWhileProcessingFlexcardStorage'));
+                logger_1.Logger.error(error);
+            }
+        }
+        storageUtil_1.StorageUtil.printAssessmentStorage();
+    }
+    addKeyToStorage(originalName, value, storage) {
+        let finalKey = `${originalName}`;
+        finalKey = finalKey.toLowerCase();
+        if (storage.fcStorage.has(finalKey)) {
+            if (this.allVersions) {
+                const storedValue = storage.fcStorage.get(finalKey);
+                if (this.isDifferentFlexcard(storedValue, originalName)) {
+                    this.markDuplicateKeyInStorage(value, finalKey, storage);
+                }
+            }
+            else {
+                this.markDuplicateKeyInStorage(value, finalKey, storage);
+            }
         }
         else {
-            storage.fcStorage.set(originalName, {
-                name: cleanedName,
-                isDuplicate: false,
-            });
+            // Key doesn't exist - safe to set
+            storage.fcStorage.set(finalKey, value);
+        }
+    }
+    markDuplicateKeyInStorage(value, finalKey, storage) {
+        // Key already exists - handle accordingly
+        logger_1.Logger.logVerbose(this.messages.getMessage('keyAlreadyInStorage', ['Flexcard', finalKey]));
+        value.isDuplicate = true;
+        storage.fcStorage.set(finalKey, value);
+    }
+    isDifferentFlexcard(storedValue, originalName) {
+        if (storedValue.originalName === originalName) {
+            return false;
         }
+        return true;
     }
     prepareStorageForFlexcards(cardsUploadInfo, originalRecords) {
-        logger_1.Logger.logVerbose('Started preparing storage for flexcards');
+        logger_1.Logger.logVerbose(this.messages.getMessage('flexcardStorageProcessingStarted'));
         let storage = storageUtil_1.StorageUtil.getOmnistudioMigrationStorage();
         for (let key of Array.from(originalRecords.keys())) {
             try {
                 let oldrecord = originalRecords.get(key);
                 let newrecord = cardsUploadInfo.get(key);
+                const originalName = oldrecord['Name'];
                 let value = {
-                    name: newrecord['newName'],
+                    name: newrecord === null || newrecord === void 0 ? void 0 : newrecord.actualName,
                     isDuplicate: false,
+                    originalName: originalName,
                 };
-                if (newrecord.hasErrors) {
-                    value.error = newrecord.errors;
+                if (newrecord === undefined) {
+                    // Card was not migrated - check if original record has error details
+                    if (oldrecord['errors'] && Array.isArray(oldrecord['errors'])) {
+                        value.error = oldrecord['errors'];
+                    }
+                    else {
+                        value.error = ['Migration Failed'];
+                    }
                     value.migrationSuccess = false;
                 }
                 else {
-                    value.migrationSuccess = true;
-                }
-                let finalKey = `${oldrecord['Name']}`;
-                if (storage.fcStorage.has(finalKey)) {
-                    // Key already exists - handle accordingly
-                    logger_1.Logger.logVerbose(`Key ${finalKey} already exists in flexcard storage`);
-                    value.isDuplicate = true;
-                    storage.fcStorage.set(finalKey, value);
-                }
-                else {
-                    // Key doesn't exist - safe to set
-                    storage.fcStorage.set(finalKey, value);
+                    if (newrecord.hasErrors) {
+                        value.error = newrecord.errors;
+                        value.migrationSuccess = false;
+                    }
+                    else {
+                        value.migrationSuccess = true;
+                    }
                 }
+                this.addKeyToStorage(originalName, value, storage);
             }
             catch (error) {
-                logger_1.Logger.logVerbose('Error occurred while processing key for flexcard storage');
+                logger_1.Logger.logVerbose(this.messages.getMessage('errorWhileProcessingFlexcardStorage'));
                 logger_1.Logger.error(error);
             }
             storageUtil_1.StorageUtil.printMigrationStorage();
@@ -536,7 +1183,7 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
     }
     getChildCards(card) {
         let childs = [];
-        const definition = JSON.parse(card[this.namespacePrefix + 'Definition__c']);
+        const definition = JSON.parse(card[this.getFieldKey('Definition__c')]);
         if (!definition)
             return childs;
         for (let state of definition.states || []) {
@@ -549,137 +1196,1030 @@ class CardMigrationTool extends base_1.BaseMigrationTool {
         return childs;
     }
     updateChildCards(card) {
-        const definition = JSON.parse(card[this.namespacePrefix + 'Definition__c']);
+        const definition = JSON.parse(card[this.getFieldKey('Definition__c')]);
         if (!definition)
             return;
         for (let state of definition.states || []) {
             if (state.childCards && Array.isArray(state.childCards)) {
+                const originalChildCards = [...state.childCards];
                 state.childCards = state.childCards.map((c) => this.cleanName(c));
+                // Check if any child card name was changed
+                for (let i = 0; i < originalChildCards.length; i++) {
+                    if (originalChildCards[i] !== state.childCards[i]) {
+                    }
+                }
             }
         }
-        card[this.namespacePrefix + 'Definition__c'] = JSON.stringify(definition);
+        card[this.getFieldKey('Definition__c')] = JSON.stringify(definition);
     }
     // Maps an indivitdual VlocityCard__c record to an OmniUiCard record.
-    mapVlocityCardRecord(cardRecord, cardsUploadInfo, invalidIpNames) {
+    mapVlocityCardRecord(cardRecord, cardsUploadInfo, invalidIpNames, urlUpdateSummaries, malformedFragmentWarnings) {
+        var _a, _b;
         // Transformed object
-        const mappedObject = {};
-        // Get the fields of the record
-        const recordFields = Object.keys(cardRecord);
-        // Map individual fields
-        recordFields.forEach((recordField) => {
-            const cleanFieldName = this.getCleanFieldName(recordField);
-            if (VlocityCard_1.default.hasOwnProperty(cleanFieldName) && cleanFieldName !== 'IsChildCard__c') {
-                mappedObject[VlocityCard_1.default[cleanFieldName]] = cardRecord[recordField];
-                // Transform ParentId__c to ClonedFromOmniUiCardKey field from uploaded response map
-                if (cleanFieldName === 'ParentID__c' && cardsUploadInfo.has(cardRecord[`${this.namespacePrefix}ParentID__c`])) {
-                    mappedObject[VlocityCard_1.default[cleanFieldName]] = cardsUploadInfo.get(cardRecord[`${this.namespacePrefix}ParentID__c`]).id;
-                }
-                // CardType__c and OmniUiCardType have different picklist values
-                if (cleanFieldName === 'CardType__c') {
-                    let ischildCard = cardRecord[`${this.namespacePrefix}IsChildCard__c`];
-                    mappedObject['OmniUiCardType'] = ischildCard ? 'Child' : 'Parent';
-                }
-                // Child Cards don't have version, so assigning 1
-                if (cleanFieldName === 'Version__c') {
-                    let versionNumber = cardRecord[`${this.namespacePrefix}Version__c`];
-                    mappedObject['VersionNumber'] = versionNumber ? versionNumber : 1;
+        let mappedObject = {};
+        if (!this.IS_STANDARD_DATA_MODEL) {
+            // Get the fields of the record
+            const recordFields = Object.keys(cardRecord);
+            // Map individual fields
+            recordFields.forEach((recordField) => {
+                const cleanFieldName = this.getCleanFieldName(recordField);
+                if (VlocityCard_1.default.hasOwnProperty(cleanFieldName) && cleanFieldName !== 'IsChildCard__c') {
+                    mappedObject[VlocityCard_1.default[cleanFieldName]] = cardRecord[recordField];
+                    // Transform ParentId__c to ClonedFromOmniUiCardKey field from uploaded response map
+                    if (cleanFieldName === 'ParentID__c' && cardsUploadInfo.has(cardRecord[this.getFieldKey('ParentID__c')])) {
+                        mappedObject[VlocityCard_1.default[cleanFieldName]] = cardsUploadInfo.get(cardRecord[this.getFieldKey('ParentID__c')]).id;
+                    }
+                    // CardType__c and OmniUiCardType have different picklist values
+                    if (cleanFieldName === 'CardType__c') {
+                        let ischildCard = cardRecord[this.getFieldKey('IsChildCard__c')];
+                        mappedObject['OmniUiCardType'] = ischildCard ? 'Child' : 'Parent';
+                    }
+                    // Child Cards don't have version, so assigning 1
+                    if (cleanFieldName === 'Version__c') {
+                        let versionNumber = cardRecord[this.getFieldKey('Version__c')];
+                        mappedObject['VersionNumber'] = versionNumber ? versionNumber : 1;
+                    }
                 }
-            }
-        });
+            });
+        }
+        else {
+            mappedObject = { ...cardRecord };
+        }
         // Clean the name
         mappedObject['Name'] = this.cleanName(mappedObject['Name']);
         mappedObject[VlocityCard_1.default.Author__c] = this.cleanName(mappedObject[VlocityCard_1.default.Author__c]);
         mappedObject[VlocityCard_1.default.Active__c] = false;
-        // Update the datasource
-        const datasource = JSON.parse(mappedObject[VlocityCard_1.default.Datasource__c] || '{}');
-        if (datasource.dataSource) {
-            const type = datasource.dataSource.type;
-            if (type === stringContants_1.Constants.DataRaptorComponentName) {
-                datasource.dataSource.value.bundle = this.cleanName(datasource.dataSource.value.bundle);
-            }
-            else if (type === stringContants_1.Constants.IntegrationProcedurePluralName) {
-                const ipMethod = datasource.dataSource.value.ipMethod || '';
-                const parts = ipMethod.split('_');
-                const newKey = parts.map((p) => this.cleanName(p, true)).join('_');
-                datasource.dataSource.value.ipMethod = newKey;
-                if (parts.length > 2) {
-                    invalidIpNames.set('DataSource', ipMethod);
-                }
+        if (this.IS_STANDARD_DATA_MODEL) {
+            if (mappedObject['OmniUiCardKey']) {
+                mappedObject['OmniUiCardKey'] =
+                    mappedObject['Name'] +
+                        '/' +
+                        mappedObject[VlocityCard_1.default.Author__c] +
+                        '/' +
+                        mappedObject[VlocityCard_1.default.Version__c] +
+                        '.0';
             }
-            mappedObject[VlocityCard_1.default.Datasource__c] = JSON.stringify(datasource);
         }
-        // Update the propertyset datasource
-        const propertySet = JSON.parse(mappedObject[VlocityCard_1.default.Definition__c] || '{}');
-        if (propertySet) {
-            if (propertySet.dataSource) {
-                const type = propertySet.dataSource.type;
-                if (type === 'DataRaptor') {
-                    propertySet.dataSource.value.bundle = this.cleanName(propertySet.dataSource.value.bundle);
+        // Update the datasource - process any nested object with a 'type' property
+        const datasource = JSON.parse(mappedObject[VlocityCard_1.default.Datasource__c] || '{}');
+        let updated = false;
+        // Process all keys that have objects with type property
+        for (const key of Object.keys(datasource)) {
+            const ds = datasource[key];
+            if (!ds || typeof ds !== 'object' || !ds.type)
+                continue;
+            if (ds.type === stringContants_1.Constants.DataRaptorComponentName && ((_a = ds.value) === null || _a === void 0 ? void 0 : _a.bundle)) {
+                ds.value.bundle = this.nameRegistry.hasDataMapperMapping(ds.value.bundle)
+                    ? this.nameRegistry.getDataMapperCleanedName(ds.value.bundle)
+                    : this.cleanName(ds.value.bundle);
+                updated = true;
+            }
+            else if (ds.type === stringContants_1.Constants.IntegrationProcedurePluralName && ((_b = ds.value) === null || _b === void 0 ? void 0 : _b.ipMethod)) {
+                const ipMethod = ds.value.ipMethod;
+                if (this.nameRegistry.hasIntegrationProcedureMapping(ipMethod)) {
+                    ds.value.ipMethod = this.nameRegistry.getIntegrationProcedureCleanedName(ipMethod);
                 }
-                else if (type === 'IntegrationProcedures') {
-                    const ipMethod = propertySet.dataSource.value.ipMethod || '';
+                else {
                     const parts = ipMethod.split('_');
-                    const newKey = parts.map((p) => this.cleanName(p, true)).join('_');
-                    propertySet.dataSource.value.ipMethod = newKey;
-                    if (parts.length > 2) {
-                        invalidIpNames.set('DataSource', ipMethod);
-                    }
-                }
-            }
-            // update the states for child cards
-            for (let i = 0; i < (propertySet.states || []).length; i++) {
-                const state = propertySet.states[i];
-                // Clean childCards property
-                if (state.childCards && Array.isArray(state.childCards)) {
-                    state.childCards = state.childCards.map((c) => this.cleanName(c));
-                }
-                // Fix the "components" for child cards
-                for (let componentKey in state.components) {
-                    if (state.components.hasOwnProperty(componentKey)) {
-                        const component = state.components[componentKey];
-                        if (component.children && Array.isArray(component.children)) {
-                            this.fixChildren(component.children);
-                        }
-                    }
-                }
-                if (state.omniscripts && Array.isArray(state.omniscripts)) {
-                    for (let osIdx = 0; osIdx < state.omniscripts.length; osIdx++) {
-                        state.omniscripts[osIdx].type = this.cleanName(state.omniscripts[osIdx].type);
-                        state.omniscripts[osIdx].subtype = this.cleanName(state.omniscripts[osIdx].subtype);
-                    }
+                    ds.value.ipMethod = parts.map((p) => this.cleanName(p, true)).join('_');
+                    if (parts.length > 2)
+                        invalidIpNames.set(key, ipMethod);
                 }
+                updated = true;
             }
-            mappedObject[VlocityCard_1.default.Definition__c] = JSON.stringify(propertySet);
         }
+        if (updated)
+            mappedObject[VlocityCard_1.default.Datasource__c] = JSON.stringify(datasource);
+        const isCardActive = cardRecord[this.getFieldKey('Active__c')];
+        this.ensureCommunityTargets(mappedObject, isCardActive);
+        // Update all dependencies comprehensively
+        this.updateAllDependenciesWithRegistry(mappedObject, invalidIpNames, urlUpdateSummaries, malformedFragmentWarnings);
         mappedObject['attributes'] = {
             type: CardMigrationTool.OMNIUICARD_NAME,
             referenceId: cardRecord['Id'],
         };
         return mappedObject;
     }
-    fixChildren(children) {
-        for (let j = 0; j < children.length; j++) {
-            const child = children[j];
-            if (child.element === 'childCardPreview') {
-                child.property.cardName = this.cleanName(child.property.cardName);
+    /**
+     * Comprehensive dependency update using NameMappingRegistry - mirrors assessment logic
+     */
+    updateAllDependenciesWithRegistry(mappedObject, invalidIpNames, urlUpdateSummaries, malformedFragmentWarnings) {
+        // Handle propertySet (Definition) - update all dependency references
+        const propertySet = JSON.parse(mappedObject[VlocityCard_1.default.Definition__c] || '{}');
+        if (propertySet) {
+            // Handle dataSource in propertySet
+            if (propertySet.dataSource) {
+                this.updateDataSourceWithRegistry(propertySet.dataSource, invalidIpNames, 'PropertySet');
             }
-            else if (child.element === 'action') {
-                if (child.property && child.property.stateAction && child.property.stateAction.omniType) {
-                    const parts = (child.property.stateAction.omniType.Name || '').split('/');
-                    child.property.stateAction.omniType.Name = parts.map((p) => this.cleanName(p)).join('/');
-                }
+            // Handle states comprehensively
+            if (propertySet.states && Array.isArray(propertySet.states)) {
+                for (let i = 0; i < propertySet.states.length; i++) {
+                    const state = propertySet.states[i];
+                    // Handle child cards using registry
+                    if (state.childCards && Array.isArray(state.childCards)) {
+                        state.childCards = state.childCards.map((c) => {
+                            if (c && this.nameRegistry.hasFlexCardMapping(c)) {
+                                return this.nameRegistry.getFlexCardCleanedName(c);
+                            }
+                            else {
+                                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['Flexcard', c])}`);
+                                return this.cleanName(c);
+                            }
+                        });
+                    }
+                    // Handle omniscripts using registry
+                    if (state.omniscripts && Array.isArray(state.omniscripts)) {
+                        for (let osIdx = 0; osIdx < state.omniscripts.length; osIdx++) {
+                            this.updateOmniScriptReferenceWithRegistry(state.omniscripts[osIdx]);
+                        }
+                    }
+                    // Handle components comprehensively using registry
+                    if (state.components) {
+                        for (const componentKey in state.components) {
+                            if (state.components.hasOwnProperty(componentKey)) {
+                                const component = state.components[componentKey];
+                                this.updateComponentDependenciesWithRegistry(component, urlUpdateSummaries, malformedFragmentWarnings);
+                            }
+                        }
+                    }
+                }
             }
-            if (child.children && Array.isArray(child.children)) {
-                this.fixChildren(child.children);
+            // Handle events[] array references (Migration)
+            if (propertySet.events && Array.isArray(propertySet.events)) {
+                this.updateEventsWithRegistry(propertySet.events, invalidIpNames);
             }
+            mappedObject[VlocityCard_1.default.Definition__c] = JSON.stringify(propertySet);
         }
     }
+    /**
+     * Update events array references (Migration)
+     * Handles: events[].actionList[].stateAction references
+     */
+    updateEventsWithRegistry(events, invalidIpNames) {
+        for (const event of events) {
+            if (!event.actionList || !Array.isArray(event.actionList)) {
+                continue;
+            }
+            for (const action of event.actionList) {
+                if (!action.stateAction) {
+                    continue;
+                }
+                const stateAction = action.stateAction;
+                // 1-2. Handle message.value.bundle (DataRaptor) and message.value.ipMethod (Integration Procedure)
+                this.processStateActionMessageWithRegistry(stateAction, invalidIpNames);
+                // 3. Handle cardName (FlexCard - Flyout childCard)
+                if (stateAction.cardName) {
+                    const originalCardName = stateAction.cardName;
+                    if (this.nameRegistry.hasFlexCardMapping(originalCardName)) {
+                        stateAction.cardName = this.nameRegistry.getFlexCardCleanedName(originalCardName);
+                    }
+                    else {
+                        logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['Flexcard', originalCardName])}`);
+                        stateAction.cardName = this.cleanName(originalCardName);
+                    }
+                }
+                // 4. Handle flyoutLwc (FlexCard child card and custom LWC references)
+                this.updateFlyoutLwcValue(stateAction);
+                if (this.hasOmniscriptFlyoutDependency(stateAction)) {
+                    this.updateOsNameWithRegistry(stateAction, 'osName');
+                }
+                // 6. Handle omniType.Name (OmniScript)
+                if (stateAction.omniType && stateAction.omniType.Name) {
+                    this.updateOmniTypeNameWithRegistry(stateAction.omniType);
+                }
+            }
+        }
+    }
+    /**
+     * Update dataSource (DataRaptor, Integration Procedures, Apex Remote) using registry
+     */
+    updateDataSourceWithRegistry(dataSource, invalidIpNames, context) {
+        var _a, _b, _c;
+        const type = dataSource.type;
+        if (type === stringContants_1.Constants.DataRaptorComponentName) {
+            // Handle DataRaptor using registry
+            const originalBundle = ((_a = dataSource.value) === null || _a === void 0 ? void 0 : _a.bundle) || '';
+            if (originalBundle && this.nameRegistry.hasDataMapperMapping(originalBundle)) {
+                dataSource.value.bundle = this.nameRegistry.getDataMapperCleanedName(originalBundle);
+            }
+            else {
+                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['DataMapper', originalBundle])}`);
+                dataSource.value.bundle = this.cleanName(originalBundle);
+            }
+        }
+        else if (type === stringContants_1.Constants.IntegrationProcedurePluralName) {
+            // Handle Integration Procedures using registry
+            const ipMethod = ((_b = dataSource.value) === null || _b === void 0 ? void 0 : _b.ipMethod) || '';
+            const hasRegistryMapping = this.nameRegistry.hasIntegrationProcedureMapping(ipMethod);
+            if (hasRegistryMapping) {
+                const cleanedIpName = this.nameRegistry.getIntegrationProcedureCleanedName(ipMethod);
+                dataSource.value.ipMethod = cleanedIpName;
+            }
+            else {
+                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['IntegrationProcedure', ipMethod])}`);
+                const parts = ipMethod.split('_');
+                const newKey = parts.map((p) => this.cleanName(p, true)).join('_');
+                dataSource.value.ipMethod = newKey;
+                if (parts.length > 2) {
+                    invalidIpNames.set(context, ipMethod);
+                }
+            }
+        }
+        else if (type === stringContants_1.Constants.ApexRemoteComponentName) {
+            if ((_c = dataSource.value) === null || _c === void 0 ? void 0 : _c.remoteClass) {
+                dataSource.value.remoteClass = this.apexNamespaceRegistry.getQualifiedClassName(dataSource.value.remoteClass);
+            }
+        }
+    }
+    /**
+     * Update OmniScript reference using registry
+     */
+    updateOmniScriptReferenceWithRegistry(omniscriptRef) {
+        const originalType = omniscriptRef.type;
+        const originalSubtype = omniscriptRef.subtype;
+        const language = omniscriptRef.language || 'English';
+        // Construct full OmniScript name to check registry
+        const fullOmniScriptName = `${originalType}_${originalSubtype}_${language}`;
+        if (this.nameRegistry.hasOmniScriptMapping(fullOmniScriptName)) {
+            // Registry has mapping for this OmniScript - extract cleaned parts
+            const cleanedFullName = this.nameRegistry.getCleanedName(fullOmniScriptName, 'OmniScript');
+            const parts = cleanedFullName.split('_');
+            if (parts.length >= 2) {
+                omniscriptRef.type = parts[0];
+                omniscriptRef.subtype = parts[1];
+                // Language doesn't typically change, but update if provided
+                if (parts.length >= 3) {
+                    omniscriptRef.language = parts[2];
+                }
+            }
+        }
+        else {
+            // No registry mapping - use original fallback approach
+            logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['Omniscript', fullOmniScriptName])}`);
+            omniscriptRef.type = this.cleanName(originalType);
+            omniscriptRef.subtype = this.cleanName(originalSubtype);
+        }
+    }
+    /**
+     * Update component dependencies comprehensively
+     */
+    updateComponentDependenciesWithRegistry(component, urlUpdateSummaries, malformedFragmentWarnings) {
+        // Handle action elements with actionList (like assessment)
+        if (component.element === 'action' && component.property && component.property.actionList) {
+            for (const action of component.property.actionList) {
+                if (action.stateAction) {
+                    // Handle message field (contains DataRaptor/IP references as JSON string)
+                    this.processStateActionMessageWithRegistry(action.stateAction);
+                    // Case 1: Direct OmniScript reference
+                    if (action.stateAction.type === stringContants_1.Constants.OmniScriptComponentName && action.stateAction.omniType) {
+                        this.updateOmniTypeNameWithRegistry(action.stateAction.omniType);
+                    }
+                    // Case 2: Flyout OmniScript reference
+                    else if (this.hasOmniscriptFlyoutDependency(action.stateAction)) {
+                        this.updateOsNameWithRegistry(action.stateAction, 'osName');
+                    }
+                    // Case 3: Flyout with flyoutLwc (ChildCard or CustomLwc)
+                    else if (this.hasFlyoutLwc(action.stateAction)) {
+                        this.updateFlyoutLwcValue(action.stateAction);
+                    }
+                    // Case A: Custom Web Page action referencing OmniScript Universal Page
+                    else if (this.isCustomWebPageAction(action.stateAction)) {
+                        this.applyOmniScriptURLRewrite(action.stateAction, urlUpdateSummaries, malformedFragmentWarnings);
+                    }
+                }
+            }
+        }
+        // Handle Custom LWC components - special case for FlexCard references
+        this.updateCustomLwcWithRegistry(component);
+        // Handle standard component actions (like assessment)
+        if (component.actions && Array.isArray(component.actions)) {
+            for (const action of component.actions) {
+                if (action.stateAction && action.stateAction.omniType) {
+                    this.updateOmniTypeNameWithRegistry(action.stateAction.omniType);
+                }
+            }
+        }
+        // Handle direct stateAction on component property (existing logic)
+        if (component.property && component.property.stateAction) {
+            if (component.property.stateAction.omniType) {
+                this.updateOmniTypeNameWithRegistry(component.property.stateAction.omniType);
+            }
+            if (this.hasOmniscriptFlyoutDependency(component.property.stateAction)) {
+                this.updateOsNameWithRegistry(component.property.stateAction, 'osName');
+            }
+            // Handle Flyout with flyoutLwc (ChildCard or CustomLwc)
+            if (this.hasFlyoutLwc(component.property.stateAction)) {
+                this.updateFlyoutLwcValue(component.property.stateAction);
+            }
+            if (this.isCustomWebPageAction(component.property.stateAction)) {
+                this.applyOmniScriptURLRewrite(component.property.stateAction, urlUpdateSummaries, malformedFragmentWarnings);
+            }
+        }
+        // Handle childCardPreview elements (from old fixChildren method)
+        if (component.element === stringContants_1.Constants.ChildCardPreview && component.property) {
+            if (component.property.cardName) {
+                const originalCardName = component.property.cardName;
+                if (this.nameRegistry.hasFlexCardMapping(originalCardName)) {
+                    component.property.cardName = this.nameRegistry.getFlexCardCleanedName(originalCardName);
+                }
+                else {
+                    logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['Flexcard', originalCardName])}`);
+                    component.property.cardName = this.cleanName(originalCardName);
+                }
+            }
+        }
+        // Handle omni-flyout elements (missing from migration logic)
+        if (component.element === stringContants_1.Constants.OmniFlyout && component.property && component.property.flyoutOmniScript) {
+            if (component.property.flyoutOmniScript.osName) {
+                const osName = component.property.flyoutOmniScript.osName;
+                if (typeof osName === 'string') {
+                    const parts = osName.split('/');
+                    if (parts.length >= 2) {
+                        // Construct full OmniScript name: Type_SubType_Language
+                        const originalOsRef = parts.join('_');
+                        if (this.nameRegistry.hasOmniScriptMapping(originalOsRef)) {
+                            // Registry has mapping - extract cleaned parts and convert back to / format
+                            const cleanedFullName = this.nameRegistry.getCleanedName(originalOsRef, 'OmniScript');
+                            const cleanedParts = cleanedFullName.split('_');
+                            if (cleanedParts.length >= 2) {
+                                component.property.flyoutOmniScript.osName = cleanedParts.join('/');
+                            }
+                        }
+                        else {
+                            // No registry mapping - use original fallback approach
+                            logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['Omniscript', originalOsRef])}`);
+                            component.property.flyoutOmniScript.osName =
+                                parts.length >= 3
+                                    ? `${this.cleanName(parts[0])}/${this.cleanName(parts[1])}/${parts[2]}`
+                                    : parts.map((p) => this.cleanName(p)).join('/');
+                        }
+                    }
+                }
+            }
+        }
+        // Check child components recursively
+        if (component.children && Array.isArray(component.children)) {
+            for (const child of component.children) {
+                this.updateComponentDependenciesWithRegistry(child, urlUpdateSummaries, malformedFragmentWarnings);
+            }
+        }
+    }
+    applyOmniScriptURLRewrite(stateAction, urlUpdateSummaries, malformedFragmentWarnings) {
+        if (this.IS_STANDARD_DATA_MODEL) {
+            return;
+        }
+        const rewrite = this.getOmniScriptURLRewrite(stateAction);
+        if (!rewrite) {
+            return;
+        }
+        const { targetName, updatedURL, malformedTokens } = rewrite;
+        stateAction[stringContants_1.Constants.WebPageTargetType].targetName = updatedURL;
+        const summary = this.formatURLRewriteSummary(targetName, updatedURL);
+        urlUpdateSummaries.add(summary);
+        // Per-card collector is optional so internal/test callers can omit it
+        // without forcing a signature update. The Map is keyed by the rewrite
+        // summary so the emission step can later subtract malformed URLs from
+        // the aggregate "Updated URLs: ..." locations message -- each malformed
+        // entry already carries the original URL, the rewritten URL, and the
+        // verify instruction inside its own warning, so listing it twice would
+        // be redundant. Same key for two actions on the same card => one entry.
+        // Defense-in-depth: skip if the formatter returns an empty string so we
+        // never store a blank warning under a real summary key.
+        if (malformedFragmentWarnings && Array.isArray(malformedTokens) && malformedTokens.length > 0) {
+            const malformedWarning = this.formatMalformedFragmentTokenWarning(targetName, updatedURL, malformedTokens);
+            if (malformedWarning) {
+                malformedFragmentWarnings.set(summary, malformedWarning);
+            }
+        }
+    }
+    /** Build a human-readable "before -> after" string for warning messages only. */
+    formatURLRewriteSummary(originalURL, updatedURL) {
+        return `${this.toReadableURL(originalURL)} -> ${this.toReadableURL(updatedURL)}`;
+    }
+    /**
+     * Decode a URL for DISPLAY purposes only (warning/log messages). The output
+     * is lossy with respect to URL parsing semantics (e.g. an encoded `%26`
+     * becomes a literal `&`) and must NOT be re-fed into a URL parser. Falls
+     * back to the raw input on malformed percent sequences.
+     */
+    toReadableURL(url) {
+        try {
+            return decodeURIComponent(url);
+        }
+        catch {
+            return url;
+        }
+    }
+    getOmniScriptURLRewrite(stateAction) {
+        var _a;
+        const targetName = (_a = stateAction[stringContants_1.Constants.WebPageTargetType]) === null || _a === void 0 ? void 0 : _a.targetName;
+        if (typeof targetName !== 'string') {
+            return undefined;
+        }
+        // Fast reject: if the raw text doesn't even mention the universal-page
+        // path or token, skip URL parsing entirely. This is a substring screen,
+        // not a security check; the strict structural validation happens after
+        // parsing in isValidOmniScriptNavigationURL.
+        if (!targetName.includes(stringContants_1.Constants.OmniScriptUniversalPagePath) ||
+            !targetName.includes(stringContants_1.Constants.OmniScriptUniversalPageToken)) {
+            return undefined;
+        }
+        const parsedURL = this.tryParseURL(targetName);
+        if (!parsedURL || !this.isValidOmniScriptNavigationURL(parsedURL)) {
+            return undefined;
+        }
+        const updatedURL = this.convertToStandardOmniScriptURL(parsedURL);
+        // Re-parse the fragment once more here purely to capture malformed-token
+        // diagnostics for the caller. Cheap (single split + map over a short
+        // string) and keeps `convertToStandardOmniScriptURL` focused on rewriting.
+        const { malformedTokens } = this.parseSlashFragmentParams(parsedURL.hash);
+        return { targetName, updatedURL, malformedTokens };
+    }
+    isCustomWebPageAction(stateAction) {
+        return (stateAction === null || stateAction === void 0 ? void 0 : stateAction.type) === stringContants_1.Constants.CustomActionType && (stateAction === null || stateAction === void 0 ? void 0 : stateAction.targetType) === stringContants_1.Constants.WebPageTargetType;
+    }
+    /**
+     * Parse a URL string without throwing. Returns the parsed URL on success or
+     * undefined for:
+     *   - syntactically invalid input (e.g. `https://[bad`, raw spaces in host,
+     *     `http:///` with no host), or
+     *   - URLs whose scheme is not `http:` or `https:` (e.g. `javascript:`,
+     *     `data:`, `file:`, `mailto:`).
+     *
+     * See URL_PARSE_BASE for why a synthetic base is supplied.
+     */
+    tryParseURL(input) {
+        let parsed;
+        try {
+            parsed = new URL(input, CardMigrationTool.URL_PARSE_BASE);
+        }
+        catch {
+            return undefined;
+        }
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            return undefined;
+        }
+        return parsed;
+    }
+    /**
+     * Verify a parsed URL has the OmniScript Navigate shape. We validate against
+     * the parsed components (pathname / searchParams / hash) rather than doing
+     * substring matches on the raw input so callers cannot smuggle the required
+     * tokens in unrelated positions (e.g. inside another query value).
+     *
+     * The pathname must START WITH `/apex/` and contain the universal-page
+     * token. Anchoring to the prefix rejects non-http(s) schemes such as
+     * `javascript:alert(1)//apex/...` whose parsed pathname does not begin
+     * with `/` (it begins with the opaque body of the scheme).
+     *
+     * Two legitimate shapes are accepted:
+     *   1. Path + query:    /apex/<ns>__OmniScriptUniversalPage?OmniScriptType=...&OmniScriptSubType=...&OmniScriptLang=...
+     *   2. Path + fragment: /apex/<ns>__OmniScriptUniversalPage?...#/OmniScriptType/.../OmniScriptSubType/.../OmniScriptLang/...
+     */
+    isValidOmniScriptNavigationURL(parsedURL) {
+        if (!parsedURL.pathname.startsWith(`${stringContants_1.Constants.OmniScriptUniversalPagePath}/`)) {
+            return false;
+        }
+        if (!parsedURL.pathname.includes(stringContants_1.Constants.OmniScriptUniversalPageToken)) {
+            return false;
+        }
+        const fragmentKeys = new Set(this.parseSlashFragmentParams(parsedURL.hash).pairs.map(([key]) => key));
+        const hasParam = (key) => parsedURL.searchParams.has(key) || fragmentKeys.has(key);
+        return (hasParam(stringContants_1.Constants.OmniScriptTypeParam) &&
+            hasParam(stringContants_1.Constants.OmniScriptSubTypeParam) &&
+            hasParam(stringContants_1.Constants.OmniScriptLangParam));
+    }
+    convertToStandardOmniScriptURL(parsedURL) {
+        var _a;
+        const paramRenames = {
+            [stringContants_1.Constants.OmniScriptTypeParam]: stringContants_1.Constants.OmniScriptStandardTypeParam,
+            [stringContants_1.Constants.OmniScriptSubTypeParam]: stringContants_1.Constants.OmniScriptStandardSubTypeParam,
+            [stringContants_1.Constants.OmniScriptLangParam]: stringContants_1.Constants.OmniScriptStandardLanguageParam,
+            [stringContants_1.Constants.OmniScriptLayoutParam]: stringContants_1.Constants.OmniScriptStandardThemeParam,
+        };
+        const paramsToClean = new Set([stringContants_1.Constants.OmniScriptTypeParam, stringContants_1.Constants.OmniScriptSubTypeParam]);
+        // Merge query-string params with fragment params. Query-string entries win on conflict.
+        const mergedEntries = [];
+        const seenKeys = new Set();
+        parsedURL.searchParams.forEach((value, key) => {
+            mergedEntries.push([key, value]);
+            seenKeys.add(key);
+        });
+        for (const [key, value] of this.parseSlashFragmentParams(parsedURL.hash).pairs) {
+            if (!seenKeys.has(key)) {
+                mergedEntries.push([key, value]);
+                seenKeys.add(key);
+            }
+        }
+        const newSearchParams = new URLSearchParams();
+        for (const [key, value] of mergedEntries) {
+            const newKey = (_a = paramRenames[key]) !== null && _a !== void 0 ? _a : key;
+            const newValue = paramsToClean.has(key) ? this.cleanName(value) : value;
+            newSearchParams.append(newKey, newValue);
+        }
+        return `${stringContants_1.Constants.OmniScriptStandardPagePath}?${newSearchParams.toString()}`;
+    }
+    /**
+     * Parse a slash-separated OmniScript fragment of the form
+     *   #/Key1/Value1/Key2/Value2/...
+     * into [key, value] pairs. Tolerates leading `#`, leading `/`, empty values
+     * (consecutive slashes), and a trailing orphan token (which is dropped).
+     *
+     * Tokens with malformed percent sequences (e.g. `Foo%`, `Bar%E2`) are kept
+     * as-is rather than throwing; decodeURIComponent raises URIError on invalid
+     * escape sequences and we don't want one bad token to crash the whole
+     * FlexCard's URL rewrite. The raw (still-encoded) tokens are also returned
+     * via `malformedTokens` so callers can surface them to customers as a
+     * "please verify" warning rather than silently shipping a best-effort guess.
+     */
+    parseSlashFragmentParams(hash) {
+        if (!hash) {
+            return { pairs: [], malformedTokens: [] };
+        }
+        const trimmed = hash.replace(/^#\/?/, '');
+        if (!trimmed) {
+            return { pairs: [], malformedTokens: [] };
+        }
+        const malformedTokens = [];
+        const tokens = trimmed.split('/').map((t) => {
+            try {
+                return decodeURIComponent(t);
+            }
+            catch {
+                malformedTokens.push(t);
+                return t;
+            }
+        });
+        const pairs = [];
+        for (let i = 0; i + 1 < tokens.length; i += 2) {
+            pairs.push([tokens[i], tokens[i + 1]]);
+        }
+        return { pairs, malformedTokens };
+    }
+    /**
+     * Update omniType.Name using registry (handles Type/SubType/Language format)
+     */
+    updateOmniTypeNameWithRegistry(omniType) {
+        const originalName = omniType.Name || '';
+        const parts = originalName.split('/');
+        if (parts.length >= 3) {
+            // Construct full OmniScript name: Type_SubType_Language
+            const fullOmniScriptName = `${parts[0]}_${parts[1]}_${parts[2]}`;
+            if (this.nameRegistry.hasOmniScriptMapping(fullOmniScriptName)) {
+                // Registry has mapping - extract cleaned parts and convert back to / format
+                const cleanedFullName = this.nameRegistry.getCleanedName(fullOmniScriptName, 'OmniScript');
+                const cleanedParts = cleanedFullName.split('_');
+                if (cleanedParts.length >= 3) {
+                    omniType.Name = cleanedParts.join('/');
+                }
+            }
+            else {
+                // No registry mapping - use original fallback approach
+                logger_1.Logger.logVerbose(`\n${this.messages.getMessage('componentMappingNotFound', ['Omniscript', fullOmniScriptName])}`);
+                omniType.Name =
+                    parts.length >= 3
+                        ? `${this.cleanName(parts[0])}/${this.cleanName(parts[1])}/${parts[2]}`
+                        : parts.map((p) => this.cleanName(p)).join('/');
+            }
+        }
+        else {
+            // Fallback for unexpected format
+            omniType.Name = parts.map((p) => this.cleanName(p)).join('/');
+        }
+    }
+    /**
+     * Update osName using registry (handles Type/SubType/Language format)
+     */
+    updateOsNameWithRegistry(stateAction, fieldName) {
+        const originalOsName = stateAction[fieldName];
+        const parts = originalOsName.split('/');
+        if (parts.length >= 3) {
+            // Construct full OmniScript name: Type_SubType_Language
+            const fullOmniScriptName = `${parts[0]}_${parts[1]}_${parts[2]}`;
+            if (this.nameRegistry.hasOmniScriptMapping(fullOmniScriptName)) {
+                // Registry has mapping - extract cleaned parts and convert back to / format
+                const cleanedFullName = this.nameRegistry.getCleanedName(fullOmniScriptName, 'OmniScript');
+                const cleanedParts = cleanedFullName.split('_');
+                if (cleanedParts.length >= 3) {
+                    stateAction[fieldName] = cleanedParts.join('/');
+                }
+            }
+            else {
+                // No registry mapping - use original fallback approach
+                logger_1.Logger.logVerbose(this.messages.getMessage('componentMappingNotFound', ['Omniscript', fullOmniScriptName]));
+                stateAction[fieldName] =
+                    parts.length >= 3
+                        ? `${this.cleanName(parts[0])}/${this.cleanName(parts[1])}/${parts[2]}`
+                        : parts.map((p) => this.cleanName(p)).join('/');
+            }
+        }
+        else {
+            // Fallback for unexpected format
+            stateAction[fieldName] = parts.map((p) => this.cleanName(p)).join('/');
+        }
+    }
+    // ==================== Assessment Helper Methods ====================
+    /**
+     * Helper method to add OmniScript dependency and warnings during assessment
+     * Handles osName in format "Type/SubType/Language" or "Type/SubType"
+     * @param osName - OmniScript name in format "Type/SubType" or "Type/SubType/Language"
+     * @param flexCardAssessmentInfo - Assessment info to update
+     */
+    addOmniScriptDependency(osName, flexCardAssessmentInfo) {
+        if (!osName || typeof osName !== 'string') {
+            return;
+        }
+        const parts = osName.split('/');
+        if (parts.length < 2) {
+            return;
+        }
+        const originalOsRef = parts.join('_');
+        // Skip if already processed
+        if (flexCardAssessmentInfo.dependenciesOS.includes(originalOsRef)) {
+            return;
+        }
+        // Clean parts - preserve language (3rd part) as-is
+        const cleanedParts = parts.length >= 3
+            ? [this.cleanName(parts[0]), this.cleanName(parts[1]), parts[2]]
+            : parts.map((p) => this.cleanName(p));
+        const cleanedOsRef = cleanedParts.join('_');
+        // Add to dependencies
+        flexCardAssessmentInfo.dependenciesOS.push(originalOsRef);
+        // Add warning if name will change
+        if (originalOsRef !== cleanedOsRef) {
+            flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [originalOsRef, cleanedOsRef]));
+            flexCardAssessmentInfo.migrationStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(flexCardAssessmentInfo.migrationStatus, 'Warnings');
+        }
+    }
+    /**
+     * Helper method to add OmniScript dependency from type/subtype/language fields
+     * @param type - OmniScript type
+     * @param subtype - OmniScript subtype
+     * @param language - OmniScript language (defaults to 'English')
+     * @param flexCardAssessmentInfo - Assessment info to update
+     */
+    addOmniScriptDependencyFromParts(type, subtype, language, flexCardAssessmentInfo) {
+        if (!type || !subtype) {
+            return;
+        }
+        const lang = language || 'English';
+        const originalOsRef = `${type}_${subtype}_${lang}`;
+        // Skip if already processed
+        if (flexCardAssessmentInfo.dependenciesOS.includes(originalOsRef)) {
+            return;
+        }
+        const cleanedOsRef = `${this.cleanName(type)}_${this.cleanName(subtype)}_${lang}`;
+        // Add to dependencies
+        flexCardAssessmentInfo.dependenciesOS.push(originalOsRef);
+        // Add warning if name will change
+        if (originalOsRef !== cleanedOsRef) {
+            flexCardAssessmentInfo.warnings.push(this.messages.getMessage('omniScriptNameChangeMessage', [originalOsRef, cleanedOsRef]));
+            flexCardAssessmentInfo.migrationStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(flexCardAssessmentInfo.migrationStatus, 'Warnings');
+        }
+    }
+    /**
+     * Helper method to add DataRaptor dependency and warnings during assessment
+     * @param bundle - DataRaptor bundle name
+     * @param flexCardAssessmentInfo - Assessment info to update
+     */
+    addDataRaptorDependency(bundle, flexCardAssessmentInfo) {
+        if (!bundle || flexCardAssessmentInfo.dependenciesDR.includes(bundle)) {
+            return;
+        }
+        const cleanedBundle = this.cleanName(bundle);
+        flexCardAssessmentInfo.dependenciesDR.push(bundle);
+        if (bundle !== cleanedBundle) {
+            flexCardAssessmentInfo.warnings.push(this.messages.getMessage('dataRaptorNameChangeMessage', [bundle, cleanedBundle]));
+            flexCardAssessmentInfo.migrationStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(flexCardAssessmentInfo.migrationStatus, 'Warnings');
+        }
+    }
+    /**
+     * Helper method to add Integration Procedure dependency and warnings during assessment
+     * @param ipMethod - Integration Procedure method name (Type_SubType format)
+     * @param flexCardAssessmentInfo - Assessment info to update
+     */
+    addIntegrationProcedureDependency(ipMethod, flexCardAssessmentInfo) {
+        if (!ipMethod || flexCardAssessmentInfo.dependenciesIP.includes(ipMethod)) {
+            return;
+        }
+        const parts = ipMethod.split('_');
+        const cleanedParts = parts.map((p) => this.cleanName(p, true));
+        const cleanedIpMethod = cleanedParts.join('_');
+        flexCardAssessmentInfo.dependenciesIP.push(ipMethod);
+        if (ipMethod !== cleanedIpMethod) {
+            flexCardAssessmentInfo.warnings.push(this.messages.getMessage('integrationProcedureNameChangeMessage', [ipMethod, cleanedIpMethod]));
+            flexCardAssessmentInfo.migrationStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(flexCardAssessmentInfo.migrationStatus, 'Warnings');
+        }
+        // Add manual intervention warning if IP has more than 2 parts
+        if (parts.length > 2) {
+            flexCardAssessmentInfo.warnings.push(this.messages.getMessage('integrationProcedureManualUpdateMessage', [ipMethod]));
+            flexCardAssessmentInfo.migrationStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(flexCardAssessmentInfo.migrationStatus, 'Needs manual intervention');
+        }
+    }
+    /**
+     * Helper method to add FlexCard dependency and warnings during assessment
+     * @param cardName - FlexCard name
+     * @param flexCardAssessmentInfo - Assessment info to update
+     */
+    addFlexCardDependency(cardName, flexCardAssessmentInfo) {
+        if (!cardName || flexCardAssessmentInfo.dependenciesFC.includes(cardName)) {
+            return;
+        }
+        const cleanedCardName = this.cleanName(cardName);
+        flexCardAssessmentInfo.dependenciesFC.push(cardName);
+        if (cardName !== cleanedCardName) {
+            flexCardAssessmentInfo.warnings.push(this.messages.getMessage('cardNameChangeMessage', [cardName, cleanedCardName]));
+            flexCardAssessmentInfo.migrationStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(flexCardAssessmentInfo.migrationStatus, 'Warnings');
+        }
+    }
+    /**
+     * Helper method to flag a Vlocity Action dependency during assessment.
+     * Vlocity Actions are not supported in standard runtime FlexCards, so the
+     * FlexCard cannot be auto-migrated and must be manually reimplemented using
+     * the FlexCard Action (cardAction) feature.
+     */
+    addVlocityActionDependency(stateAction, flexCardAssessmentInfo) {
+        const actionName = stateAction.name || stateAction.displayName || 'Unnamed Vlocity Action';
+        if (!flexCardAssessmentInfo.dependenciesVlocityAction.includes(actionName)) {
+            flexCardAssessmentInfo.dependenciesVlocityAction.push(actionName);
+        }
+        const warning = this.messages.getMessage('vlocityActionNotSupportedMessage', [actionName]);
+        if (!flexCardAssessmentInfo.warnings.includes(warning)) {
+            flexCardAssessmentInfo.warnings.push(warning);
+        }
+        flexCardAssessmentInfo.migrationStatus = (0, stringUtils_1.getUpdatedAssessmentStatus)(flexCardAssessmentInfo.migrationStatus, 'Needs manual intervention');
+    }
+    // ==================== End Assessment Helper Methods ====================
     getCardFields() {
-        return Object.keys(VlocityCard_1.default);
+        return this.IS_STANDARD_DATA_MODEL
+            ? Object.values(VlocityCard_1.default).filter((value) => value !== '')
+            : Object.keys(VlocityCard_1.default);
+    }
+    getFieldKey(fieldName) {
+        return this.IS_STANDARD_DATA_MODEL ? VlocityCard_1.default[fieldName] : this.namespacePrefix + fieldName;
+    }
+    getQueryNamespace() {
+        return this.IS_STANDARD_DATA_MODEL ? '' : this.namespace;
+    }
+    getCardObjectName() {
+        return this.IS_STANDARD_DATA_MODEL ? CardMigrationTool.OMNIUICARD_NAME : CardMigrationTool.VLOCITYCARD_NAME;
+    }
+    /**
+     * Check if a FlexCard has dependencies on Angular OmniScripts
+     */
+    hasAngularOmniScriptDependencies(card) {
+        try {
+            const definition = JSON.parse(card[this.getFieldKey('Definition__c')] || '{}');
+            if (definition && definition.states) {
+                for (const state of definition.states) {
+                    // Check direct OmniScript references in states
+                    if (state.omniscripts && Array.isArray(state.omniscripts)) {
+                        for (const os of state.omniscripts) {
+                            if (os.type && os.subtype) {
+                                const osRef = `${os.type}_${os.subtype}_${os.language || 'English'}`;
+                                if (this.nameRegistry.isAngularOmniScript(osRef)) {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    // Check OmniScript references in component actions
+                    if (state.components) {
+                        for (const componentKey in state.components) {
+                            if (state.components.hasOwnProperty(componentKey)) {
+                                const component = state.components[componentKey];
+                                if (this.componentHasAngularOmniScriptDependency(component)) {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Check OmniScript references in events[] array
+            if (definition && definition.events && Array.isArray(definition.events)) {
+                if (this.eventsHaveAngularOmniScriptDependency(definition.events)) {
+                    return true;
+                }
+            }
+        }
+        catch (err) {
+            logger_1.Logger.error(`Error checking Angular dependencies for card ${card['Name']}: ${err.message}`);
+        }
+        return false;
+    }
+    /**
+     * Check if events array has Angular OmniScript dependencies
+     */
+    eventsHaveAngularOmniScriptDependency(events) {
+        for (const event of events) {
+            if (!event.actionList || !Array.isArray(event.actionList)) {
+                continue;
+            }
+            for (const action of event.actionList) {
+                if (!action.stateAction) {
+                    continue;
+                }
+                const stateAction = action.stateAction;
+                // Check omniType.Name
+                if (stateAction.omniType) {
+                    if (this.checkOmniTypeForAngular(stateAction.omniType)) {
+                        return true;
+                    }
+                }
+                if (this.hasOmniscriptFlyoutDependency(stateAction)) {
+                    if (this.checkOsNameForAngular(stateAction.osName)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    hasOmniscriptFlyoutDependency(stateAction) {
+        return (stateAction.type === stringContants_1.Constants.Flyout &&
+            stateAction.flyoutType === stringContants_1.Constants.OmniScriptPluralName &&
+            stateAction.osName);
+    }
+    hasFlexCardFlyoutDependency(stateAction) {
+        return (stateAction.type === stringContants_1.Constants.Flyout && stateAction.flyoutType === stringContants_1.Constants.ChildCard && stateAction.flyoutLwc);
+    }
+    hasCustomLwcFlyoutDependency(stateAction) {
+        return (stateAction.type === stringContants_1.Constants.Flyout && stateAction.flyoutType === stringContants_1.Constants.CustomLwc && stateAction.flyoutLwc);
+    }
+    hasFlyoutLwc(stateAction) {
+        return stateAction.type === stringContants_1.Constants.Flyout && stateAction.flyoutLwc;
+    }
+    /**
+     * Recursively check if a component has Angular Omniscript dependencies
+     */
+    componentHasAngularOmniScriptDependency(component) {
+        // Pattern 1: Handle action elements with actionList (like migration logic)
+        if (component.element === 'action' && component.property && component.property.actionList) {
+            for (const action of component.property.actionList) {
+                if (action.stateAction) {
+                    // Case 1: Direct OmniScript reference with type check
+                    if (action.stateAction.type === stringContants_1.Constants.OmniScriptComponentName && action.stateAction.omniType) {
+                        if (this.checkOmniTypeForAngular(action.stateAction.omniType)) {
+                            return true;
+                        }
+                    }
+                    // Case 1b: Direct OmniScript reference without type check (for test compatibility)
+                    else if (action.stateAction.omniType && !action.stateAction.type) {
+                        if (this.checkOmniTypeForAngular(action.stateAction.omniType)) {
+                            return true;
+                        }
+                    }
+                    // Case 2: Flyout OmniScript reference
+                    else if (this.hasOmniscriptFlyoutDependency(action.stateAction)) {
+                        if (this.checkOsNameForAngular(action.stateAction.osName)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        // Pattern 2: Handle standard component actions (like migration logic)
+        if (component.actions && Array.isArray(component.actions)) {
+            for (const action of component.actions) {
+                if (action.stateAction && action.stateAction.omniType) {
+                    if (this.checkOmniTypeForAngular(action.stateAction.omniType)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        // Pattern 3: Handle direct stateAction on component property (like migration logic)
+        if (component.property && component.property.stateAction) {
+            if (component.property.stateAction.omniType) {
+                if (this.checkOmniTypeForAngular(component.property.stateAction.omniType)) {
+                    return true;
+                }
+            }
+            if (this.hasOmniscriptFlyoutDependency(component.property.stateAction)) {
+                if (this.checkOsNameForAngular(component.property.stateAction.osName)) {
+                    return true;
+                }
+            }
+        }
+        // Pattern 4: Handle omni-flyout elements (for test compatibility)
+        if (component.element === stringContants_1.Constants.OmniFlyout && component.property && component.property.flyoutOmniScript) {
+            if (component.property.flyoutOmniScript.osName) {
+                if (this.checkOsNameForAngular(component.property.flyoutOmniScript.osName)) {
+                    return true;
+                }
+            }
+        }
+        // Recursively check child components
+        if (component.children && Array.isArray(component.children)) {
+            for (const child of component.children) {
+                if (this.componentHasAngularOmniScriptDependency(child)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if an omniType references an Angular OmniScript
+     * Handles both string format and object with Name property
+     */
+    checkOmniTypeForAngular(omniType) {
+        if (!omniType) {
+            return false;
+        }
+        // Check if IsWebCompEnabled is explicitly false (Angular OmniScript)
+        if (typeof omniType === 'object' && omniType.IsWebCompEnabled === false) {
+            return true;
+        }
+        let omniTypeName;
+        // Handle both string omniType and object with Name property
+        if (typeof omniType === 'string') {
+            omniTypeName = omniType;
+        }
+        else if (omniType.Name && typeof omniType.Name === 'string') {
+            omniTypeName = omniType.Name;
+        }
+        else {
+            return false;
+        }
+        const parts = omniTypeName.split('/');
+        if (parts.length >= 3) {
+            // Construct full OmniScript name: Type_SubType_Language
+            const fullOmniScriptName = `${parts[0]}_${parts[1]}_${parts[2]}`;
+            return this.nameRegistry.isAngularOmniScript(fullOmniScriptName);
+        }
+        return false;
+    }
+    /**
+     * Check if an osName string references an Angular OmniScript
+     * Handles Type/SubType/Language format in string
+     */
+    checkOsNameForAngular(osName) {
+        if (!osName || typeof osName !== 'string') {
+            return false;
+        }
+        const parts = osName.split('/');
+        if (parts.length >= 3) {
+            // Construct full OmniScript name: Type_SubType_Language
+            const fullOmniScriptName = `${parts[0]}_${parts[1]}_${parts[2]}`;
+            return this.nameRegistry.isAngularOmniScript(fullOmniScriptName);
+        }
+        return false;
+    }
+    /**
+     * Ensures that the FlexCard Definition includes required Lightning Community targets
+     * Adds "lightningCommunity__Page" and "lightningCommunity__Default" if missing
+     * This is needed as vlocity wrapper can have flexcard which is unpublished but omniwapper needs published card
+     */
+    ensureCommunityTargets(mappedObject, isCardActive) {
+        if (!isCardActive) {
+            return;
+        }
+        const definition = JSON.parse(mappedObject[VlocityCard_1.default.Definition__c] || '{}');
+        if (!definition || !definition.xmlObject) {
+            return;
+        }
+        // Initialize targets structure if it doesn't exist
+        if (!definition.xmlObject.targets) {
+            definition.xmlObject.targets = { target: [] };
+        }
+        // Ensure target is an array
+        if (!Array.isArray(definition.xmlObject.targets.target)) {
+            definition.xmlObject.targets.target = [];
+        }
+        const requiredTargets = [
+            'lightning__RecordPage',
+            'lightning__AppPage',
+            'lightning__HomePage',
+            'lightningCommunity__Page',
+            'lightningCommunity__Default',
+        ];
+        const currentTargets = definition.xmlObject.targets.target;
+        // Add missing community targets
+        for (const requiredTarget of requiredTargets) {
+            if (!currentTargets.includes(requiredTarget)) {
+                currentTargets.push(requiredTarget);
+            }
+        }
+        logger_1.Logger.logVerbose(`Targets processed`);
+        // Save the updated definition back to the mappedObject
+        mappedObject[VlocityCard_1.default.Definition__c] = JSON.stringify(definition);
+    }
+    /**
+     * Prioritizes FlexCards by name characteristics:
+     * - Clean names (alphanumeric only) are processed first
+     * - Names with special characters are processed after
+     * This avoids naming conflicts during migration when special characters are cleaned
+     */
+    prioritizeFlexCardsWithoutSpecialCharacters(flexCards) {
+        const nameField = this.getFieldKey('Name');
+        return (0, recordPrioritization_1.prioritizeCleanNamesFirst)(flexCards, nameField);
     }
 }
 exports.CardMigrationTool = CardMigrationTool;
 CardMigrationTool.VLOCITYCARD_NAME = 'VlocityCard__c';
 CardMigrationTool.OMNIUICARD_NAME = 'OmniUiCard';
 CardMigrationTool.VERSION_PROP = 'Version__c';
+CardMigrationTool.URL_PARSE_BASE = 'https://placeholder.local';
 //# sourceMappingURL=flexcard.js.map