mcdev 9.0.2 → 10.0.0

package/lib/metadataTypes/Journey.js

@@ -11,7 +11,7 @@ import File from '../util/file.js';
 import ReplaceCbReference from '../util/replaceContentBlockReference.js';
 import Retriever from '../Retriever.js';
 import pLimit from 'p-limit';
-import yoctoSpinner from 'yocto-spinner';
+import { createSpinner } from '../util/progress.js';
 
 /**
  * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
@@ -23,7 +23,6 @@ import yoctoSpinner from 'yocto-spinner';
  * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
  * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
  * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
- * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
  * @typedef {import('../../types/mcdev.d.js').TypeKeyCombo} TypeKeyCombo
  */
 
@@ -75,7 +74,7 @@ class Journey extends MetadataType {
                 }
                 if (singleKey.includes('/')) {
                     // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the ID for the retrieve as we always aim to retrieve the latest version only
-                    singleKey = singleKey.split('/')[0];
+                    singleKey = singleKey.split('/', 1)[0];
                 }
                 mode = 'id';
             } else if (key.startsWith('name:')) {
@@ -100,8 +99,7 @@ class Journey extends MetadataType {
                 // caching or single retrieve
                 return await super.retrieveREST(
                     retrieveDir,
-                    `${uri}${singleKey}?extras=${extras}${key && key.includes('/') ? '&versionNumber=' + key.split('/')[1] : ''}`,
-                    null,
+                    `${uri}${singleKey}?extras=${extras}${key && key.includes('/') ? '&versionNumber=' + key.split('/', 2)[1] : ''}`,
                     key
                 );
             } else {
@@ -167,7 +165,8 @@ class Journey extends MetadataType {
                                                       ? Util.getGrayMsg(
                                                             ' - ' +
                                                                 ex.endpoint.split(
-                                                                    'rest.marketingcloudapis.com'
+                                                                    'rest.marketingcloudapis.com',
+                                                                    2
                                                                 )[1]
                                                         )
                                                       : ''
@@ -189,7 +188,7 @@ class Journey extends MetadataType {
                     }
                     parsed = this.parseResponseBody({ items: details.filter(Boolean) });
                     // * retrieveDir is mandatory in this method as it is not used for caching (there is a seperate method for that)
-                    const savedMetadata = await this.saveResults(parsed, retrieveDir, null, null);
+                    const savedMetadata = await this.saveResults(parsed, retrieveDir);
                     Util.logger.info(
                         `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})` +
                             Util.getKeysString(
@@ -255,7 +254,7 @@ class Journey extends MetadataType {
             }
             if (id.includes('/')) {
                 // in the journey URL the version is appended after the ID, separated by a forward-slash.
-                [id, version] = id.split('/');
+                [id, version] = id.split('/', 2);
             }
             try {
                 const response = await this.client.rest.get(
@@ -269,7 +268,7 @@ class Journey extends MetadataType {
         } else {
             if (key.includes('/')) {
                 // in the journey URL the version is appended after the ID, separated by a forward-slash.
-                [key, version] = key.split('/');
+                [key, version] = key.split('/', 2);
             }
 
             // delete by key with specified version does not work, therefore we need to get the ID first
@@ -416,15 +415,14 @@ class Journey extends MetadataType {
      * @param {MetadataTypeMap} results metadata results from deploy
      * @param {string} retrieveDir directory where metadata should be stored after deploy/retrieve
      * @param {string} [overrideType] for use when there is a subtype (such as folder-queries)
-     * @param {TemplateMap} [templateVariables] variables to be replaced in the metadata
      * @returns {Promise.<MetadataTypeMap>} Promise of saved metadata
      */
-    static async saveResults(results, retrieveDir, overrideType, templateVariables) {
+    static async saveResults(results, retrieveDir, overrideType) {
         if (Object.keys(results).length) {
             // only execute the following if records were found
             await this._postRetrieveTasksBulk(results);
         }
-        return super.saveResults(results, retrieveDir, overrideType, templateVariables);
+        return super.saveResults(results, retrieveDir, overrideType);
     }
 
     /**
@@ -1153,18 +1151,124 @@ class Journey extends MetadataType {
                     }
                     break;
                 }
-                case 'SMSSYNC': {
+                case 'SMSSYNC':
+                case 'PUSHINBOXACTIVITY':
+                case 'PUSHNOTIFICATIONACTIVITY':
+                case 'INAPPSYNCACTIVITY': {
                     const configurationArguments = activity.configurationArguments;
                     if (configurationArguments) {
+                        // early cross-BU dup-name detection: scan the SOURCE cache for the given
+                        // type/id and warn (loud) when that item's name is shared by >1 id. This is
+                        // early-detection for journey-only pipelines that never run the type-level
+                        // retrieve; the deploy-time hard-error remains the enforcement point.
+                        // searchForField returns only the first match, so we must scan to detect >1.
+                        const warnOnSourceDupName = (type, id) => {
+                            const typeCache = cache.getCache()?.[type];
+                            if (!typeCache) {
+                                return;
+                            }
+                            // find the source item's name by id
+                            let sourceName;
+                            for (const key in typeCache) {
+                                if (typeCache[key]?.id === id) {
+                                    sourceName = typeCache[key]?.name;
+                                    break;
+                                }
+                            }
+                            if (!sourceName) {
+                                return;
+                            }
+                            // collect all source items sharing that name
+                            const potentials = [];
+                            for (const key in typeCache) {
+                                if (typeCache[key]?.name === sourceName) {
+                                    potentials.push(typeCache[key]);
+                                }
+                            }
+                            if (potentials.length > 1) {
+                                const details = potentials
+                                    .map(
+                                        (item) =>
+                                            `${item.id} (createdDate: ${item.createdDate || 'n/a'})`
+                                    )
+                                    .join(', ');
+                                Util.logger.warn(
+                                    ` - ${type}: name "${sourceName}" is used by ${potentials.length} items: ${details}. Names must be unique within a BU for cross-BU deploys — clean these up.`
+                                );
+                            }
+                        };
+                        // mobilePush
+                        try {
+                            if (configurationArguments.pushMessageId) {
+                                // faithful id-based ref (primary/unchanged)
+                                configurationArguments.r__mobilePush_key = cache.searchForField(
+                                    'mobilePush',
+                                    configurationArguments.pushMessageId,
+                                    'id',
+                                    'id'
+                                );
+                                // additionally write the portable name ref for cross-BU deploys
+                                configurationArguments.r__mobilePush_name = cache.searchForField(
+                                    'mobilePush',
+                                    configurationArguments.pushMessageId,
+                                    'id',
+                                    'name'
+                                );
+                                warnOnSourceDupName(
+                                    'mobilePush',
+                                    configurationArguments.pushMessageId
+                                );
+                                delete configurationArguments.pushMessageId;
+                            }
+                            if (configurationArguments.application?.id) {
+                                // faithful id-based ref (primary/unchanged)
+                                configurationArguments.r__mobilePushApp_key = cache.searchForField(
+                                    'mobilePushApp',
+                                    configurationArguments.application.id,
+                                    'id',
+                                    'key'
+                                );
+                                // additionally write the portable name ref for cross-BU deploys
+                                configurationArguments.r__mobilePushApp_name = cache.searchForField(
+                                    'mobilePushApp',
+                                    configurationArguments.application.id,
+                                    'id',
+                                    'name'
+                                );
+                                warnOnSourceDupName(
+                                    'mobilePushApp',
+                                    configurationArguments.application.id
+                                );
+                                delete configurationArguments.application;
+                            }
+                        } catch (ex) {
+                            Util.logger.warn(
+                                ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
+                                    metadata[this.definition.keyField]
+                                }) activity-key=${activity.key}: ${ex.message}`
+                            );
+                        }
                         // mobileMessage
                         try {
                             if (configurationArguments.messageId) {
+                                // faithful id-based ref (primary/unchanged)
                                 configurationArguments.r__mobileMessage_key = cache.searchForField(
                                     'mobileMessage',
                                     configurationArguments.messageId,
                                     'id',
                                     'id'
                                 );
+                                // additionally write the portable name ref for cross-BU deploys
+                                configurationArguments.r__mobileMessage_name = cache.searchForField(
+                                    'mobileMessage',
+                                    configurationArguments.messageId,
+                                    'id',
+                                    'name'
+                                );
+                                warnOnSourceDupName(
+                                    'mobileMessage',
+                                    configurationArguments.messageId
+                                );
                                 delete configurationArguments.messageId;
                             }
                         } catch (ex) {
@@ -1286,25 +1390,53 @@ class Journey extends MetadataType {
                                     metadata[this.definition.keyField]
                                 }) activity-key=${activity.key}: ${ex.message}`
                             );
+                            continue;
                         }
                         // Don't replace the field Id with the name if DE CustomerKey was not found
                         try {
+                            DataExtensionField.buObject = this.buObject;
+                            DataExtensionField.client = this.client;
+                            DataExtensionField.properties = this.properties;
+                            let alreadyFetchedDe = false;
                             if (!cache.getCache().dataExtensionField) {
+                                // no dataExtensionField cache yet: retrieve fields for this specific DE
                                 tempCachedFields = true;
-                                DataExtensionField.buObject = this.buObject;
-                                DataExtensionField.client = this.client;
-                                DataExtensionField.properties = this.properties;
-                                const fields = await DataExtensionField.retrieveFieldsForSingleDe(
-                                    contactField.r__dataExtension_key
-                                );
+                                alreadyFetchedDe = true;
+                                const fields =
+                                    await DataExtensionField.retrieveFieldsForSingleDeAuto(
+                                        contactField.r__dataExtension_key
+                                    );
                                 cache.setMetadata('dataExtensionField', fields);
                             }
-                            contactField.r__dataExtensionField_name = cache.searchForField(
-                                'dataExtensionField',
-                                contactField.field,
-                                'ObjectID',
-                                'Name'
-                            );
+                            let fieldName;
+                            try {
+                                fieldName = cache.searchForField(
+                                    'dataExtensionField',
+                                    contactField.field,
+                                    'ObjectID',
+                                    'Name'
+                                );
+                            } catch (ex) {
+                                if (alreadyFetchedDe) {
+                                    throw ex;
+                                }
+                                // field not in existing cache - retrieve fields for this specific DE
+                                const fields =
+                                    await DataExtensionField.retrieveFieldsForSingleDeAuto(
+                                        contactField.r__dataExtension_key
+                                    );
+                                if (Object.keys(fields).length > 0) {
+                                    cache.mergeMetadata('dataExtensionField', fields);
+                                }
+                                // throws if still not found, handled by outer catch
+                                fieldName = cache.searchForField(
+                                    'dataExtensionField',
+                                    contactField.field,
+                                    'ObjectID',
+                                    'Name'
+                                );
+                            }
+                            contactField.r__dataExtensionField_name = fieldName;
                             delete contactField.field;
                         } catch (ex) {
                             Util.logger.warn(
@@ -1364,16 +1496,18 @@ class Journey extends MetadataType {
                             config.eventDefinitionKey = config.r__event_key;
                             delete config.r__event_key;
                         }
-                        if (config?.r__dataExtension_key) {
-                            // trigger found; there can only be one entry in this array
-                            config.dataExtensionId = cache.searchForField(
-                                'dataExtension',
-                                config.r__dataExtension_key,
-                                'CustomerKey',
-                                'ObjectID'
-                            );
-                            delete config.r__dataExtension_key;
+                        if (!config?.r__dataExtension_key) {
+                            continue;
                         }
+
+                        // trigger found; there can only be one entry in this array
+                        config.dataExtensionId = cache.searchForField(
+                            'dataExtension',
+                            config.r__dataExtension_key,
+                            'CustomerKey',
+                            'ObjectID'
+                        );
+                        delete config.r__dataExtension_key;
                     }
                     const warnings = await Event.preDeployTasks_SalesforceEntryEvents(
                         metadata.triggers[0].type,
@@ -1686,18 +1820,106 @@ class Journey extends MetadataType {
 
                     break;
                 }
-                case 'SMSSYNC': {
+                case 'SMSSYNC':
+                case 'PUSHINBOXACTIVITY':
+                case 'PUSHNOTIFICATIONACTIVITY':
+                case 'INAPPSYNCACTIVITY': {
                     const configurationArguments = activity.configurationArguments;
                     if (configurationArguments) {
-                        // mobileMessage
-                        if (configurationArguments.r__mobileMessage_key) {
-                            configurationArguments.messageId = cache.searchForField(
+                        // REFERENCE resolution helper: key-first, then name-fallback, to a single
+                        // target-BU cache item. This is a reference site — 0 matches means the
+                        // referenced item is MISSING (never a create). searchForField returns only
+                        // the first name match, so we scan to detect >1 (ambiguous → hard error).
+                        const resolveMobileRef = (type, key, name) => {
+                            // try the id-based key first (works for same-BU deploys)
+                            let match = key ? cache.getByKey(type, key) : undefined;
+                            // key miss (e.g. cross-BU): fall back to resolving by the portable name
+                            if (!match && name) {
+                                const typeCache = cache.getCache()?.[type];
+                                const potentials = [];
+                                for (const cacheKey in typeCache) {
+                                    if (typeCache[cacheKey]?.name === name) {
+                                        potentials.push(typeCache[cacheKey]);
+                                    }
+                                }
+                                if (potentials.length > 1) {
+                                    // ambiguous name → hard-error listing all matching ids
+                                    throw new Error(
+                                        `found multiple ${type} name matches in cache for name "${name}". Identified ids: ${potentials
+                                            .map((p) => p.id)
+                                            .join(
+                                                ', '
+                                            )}. Names must be unique within a BU — clean up the duplicates first.`
+                                    );
+                                } else if (potentials.length === 1) {
+                                    match = potentials[0];
+                                }
+                            }
+                            return match;
+                        };
+                        // mobilePush REFERENCE resolution: resolve to the target-BU id (key==id).
+                        // delete-parity: retain r__mobilePush_key + r__mobilePush_name.
+                        if (
+                            configurationArguments.r__mobilePush_key ||
+                            configurationArguments.r__mobilePush_name
+                        ) {
+                            const mobilePush = resolveMobileRef(
+                                'mobilePush',
+                                configurationArguments.r__mobilePush_key,
+                                configurationArguments.r__mobilePush_name
+                            );
+                            // 0 matches on key AND name → referenced item is missing on target BU
+                            if (!mobilePush) {
+                                throw new Error(
+                                    `mobilePush '${configurationArguments.r__mobilePush_name || configurationArguments.r__mobilePush_key}' not found on target BU — must be deployed first`
+                                );
+                            }
+                            configurationArguments.pushMessageId = mobilePush.id;
+                        }
+                        // mobilePushApp REFERENCE resolution: resolve to the target-BU app object.
+                        // shape parity: keep application = { id, name } (this site's existing shape).
+                        // delete-parity: retain r__mobilePushApp_key + r__mobilePushApp_name.
+                        if (
+                            configurationArguments.r__mobilePushApp_key ||
+                            configurationArguments.r__mobilePushApp_name
+                        ) {
+                            const mobilePushApp = resolveMobileRef(
+                                'mobilePushApp',
+                                configurationArguments.r__mobilePushApp_key,
+                                configurationArguments.r__mobilePushApp_name
+                            );
+                            // 0 matches → mobilePushApp is retrieve-only/GUI-created; hard error
+                            if (!mobilePushApp) {
+                                throw new Error(
+                                    `mobilePushApp '${configurationArguments.r__mobilePushApp_name || configurationArguments.r__mobilePushApp_key}' not found on target BU — must be created via GUI first`
+                                );
+                            }
+                            configurationArguments.application = {
+                                id: mobilePushApp.id,
+                                name: mobilePushApp.name,
+                            };
+                        }
+
+                        // mobileMessage REFERENCE resolution: resolve to the target-BU id (key==id).
+                        // delete-parity: DELETE r__mobileMessage_key + r__mobileMessage_name.
+                        if (
+                            configurationArguments.r__mobileMessage_key ||
+                            configurationArguments.r__mobileMessage_name
+                        ) {
+                            const mobileMessage = resolveMobileRef(
                                 'mobileMessage',
                                 configurationArguments.r__mobileMessage_key,
-                                'id',
-                                'id'
+                                configurationArguments.r__mobileMessage_name
                             );
+                            // 0 matches on key AND name → referenced item is missing on target BU
+                            if (!mobileMessage) {
+                                throw new Error(
+                                    `mobileMessage '${configurationArguments.r__mobileMessage_name || configurationArguments.r__mobileMessage_key}' not found on target BU — must be deployed first`
+                                );
+                            }
+                            configurationArguments.messageId = mobileMessage.id;
                             delete configurationArguments.r__mobileMessage_key;
+                            delete configurationArguments.r__mobileMessage_name;
                         }
                         // mobileKeyword
                         if (configurationArguments.r__mobileKeyword_key?.current) {
@@ -1751,46 +1973,61 @@ class Journey extends MetadataType {
                         activity?.arguments?.activityData?.updateContactFields ?? [];
                     let tempCachedFields = false;
                     for (const contactField of contactFields) {
+                        if (!contactField.r__dataExtension_key) {
+                            continue;
+                        }
+                        contactField.dataExtensionId = cache.searchForField(
+                            'dataExtension',
+                            contactField.r__dataExtension_key,
+                            'CustomerKey',
+                            'ObjectID'
+                        );
+                        if (!contactField.r__dataExtensionField_name) {
+                            continue;
+                        }
+                        DataExtensionField.buObject = this.buObject;
+                        DataExtensionField.client = this.client;
+                        DataExtensionField.properties = this.properties;
+                        let alreadyFetchedDe = false;
+                        if (!cache.getCache().dataExtensionField) {
+                            // no dataExtensionField cache yet: retrieve fields for this specific DE
+                            tempCachedFields = true;
+                            alreadyFetchedDe = true;
+                            const fields = await DataExtensionField.retrieveFieldsForSingleDeAuto(
+                                contactField.r__dataExtension_key
+                            );
+                            cache.setMetadata('dataExtensionField', fields);
+                        }
+                        let fieldObjectId;
                         try {
-                            contactField.dataExtensionId = cache.searchForField(
-                                'dataExtension',
-                                contactField.r__dataExtension_key,
+                            fieldObjectId = cache.searchForField(
+                                'dataExtensionField',
+                                `[${contactField.r__dataExtension_key}].[${contactField.r__dataExtensionField_name}]`,
                                 'CustomerKey',
                                 'ObjectID'
                             );
                         } catch (ex) {
-                            Util.logger.warn(
-                                ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
-                                    metadata[this.definition.keyField]
-                                }) activity-key=${activity.key}: ${ex.message}`
+                            // field not in existing cache - retrieve fields for this specific DE
+                            if (alreadyFetchedDe) {
+                                throw ex;
+                            }
+                            const fields = await DataExtensionField.retrieveFieldsForSingleDeAuto(
+                                contactField.r__dataExtension_key
                             );
-                        }
-                        try {
-                            if (!cache.getCache().dataExtensionField) {
-                                tempCachedFields = true;
-                                DataExtensionField.buObject = this.buObject;
-                                DataExtensionField.client = this.client;
-                                DataExtensionField.properties = this.properties;
-                                const fields = await DataExtensionField.retrieveFieldsForSingleDe(
-                                    contactField.r__dataExtension_key
-                                );
-                                cache.setMetadata('dataExtensionField', fields);
+                            if (Object.keys(fields).length > 0) {
+                                cache.mergeMetadata('dataExtensionField', fields);
                             }
-                            contactField.field = cache.searchForField(
+                            // throws if still not found, handled by outer catch
+                            fieldObjectId = cache.searchForField(
                                 'dataExtensionField',
                                 `[${contactField.r__dataExtension_key}].[${contactField.r__dataExtensionField_name}]`,
                                 'CustomerKey',
                                 'ObjectID'
                             );
-                            delete contactField.r__dataExtensionField_name;
-                            delete contactField.r__dataExtension_key;
-                        } catch (ex) {
-                            Util.logger.warn(
-                                ` - ${this.definition.type} '${metadata[this.definition.nameField]}'(${
-                                    metadata[this.definition.keyField]
-                                }) activity - key=${activity.key}: ${ex.message} `
-                            );
                         }
+                        contactField.field = fieldObjectId;
+                        delete contactField.r__dataExtensionField_name;
+                        delete contactField.r__dataExtension_key;
                     }
                     if (tempCachedFields) {
                         // reset dataExtensionField caching to trigger re-caching
@@ -1899,91 +2136,93 @@ class Journey extends MetadataType {
                 }
             }
             const triggeredSend = activity.configurationArguments?.triggeredSend;
-            if (triggeredSend) {
-                // the following is very similar but not equal to the variables in TriggeredSend.js
-                if (triggeredSend.bccEmail !== undefined) {
-                    try {
-                        let bccEmail = Array.isArray(triggeredSend.bccEmail)
-                            ? triggeredSend.bccEmail.join(';')
-                            : triggeredSend.bccEmail;
-                        bccEmail = ReplaceCbReference.replaceReference(
-                            bccEmail,
-                            parentName,
-                            findAssetKeys
-                        );
-                        triggeredSend.bccEmail = bccEmail.split(';').filter((el) => el !== '');
-                        changes = true;
-                    } catch (ex) {
-                        if (ex.code !== 200) {
-                            error = ex;
-                        }
-                    }
-                }
-                if (triggeredSend.ccEmail !== undefined) {
-                    try {
-                        let ccEmail = Array.isArray(triggeredSend.ccEmail)
-                            ? triggeredSend.ccEmail?.join(';')
-                            : triggeredSend.ccEmail;
-                        ccEmail = ReplaceCbReference.replaceReference(
-                            ccEmail,
-                            parentName,
-                            findAssetKeys
-                        );
-                        triggeredSend.ccEmail = ccEmail.split(';').filter((el) => el !== '');
-                        changes = true;
-                    } catch (ex) {
-                        if (ex.code !== 200) {
-                            error = ex;
-                        }
-                    }
-                }
+            if (!triggeredSend) {
+                continue;
+            }
+
+            // the following is very similar but not equal to the variables in TriggeredSend.js
+            if (triggeredSend.bccEmail !== undefined) {
                 try {
-                    triggeredSend.dynamicEmailSubject = ReplaceCbReference.replaceReference(
-                        triggeredSend.dynamicEmailSubject,
+                    let bccEmail = Array.isArray(triggeredSend.bccEmail)
+                        ? triggeredSend.bccEmail.join(';')
+                        : triggeredSend.bccEmail;
+                    bccEmail = ReplaceCbReference.replaceReference(
+                        bccEmail,
                         parentName,
                         findAssetKeys
                     );
+                    triggeredSend.bccEmail = bccEmail.split(';').filter((el) => el !== '');
                     changes = true;
                 } catch (ex) {
                     if (ex.code !== 200) {
                         error = ex;
                     }
                 }
+            }
+            if (triggeredSend.ccEmail !== undefined) {
                 try {
-                    triggeredSend.emailSubject = ReplaceCbReference.replaceReference(
-                        triggeredSend.emailSubject,
+                    let ccEmail = Array.isArray(triggeredSend.ccEmail)
+                        ? triggeredSend.ccEmail?.join(';')
+                        : triggeredSend.ccEmail;
+                    ccEmail = ReplaceCbReference.replaceReference(
+                        ccEmail,
                         parentName,
                         findAssetKeys
                     );
+                    triggeredSend.ccEmail = ccEmail.split(';').filter((el) => el !== '');
                     changes = true;
                 } catch (ex) {
                     if (ex.code !== 200) {
                         error = ex;
                     }
                 }
-                try {
-                    triggeredSend.preHeader = ReplaceCbReference.replaceReference(
-                        triggeredSend.preHeader,
-                        parentName,
-                        findAssetKeys
-                    );
-                    changes = true;
-                } catch (ex) {
-                    if (ex.code !== 200) {
-                        error = ex;
-                    }
+            }
+            try {
+                triggeredSend.dynamicEmailSubject = ReplaceCbReference.replaceReference(
+                    triggeredSend.dynamicEmailSubject,
+                    parentName,
+                    findAssetKeys
+                );
+                changes = true;
+            } catch (ex) {
+                if (ex.code !== 200) {
+                    error = ex;
                 }
-                try {
-                    triggeredSend.exclusionFilter = ReplaceCbReference.replaceReference(
-                        triggeredSend.exclusionFilter,
-                        parentName,
-                        findAssetKeys
-                    );
-                    changes = true;
-                } catch (ex) {
-                    if (ex.code !== 200) {
-                        error = ex;
-                    }
+            }
+            try {
+                triggeredSend.emailSubject = ReplaceCbReference.replaceReference(
+                    triggeredSend.emailSubject,
+                    parentName,
+                    findAssetKeys
+                );
+                changes = true;
+            } catch (ex) {
+                if (ex.code !== 200) {
+                    error = ex;
+                }
+            }
+            try {
+                triggeredSend.preHeader = ReplaceCbReference.replaceReference(
+                    triggeredSend.preHeader,
+                    parentName,
+                    findAssetKeys
+                );
+                changes = true;
+            } catch (ex) {
+                if (ex.code !== 200) {
+                    error = ex;
+                }
+            }
+            try {
+                triggeredSend.exclusionFilter = ReplaceCbReference.replaceReference(
+                    triggeredSend.exclusionFilter,
+                    parentName,
+                    findAssetKeys
+                );
+                changes = true;
+            } catch (ex) {
+                if (ex.code !== 200) {
+                    error = ex;
                 }
             }
         }
@@ -2080,17 +2319,17 @@ class Journey extends MetadataType {
             Multistep: `Publishing multi-step journey…`,
         };
         for (const definitionType of Object.keys(processingOrder)) {
-            const spinner = yoctoSpinner({
+            const spinner = createSpinner({
                 text: processingOrder[definitionType],
             });
 
             for (let key of keyArr) {
-                let objectId;
-                let version;
-                let journey;
                 if (!key) {
                     continue;
                 }
+                let objectId;
+                let version;
+                let journey;
                 if (key.startsWith('%23')) {
                     // if the key started with %23 assume an ID was copied from the URL but the user forgot to prefix it with id:
                     // correct the format
@@ -2110,14 +2349,14 @@ class Journey extends MetadataType {
                         key = 'id:' + objectId;
                     }
                     if (objectId.includes('/')) {
-                        version = objectId.split('/')[1];
+                        version = objectId.split('/', 2)[1];
                         // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the ID for caching as we always aim to retrieve the latest version only
-                        objectId = objectId.split('/')[0];
+                        objectId = objectId.split('/', 1)[0];
                     } else {
                         // if we didn't find a version we need to cache this from the API after all
                         if (key.includes('/')) {
                             // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the key for caching as we always aim to retrieve the latest version only
-                            key = key.split('/')[0];
+                            key = key.split('/', 1)[0];
                         }
                     }
                     journey = Object.values(metadataMap.metadata).find((el) => el.id === objectId);
@@ -2270,12 +2509,11 @@ class Journey extends MetadataType {
                                         spinner
                                     )
                                 );
-                                publishedJourneyCounter.multiStep++;
                             } else {
                                 // no guarantees if the journey was actually published
                                 executedKeyArr.push(key);
-                                publishedJourneyCounter.multiStep++;
                             }
+                            publishedJourneyCounter.multiStep++;
                         } catch (ex) {
                             switch (ex.message) {
                                 case 'Cannot publish interaction in Published status.': {
@@ -2458,7 +2696,7 @@ class Journey extends MetadataType {
      * @param {string} statusUrl URL to check the status of the publish request
      * @param {string} key journey-key or id for log messages
      * @param {string} name journey-name for log messages
-     * @param {import('yocto-spinner').Spinner} spinner reference to spinner to allow stopping it when done
+     * @param {import('../util/progress.js').Spinner} spinner reference to spinner to allow stopping it when done
      * @param {number} [tries] number of tries used to check the status
      * @returns {Promise.<string>} key of the item that was published successfully
      */
@@ -2521,24 +2759,26 @@ class Journey extends MetadataType {
         const messages = { errors: [], warnings: [] };
         for (const type in types) {
             let counter = 1;
-            if (response[type] && response[type].length) {
-                messages[type].push(`   ${types[type]}:`);
-                for (const msg of response[type]) {
-                    messages[type].push(
-                        `     #${counter++}: ${msg.errorDetail.split(' EmailID: ').join('\n       EmailID: ').split(' Personalization error: ').join('\n       Personalization error: ')}`,
-                        Util.getGrayMsg(`     Code: ${msg.errorCode}`)
-                    );
-                    if (msg.additionalInfo && Object.keys(msg.additionalInfo).length) {
-                        messages[type].push(Util.getGrayMsg(`     Additional Info:`));
-                        for (const key in msg.additionalInfo) {
-                            messages[type].push(
-                                Util.getGrayMsg(`       ${key}: ${msg.additionalInfo[key]}`)
-                            );
-                        }
+            if (!(response[type] && response[type].length)) {
+                continue;
+            }
+
+            messages[type].push(`   ${types[type]}:`);
+            for (const msg of response[type]) {
+                messages[type].push(
+                    `     #${counter++}: ${msg.errorDetail.replaceAll(' EmailID: ', '\n       EmailID: ').replaceAll(' Personalization error: ', '\n       Personalization error: ')}`,
+                    Util.getGrayMsg(`     Code: ${msg.errorCode}`)
+                );
+                if (msg.additionalInfo && Object.keys(msg.additionalInfo).length) {
+                    messages[type].push(Util.getGrayMsg(`     Additional Info:`));
+                    for (const key in msg.additionalInfo) {
+                        messages[type].push(
+                            Util.getGrayMsg(`       ${key}: ${msg.additionalInfo[key]}`)
+                        );
                     }
-                    // add spacer line
-                    messages[type].push('');
                 }
+                // add spacer line
+                messages[type].push('');
             }
         }
         for (const msg of messages.errors) {
@@ -2561,12 +2801,12 @@ class Journey extends MetadataType {
         const metadataMap = await this.retrieveForCache();
 
         for (let key of keyArr) {
-            let objectId;
-            let version;
-            let journey;
             if (!key) {
                 continue;
             }
+            let objectId;
+            let version;
+            let journey;
             if (key.startsWith('%23')) {
                 // if the key started with %23 assume an ID was copied from the URL but the user forgot to prefix it with id:
                 // correct the format
@@ -2586,14 +2826,14 @@ class Journey extends MetadataType {
                     key = 'id:' + objectId;
                 }
                 if (objectId.includes('/')) {
-                    version = objectId.split('/')[1];
+                    version = objectId.split('/', 2)[1];
                     // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the ID for caching as we always aim to retrieve the latest version only
-                    objectId = objectId.split('/')[0];
+                    objectId = objectId.split('/', 1)[0];
                 } else {
                     // if we didn't find a version we need to cache this from the API after all
                     if (key.includes('/')) {
                         // in the journey URL the version is appended after the ID, separated by a forward-slash. Needs to be removed from the key for caching as we always aim to retrieve the latest version only
-                        key = key.split('/')[0];
+                        key = key.split('/', 1)[0];
                     }
                 }
                 journey = Object.values(metadataMap.metadata).find((el) => el.id === objectId);
@@ -2646,7 +2886,7 @@ class Journey extends MetadataType {
                         } else {
                             throw new Error(response);
                         }
-                        const spinner = yoctoSpinner({
+                        const spinner = createSpinner({
                             text: `Validating journey…`,
                         }).start();
 
@@ -2743,7 +2983,7 @@ class Journey extends MetadataType {
         await Promise.allSettled(
             keyArr.map((key) =>
                 apiLimit(async () => {
-                    [key, version] = key.split('/');
+                    [key, version] = key.split('/', 2);
                     if (!journeyCache.metadata[key]) {
                         Util.logger.error(
                             ` ☇ skipping audit log of ${this.definition.type} ${key}: not found on server`
@@ -2880,7 +3120,7 @@ class Journey extends MetadataType {
         await Promise.allSettled(
             keyArr.map((key) =>
                 apiLimit(async () => {
-                    [key, version] = key.split('/');
+                    [key, version] = key.split('/', 2);
                     if (journeyCache.metadata[key]) {
                         switch (journeyCache.metadata[key].definitionType) {
                             case 'Transactional': {
@@ -3000,7 +3240,7 @@ class Journey extends MetadataType {
         await Promise.allSettled(
             keyArr.map((key) =>
                 apiLimit(async () => {
-                    [key, version] = key.split('/');
+                    [key, version] = key.split('/', 2);
                     if (journeyCache.metadata[key]) {
                         if (
                             (!version || journeyCache.metadata[key].version == version) &&
@@ -3099,7 +3339,7 @@ class Journey extends MetadataType {
         await Promise.allSettled(
             keyArr.map((key) =>
                 apiLimit(async () => {
-                    [key, version] = key.split('/');
+                    [key, version] = key.split('/', 2);
                     if (journeyCache.metadata[key]) {
                         if (
                             (!version || journeyCache.metadata[key].version == version) &&