@capillarytech/creatives-library 9.0.61-alpha.3 → 9.0.62

package/v2Components/FormBuilder/Functional/channels/mobilepush/config.js

@@ -0,0 +1,75 @@
+/**
+ * MOBILEPUSH channel config — declarative capabilities + field ids for the MPUSH
+ * adapter. MOBILEPUSH is a two-tab channel (Android=tab 0, iOS=tab 1); iOS field
+ * ids carry the legacy `2` suffix (message-editor2). The containers mutate the
+ * schema at runtime (CTA row splices), so the engine's reconcile path is active.
+ */
+import { MOBILE_PUSH } from '../../../../../v2Containers/CreativesContainer/constants';
+import { TEMPLATE_NAME_FIELD } from '../../constants';
+
+// The exact legacy error VALUE written for brace mismatches — containers pattern
+// on it (string ≠ boolean true matters: Classic's cross-tab toast reacts only to
+// boolean true). Mirrors errorMessageForTags.TAG_BRACKET_COUNT_MISMATCH_ERROR.
+export const ERROR_VALUE = {
+  BRACKET: 'tagBracketCountMismatchError',
+};
+
+// Legacy tab semantics: 1-based currentTab, 1=Android, 2=iOS (Classic.js:483-486).
+export const TABS = {
+  ANDROID: 0,
+  IOS: 1,
+  /** iOS field ids get suffix '2'; Android none (Classic.js:967). */
+  suffixFor: (tabIndex) => (tabIndex > 0 ? `${Number(tabIndex) + 1}` : ''),
+};
+
+export const fieldIds = {
+  name: TEMPLATE_NAME_FIELD, // root field
+  editor: 'message-editor', // per-tab, suffixed on iOS
+  title: 'message-title', // per-tab, suffixed on iOS
+  image: 'image', // per-tab (imageSchema only), same id on both panes
+  bracketError: 'bracket-error',
+};
+
+// The 13 fixed CTA/deeplink rules of Classic's validateForm MPUSH block
+// (Classic.js:1037-1135), in source order. kind: 'empty' => `=== ""` fails
+// (absent field passes); kind: 'url' => isValidExternalLink semantics.
+// Named fieldId (not `key:`) so gitleaks' generic-api-key rule stops matching.
+export const CTA_RULES = [
+  { fieldId: 'cta-deeplink-select', kind: 'empty' },
+  { fieldId: 'cta-deeplink2-select', kind: 'empty' },
+  { fieldId: 'cta-deeplink-text', kind: 'url' },
+  { fieldId: 'cta-deeplink2-text', kind: 'url' },
+  { fieldId: 'secondary-cta-0-link', kind: 'empty' },
+  { fieldId: 'secondary-cta-0-label', kind: 'empty' },
+  { fieldId: 'cta-deeplink-secondary-cta-0-text', kind: 'url' },
+  { fieldId: 'cta-deeplink-secondary-cta-0-select', kind: 'empty' },
+  { fieldId: 'secondary-cta-1-label', kind: 'empty' },
+  { fieldId: 'cta-deeplink-secondary-cta-1-text', kind: 'url' },
+  { fieldId: 'cta-deeplink-secondary-cta-1-select', kind: 'empty' },
+  { fieldId: 'cta-deeplink-secondary-cta-1-text2', kind: 'url' },
+  { fieldId: 'cta-deeplink-secondary-cta-1-select2', kind: 'empty' },
+];
+
+export default {
+  channel: MOBILE_PUSH,
+  fieldIds,
+  // Classic passes the live 1-based currentTab as showLiquidErrorInFooter's second
+  // argument for MPUSH (Classic.js:1352, 1487); SMS is the only null channel.
+  footerTabArg: 'currentTab',
+  features: {
+    tabs: true,
+    versions: false,
+    languages: false,
+    unicode: false,
+    liquid: true, // LIQUID_SUPPORTED_CHANNELS member; pipeline runs only outside isFullMode
+    askAira: true, // textarea only (Classic.js:2927)
+    preview: true,
+    imageUpload: true,
+    cta: true,
+    bridgeFieldEvents: true, // checkbox/radio/select commits use the performFormDataUpdate signature (true, formData, field)
+    inlineErrorWithLiquid: true, // MPUSH keeps the inline textarea error despite liquid (Classic.js:2908-2915)
+    liveValidation: false, // Classic re-validates typing only under startValidation (Classic.js:334-345)
+    validateOnExternalChange: true, // background validity on parent/schema/tags changes gates the save flows (Classic.js:516-578, 1361)
+    emitFormDataOnSchemaSync: true, // push formData up on init + schema re-inits; copy-content handlers read it (Classic.js:1906-1911)
+  },
+};

