@capillarytech/creatives-library 8.0.329 → 8.0.330-alpha.0

package/constants/unified.js

@@ -168,6 +168,10 @@ export const COMBINED_SMS_TEMPLATE_VAR_REGEX = /\{\{[^}]+\}\}|\{\#[^#]*\#\}/g;
 export const MUSTACHE_VAR_TOKEN_FULL_STRING_REGEX = /^\{\{[^}]+\}\}$/;
 /** Full-string check: one DLT hash token. */
 export const DLT_HASH_VAR_TOKEN_FULL_STRING_REGEX = /^\{\#[^#]*\#\}$/;
+/** Full-string with capture group: inner name for `{{ name }}`-style tokens (whitespace-tolerant). */
+export const MUSTACHE_TOKEN_INNER_NAME_REGEX = /^\{\{\s*([^}]+?)\s*\}\}$/;
+/** Full-string with capture group: inner name/body for `{# name #}` DLT tokens (whitespace-tolerant). */
+export const DLT_HASH_TOKEN_INNER_NAME_REGEX = /^\{#\s*(.*?)\s*#\}$/;
 /** Global with capture group: inner name inside `{{name}}`. */
 export const MUSTACHE_VAR_NAME_CAPTURE_REGEX = /\{\{([^}]+)\}\}/g;
 /** Global with capture group: inner body inside `{#body#}`. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capillarytech/creatives-library",
   "author": "meharaj",
-  "version": "8.0.329",
+  "version": "8.0.330-alpha.0",
   "description": "Capillary creatives ui",
   "main": "./index.js",
   "module": "./index.es.js",

package/utils/commonUtils.js

@@ -539,4 +539,22 @@ export const isValidMobile = (mobile) => PHONE_REGEX.test(mobile);
 export const formatPhoneNumber = (phone) => {
   if (!phone) return '';
   return String(phone).replace(/[^\d]/g, '');
-};
+};
+
+/**
+ * TRAI sender IDs on persisted RCS SMS fallback: may live on the merged object, under
+ * `templateConfigs`, or (legacy) `templateConfigs.header`. Same resolution order as
+ * `createPayload` in `Rcs/index.js`.
+ */
+export function extractRegisteredSenderIdsFromSmsFallbackRecord(record) {
+  if (!record || typeof record !== 'object') return null;
+  const tc = record.templateConfigs && typeof record.templateConfigs === 'object'
+    ? record.templateConfigs
+    : {};
+  const candidates = [record.registeredSenderIds, tc.registeredSenderIds, tc.header];
+  for (let i = 0; i < candidates.length; i += 1) {
+    const a = candidates[i];
+    if (Array.isArray(a) && a.length > 0) return a;
+  }
+  return null;
+}

package/utils/templateVarUtils.js

@@ -7,7 +7,9 @@ import {
   COMBINED_SMS_TEMPLATE_VAR_REGEX,
   DEFAULT_MUSTACHE_VAR_REGEX,
   DLT_HASH_VAR_TOKEN_FULL_STRING_REGEX,
+  DLT_HASH_TOKEN_INNER_NAME_REGEX,
   DLT_VAR_BODY_CAPTURE_REGEX,
+  MUSTACHE_TOKEN_INNER_NAME_REGEX,
   MUSTACHE_VAR_NAME_CAPTURE_REGEX,
   MUSTACHE_VAR_TOKEN_FULL_STRING_REGEX,
 } from '../constants/unified';
@@ -115,13 +117,36 @@ export const extractTemplateVariables = (templateStr = '', captureRegex) => {
   return variables;
 };
 
