@designcrowd/library.brand-page 6.2.11 → 6.2.12

package/lib/src/metadata-builder/builders/section-field-utils.js

@@ -1,7 +1,11 @@
 import { BUTTON_LINK_TYPE } from '../../brand-page/models';
+import { normalizeTextStyleAgainstRole, omitTypography, } from '../../brand-page/utils/text-style.util';
+import { computeLegacyTargets, contentFieldReconnectSpec, isCanonicalTextStyleType, reconnectTextStyle, } from '../../brand-page/utils/text-role-reconnect.util';
 import { isTiptapDocument, } from '../parsers/section-tool-arguments';
 import { hasRTEContent } from '../../brand-page-maker/utils';
 import { useExternalRichTextEditor } from '../../brand-page-maker/composables/rich-text-editor/useRichTextEditor';
+import { relinkDocToRole } from '../../brand-page-maker/utils/rich-text-editor.util';
+import { docHasColourableRun, setRteTextColor, } from '../../shared/color-strategies/rte-color';
 import { applyStyleToRTEText } from '../helpers/rte.helpers';
 import { getSectionFieldMap, getStyleFieldMap } from './section-field-maps';
 const isUrlField = (aiKey) => aiKey.endsWith('_url');
@@ -58,6 +62,13 @@ export const applyScalarFields = (content, args, sectionType) => {
 /**
  * Convert AI-sent style value to the format expected by the model.
  * - letterSpacing: unitless 0-100 → em string (e.g., 50 → '0.5em')
+ * - lineHeight: coerced to a plain numeric string, UNSNAPPED — snapping here would shift a
+ *   value that's actually equal to its role (e.g. 1.25) off that equality before
+ *   `applyAiStyle` gets a chance to drop it as a role-equal non-override (R2). Only a value
+ *   that survives the role-equal check is snapped (`snapLineHeight`, in `applyAiStyle`), and the
+ *   drop runs AGAIN after snapping: a role can itself hold a non-grid value (e.g. heading3's
+ *   native 1.25), so comparing before snapping catches an exact match at full precision, and
+ *   re-comparing after catches a snap that LANDS the override exactly on the role's value.
  * - null → '' (explicitly clear/reset the property)
  * - everything else passes through as-is
  */
@@ -70,56 +81,116 @@ export const normalizeStyleValue = (key, value) => {
         return `${value / 100}em`;
     }
     if (key === 'lineHeight') {
-        // Snap to 0.1 increments to match the UI slider step
         const num = typeof value === 'number' ? value : parseFloat(String(value));
         if (!isNaN(num))
-            return String(Math.floor(num * 10) / 10);
+            return String(num);
     }
     return value;
 };