package/v2Components/FormBuilder/Functional/channels/mobilepush/getEditorErrorDescriptor.js

@@ -0,0 +1,74 @@
+/**
+ * MOBILEPUSH editor-error descriptor — the library-mode footer echo of the ACTIVE
+ * tab's editor error (Classic's render-phase footer push, Classic.js:2885-2895).
+ * Mirrored rules: full mode returns null (MPUSH errors show inline); the whole echo
+ * is gated on checkValidation (Classic computes no errorData pre-save, 334-345);
+ * personalization restriction has its own message (2877-2879); otherwise the schema
+ * field's errorMessage (already localized by the containers) is echoed as-is.
+ */
+
+import { hasPersonalizationTags } from '../../../../../utils/commonUtils';
+import formMessages from '../../../messages';
+import { EDITOR_ERROR_KIND, SECTION_TYPE, CONTAINER_TYPE } from '../../constants';
+import { ERROR_VALUE, TABS } from './config';
+
+/** Find a leaf field by id inside one pane of the tabs container. */
+const findPaneField = (schema, tabIndex, fieldId) => {
+  const container = (schema?.containers || []).find(
+    (candidate) => candidate?.type === CONTAINER_TYPE.TABS
+      && (candidate.isActive === undefined || candidate.isActive),
+  );
+  const pane = container?.panes?.[tabIndex];
+  let found = null;
+  const visitSection = (section) => {
+    if (!section || found) return;
+    if (section.type === SECTION_TYPE.PARENT) {
+      (section.childSections || []).forEach(visitSection);
+    } else if (section.type === SECTION_TYPE.MULTICOLS) {
+      (section.inputFields || []).concat(section.actionFields || []).forEach((row) => {
+        (row?.cols || []).forEach((col) => { if (col?.id === fieldId) found = col; });
+      });
+    } else if (section.type === SECTION_TYPE.COL_LABEL) {
+      (section.inputFields || []).concat(section.actionFields || []).forEach((col) => {
+        if (col?.id === fieldId) found = col;
+      });
+    }
+  };
+  (pane?.sections || []).forEach(visitSection);
+  return found;
+};
+
+/**
+ * @param {object} legacyFormData  the legacy dialect ({0: {...}, 1: {...}, ...})
+ * @param {object} ctx  { isFullMode, currentTab (1-based), errorData, schema,
+ *                        checkValidation, restrictPersonalization }
+ * @returns null | { text, kind } | { message: intlDescriptor, kind }
+ */
+export default function getEditorErrorDescriptor(legacyFormData = {}, ctx = {}) {
+  if (ctx.isFullMode) return null;
+  // Classic parity: no footer echo before a save attempt (see header).
+  if (!ctx.checkValidation) return null;
+
+  const tabIndex = Math.max(((ctx.currentTab || 1) - 1), 0);
+  const suffix = TABS.suffixFor(tabIndex);
+  const editorId = `message-editor${suffix}`;
+  const editorError = ctx.errorData?.[tabIndex]?.[editorId];
+  if (!editorError) return null;
+
+  const tab = legacyFormData?.[tabIndex] || {};
+  const content = tab[editorId];
+
+  if (ctx.restrictPersonalization && content && hasPersonalizationTags(String(content))) {
+    return {
+      message: formMessages.personalizationTagsErrorMessage,
+      kind: EDITOR_ERROR_KIND.MISSING,
+    };
+  }
+
+  const field = findPaneField(ctx.schema, tabIndex, editorId);
+  if (!field?.errorMessage) return null;
+  return {
+    text: field.errorMessage,
+    kind: editorError === ERROR_VALUE.BRACKET ? EDITOR_ERROR_KIND.BRACE : EDITOR_ERROR_KIND.MISSING,
+  };
+}

package/v2Components/FormBuilder/Functional/channels/mobilepush/index.js