+/**
+ * Looks up the inner name of a `{{name}}` or `{#name#}` token in a flat key→value map.
+ * Handles both exact matches and dot-path suffixes (e.g. `tag.FORMAT_1` → name `FORMAT_1`).
+ * Returns the resolved string value, or `undefined` if not found / blank.
+ */
+function resolveUserVarForToken(segment, userVarMap) {
+  if (!userVarMap || typeof userVarMap !== 'object') return undefined;
+  const mMustache = segment.match(MUSTACHE_TOKEN_INNER_NAME_REGEX);
+  const mDlt = segment.match(DLT_HASH_TOKEN_INNER_NAME_REGEX);
+  const innerName = ((mMustache ? mMustache[1] : (mDlt ? mDlt[1] : '')) ?? '').trim();
+  if (!innerName) return undefined;
+  const direct = userVarMap[innerName];
+  if (direct != null && String(direct).trim() !== '') return String(direct);
+  const hit = Object.keys(userVarMap).find((k) => k === innerName || k.endsWith(`.${innerName}`));
+  if (hit != null && userVarMap[hit] != null && String(userVarMap[hit]).trim() !== '') return String(userVarMap[hit]);
+  return undefined;
+}
+
 /**
  * SMS / DLT template preview: replace `{{…}}` / `{#…#}` tokens using `varMapData` keys `${token}_${index}`.
  * Used by SmsTraiEdit (RCS SMS fallback) and UnifiedPreview fallback SMS bubble.
  * DLT `{#…#}`: empty / unset slot values show the raw token (matches DLT preview UX); mustache `{{…}}` still
  * resolves to empty when the slot is cleared.
+ *
+ * @param {string} templateStr
+ * @param {Object} varMapData - Slot map (`${token}_${index}` → value)
+ * @param {Object|null} [userVarMap] - Optional Test & Preview custom values; used as fallback when a slot
+ *   is absent or blank. When omitted the function behaves identically to its original two-argument form.
  */
-export const getFallbackResolvedContent = (templateStr = '', varMapData = {}) => {
+export const getFallbackResolvedContent = (templateStr = '', varMapData = {}, userVarMap = null) => {
   const fallbackVarSlotMap = varMapData ?? {};
   const templateSegments = splitTemplateVarString(templateStr, COMBINED_SMS_TEMPLATE_VAR_REGEX);
   return templateSegments
@@ -132,13 +157,17 @@ export const getFallbackResolvedContent = (templateStr = '', varMapData = {}) =>
       if (Object.prototype.hasOwnProperty.call(fallbackVarSlotMap, slotKey)) {
         const slotValue = fallbackVarSlotMap[slotKey];
         if (isDltHashVarToken(segment)) {
-          if (slotValue == null) return segment;
-          const str = String(slotValue);
-          if (str.trim() === '') return segment;
-          return str;
+          if (slotValue == null || String(slotValue).trim() === '') {
+            if (userVarMap) { const uv = resolveUserVarForToken(segment, userVarMap); if (uv !== undefined) return uv; }
+            return segment;
+          }
+          return String(slotValue);
         }
-        return slotValue == null ? '' : String(slotValue);
+        if (slotValue != null && String(slotValue).trim() !== '') return String(slotValue);
+        if (userVarMap) { const uv = resolveUserVarForToken(segment, userVarMap); if (uv !== undefined) return uv; }
+        return '';
       }
+      if (userVarMap) { const uv = resolveUserVarForToken(segment, userVarMap); if (uv !== undefined) return uv; }
       if (isDltHashVarToken(segment)) return segment;
       return '';
     })

package/utils/tests/templateVarUtils.test.js

@@ -157,4 +157,48 @@ describe('templateVarUtils', () => {
       expect(extractTemplateVariables('{{x}} {{y}}', globalRe)).toEqual(['x', 'y']);
     });
   });
+
+  describe('getFallbackResolvedContent — userVarMap (third param)', () => {
+    it('falls back to userVarMap for mustache slot absent from varMapData', () => {
+      expect(getFallbackResolvedContent('Hi {{name}}', {}, { name: 'Alice' })).toBe('Hi Alice');
+    });
+
+    it('falls back to userVarMap for DLT slot absent from varMapData', () => {
+      expect(getFallbackResolvedContent('{#city#}', {}, { city: 'Mumbai' })).toBe('Mumbai');
+    });
+
+    it('falls back to userVarMap when mustache slot is present but blank', () => {
+      expect(getFallbackResolvedContent('{{x}}', { '{{x}}_0': '' }, { x: 'val' })).toBe('val');
+    });
+
+    it('falls back to userVarMap when DLT slot is present but blank', () => {
+      expect(getFallbackResolvedContent('{#x#}', { '{#x#}_0': '' }, { x: 'val' })).toBe('val');
+    });
+
+    it('slot wins over userVarMap when mustache slot is non-empty', () => {
+      expect(getFallbackResolvedContent('{{x}}', { '{{x}}_0': 'slot-val' }, { x: 'user-val' })).toBe('slot-val');
+    });
+
+    it('slot wins over userVarMap when DLT slot is non-empty', () => {
+      expect(getFallbackResolvedContent('{#x#}', { '{#x#}_0': 'slot' }, { x: 'user' })).toBe('slot');
+    });
+
+    it('resolves dot-path suffix key from userVarMap', () => {
+      expect(
+        getFallbackResolvedContent('{{FORMAT_1}}', {}, { 'expiry.FORMAT_1': 'Dec 2025' }),
+      ).toBe('Dec 2025');
+    });
+
+    it('userVarMap null behaves identically to the two-argument form', () => {
+      expect(getFallbackResolvedContent('{{a}}', { '{{a}}_0': 'x' }, null)).toBe('x');
+    });
+
+    it('blank userVarMap value leaves mustache token as empty string', () => {
+      expect(getFallbackResolvedContent('{{a}}', {}, { a: '' })).toBe('');
+    });
+
+    it('blank userVarMap value leaves DLT token as raw token', () => {
+      expect(getFallbackResolvedContent('{#a#}', {}, { a: '' })).toBe('{#a#}');
+    });
+  });
 });