+/** Snap a line-height value to the UI slider's 0.1 step. Pure — returns a new object. */
+const snapLineHeight = (style) => {
+    const { lineHeight } = style;
+    if (typeof lineHeight !== 'string')
+        return style;
+    const num = parseFloat(lineHeight);
+    if (isNaN(num))
+        return style;
+    return { ...style, lineHeight: String(Math.floor(num * 10) / 10) };
+};
+/**
+ * Whether this call is a REAL canonical switch (R19): both the stored and the INCOMING role (the
+ * raw value the call sent, before any reconnect fallback) are canonical, and differ. Decided once
+ * from `incoming.textStyleType` and shared by `applyAiStyle` (which resets the style object) and
+ * the caller of `applyStoredDocStyleConsequences` (which resets the stored doc), so both agree: a
+ * retired-key call reconnects in `applyAiStyle` (not a switch — it keeps the look as overrides) but
+ * can still land on a canonical role that differs from the stored one, which deriving it from the
+ * RESULT instead would misread as a switch and relink a doc whose overrides were meant to survive.
+ */
+export const isRealCanonicalSwitch = (existingRole, incomingRole) => isCanonicalTextStyleType(existingRole) &&
+    isCanonicalTextStyleType(incomingRole) &&
+    incomingRole !== existingRole;
 /**
- * When an executor is about to mark a content-level text style "custom" by
- * clearing `textStyleType`, the resolved preset values (font, size, spacing,
- * etc.) must first be copied onto the style — otherwise the renderer falls
- * back to browser defaults because `textStyleType` no longer points at a
- * preset.
+ * Apply an AI-sent style to a field, honouring the role model under partial-update semantics
+ * (a property present = update; absent = no change).
  *
- * The category is read from the existing `style.textStyleType`, which is the
- * authoritative per-section + per-field reference set by the content factory.
- * Existing style values win over preset defaults (the content may already
- * carry user overrides on top of the preset).
+ * The role is the EFFECTIVE one — `incoming.textStyleType ?? existing.textStyleType` — so a sparse
+ * update that omits the role KEEPS the element's current role. When that role is canonical, keep
+ * the link and store a sparse override: incoming props layer on and `normalizeTextStyleAgainstRole`
+ * drops any prop equal to the role, so the page-scoped role CSS drives it and a later global edit
+ * repaints the block.
+ *
+ * A REAL canonical switch (both the old and the new role are canonical, and differ — R19) is a
+ * reset, not a patch: it starts from `omitTypography(existing)` before layering this call's own
+ * style on top, so a stale override from the old role doesn't survive as a bogus override of the
+ * new one. Colour, background, alignment and `applyAutoScale` aren't typography, so they carry
+ * over untouched; the call's own text and overrides win (they're applied after the reset).
+ *
+ * Any other role — a retired key the pipeline still emits, `none`, or no role at all — reconnects
+ * the way the upgrade does (`reconnectTextStyle`, with the field's `spec`): its starting role, else
+ * the retired role's successor, else the role nearest its size, keeping its look as overrides.
  */