@@ -0,0 +1,28 @@
+/**
+ * MOBILEPUSH channel adapter — the isolation unit for MPUSH. Bundles config + the
+ * pure validate + the identity payload builder + the platform-specific submit
+ * pipeline + the single-platform modal semantics + the channel's renderer
+ * registry. The shell looks this up via channels/registry by `schema.channel`;
+ * it imports nothing from other channels.
+ */
+import { MOBILE_PUSH } from '../../../../../v2Containers/CreativesContainer/constants';
+import config from './config';
+import validate from './validate';
+import buildSubmitPayload from './buildSubmitPayload';
+import runSubmitPipeline from './runSubmitPipeline';
+import modals from './modals';
+import getEditorErrorDescriptor from './getEditorErrorDescriptor';
+import { createMpushRegistry } from '../../renderers/mpushRenderers';
+
+const mpushAdapter = {
+  channel: MOBILE_PUSH,
+  config,
+  validate,
+  buildSubmitPayload,
+  runSubmitPipeline,
+  modals,
+  getEditorErrorDescriptor,
+  createRegistry: createMpushRegistry,
+};
+
+export default mpushAdapter;

package/v2Components/FormBuilder/Functional/channels/mobilepush/modals.js

@@ -0,0 +1,21 @@
+/**
+ * Single-platform save confirmation (Classic handleOk, Classic.js:2674-2709).
+ * The OK button's id ('android'|'ios') is the dispatch key: confirming saves that
+ * platform alone, but only if its validity flag is true — a falsy flag silently
+ * closes the modal (Classic parity). Modal CONTENT stays container-owned.
+ */
+
+import { ANDROID, IOS } from '../../../../../constants/unified';
+
+const mpushModals = {
+  handleOk: (id, { platform, submitSingleTab } = {}) => {
+    if (!platform || typeof submitSingleTab !== 'function') return;
+    if (id === ANDROID && platform.androidValid) {
+      submitSingleTab(ANDROID);
+    } else if (id === IOS && platform.iosValid) {
+      submitSingleTab(IOS);
+    }
+  },
+};
+
+export default mpushModals;

package/v2Components/FormBuilder/Functional/channels/mobilepush/runSubmitPipeline.js

@@ -0,0 +1,45 @@
+/**
+ * MOBILEPUSH submit pipeline (Classic.js:1397-1405, 1473-1522). Full mode submits
+ * the raw legacy formData (no liquid, no getChannelData); library mode runs
+ * validateMobilePushContent over [androidTab, iosTab]. Classic quirks preserved:
+ * the util's nested per-platform error objects go to the footer AS-IS, its initial
+ * empty "clear" call still triggers stopValidation + onFormValidityChange(false),
+ * its onSuccess contentToSubmit is IGNORED (the full formData is submitted), and
+ * singleTab from the single-platform modal skips the other platform (1519).
+ */
+
+import { validateMobilePushContent } from '../../../../../utils/commonUtils';
+
+export default function runSubmitPipeline(legacyFormData, ctx = {}, callbacks = {}) {
+  const {
+    isFullMode, singleTab, currentTab, getLiquidTags, formatMessage, messages,
+  } = ctx;
+  const {
+    onSubmit, pushFooter, stopValidation, onFormValidityChange,
+  } = callbacks;
+
+  const runLiquid = !isFullMode && typeof getLiquidTags === 'function';
+  if (!runLiquid) {
+    if (onSubmit) onSubmit(legacyFormData);
+    return;
+  }
+
+  validateMobilePushContent(legacyFormData, {
+    currentTab,
+    onError: ({ standardErrors, liquidErrors }) => {
+      if (pushFooter) pushFooter({ STANDARD_ERROR_MSG: standardErrors, LIQUID_ERROR_MSG: liquidErrors });
+      if (stopValidation) stopValidation();
+      // Block save: tell the parent the form is invalid (Classic passes the last
+      // sync errorData — the shell's callback supplies it).
+      if (onFormValidityChange) onFormValidityChange(false);
+    },
+    onSuccess: () => {
+      if (pushFooter) pushFooter({ STANDARD_ERROR_MSG: [], LIQUID_ERROR_MSG: [] });
+      if (onSubmit) onSubmit(legacyFormData);
+    },
+    getLiquidTags,
+    formatMessage,
+    messages,
+    singleTab: singleTab ? `${singleTab}`.toUpperCase() : undefined,
+  });
+}

package/v2Components/FormBuilder/Functional/channels/mobilepush/tests/getEditorErrorDescriptor.test.js

