@capillarytech/creatives-library 9.0.50-alpha.1 → 9.0.50

package/v2Containers/Rcs/tests/carouselUtils.test.js

@@ -853,7 +853,7 @@ describe('buildCarouselCardContentForPayload', () => {
       expect(out[0].cardVarMapped).toBeUndefined();
     });
 
-    it('builds cardVarMapped from title and description tokens, sanitizing values', () => {
+    it('renumbers non-numeric title/description tokens to sequential {{N}} slots and keys cardVarMapped by number', () => {
       const out = buildCarouselCardContentForPayload(
         [{ title: 'Hi {{name}}', description: 'Pts {{points}}', mediaType: RCS_MEDIA_TYPES.NONE }],
         {
@@ -863,7 +863,9 @@ describe('buildCarouselCardContentForPayload', () => {
           rcsVarRegex,
         },
       );
-      expect(out[0].cardVarMapped).toEqual({ name: 'Bob', points: '' });
+      expect(out[0].title).toBe('Hi {{1}}');
+      expect(out[0].description).toBe('Pts {{2}}');
+      expect(out[0].cardVarMapped).toEqual({ 1: 'Bob', 2: '' });
     });
 
     it('defaults an unmapped token value to empty string via sanitizeCardVarMappedValue', () => {
@@ -871,7 +873,8 @@ describe('buildCarouselCardContentForPayload', () => {
         [{ title: 'Hi {{missing}}', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE }],
         { isSlotMappingMode: true, cardVarMapped: {}, selectedCarouselHeight: 'SHORT', rcsVarRegex },
       );
-      expect(out[0].cardVarMapped).toEqual({ missing: '' });
+      expect(out[0].title).toBe('Hi {{1}}');
+      expect(out[0].cardVarMapped).toEqual({ 1: '' });
     });
 
     it('handles a missing cardVarMapped object entirely', () => {
@@ -879,7 +882,23 @@ describe('buildCarouselCardContentForPayload', () => {
         [{ title: 'Hi {{name}}', description: 'D', mediaType: RCS_MEDIA_TYPES.NONE }],
         { isSlotMappingMode: true, cardVarMapped: undefined, selectedCarouselHeight: 'SHORT', rcsVarRegex },
       );
-      expect(out[0].cardVarMapped).toEqual({ name: '' });
+      expect(out[0].title).toBe('Hi {{1}}');
+      expect(out[0].cardVarMapped).toEqual({ 1: '' });
+    });
+
+    it('leaves an already-numeric slot untouched and only renumbers the legacy/named slot alongside it', () => {
+      const out = buildCarouselCardContentForPayload(
+        [{ title: 'Hi {{1}}', description: 'Pts {{first_name}} exp {{3}}', mediaType: RCS_MEDIA_TYPES.NONE }],
+        {
+          isSlotMappingMode: true,
+          cardVarMapped: { 1: 'test', first_name: '{{first_name}}', 3: 'test' },
+          selectedCarouselHeight: 'SHORT',
+          rcsVarRegex,
+        },
+      );
+      expect(out[0].title).toBe('Hi {{1}}');
+      expect(out[0].description).toBe('Pts {{2}} exp {{3}}');
+      expect(out[0].cardVarMapped).toEqual({ 1: 'test', 2: '{{first_name}}', 3: 'test' });
     });
 
     it('skips a matched token that strips down to an empty variable name', () => {

package/v2Containers/Rcs/tests/index.test.js

@@ -1259,11 +1259,14 @@ describe('RCS createPayload', () => {
     });
     wrapper.update();
 
-    // The focused occurrence's own token is replaced with the picked tag, while the untouched
-    // duplicate keeps its original {{user_name}} token but syncs to the same resolved value.
+    // The persisted API contract requires title/description to only ever hold {{1}}, {{2}}, …
+    // — never the picked tag's name — so the focused occurrence's own token is normalized to its
+    // numeric slot instead of being replaced with {{first_name}}; the tag itself lives in
+    // cardVarMapped. The untouched duplicate keeps its original {{user_name}} token but syncs to
+    // the same resolved value.
     const renamedVarArea = wrapper.find('CapInputTextArea').filterWhere((n) => {
       const id = n.prop('id') || '';
-      return id.includes('{{first_name}}_');
+      return id.includes('{{1}}_');
     });
     const duplicateVarArea = wrapper.find('CapInputTextArea').filterWhere((n) => {
       const id = n.prop('id') || '';
@@ -1273,6 +1276,265 @@ describe('RCS createPayload', () => {
     expect(duplicateVarArea.at(0).prop('value')).toBe('{{first_name}}');
   });
 
+  it('normalizes a hydrated legacy/semantic token to its numeric slot in the payload even without touching TagList', () => {
+    const getFormData = jest.fn();
+    const templateData = {
+      name: 'RenewalReminder',
+      versions: {
+        base: {
+          content: {
+            RCS: {
+              rcsContent: {
+                cardType: 'STANDALONE',
+                cardSettings: { cardOrientation: 'VERTICAL', cardWidth: 'SMALL' },
+                cardContent: [
+                  {
+                    title: '',
+                    description:
+                      'Hello {{1}}, your {{first_name}} renews on {{3}}. Renew via our website to avoid disruption. Thank you, Capillary Technologies.',
+                    mediaType: 'NONE',
+                    // Slots 1 and 3 were typed directly; slot 2's token was hydrated as a legacy
+                    // semantic name that was never touched via TagList (self-referential value).
+                    cardVarMapped: { 1: 'test', first_name: '{{first_name}}', 3: 'test' },
+                    suggestions: [
+                      { type: 'QUICK_REPLY', text: 'stop' },
+                    ],
+                  },
+                ],
+                contentType: 'RICHCARD',
+              },
+            },
+          },
+        },
+      },
+      type: 'RCS',
+    };
+
+    const wrapper = mountWithIntl(
+      <Provider store={store}>
+        <Rcs
+          actions={{
+            clearCreateResponse: jest.fn(),
+            getTemplateDetails: jest.fn(),
+            uploadRcsAsset: jest.fn(),
+            clearRcsMediaAsset: jest.fn(),
+            editTemplate: jest.fn(),
+            clearEditResponse: jest.fn(),
+          }}
+          globalActions={{ fetchSchemaForEntity }}
+          onCreateComplete={onCreateComplete}
+          handleClose={handleClose}
+          intl={{ formatMessage }}
+          location={{ pathname: '/rcs/create', query: { type: false, module: 'default' }, search: '' }}
+          params={params}
+          templateData={templateData}
+          rcsData={{}}
+          isFullMode={false}
+          isEditFlow={false}
+          loadingTags={false}
+          metaEntities={[]}
+          isDltEnabled={false}
+          smsRegister={'DLT'}
+          getFormData={getFormData}
+        />
+      </Provider>,
+    );
+
+    // No TagList/VarSegment interaction at all — click Done straight away.
+    const doneBtn = wrapper.find('CapButton.rcs-done-btn').at(0);
+    expect(doneBtn.exists()).toBe(true);
+    act(() => {
+      doneBtn.prop('onClick')();
+    });
+    expect(getFormData).toHaveBeenCalled();
+    const payloadArg = getFormData.mock.calls[0][0].value;
+    const card = payloadArg.versions.base.content.RCS.rcsContent.cardContent[0];
+
+    expect(card.description).toBe(
+      'Hello {{1}}, your {{2}} renews on {{3}}. Renew via our website to avoid disruption. Thank you, Capillary Technologies.',
+    );
+    expect(card.cardVarMapped).toEqual({ 1: 'test', 2: '{{first_name}}', 3: 'test' });
+  });
+
+  it('standalone full-mode EDIT of an already-approved template: correct sequential numeric slots pass through byte-identical (no regression)', async () => {
+    const getFormData = jest.fn();
+    const templateData = {
+      name: 'ApprovedPromoCard',
+      versions: {
+        base: {
+          content: {
+            RCS: {
+              rcsContent: {
+                cardType: 'STANDALONE',
+                cardSettings: { cardOrientation: 'VERTICAL', cardWidth: 'SMALL' },
+                cardContent: [
+                  {
+                    title: 'Hi {{1}}',
+                    description: 'Your order {{2}} ships on {{3}}.',
+                    mediaType: 'IMAGE',
+                    media: { mediaUrl: 'https://cdn.example.com/card.png' },
+                    cardVarMapped: { 1: '{{first_name}}', 2: 'ORD-42', 3: '{{ship_date}}' },
+                    suggestions: [{ type: 'QUICK_REPLY', text: 'stop' }],
+                  },
+                ],
+                contentType: 'RICHCARD',
+              },
+            },
+          },
+        },
+      },
+      type: 'RCS',
+    };
+
+    const rcsProps = (rcsData) => ({
+      actions: {
+        clearCreateResponse: jest.fn(),
+        getTemplateDetails: jest.fn(),
+        uploadRcsAsset: jest.fn(),
+        clearRcsMediaAsset: jest.fn(),
+        editTemplate: jest.fn(),
+        clearEditResponse: jest.fn(),
+      },
+      globalActions: { fetchSchemaForEntity },
+      onCreateComplete,
+      handleClose,
+      intl: { formatMessage },
+      location: { pathname: '/rcs/edit', query: { type: false, module: 'default' }, search: '' },
+      params,
+      rcsData,
+      isFullMode: true,
+      isEditFlow: false,
+      loadingTags: false,
+      metaEntities: [],
+      isDltEnabled: false,
+      smsRegister: 'DLT',
+      getFormData,
+    });
+
+    const wrapper = mountWithIntl(
+      <Provider store={store}>
+        <Rcs {...rcsProps({})} />
+      </Provider>,
+    );
+
+    // Mirrors real usage: the component mounts before rcsData.templateDetails arrives (fetched via
+    // getTemplateDetails), then the prop updates once the template loads — matching how
+    // rcsHydrationDetails / setEditFlow(true) actually fire in the app. Updating rcsData in the
+    // same synchronous pass as mount would run the hydration effect and the templateType-reset
+    // effect together against stale pre-hydration closures, clobbering the hydrated title/desc.
+    await act(async () => {
+      await Promise.resolve();
+    });
+    wrapper.update();
+    await act(async () => {
+      wrapper.setProps({
+        children: <Rcs {...rcsProps({ templateDetails: templateData })} />,
+      });
+      await Promise.resolve();
+    });
+    wrapper.update();
+
+    const doneBtn = wrapper.find('CapButton.rcs-done-btn').at(0);
+    expect(doneBtn.exists()).toBe(true);
+    act(() => {
+      doneBtn.prop('onClick')();
+    });
+    expect(getFormData).toHaveBeenCalled();
+    const card = getFormData.mock.calls[0][0].value.versions.base.content.RCS.rcsContent.cardContent[0];
+
+    expect(card.title).toBe('Hi {{1}}');
+    expect(card.description).toBe('Your order {{2}} ships on {{3}}.');
+    expect(card.cardVarMapped).toEqual({ 1: '{{first_name}}', 2: 'ORD-42', 3: '{{ship_date}}' });
+  });
+
+  it('standalone full-mode EDIT: a legacy/semantic token still self-heals to its numeric slot (same fix applies outside library mode)', async () => {
+    const getFormData = jest.fn();
+    const templateData = {
+      name: 'LegacyPromoCard',
+      versions: {
+        base: {
+          content: {
+            RCS: {
+              rcsContent: {
+                cardType: 'STANDALONE',
+                cardSettings: { cardOrientation: 'VERTICAL', cardWidth: 'SMALL' },
+                cardContent: [
+                  {
+                    title: '',
+                    // Legacy key "first_name" holds a DIFFERENT tag ({{loyalty_points}}) as its value —
+                    // deliberately not self-referential: normalizeCardVarMapped (full-mode hydration
+                    // only) clears a legacy key whose value is the exact same {{tagName}} as the key
+                    // itself, treating that as "never actually filled." That heuristic is pre-existing
+                    // and orthogonal to this fix, so avoid colliding with it here.
+                    description: 'Hello {{1}}, your {{first_name}} renews on {{3}}.',
+                    mediaType: 'NONE',
+                    cardVarMapped: { 1: 'test', first_name: '{{loyalty_points}}', 3: 'test' },
+                    suggestions: [{ type: 'QUICK_REPLY', text: 'stop' }],
+                  },
+                ],
+                contentType: 'RICHCARD',
+              },
+            },
+          },
+        },
+      },
+      type: 'RCS',
+    };
+
+    const rcsProps = (rcsData) => ({
+      actions: {
+        clearCreateResponse: jest.fn(),
+        getTemplateDetails: jest.fn(),
+        uploadRcsAsset: jest.fn(),
+        clearRcsMediaAsset: jest.fn(),
+        editTemplate: jest.fn(),
+        clearEditResponse: jest.fn(),
+      },
+      globalActions: { fetchSchemaForEntity },
+      onCreateComplete,
+      handleClose,
+      intl: { formatMessage },
+      location: { pathname: '/rcs/edit', query: { type: false, module: 'default' }, search: '' },
+      params,
+      rcsData,
+      isFullMode: true,
+      isEditFlow: false,
+      loadingTags: false,
+      metaEntities: [],
+      isDltEnabled: false,
+      smsRegister: 'DLT',
+      getFormData,
+    });
+
+    const wrapper = mountWithIntl(
+      <Provider store={store}>
+        <Rcs {...rcsProps({})} />
+      </Provider>,
+    );
+
+    // See the previous test for why hydration must arrive via a prop update, not the initial mount.
+    await act(async () => {
+      await Promise.resolve();
+    });
+    wrapper.update();
+    await act(async () => {
+      wrapper.setProps({
+        children: <Rcs {...rcsProps({ templateDetails: templateData })} />,
+      });
+      await Promise.resolve();
+    });
+    wrapper.update();
+
+    const doneBtn = wrapper.find('CapButton.rcs-done-btn').at(0);
+    act(() => {
+      doneBtn.prop('onClick')();
+    });
+    const card = getFormData.mock.calls[0][0].value.versions.base.content.RCS.rcsContent.cardContent[0];
+
+    expect(card.description).toBe('Hello {{1}}, your {{2}} renews on {{3}}.');
+    expect(card.cardVarMapped).toEqual({ 1: 'test', 2: '{{loyalty_points}}', 3: 'test' });
+  });
+
   it('should keep two tags + freetext inside the variable textarea in non-full mode edit (not merged into static text)', () => {
     const templateData = {
       name: 'TwoTagsAndFreeText',

package/v2Containers/Rcs/tests/utils.test.js

@@ -604,77 +604,75 @@ describe('RCS utils', () => {
   });
 
   describe('mapRcsCardContentForConsumerWithResolvedTags', () => {
-    it('sets title and description to resolved tag strings on each card', () => {
-      const out = mapRcsCardContentForConsumerWithResolvedTags(
-        [
-          {
-            title: '',
-            description: 'Visit {{gt}} discount',
-            mediaType: 'NONE',
-            cardVarMapped: { gt: '{{loyalty_points}}', 1: '{{loyalty_points}}' },
-          },
-        ],
-        {},
-        false,
-      );
+    it('leaves numeric-slot title/description untouched — consumers get the same {{1}}, {{2}}, … contract as the editor', () => {
+      const out = mapRcsCardContentForConsumerWithResolvedTags([
+        {
+          title: '',
+          description: 'Visit {{gt}} discount',
+          mediaType: 'IMAGE',
+          cardVarMapped: { gt: '{{loyalty_points}}', 1: '{{loyalty_points}}' },
+        },
+      ]);
+      expect(out[0].title).toBe('');
+      // No resolution happens here — the tag reference lives only in cardVarMapped, never baked
+      // into the text (that used to replace {{gt}} with {{loyalty_points}}).
+      expect(out[0].description).toBe('Visit {{gt}} discount');
+      expect(out[0].cardVarMapped).toEqual({ gt: '{{loyalty_points}}', 1: '{{loyalty_points}}' });
+    });
+
+    it('forces title to empty for text-only cards (mediaType NONE/TEXT), matching the editor\'s own display', () => {
+      const out = mapRcsCardContentForConsumerWithResolvedTags([
+        {
+          title: 'Stale title',
+          description: 'Hi {{1}}',
+          mediaType: 'NONE',
+          cardVarMapped: { 1: 'test' },
+        },
+      ]);
       expect(out[0].title).toBe('');
-      expect(out[0].description).toBe('Visit {{loyalty_points}} discount');
+      expect(out[0].description).toBe('Hi {{1}}');
     });
 
-    it('merges root rcsCardVarMapped with nested cardVarMapped', () => {
+    it('ignores any extra legacy args (root map / isFullMode) — only this card\'s own cardVarMapped is used', () => {
       const out = mapRcsCardContentForConsumerWithResolvedTags(
         [
           {
-            title: 'Hi {{first_name}}',
-            description: 'Pts {{promotion_points}}',
+            title: 'Hi {{1}}',
+            description: 'Pts {{2}}',
             mediaType: 'IMAGE',
-            cardVarMapped: {
-              promotion_points: '{{loyalty_points}}',
-              2: '{{loyalty_points}}',
-            },
+            cardVarMapped: { 1: '{{first_name}}', 2: '{{loyalty_points}}' },
           },
         ],
-        {
-          first_name: '{{customer_name}}',
-          1: '{{customer_name}}',
-        },
+        { 1: '{{customer_name}}' },
         false,
       );
-      expect(out[0].title).toBe('Hi {{customer_name}}');
-      expect(out[0].description).toBe('Pts {{loyalty_points}}');
+      expect(out[0].title).toBe('Hi {{1}}');
+      expect(out[0].description).toBe('Pts {{2}}');
+      expect(out[0].cardVarMapped).toEqual({ 1: '{{first_name}}', 2: '{{loyalty_points}}' });
     });
 
     it('passes through null or non-object items in the card array unchanged', () => {
-      const out = mapRcsCardContentForConsumerWithResolvedTags([null, 'string', 42], {}, false);
+      const out = mapRcsCardContentForConsumerWithResolvedTags([null, 'string', 42]);
       expect(out).toEqual([null, 'string', 42]);
     });
 
-    it('preserves a voucher/offer tag value (parenthesized key) in the emitted cardVarMapped, and keeps the raw tag in the description', () => {
-      const out = mapRcsCardContentForConsumerWithResolvedTags(
-        [
-          {
-            title: '',
-            description: 'This is Bird with colorful feathers {{voucher(1190738)}}',
-            mediaType: 'NONE',
-            cardVarMapped: { 'voucher(1190738)': 'SAVE20' },
-          },
-        ],
-        {},
-        false,
-      );
-      expect(out[0].cardVarMapped).toEqual({ 'voucher(1190738)': 'SAVE20' });
-      // The typed value is a literal preview string, not another mustache tag — the raw
-      // {{voucher(...)}} token must survive so the editor can re-render an editable slot
-      // on reopen, and so the backend can resolve a real per-recipient code at send time.
-      expect(out[0].description).toBe('This is Bird with colorful feathers {{voucher(1190738)}}');
-    });
-
-    it('BUG REPRO: 2-card carousel — card 1 description resolves to card 0\'s value instead of its own tag pick', () => {
-      // Mirrors CreativesContainer/index.js ~1448-1461: rootRcsCardVarMapped is derived ONLY from
-      // cardContentFromSubmit[0] (the FIRST card's own cardVarMapped) and reused for every card.
-      // Card 0: title slot 1 -> user_id_b64, desc slot 2 -> voucher(1190738).
-      // Card 1: title slot 3 -> user_id_b64 (same semantic name as card 0), desc slot 4 -> first_name
-      // (the user's actual pick for card 1's own description slot, via "Add labels" while focused on card 1).
+    it('preserves a voucher/offer tag value (parenthesized key) in the emitted cardVarMapped, and keeps the raw {{N}} slot in the description', () => {
+      const out = mapRcsCardContentForConsumerWithResolvedTags([
+        {
+          title: '',
+          description: 'This is Bird with colorful feathers {{1}}',
+          mediaType: 'NONE',
+          cardVarMapped: { 'voucher(1190738)': 'SAVE20', 1: 'SAVE20' },
+        },
+      ]);
+      expect(out[0].cardVarMapped).toEqual({ 'voucher(1190738)': 'SAVE20', 1: 'SAVE20' });
+      expect(out[0].description).toBe('This is Bird with colorful feathers {{1}}');
+    });
+
+    it('carousel: each card keeps its own numeric slots and its own cardVarMapped — no cross-card leak', () => {
+      // Previously, CreativesContainer derived a "root" map from card 0 only and merged it into
+      // every card's resolution, which could leak card 0's values into card 1's text. Since text is
+      // no longer resolved at all, that leak class is gone: each card's output is self-contained.
       const card0 = {
         title: 'This is a bird {{1}}',
         description: 'This is Bird with colorful feathers {{2}}',
@@ -687,29 +685,16 @@ describe('RCS utils', () => {
         mediaType: 'IMAGE',
         cardVarMapped: { 3: '{{user_id_b64}}', 4: '{{first_name}}' },
       };
-      // rootRcsCardVarMapped, as CreativesContainer actually builds it: card 0's own map only.
-      const rootRcsCardVarMappedFromFirstCardOnly = { 1: '{{user_id_b64}}', 2: '{{voucher(1190738)}}' };
-
-      const out = mapRcsCardContentForConsumerWithResolvedTags(
-        [card0, card1],
-        rootRcsCardVarMappedFromFirstCardOnly,
-        true,
-      );
 
-      // Card 0 resolves correctly.
-      expect(out[0].title).toBe('This is a bird {{user_id_b64}}');
-      expect(out[0].description).toBe('This is Bird with colorful feathers {{voucher(1190738)}}');
+      const out = mapRcsCardContentForConsumerWithResolvedTags([card0, card1]);
 
-      // Card 1's title happens to resolve "correctly" only by coincidence (both root slot "1" and
-      // card 1's own slot "3" hold the same semantic value, user_id_b64).
-      expect(out[1].title).toBe('This is a park {{user_id_b64}}');
+      expect(out[0].title).toBe('This is a bird {{1}}');
+      expect(out[0].description).toBe('This is Bird with colorful feathers {{2}}');
+      expect(out[0].cardVarMapped).toEqual({ 1: '{{user_id_b64}}', 2: '{{voucher(1190738)}}' });
 
-      // Card 1's description SHOULD resolve using its own cardVarMapped slot 4 ({{first_name}}),
-      // not card 0's leaked slot 2 ({{voucher(1190738)}}). This is the reported bug: it currently
-      // resolves to card 0's value because resolveRcsCardPreviewStrings restarts slot numbering at
-      // 0 for every card (utils.js ~345-351) while the merged map still carries card 0's leftover
-      // global-numbered keys (via the root map bug in CreativesContainer).
-      expect(out[1].description).toBe('This park has a cat and a bird {{first_name}}');
+      expect(out[1].title).toBe('This is a park {{3}}');
+      expect(out[1].description).toBe('This park has a cat and a bird {{4}}');
+      expect(out[1].cardVarMapped).toEqual({ 3: '{{user_id_b64}}', 4: '{{first_name}}' });
     });
   });
 

package/v2Containers/Rcs/utils.js

@@ -360,53 +360,28 @@ export function resolveRcsCardPreviewStrings(
 }
 
 /**
- * Campaign consumer payload: replace each card's `title` / `description` with VarSegment-resolved
- * tag strings (same rules as {@link resolveRcsCardPreviewStrings}). Root `rcsCardVarMapped` merges
- * with per-card `cardVarMapped` for resolution; emitted `cardVarMapped` omits SMS-fallback slot keys
- * (root/nested merged with {@link pickRcsCardVarMappedEntries} per side).
+ * Campaign consumer payload: pass each card's `title` / `description` through unchanged — per the
+ * API contract (see `createPayload`), they only ever contain sequential numeric slot placeholders
+ * (`{{1}}`, `{{2}}`, …), never a tag name or literal value baked into the text. Personalization tag
+ * references and literal values alike live solely in the emitted `cardVarMapped`, so the backend
+ * resolves every slot from that map. `cardVarMapped` is filtered to this card's own numeric/semantic
+ * entries via `pickRcsCardVarMappedEntries` (drops stray/SMS-fallback keys). Text-only cards
+ * (`mediaType` NONE/TEXT) never surface a title to consumers, matching the editor's own display.
  */
-export function mapRcsCardContentForConsumerWithResolvedTags(
-  cardContentArray,
-  rootRcsCardVarMapped,
-  isFullMode,
-) {
-  const rootRecord =
-    rootRcsCardVarMapped != null && typeof rootRcsCardVarMapped === 'object'
-      ? rootRcsCardVarMapped
-      : {};
+export function mapRcsCardContentForConsumerWithResolvedTags(cardContentArray) {
   const list = Array.isArray(cardContentArray) ? cardContentArray : [];
-  const isLibraryMode = isFullMode !== true;
-  let carouselSlotOffset = 0;
   return list.map((card) => {
     if (!card || typeof card !== 'object') return card;
     const nested =
       card.cardVarMapped != null && typeof card.cardVarMapped === 'object'
         ? card.cardVarMapped
         : {};
-    const rootClean = pickRcsCardVarMappedEntries(rootRecord);
     const nestedClean = pickRcsCardVarMappedEntries(nested);
-    const merged = { ...rootClean, ...nestedClean };
     const textOnly = isRcsTextOnlyCardMediaType(card.mediaType);
-    const cardTitle = card.title ?? '';
-    const cardDescription = card.description ?? '';
-    const { rcsTitle, rcsDesc } = resolveRcsCardPreviewStrings(
-      cardTitle,
-      cardDescription,
-      merged,
-      isLibraryMode,
-      textOnly,
-      true,
-      carouselSlotOffset,
-    );
-    const effectiveTitleForCount = textOnly ? '' : String(cardTitle);
-    const titleVarCount = (effectiveTitleForCount.match(rcsVarRegex) || []).length;
-    const descVarCount = (String(cardDescription).match(rcsVarRegex) || []).length;
-    carouselSlotOffset += titleVarCount + descVarCount;
     const { cardVarMapped: _drop, ...cardRest } = card;
     return {
       ...cardRest,
-      title: rcsTitle,
-      description: rcsDesc,
+      ...(textOnly ? { title: '' } : {}),
       ...(Object.keys(nestedClean).length > 0 ? { cardVarMapped: nestedClean } : {}),
     };
   });