-export const resolveGlobalPresetIntoStyle = (style, textStyleOptions) => {
-    const base = { ...(style ?? {}) };
-    const currentTextStyleType = base.textStyleType;
-    if (!currentTextStyleType || !textStyleOptions?.[currentTextStyleType]) {
-        base.textStyleType = undefined;
-        return base;
-    }
-    const presetStyle = textStyleOptions[currentTextStyleType].style;
-    const presetDefaults = {};
-    for (const [k, v] of Object.entries(presetStyle)) {
-        if (k === 'textStyleType' || v === undefined)
-            continue;
-        presetDefaults[k] = v;
+export const applyAiStyle = (existing, incoming, textStyleOptions, spec = {}) => {
+    const existingRole = existing
+        ?.textStyleType;
+    const role = incoming.textStyleType ?? existingRole;
+    const base = isRealCanonicalSwitch(existingRole, incoming.textStyleType)
+        ? omitTypography(existing ?? {})
+        : (existing ?? {});
+    const merged = { ...base, ...incoming, textStyleType: role };
+    if (isCanonicalTextStyleType(role)) {
+        const normalized = normalizeTextStyleAgainstRole(merged, textStyleOptions);
+        // Snap and re-check only a lineHeight that is BOTH this call's own (not one inherited
+        // untouched from the stored style — an unrelated patch must not silently rewrite it) AND
+        // survived the first role-equal pass as a genuine override.
+        if ('lineHeight' in incoming && 'lineHeight' in normalized) {
+            return normalizeTextStyleAgainstRole(snapLineHeight(normalized), textStyleOptions);
+        }
+        return normalized;
     }
-    return { ...presetDefaults, ...base, textStyleType: undefined };
+    return reconnectTextStyle(merged, computeLegacyTargets(textStyleOptions), textStyleOptions, spec);
 };
 /**
- * Applies per-element style overrides while detaching the element from any
- * global text-style preset. When a style is bound to a `textStyleType` preset,
- * the renderer (`getCopyrightTextStyle` / `getTextStyleByContentTextStyle`)
- * replaces the whole style with that preset and discards per-element values such
- * as `fontFamily`. Resolving the preset in and clearing `textStyleType` makes the
- * override stick — the same disconnect rule section content follows.
+ * BP-5969 (R18, R19) — what a style-only patch (no new text in the same call) does to an already-
+ * stored RTE doc. A real role switch relinks every run to the new role (the document-level half of
+ * the reset `applyAiStyle` already gave the style object above), keeping any typography the call's
+ * own `nextStyle` still overrides via `relinkDocToRole`'s `styleOverrides` arg. A colour-only patch,
+ * OR a colour riding along with a switch in the same call (James Joung, 2026-10-01: a role switch
+ * and a recolour with no text both apply), recolours every run and clears the now-redundant style
+ * colour (kept only when the doc has no run to hold it — an empty field's colour waits for the
+ * maker's first keystroke, `buildInitialMarks`). Both consequences can apply to one call: the
+ * switch's relink runs first, then the colour branch recolours the relinked doc.
  *
- * Idempotent: once `textStyleType` is cleared, subsequent calls just merge the
- * updates without re-resolving a preset.
+ * No-op for anything but a stored Tiptap document — a legacy HTML string is handled by the caller's
+ * own `ApplyColorToRTE` rewrite instead.
  */
-export const applyDetachedStyleOverride = (current, updates, textStyleOptions) => ({
-    ...resolveGlobalPresetIntoStyle(current, textStyleOptions),
-    ...updates,
-});
+export const applyStoredDocStyleConsequences = (existingText, existingRole, nextStyle, incomingStyle, textStyleOptions) => {
+    if (!isTiptapDocument(existingText))
+        return existingText;
+    // Decided from the call's own RAW textStyleType (via isRealCanonicalSwitch), the same test
+    // applyAiStyle already made for the style object, not re-derived from nextStyle.textStyleType:
+    // a retired-key call reconnects (not a switch) in applyAiStyle but can still land on a canonical
+    // role that differs from the stored one, which re-deriving from the RESULT would misread as a
+    // switch. When it IS a real switch, nextStyle.textStyleType equals incomingStyle.textStyleType.
+    const isRealSwitch = isRealCanonicalSwitch(existingRole, incomingStyle.textStyleType);
+    const nextRole = nextStyle.textStyleType;
+    let text = existingText;
+    if (isRealSwitch) {
+        const roleStyle = textStyleOptions?.[nextRole]
+            ?.style;
+        text = relinkDocToRole(text, roleStyle, nextStyle);
+    }
+    const newColor = incomingStyle.color;
+    if (typeof newColor === 'string' &&
+        newColor &&
+        docHasColourableRun(text)) {
+        const recoloured = setRteTextColor(text, newColor);
+        if (recoloured) {
+            delete nextStyle.color;
+            return recoloured;
+        }
+    }
+    return text;
+};
 export const applyStyleFields = (content, args, sectionType, textStyleOptions, applyColor) => {
     const styleMap = getStyleFieldMap(sectionType);
     if (!styleMap)
@@ -144,27 +215,32 @@ export const applyStyleFields = (content, args, sectionType, textStyleOptions, a
                 if (normalized !== undefined)
                     filtered[k] = normalized;
             }
-            const resolved = resolveGlobalPresetIntoStyle(content[modelKey], textStyleOptions);
-            record[modelKey] = { ...resolved, ...filtered, textStyleType: undefined };
-            // A colour patch without new text leaves the field's EXISTING inline
-            // textStyle marks in place — and inline marks override every style layer
-            // at render, so the old colour survives on a recoloured band (invisible
-            // text, AI QA 2026-07-05 rerun). Propagate the new colour into the
-            // stored HTML, mirroring global-font-propagation for font families.
+            const existingStyle = content[modelKey];
+            const existingRole = existingStyle?.textStyleType;
+            record[modelKey] = applyAiStyle(existingStyle, filtered, textStyleOptions, contentFieldReconnectSpec(sectionType, modelKey));
+            // A style-only patch (no new text in this call) leaves the field's EXISTING inline
+            // textStyle marks in place — and inline marks override every style layer at render, so the
+            // old look survives a recoloured band (invisible text, AI QA 2026-07-05 rerun) or a role
+            // switch (the overrides reset above, but the stored doc's runs don't follow on their own).
+            // Propagate the consequence into the stored text, mirroring global-role-propagation.
             const textKey = modelKey.endsWith('Style')
                 ? modelKey.slice(0, -'Style'.length)
                 : undefined;
             const textAiKey = aiKey.endsWith('_style')
                 ? aiKey.slice(0, -'_style'.length)
                 : undefined;
-            const newColor = filtered.color;
-            if (textKey &&
-                typeof newColor === 'string' &&
-                newColor &&
-                !(textAiKey && textAiKey in args) &&
-                typeof record[textKey] === 'string' &&
-                hasRTEContent(record[textKey])) {
-                record[textKey] = applyColorToHtml(record[textKey], newColor);
+            const textSentThisCall = !!(textAiKey && textAiKey in args);
+            if (textKey && !textSentThisCall) {
+                const existingText = record[textKey];
+                if (isTiptapDocument(existingText)) {
+                    record[textKey] = applyStoredDocStyleConsequences(existingText, existingRole, record[modelKey], filtered, textStyleOptions);
+                }
+                else if (typeof filtered.color === 'string' &&
+                    filtered.color &&
+                    typeof existingText === 'string' &&
+                    hasRTEContent(existingText)) {
+                    record[textKey] = applyColorToHtml(existingText, filtered.color);
+                }
             }
         }
     }

package/lib/src/metadata-builder/builders/section-rules/global-styles.rules.d.ts

@@ -1,6 +1,8 @@
-import type { UpdateGlobalStylesArguments } from '../../parsers/ai-toolcall-parser';
-import type { TextStyleType } from '../../../brand-page/models/styles.model';
+import type { UpdateGlobalStylesArguments, TextStyleOptionStyle } from '../../parsers/ai-toolcall-parser';
+import { type TextStyleType } from '../../../brand-page/models/styles.model';
 export declare const TEXT_STYLE_OPTION_KEYS: TextStyleType[];
+/** Role definitions accept numeric wire values but store their canonical string representation. */
+export declare const normalizeGlobalTextStyleOption: (style: TextStyleOptionStyle) => TextStyleOptionStyle;
 type GlobalStyleCheck = (args: UpdateGlobalStylesArguments) => string | null;
 export declare const GLOBAL_STYLE_CHECKS: GlobalStyleCheck[];
 export {};

package/lib/src/metadata-builder/builders/section-rules/global-styles.rules.js

@@ -1,26 +1,42 @@
-import { STYLE_RULES } from '../../sanitizers/sanitizer-rules';
+import { CANONICAL_TEXT_STYLE_TYPES, LEGACY_TEXT_STYLE_TYPES, } from '../../../brand-page/models/styles.model';
 import { validateStringStyleAttrs } from '../../sanitizers/section-args-validator';
 export const TEXT_STYLE_OPTION_KEYS = [
-    'titles',
-    'headings',
-    'paragraphs',
-    'buttons',
+    ...CANONICAL_TEXT_STYLE_TYPES,
+    ...LEGACY_TEXT_STYLE_TYPES,
 ];
+/** Role definitions accept numeric wire values but store their canonical string representation. */
+export const normalizeGlobalTextStyleOption = (style) => {
+    const normalized = { ...style };
+    const lineHeight = style.lineHeight;
+    const fontWeight = style.fontWeight;
+    if (typeof lineHeight === 'number' && !isNaN(lineHeight)) {
+        normalized.lineHeight = String(lineHeight);
+    }
+    else if (lineHeight != null) {
+        const value = parseFloat(String(lineHeight).trim());
+        if (!isNaN(value) && String(lineHeight).trim() !== String(value)) {
+            normalized.lineHeight = String(value);
+        }
+    }
+    if (typeof fontWeight === 'number' && !isNaN(fontWeight)) {
+        normalized.fontWeight = String(fontWeight);
+    }
+    return normalized;
+};
 export const GLOBAL_STYLE_CHECKS = [
-    // textFontFamily: must be a recognized camelCase font key (e.g. 'playfairDisplay')
     (args) => {
-        const font = args.textStyles?.textFontFamily;
-        if (font == null)
+        const keepRuns = args.textStyles?.keepRuns;
+        if (keepRuns == null)
             return null;
-        return !STYLE_RULES.fontFamilyKeys.has(font)
-            ? `"textFontFamily" "${font}" is not a recognized font family key`
+        return !Array.isArray(keepRuns) ||
+            keepRuns.some((run) => typeof run !== 'string')
+            ? `"textStyles.keepRuns" must be an array of strings`
             : null;
     },
-    // textStyleOptions[category].style — fontSize, fontFamily, lineHeight, letterSpacing
     ...TEXT_STYLE_OPTION_KEYS.map((category) => (args) => {
         const style = args.textStyles?.textStyleOptions?.[category]?.style;
         if (!style)
             return null;
-        return validateStringStyleAttrs(`textStyleOptions.${category}.style`, style);
+        return validateStringStyleAttrs(`textStyleOptions.${category}.style`, normalizeGlobalTextStyleOption(style));
     }),
 ];

package/lib/src/metadata-builder/builders/section-rules/social-links.rules.js

@@ -1,7 +1,11 @@
 import { SOCIAL_LINKS_ICON_DISPLAY_STYLES } from '../../../brand-page/models';
-import { enumCheck, itemCapCheck, runChecks, } from '../../sanitizers/section-args-validator';
+import { MAX_TITLE_LENGTH } from '../../../brand-page/constants/font.constants';
+import { enumCheck, itemCapCheck, runChecks, styleCheck, } from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
 const CHECKS = [
+    ...textAndRteChecks('title', MAX_TITLE_LENGTH),
     enumCheck('icon_style', Object.keys(SOCIAL_LINKS_ICON_DISPLAY_STYLES), 'social-links'),
+    styleCheck('title_style'),
     itemCapCheck({ brandSite: 4, brandPage: 4, arrayField: 'links' }, 'social-links'),
 ];
 export function validateSocialLinks(args, ctx) {

package/lib/src/metadata-builder/helpers/rte.helpers.d.ts

@@ -6,7 +6,7 @@ import type { Editor } from '@tiptap/vue-3';
  * chains. DOM-bound — client-only callers (font propagation, section style
  * fields).
  */
-export declare const applyStyleToRTEText: (externalEditor: Editor, contentText: string, newContentStyle: TextStyleDeclaration) => string;
+export declare const applyStyleToRTEText: (externalEditor: Editor, contentText: string, newContentStyle: TextStyleDeclaration, keepRuns?: readonly string[]) => string;
 /**
  * Converts a Tiptap JSON document (ProseMirror document model) to an HTML
  * string via Tiptap's schema-driven static renderer (renderRteToHtml →

package/lib/src/metadata-builder/helpers/rte.helpers.js

@@ -1,14 +1,17 @@
-import { renderRteToHtml, getRTEColor } from '../../brand-page-maker/utils';
+import { renderRteToHtml } from '@shared/rte-render.util';
+import { getRTEColor, isRoleVarRef, restoreLinkUnderlines, } from '../../brand-page-maker/utils';
 import { getRenderText } from '../../brand-page/utils';
 import { ESCAPED_NEWLINE_CHARACTER } from '../../constants/ui';
 import { isTiptapDocument } from '../parsers/section-tool-arguments';
+// A kept phrase matches whole words only: "Taste" must not keep the start of "Tasteful".
+const isWordChar = (char) => char !== undefined && /[\p{L}\p{N}_]/u.test(char);
 /**
  * Applies a TextStyleDeclaration to RTE HTML by loading it into the given
  * (external/headless) Tiptap editor and rewriting inline marks via command
  * chains. DOM-bound — client-only callers (font propagation, section style
  * fields).
  */
-export const applyStyleToRTEText = (externalEditor, contentText, newContentStyle) => {
+export const applyStyleToRTEText = (externalEditor, contentText, newContentStyle, keepRuns) => {
     if (!contentText) {
         return contentText;
     }
@@ -16,47 +19,101 @@ export const applyStyleToRTEText = (externalEditor, contentText, newContentStyle
         ? getRenderText(contentText)
         : contentText;
     externalEditor.commands.setContent(content);
-    let chain = externalEditor.chain().selectAll();
-    if (newContentStyle?.fontFamily) {
-        chain = chain.setFontFamily(newContentStyle.fontFamily);
+    const kept = new Set(keepRuns?.map((text) => text.trim().toLowerCase()).filter(Boolean));
+    const apply = (from, to) => {
+        let chain = from === 0
+            ? externalEditor.chain().selectAll()
+            : externalEditor.chain().setTextSelection({ from, to });
+        if (newContentStyle?.fontFamily) {
+            chain = chain.setFontFamily(newContentStyle.fontFamily);
+        }
+        if (newContentStyle?.fontSize) {
+            chain = chain.setFontSize(newContentStyle.fontSize);
+        }
+        if (newContentStyle?.letterSpacing) {
+            chain = chain.setLetterSpacing(newContentStyle.letterSpacing);
+        }
+        if (newContentStyle?.lineHeight) {
+            chain = chain.setLineHeight(newContentStyle.lineHeight);
+        }
+        if (newContentStyle?.color) {
+            chain = chain.setMark('textStyle', {
+                color: getRTEColor(newContentStyle.color, 'text'),
+            });
+        }
+        if ('backgroundColor' in (newContentStyle || {})) {
+            chain = newContentStyle.backgroundColor
+                ? chain.setMark('highlight', {
+                    color: getRTEColor(newContentStyle.backgroundColor, 'background'),
+                })
+                : chain.unsetHighlight();
+        }
+        if (newContentStyle?.textAlign) {
+            chain = chain.setTextAlign(newContentStyle.textAlign);
+        }
+        // Emphasis is touched only when the style names it: a colour-only rewrite keeps every
+        // <strong>/<em>/<u>/<s>. A role ref replaces the competing marks, as the JSON relink does.
+        const { fontWeight, fontStyle, textDecoration } = newContentStyle ?? {};
+        if (newContentStyle && 'textDecoration' in newContentStyle) {
+            chain = textDecoration?.includes('line-through')
+                ? chain.setStrike()
+                : chain.unsetStrike();
+            chain = textDecoration?.includes('underline')
+                ? chain.setUnderline()
+                : chain.unsetUnderline();
+            if (isRoleVarRef(textDecoration))
+                chain = chain.setTextDecoration(textDecoration);
+        }
+        if (newContentStyle && 'fontWeight' in newContentStyle) {
+            chain = fontWeight === 'bold' ? chain.setBold() : chain.unsetBold();
+            if (isRoleVarRef(fontWeight))
+                chain = chain.setFontWeight(fontWeight);
+        }
+        if (newContentStyle && 'fontStyle' in newContentStyle) {
+            chain = fontStyle === 'italic' ? chain.setItalic() : chain.unsetItalic();
+            if (isRoleVarRef(fontStyle))
+                chain = chain.setFontStyle(fontStyle);
+        }
+        chain.command(restoreLinkUnderlines(externalEditor)).run();
+    };
+    if (!kept.size) {
+        apply(0, externalEditor.state.doc.content.size);
+        return externalEditor.getHTML();
     }
-    if (newContentStyle?.fontSize) {
-        chain = chain.setFontSize(newContentStyle.fontSize);
-    }
-    if (newContentStyle?.letterSpacing) {
-        chain = chain.setLetterSpacing(newContentStyle.letterSpacing);
-    }
-    if (newContentStyle?.lineHeight) {
-        chain = chain.setLineHeight(newContentStyle.lineHeight);
-    }
-    if (newContentStyle?.color) {
-        chain = chain.setMark('textStyle', {
-            color: getRTEColor(newContentStyle.color, 'text'),
+    const nodes = [];
+    externalEditor.state.doc.descendants((node, pos) => {
+        if (!node.isText || !node.text)
+            return;
+        nodes.push({
+            from: pos,
+            text: node.text,
         });
+    });
+    for (const node of nodes) {
+        const text = node.text.toLowerCase();
+        const ranges = [];
+        kept.forEach((keptText) => {
+            let start = text.indexOf(keptText);
+            while (start !== -1) {
+                const end = start + keptText.length;
+                const isWholeWords = !isWordChar(text[start - 1]) && !isWordChar(text[end]);
+                if (isWholeWords)
+                    ranges.push([start, end]);
+                start = text.indexOf(keptText, isWholeWords ? end : start + 1);
+            }
+        });
+        ranges.sort(([left], [right]) => left - right);
+        let offset = 0;
+        for (const [start, end] of ranges) {
+            if (offset < start) {
+                apply(node.from + offset, node.from + start);
+            }
+            offset = Math.max(offset, end);
+        }
+        if (offset < node.text.length) {
+            apply(node.from + offset, node.from + node.text.length);
+        }
     }
-    if ('backgroundColor' in (newContentStyle || {})) {
-        chain = newContentStyle.backgroundColor
-            ? chain.setMark('highlight', {
-                color: getRTEColor(newContentStyle.backgroundColor, 'background'),
-            })
-            : chain.unsetHighlight();
-    }
-    if (newContentStyle?.textAlign) {
-        chain = chain.setTextAlign(newContentStyle.textAlign);
-    }
-    const hasStrike = newContentStyle?.textDecoration?.includes('line-through');
-    const hasUnderline = newContentStyle?.textDecoration?.includes('underline');
-    chain = hasStrike ? chain.setStrike() : chain.unsetStrike();
-    chain = hasUnderline ? chain.setUnderline() : chain.unsetUnderline();
-    chain =
-        newContentStyle?.fontWeight === 'bold'
-            ? chain.setBold()
-            : chain.unsetBold();
-    chain =
-        newContentStyle?.fontStyle === 'italic'
-            ? chain.setItalic()
-            : chain.unsetItalic();
-    chain.run();
     return externalEditor.getHTML();
 };
 /**

package/lib/src/metadata-builder/metadata-executor.js

@@ -1,6 +1,7 @@
 import cloneDeep from 'lodash.clonedeep';
 import {} from '../brand-page/models';
 import { referencifyModelColors } from '../brand-page/utils/color-palette-referencify.util';
+import { applyTextContrast } from '../brand-page/utils/container-text-color.util';
 import { BUILDER_TYPES, } from './models';
 import { BannerSectionBuilder, BookingSectionBuilder, SupportMeBuilder, AboutSectionBuilder, ContactFormBuilder, DividerSectionBuilder, TextSectionBuilder, TestimonialSectionBuilder, ImagesSectionBuilder, ShapesSectionBuilder, SocialLinksBuilder, ImageGalleryBuilder, ProfileSectionBuilder, MailingListSectionBuilder, ButtonSectionBuilder, DeleteSectionBuilder, MoveSectionBuilder, } from './builders/section-builders';
 import { AddPageBuilder } from './builders/add-page-builder';
@@ -12,6 +13,26 @@ import { FooterBuilder } from './builders/footer-builder';
 import { GlobalStylesBuilder } from './builders/global-styles-builder';
 import { HeaderBuilder } from './builders/header-builder';
 import { UndoBuilder } from './builders/undo-builder';
+/**
+ * BP-5969 (ADR-0020): bake a birth-time contrast colour into an uncoloured section's text so
+ * the AI path matches the maker's Add path (which bakes via `applyTextContrast` in
+ * `addItemByType`). Runs AFTER referencify, so section surfaces are palette refs the
+ * contrast resolver can read. Limited to `touchedContentIds` (the sections this call's own
+ * requests created or updated, via each result's `contentId`) — sweeping every section on every
+ * apply follows the prompt for sections it never touched too, recolouring content the call
+ * didn't ask about and re-writing RTE style objects a migration had already stripped. Mutates
+ * `model` in place and returns it.
+ */
+const bakeContrastAcrossModel = (model, touchedContentIds) => {
+    model.pages?.forEach((page) => {
+        page.contents?.forEach((content) => {
+            if (content.id && touchedContentIds.has(content.id)) {
+                applyTextContrast(content, model.styles, model.brandPageType);
+            }
+        });
+    });
+    return model;
+};
 // Lazy initialization to avoid circular dependency issues
 const getBuilderRegistry = () => ({
     // Section builders (create)
@@ -127,6 +148,7 @@ export class MetadataExecutor {
             results.push(result);
             model = result.model;
         }
+        const touchedContentIds = new Set(results.flatMap((result) => (result.contentId ? [result.contentId] : [])));
         return {
             // The inbound half of the AI colour bridge. The AI answers in literals (it
             // was sent literals — see `minifyBrandPageMetadata`) and migration-21 is
@@ -134,7 +156,7 @@ export class MetadataExecutor {
             // half hex, and editing a palette role silently skips every section the AI
             // touched. Mutates `model` in place — minting into `model.styles.colors` — and
             // returns it; touches no store.
-            model: referencifyModelColors(model),
+            model: bakeContrastAcrossModel(referencifyModelColors(model), touchedContentIds),
             results,
         };
     }

package/lib/src/metadata-builder/models.d.ts

@@ -84,6 +84,8 @@ export interface BuilderResult {
     request: MetadataBuilderRequest;
     model: BrandPageModel;
     errors?: string[];
+    /** Non-failing feedback for an accepted tool call that dropped unsupported input. */
+    warnings?: string[];
     /**
      * Set by the UndoBuilder to signal that the caller should restore the
      * website to the snapshot taken before the most recent change-producing

package/lib/src/metadata-builder/parsers/ai-toolcall-parser.d.ts

@@ -1,6 +1,7 @@
 import type { AiAssistantToolCall } from '../../clients/ai-assistant-client';
 import type { FooterDisplayStyle, HeaderDisplayStyle, NavigationDisplayType } from '../../brand-page/constants';
 import type { SectionType, TextStyleArguments } from './section-tool-arguments';
+import type { TextStyleType } from '../../brand-page/models';
 export declare const AI_ASSISTANT_TOOL_NAMES: {
     readonly BUILD_PROFILE_SECTION: "build_profile_section";
     readonly BUILD_TEXT_SECTION: "build_text_section";
@@ -135,6 +136,11 @@ export interface UpdateFooterArguments {
     /** Mobile-only styling (display_style, background_color, icon_color, is_logo_visible, logo sizes). */
     mobile?: ViewportFooterOverrides;
 }
+/**
+ * A role's typography patch. A sent `fontWeight` / `fontStyle` / `textDecoration` relinks the
+ * role's existing content even when it equals the stored role (the pipeline sends them only when
+ * the user asked); the other properties relink only when they change (`global-role-propagation`).
+ */
 export interface TextStyleOptionStyle {
     fontFamily?: string;
     fontSize?: string;
@@ -164,25 +170,18 @@ export interface UpdateGlobalStylesArguments {
         style?: {
             color?: string;
         };
-        textFontFamily?: string;
-        textStyleOptions?: {
-            titles?: {
-                style?: TextStyleOptionStyle;
-                isModified?: boolean;
-            };
-            headings?: {
-                style?: TextStyleOptionStyle;
-                isModified?: boolean;
-            };
-            paragraphs?: {
-                style?: TextStyleOptionStyle;
-                isModified?: boolean;
-            };
-            buttons?: {
-                style?: TextStyleOptionStyle;
-                isModified?: boolean;
-            };
-        };
+        /** Retired — accepted from the pipeline but ignored (`0036-retire-text-font-family.md`). */
+        textFontFamily?: unknown;
+        textStyleOptions?: Partial<Record<TextStyleType, {
+            style?: TextStyleOptionStyle;
+            isModified?: boolean;
+        }>>;
+        /**
+         * BP-5969 (R16) — the run texts the user explicitly asked to keep during this site-wide
+         * change. The library skips relinking a run or a plain field whose trimmed text matches one
+         * of these, case-insensitively; every other run of the changed role/property still relinks.
+         */
+        keepRuns?: string[];
     };
     buttonStyles?: {
         style?: {