@@ -0,0 +1,162 @@
+/**
+ * MPUSH getEditorErrorDescriptor — the library-mode footer echo of the active
+ * tab's editor error (mirror of Classic's render-phase push, Classic.js:2885-2895).
+ */
+import getEditorErrorDescriptor from '../getEditorErrorDescriptor';
+import { ERROR_VALUE } from '../config';
+import { EDITOR_ERROR_KIND } from '../../../constants';
+import formMessages from '../../../../messages';
+
+const EDITOR_ERROR_TEXT = 'Template message has unsupported/missing tags!';
+
+const schemaWithEditor = (fieldId = 'message-editor', paneIndex = 0) => {
+  const panes = [{ sections: [] }, { sections: [] }];
+  panes[paneIndex] = {
+    sections: [{
+      type: 'multicols',
+      inputFields: [{ cols: [{ id: fieldId, type: 'textarea', errorMessage: EDITOR_ERROR_TEXT }] }],
+    }],
+  };
+  return { containers: [{ id: 'pane', type: 'tabs', panes }] };
+};
+
+// Same editor field, but reached through parent -> col-label sections (the other
+// findPaneField walk branches).
+const colLabelSchema = (fieldId = 'message-editor') => ({
+  containers: [{
+    id: 'pane',
+    type: 'tabs',
+    panes: [{
+      sections: [{
+        type: 'parent',
+        childSections: [{
+          type: 'col-label',
+          inputFields: [{ id: fieldId, type: 'textarea', errorMessage: EDITOR_ERROR_TEXT }],
+        }],
+      }],
+    }, { sections: [] }],
+  }],
+});
+
+const legacyWith = (content, tabIndex = 0, fieldId = 'message-editor') => ({
+  [tabIndex]: { [fieldId]: content, tabKey: `k${tabIndex}` },
+});
+
+const baseCtx = (overrides = {}) => ({
+  isFullMode: false,
+  currentTab: 1,
+  schema: schemaWithEditor(),
+  checkValidation: true,
+  restrictPersonalization: false,
+  ...overrides,
+});
+
+describe('channels/mobilepush/getEditorErrorDescriptor', () => {
+  it('returns null in full mode (MPUSH errors show inline there, never as an inline-brace override)', () => {
+    const ctx = baseCtx({ isFullMode: true, errorData: { 0: { 'message-editor': true } } });
+    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toBeNull();
+  });
+
+  it('returns null when the active tab has no editor error', () => {
+    const ctx = baseCtx({ errorData: { 0: { 'message-editor': false } } });
+    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toBeNull();
+  });
+
+  it('echoes the schema errorMessage for a generic editor error', () => {
+    const ctx = baseCtx({ errorData: { 0: { 'message-editor': true } } });
+    expect(getEditorErrorDescriptor(legacyWith('{{unknown}}'), ctx)).toEqual({
+      text: EDITOR_ERROR_TEXT,
+      kind: EDITOR_ERROR_KIND.MISSING,
+    });
+  });
+
+  it('finds the editor field through parent -> col-label pane sections too', () => {
+    const ctx = baseCtx({ schema: colLabelSchema(), errorData: { 0: { 'message-editor': true } } });
+    expect(getEditorErrorDescriptor(legacyWith('{{unknown}}'), ctx)).toEqual({
+      text: EDITOR_ERROR_TEXT,
+      kind: EDITOR_ERROR_KIND.MISSING,
+    });
+  });
+
+  it('defaults: no arguments => null; missing currentTab resolves to tab 0', () => {
+    expect(getEditorErrorDescriptor()).toBeNull();
+    const ctx = baseCtx({ errorData: { 0: { 'message-editor': true } } });
+    delete ctx.currentTab;
+    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toEqual({
+      text: EDITOR_ERROR_TEXT,
+      kind: EDITOR_ERROR_KIND.MISSING,
+    });
+  });
+
+  it('an inactive tabs container hides the field => no echo (null)', () => {
+    const schema = schemaWithEditor();
+    schema.containers[0].isActive = false;
+    const ctx = baseCtx({ schema, errorData: { 0: { 'message-editor': true } } });
+    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toBeNull();
+  });
+
+  it('also locates the editor field among a multicols row\'s actionFields', () => {
+    const schema = schemaWithEditor();
+    const section = schema.containers[0].panes[0].sections[0];
+    section.actionFields = section.inputFields;
+    section.inputFields = [];
+    const ctx = baseCtx({ schema, errorData: { 0: { 'message-editor': true } } });
+    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toEqual({
+      text: EDITOR_ERROR_TEXT,
+      kind: EDITOR_ERROR_KIND.MISSING,
+    });
+  });
+
+  it('marks a brace error with the BRACE kind', () => {
+    const ctx = baseCtx({ errorData: { 0: { 'message-editor': ERROR_VALUE.BRACKET } } });
+    expect(getEditorErrorDescriptor(legacyWith('abc {{full_name'), ctx)).toEqual({
+      text: EDITOR_ERROR_TEXT,
+      kind: EDITOR_ERROR_KIND.BRACE,
+    });
+  });
+
+  it('gates EVERY error on checkValidation — no footer echo before a save attempt (Classic parity: errorData is only computed under startValidation, Classic.js:334-345)', () => {
+    const generic = { 0: { 'message-editor': true } };
+    expect(getEditorErrorDescriptor(legacyWith('{{unknown}}'), baseCtx({ errorData: generic, checkValidation: false }))).toBeNull();
+    const brace = { 0: { 'message-editor': ERROR_VALUE.BRACKET } };
+    expect(getEditorErrorDescriptor(legacyWith('abc {{full_name'), baseCtx({ errorData: brace, checkValidation: false }))).toBeNull();
+  });
+
+  it('gates the EMPTY-content error on checkValidation (hidden until Save, like the inline message)', () => {
+    const errorData = { 0: { 'message-editor': true } };
+    expect(getEditorErrorDescriptor(legacyWith(''), baseCtx({ errorData, checkValidation: false }))).toBeNull();
+    expect(getEditorErrorDescriptor(legacyWith('   '), baseCtx({ errorData, checkValidation: false }))).toBeNull();
+    expect(getEditorErrorDescriptor(legacyWith(''), baseCtx({ errorData, checkValidation: true }))).toEqual({
+      text: EDITOR_ERROR_TEXT,
+      kind: EDITOR_ERROR_KIND.MISSING,
+    });
+  });
+
+  it('returns the personalization intl descriptor when restricted tokens are present', () => {
+    const ctx = baseCtx({
+      restrictPersonalization: true,
+      errorData: { 0: { 'message-editor': true } },
+    });
+    expect(getEditorErrorDescriptor(legacyWith('hi [eventAttr]'), ctx)).toEqual({
+      message: formMessages.personalizationTagsErrorMessage,
+      kind: EDITOR_ERROR_KIND.MISSING,
+    });
+  });
+
+  it('resolves the iOS tab through the suffixed field id (currentTab=2 => message-editor2)', () => {
+    const ctx = baseCtx({
+      currentTab: 2,
+      schema: schemaWithEditor('message-editor2', 1),
+      errorData: { 1: { 'message-editor2': true } },
+    });
+    expect(getEditorErrorDescriptor(legacyWith('{{x}}', 1, 'message-editor2'), ctx)).toEqual({
+      text: EDITOR_ERROR_TEXT,
+      kind: EDITOR_ERROR_KIND.MISSING,
+    });
+  });
+
+  it('returns null when the schema pane has no errorMessage to echo', () => {
+    const ctx = baseCtx({ schema: { containers: [] }, errorData: { 0: { 'message-editor': true } } });
+    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toBeNull();
+  });
+});