package/v2Components/CommonTestAndPreview/index.js

@@ -97,6 +97,7 @@ import {
   extractPreviewFromLiquidResponse,
   getSmsFallbackTextForTagExtraction,
 } from './previewApiUtils';
+import { pickFirstSmsFallbackTemplateString } from '../../v2Containers/Rcs/rcsLibraryHydrationUtils';
 
 import { isValidEmail, isValidMobile, formatPhoneNumber } from '../../utils/commonUtils';
 import { getMembersLookup } from '../../services/api';
@@ -1039,78 +1040,77 @@ const CommonTestAndPreview = (props) => {
    * rcsMessageContent: { channel, accountId?, rcsRichCardContent: { contentType, cardType, cardSettings, cardContent }, smsFallBackContent? }
    * Then rcsDeliverySettings, executionParams, clientName last.
    */
-  const buildRcsTestMessagePayload = (formDataObj, _contentStr, customValuesObj, deliverySettingsOverride, basePayload, rcsExtra = {}) => {
-    const plainCustom =
-      customValuesObj != null && typeof customValuesObj.toJS === 'function'
-        ? customValuesObj.toJS()
-        : (customValuesObj || {});
-    const userVarMap = Object.fromEntries(
-      Object.entries(plainCustom).filter(([, v]) => v != null && String(v).trim() !== '')
-    );
-    const rcsData = formDataObj?.versions?.base?.content?.RCS ?? formDataObj?.content?.RCS ?? {};
-    const rcsContent = rcsData?.rcsContent || {};
-    const smsFallback = rcsData?.smsFallBackContent || {};
-    let cardContentList = [];
-    if (Array.isArray(rcsContent?.cardContent)) {
-      cardContentList = rcsContent.cardContent;
-    } else if (rcsContent?.cardContent) {
-      cardContentList = [rcsContent.cardContent];
+  const buildRcsTestMessagePayload = (
+    creativeFormData,
+    _unusedEditorContentString,
+    _customValuesObj,
+    deliverySettingsOverride,
+    basePayload,
+    _rcsTestMetaExtras = {},
+  ) => {
+    const rcsSectionFromForm =
+      creativeFormData?.versions?.base?.content?.RCS ?? creativeFormData?.content?.RCS ?? {};
+    const rcsContentFromForm = rcsSectionFromForm?.rcsContent || {};
+    const smsFallbackFromCreativeForm = rcsSectionFromForm?.smsFallBackContent || {};
+    let rcsCardPayloadList = [];
+    if (Array.isArray(rcsContentFromForm?.cardContent)) {
+      rcsCardPayloadList = rcsContentFromForm.cardContent;
+    } else if (rcsContentFromForm?.cardContent) {
+      rcsCardPayloadList = [rcsContentFromForm.cardContent];
     }
-    // Merge test customValues into cardVarMapped (template snapshot + user-entered RCS + fallback SMS tags).
-    const cardContent = cardContentList.map((rcsCard) => {
-      const baseMap = rcsCard.cardVarMapped || {};
-      const mergedCardVarMapped =
-        Object.keys(userVarMap).length > 0 ? { ...baseMap, ...userVarMap } : baseMap;
-      const mediaNorm = rcsCard?.media ? normalizeRcsTestCardMedia(rcsCard.media) : undefined;
-      const suggestionsRaw = Array.isArray(rcsCard?.suggestions) ? rcsCard.suggestions : [];
-      const suggestionsMapped = suggestionsRaw.map((suggestionItem, i) =>
-        mapRcsSuggestionForTestMeta(suggestionItem, i));
+    // Raw title/description with template tags; SMS fallback uses tagged template fields (pickFirst…).
+    const cardContentForTestMetaApi = rcsCardPayloadList.map((singleRcsCardPayload) => {
+      const normalizedCardMediaForTestApi = singleRcsCardPayload?.media
+        ? normalizeRcsTestCardMedia(singleRcsCardPayload.media)
+        : undefined;
+      const suggestionsFromCard = Array.isArray(singleRcsCardPayload?.suggestions)
+        ? singleRcsCardPayload.suggestions
+        : [];
+      const suggestionsFormattedForTestMeta = suggestionsFromCard.map((suggestionItem, index) =>
+        mapRcsSuggestionForTestMeta(suggestionItem, index));
       return {
-        title: rcsCard?.title ?? '',
-        description: rcsCard?.description ?? '',
-        mediaType: rcsCard?.mediaType ?? MEDIA_TYPE_TEXT,
-        ...(mediaNorm && { media: mediaNorm }),
-        ...(Object.keys(mergedCardVarMapped).length > 0 && { cardVarMapped: mergedCardVarMapped }),
-        ...(suggestionsMapped.length > 0 && { suggestions: suggestionsMapped }),
+        title: singleRcsCardPayload?.title ?? '',
+        description: singleRcsCardPayload?.description ?? '',
+        mediaType: singleRcsCardPayload?.mediaType ?? MEDIA_TYPE_TEXT,
+        ...(normalizedCardMediaForTestApi && { media: normalizedCardMediaForTestApi }),
+        ...(suggestionsFormattedForTestMeta.length > 0 && {
+          suggestions: suggestionsFormattedForTestMeta,
+        }),
       };
     });
-    // Prefer parent `smsFallbackContent` snapshot (rcsExtra) — includes VarSegment-resolved body via
-    // getSmsFallbackTextForTagExtraction. Nested formData.smsFallBackContent is often stale vs live editor.
-    const rcsExtraFallbackTemplate = rcsExtra?.smsFallbackTemplateContent;
-    const hasResolvedFallbackBodyFromRcsExtra =
-      rcsExtraFallbackTemplate != null
-      && String(rcsExtraFallbackTemplate).trim() !== '';
-    const smsMessageRaw = hasResolvedFallbackBodyFromRcsExtra
-      ? String(rcsExtraFallbackTemplate)
-      : (smsFallback?.smsContent ?? smsFallback?.message ?? '');
+    const smsFallbackTaggedTemplateBody = pickFirstSmsFallbackTemplateString(
+      smsFallbackFromCreativeForm,
+    ) || '';
     const smsSenderFromDelivery = deliverySettingsOverride?.cdmaSenderId?.includes('|')
       ? deliverySettingsOverride.cdmaSenderId.split('|')[1]
       : deliverySettingsOverride?.cdmaSenderId;
     const deliveryFallbackSmsId =
       typeof smsSenderFromDelivery === 'string' ? smsSenderFromDelivery.trim() : '';
     const creativeFallbackSmsId =
-      smsFallback?.senderId != null ? String(smsFallback.senderId).trim() : '';
+      smsFallbackFromCreativeForm?.senderId != null
+        ? String(smsFallbackFromCreativeForm.senderId).trim()
+        : '';
     const fallbackSmsSenderIdForChannel = deliveryFallbackSmsId || creativeFallbackSmsId || '';
 
     const smsFallBackContent =
-      smsMessageRaw.trim() !== ''
-        ? { message: smsMessageRaw }
+      smsFallbackTaggedTemplateBody.trim() !== ''
+        ? { message: smsFallbackTaggedTemplateBody }
         : undefined;
 
     // accountId: WeCRM account id (not sourceAccountIdentifier) for createMessageMeta
     const accountIdForMeta =
-      rcsContent?.accountId != null && String(rcsContent.accountId).trim() !== ''
-        ? String(rcsContent.accountId)
+      rcsContentFromForm?.accountId != null && String(rcsContentFromForm.accountId).trim() !== ''
+        ? String(rcsContentFromForm.accountId)
         : undefined;
 
     const rcsRichCardContent = {
       contentType: RCS_TEST_META_CONTENT_TYPE_RICHCARD,
-      cardType: rcsContent?.cardType ?? RCS_TEST_META_CARD_TYPE_STANDALONE,
-      cardSettings: rcsContent?.cardSettings ?? {
+      cardType: rcsContentFromForm?.cardType ?? RCS_TEST_META_CARD_TYPE_STANDALONE,
+      cardSettings: rcsContentFromForm?.cardSettings ?? {
         cardOrientation: RCS_TEST_META_CARD_ORIENTATION_VERTICAL,
         cardWidth: RCS_TEST_META_CARD_WIDTH_SMALL,
       },
-      ...(cardContent.length > 0 && { cardContent }),
+      ...(cardContentForTestMetaApi.length > 0 && { cardContent: cardContentForTestMetaApi }),
     };
 
     const rcsMessageContent = {
@@ -3299,15 +3299,7 @@ const CommonTestAndPreview = (props) => {
       uniqueUserIds,
       previewData,
       deliveryOverride,
-      channel === CHANNELS.RCS
-        ? {
-          smsFallbackTemplateContent:
-            smsFallbackTextForTagExtraction
-            || smsFallbackContent?.templateContent
-            || smsFallbackContent?.content
-            || '',
-        }
-        : {},
+      {},
     );
 
     actions.createMessageMetaRequested(

package/v2Components/SmsFallback/smsFallbackUtils.js

@@ -1,5 +1,6 @@
 import get from 'lodash/get';
 import { getFallbackResolvedContentForCardDisplay } from '../../utils/templateVarUtils';
+import { extractRegisteredSenderIdsFromSmsFallbackRecord } from '../../utils/commonUtils';
 import { SMS_CATEGORY_FILTERS } from './constants';
 
 export function buildFallbackDataFromTemplate(template) {
@@ -16,9 +17,14 @@ export function buildFallbackDataFromTemplate(template) {
   const content = smsEditor;
   const headerList = Array.isArray(base.header) ? base.header : [];
   const senderId = (headerList[0]) || base.senderId || '';
+  const templateName =
+    template.name
+    || base.template_name
+    || base['template-name']
+    || '';
   return {
     smsTemplateId: template._id || '',
-    templateName: template.name || '',
+    templateName,
     content,
     templateContent,
     senderId,
@@ -35,14 +41,19 @@ export function mapFallbackValueToEditTemplateData(source) {
     rcsSmsFallbackVarMappedFromSource != null
     && typeof rcsSmsFallbackVarMappedFromSource === 'object'
     && Object.keys(rcsSmsFallbackVarMappedFromSource).length > 0;
+  const registeredSenderIdsForHeader =
+    extractRegisteredSenderIdsFromSmsFallbackRecord(source);
   return {
     _id: source?.smsTemplateId,
     name: source?.templateName,
     versions: {
       base: {
         'sms-editor': source?.templateContent || source?.content,
-        ...(Array.isArray(source?.registeredSenderIds) && source.registeredSenderIds.length
-          ? { header: source.registeredSenderIds }
+        ...(source?.templateName != null && String(source.templateName).trim() !== ''
+          ? { template_name: String(source.templateName).trim() }
+          : {}),
+        ...(Array.isArray(registeredSenderIdsForHeader) && registeredSenderIdsForHeader.length
+          ? { header: registeredSenderIdsForHeader }
           : {}),
         ...(typeof source?.unicodeValidity === 'boolean'
           ? { 'unicode-validity': source.unicodeValidity }

package/v2Components/SmsFallback/tests/smsFallbackUtils.test.js

@@ -50,6 +50,21 @@ describe('smsFallbackUtils', () => {
       };
       expect(buildFallbackDataFromTemplate(template).unicodeValidity).toBe(true);
     });
+
+    it('uses versions.base.template_name when root name is empty (DLT detail shape)', () => {
+      const template = {
+        _id: 'dlt1',
+        name: '',
+        versions: {
+          base: {
+            template_name: 'DLT Registered Name',
+            'sms-editor': 'Hi',
+            header: ['H1'],
+          },
+        },
+      };
+      expect(buildFallbackDataFromTemplate(template).templateName).toBe('DLT Registered Name');
+    });
   });
 
   describe('getSmsFallbackCardDisplayContent', () => {
@@ -101,6 +116,7 @@ describe('smsFallbackUtils', () => {
         versions: {
           base: {
             'sms-editor': 'body',
+            template_name: 'N',
             header: ['h1'],
             'unicode-validity': false,
           },

package/v2Components/TestAndPreviewSlidebox/index.js

@@ -84,6 +84,10 @@ TestAndPreviewSlidebox.propTypes = {
     templateName: PropTypes.string,
     [RCS_SMS_FALLBACK_VAR_MAPPED_PROP]: PropTypes.object,
   }),
+  /** Passed to CommonTestAndPreview for RCS test-meta resolution (slot semantics vs full-mode). */
+  rcsTestPreviewOptions: PropTypes.shape({
+    isLibraryMode: PropTypes.bool,
+  }),
   // Redux props are passed through
   actions: PropTypes.object.isRequired,
   extractedTags: PropTypes.array.isRequired,
@@ -115,6 +119,7 @@ TestAndPreviewSlidebox.defaultProps = {
   currentTab: 1,
   messageMetaConfigId: null,
   prefilledValues: {},
+  rcsTestPreviewOptions: undefined,
   senderDetailsByChannel: {},
   wecrmAccounts: [],
   isLoadingSenderDetails: false,

package/v2Containers/CreativesContainer/index.js

@@ -43,6 +43,7 @@ import {EXTERNAL_URL, SITE_URL, WEBPUSH_MEDIA_TYPES} from '../WebPush/constants'
 import { IMAGE, VIDEO } from '../Facebook/Advertisement/constant';
 import { RCS_STATUSES } from '../Rcs/constants';
 import { mapRcsCardContentForConsumerWithResolvedTags } from '../Rcs/utils';
+import { pickRcsCardVarMappedEntries } from '../Rcs/rcsLibraryHydrationUtils';
 import { RCS_SMS_FALLBACK_VAR_MAPPED_PROP } from '../../v2Components/CommonTestAndPreview/constants';
 import { CREATIVE } from '../Facebook/constants';
 import { LOYALTY } from '../App/constants';
@@ -764,8 +765,13 @@ export class Creatives extends React.Component {
               rootMirrorCardVarMapped != null && typeof rootMirrorCardVarMapped === 'object'
                 ? rootMirrorCardVarMapped
                 : {};
-            const mergedFromRootAndNested = { ...rootRecord, ...nestedRecord };
-            return Object.keys(mergedFromRootAndNested).length > 0 ? mergedFromRootAndNested : null;
+            const mergedFromRootAndNested = {
+              ...pickRcsCardVarMappedEntries(rootRecord),
+              ...pickRcsCardVarMappedEntries(nestedRecord),
+            };
+            return Object.keys(mergedFromRootAndNested).length > 0
+              ? mergedFromRootAndNested
+              : null;
           })();
           // Campaigns (embedded): do not duplicate `cardVarMapped` as root `rcsCardVarMapped` on send —
           // slot map stays on `versions…cardContent[0].cardVarMapped` only. Library full mode keeps root mirror.
@@ -1348,7 +1354,7 @@ export class Creatives extends React.Component {
           const cardVarMappedFromFirstRcsCard =
             firstCardFromSubmit?.cardVarMapped != null
             && typeof firstCardFromSubmit.cardVarMapped === 'object'
-              ? firstCardFromSubmit.cardVarMapped
+              ? pickRcsCardVarMappedEntries(firstCardFromSubmit.cardVarMapped)
               : null;
           const includeRootRcsCardVarMappedOnConsumerPayload =
             cardVarMappedFromFirstRcsCard

package/v2Containers/Rcs/constants.js

@@ -90,13 +90,17 @@ export const RCS_MEDIA_TYPES = {
   VIDEO: 'VIDEO',
 };
 
-export const rcsVarRegex = /\{\{\w+\}\}/g;
-export const rcsVarTestRegex = /\{\{\w+\}\}/;
+/** Match `{{…}}` placeholders including Liquid-style names (e.g. `tag.FORMAT_1`). Must align with split + `isAnyTemplateVarToken` / SMS fallback. */
+export const rcsVarRegex = /\{\{[^}]+\}\}/g;
+/** True when the whole string is a single RCS/mustache token (used when testing segment tokens). */
+export const rcsVarTestRegex = /^\{\{[^}]+\}\}$/;
 
 /** Matches all `{{N}}` numeric-index variable tokens in a template string (global). */
 export const RCS_NUMERIC_VAR_TOKEN_REGEX = /\{\{(\d+)\}\}/g;
 /** `cardVarMapped` slot keys that are numeric only (legacy ordering). */
 export const RCS_NUMERIC_VAR_NAME_REGEX = /^\d+$/;
+/** Semantic Liquid-style keys on RCS `cardVarMapped` (same class as `{{…}}` inner names in the editor). */
+export const RCS_CARD_VAR_MAPPED_SEMANTIC_KEY_REGEX = /^[\w.]+$/;
 /** Escape `RegExp` metacharacters when building a pattern from user/tag text. */
 export const RCS_REGEX_META_CHARS_PATTERN = /[.*+?^${}()|[\]\\]/g;
 /** Entire string is a single `{{tag}}` token (value still a placeholder). */