package/v2Components/FormBuilder/Functional/channels/mobilepush/tests/modals.test.js

@@ -0,0 +1,37 @@
+/**
+ * MPUSH modal semantics — Classic's single-platform handleOk (Classic.js:2674-2709):
+ * the OK id dispatches a single-platform save only when that platform's last
+ * validation flag is true; anything else silently closes the modal.
+ */
+import mpushModals from '../modals';
+
+describe('channels/mobilepush/modals.handleOk', () => {
+  const run = (id, platform) => {
+    const submitSingleTab = jest.fn();
+    mpushModals.handleOk(id, { platform, submitSingleTab });
+    return submitSingleTab;
+  };
+
+  it('android OK + androidValid => saves android alone', () => {
+    expect(run('android', { androidValid: true, iosValid: false }))
+      .toHaveBeenCalledWith('android');
+  });
+
+  it('ios OK + iosValid => saves ios alone', () => {
+    expect(run('ios', { androidValid: false, iosValid: true }))
+      .toHaveBeenCalledWith('ios');
+  });
+
+  it('a falsy platform flag silently closes (no submit) — Classic parity', () => {
+    expect(run('android', { androidValid: false, iosValid: true })).not.toHaveBeenCalled();
+    expect(run('ios', { androidValid: true, iosValid: false })).not.toHaveBeenCalled();
+  });
+
+  it('unknown id / missing platform / missing callback are all no-ops', () => {
+    expect(run('template-back-confirm-modal', { androidValid: true, iosValid: true }))
+      .not.toHaveBeenCalled();
+    expect(run('android', null)).not.toHaveBeenCalled();
+    expect(() => mpushModals.handleOk('android', { platform: { androidValid: true } })).not.toThrow();
+    expect(() => mpushModals.handleOk('android')).not.toThrow();
+  });
+});

package/v2Components/FormBuilder/Functional/channels/mobilepush/tests/runSubmitPipeline.test.js

@@ -0,0 +1,70 @@
+/**
+ * MPUSH submit pipeline — Classic's onSubmitWrapper short-circuit +
+ * validateFormBuilderMPush contract (Classic.js:1397-1405, 1473-1522).
+ */
+import runSubmitPipeline from '../runSubmitPipeline';
+import { validateMobilePushContent } from '../../../../../../utils/commonUtils';
+
+jest.mock('../../../../../../utils/commonUtils', () => ({
+  validateMobilePushContent: jest.fn(),
+}));
+
+const legacy = { 'template-name': 'p', 0: { 'message-editor': 'a' }, 1: {} };
+
+const buildCallbacks = () => ({
+  onSubmit: jest.fn(),
+  pushFooter: jest.fn(),
+  stopValidation: jest.fn(),
+  onFormValidityChange: jest.fn(),
+});
+
+describe('channels/mobilepush/runSubmitPipeline', () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it('full mode submits the raw legacy formData directly — no liquid validation', () => {
+    const callbacks = buildCallbacks();
+    runSubmitPipeline(legacy, { isFullMode: true, getLiquidTags: jest.fn() }, callbacks);
+    expect(callbacks.onSubmit).toHaveBeenCalledWith(legacy);
+    expect(validateMobilePushContent).not.toHaveBeenCalled();
+  });
+
+  it('library mode without getLiquidTags also submits directly', () => {
+    const callbacks = buildCallbacks();
+    runSubmitPipeline(legacy, { isFullMode: false }, callbacks);
+    expect(callbacks.onSubmit).toHaveBeenCalledWith(legacy);
+    expect(validateMobilePushContent).not.toHaveBeenCalled();
+  });
+
+  it('library mode runs the liquid pipeline; singleTab is upper-cased; success submits the FULL formData', () => {
+    const callbacks = buildCallbacks();
+    runSubmitPipeline(legacy, {
+      isFullMode: false, getLiquidTags: jest.fn(), singleTab: 'android', currentTab: 1,
+    }, callbacks);
+    const options = validateMobilePushContent.mock.calls[0][1];
+    expect(options.singleTab).toBe('ANDROID');
+    options.onSuccess('{"ignored":"single-tab json"}', 'android');
+    expect(callbacks.onSubmit).toHaveBeenCalledWith(legacy); // contentToSubmit IGNORED
+    expect(callbacks.pushFooter).toHaveBeenCalledWith({ STANDARD_ERROR_MSG: [], LIQUID_ERROR_MSG: [] });
+  });
+
+  it('error callback forwards the nested per-platform objects AS-IS, stops validation, and blocks the save', () => {
+    const callbacks = buildCallbacks();
+    runSubmitPipeline(legacy, { isFullMode: false, getLiquidTags: jest.fn() }, callbacks);
+    const options = validateMobilePushContent.mock.calls[0][1];
+    const standardErrors = { ANDROID: ['bad tag'], IOS: [], generic: [] };
+    options.onError({ standardErrors, liquidErrors: [] });
+    expect(callbacks.pushFooter).toHaveBeenCalledWith({ STANDARD_ERROR_MSG: standardErrors, LIQUID_ERROR_MSG: [] });
+    expect(callbacks.stopValidation).toHaveBeenCalled();
+    expect(callbacks.onFormValidityChange).toHaveBeenCalledWith(false);
+    expect(callbacks.onSubmit).not.toHaveBeenCalled();
+    expect(options.singleTab).toBeUndefined(); // no modal => both platforms validate
+  });
+
+  it('tolerates missing callbacks (every callback is optional)', () => {
+    runSubmitPipeline(legacy, { isFullMode: false, getLiquidTags: jest.fn() }, {});
+    const options = validateMobilePushContent.mock.calls[0][1];
+    expect(() => options.onError({ standardErrors: [], liquidErrors: [] })).not.toThrow();
+    expect(() => options.onSuccess('x')).not.toThrow();
+    expect(() => runSubmitPipeline(legacy, { isFullMode: true }, {})).not.toThrow();
+  });
+});