@designcrowd/library.brand-page 6.2.11-builder-v2-1 → 6.2.12

package/lib/src/shared/publish-brand-page-with-state/PublishBrandPageModalWithState.mixin.d.ts

@@ -70,6 +70,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             isVariation: boolean;
             isExcluded: boolean;
         } | undefined;
+        bp_6136_v2_ai_builder?: {
+            key: string;
+            value: string;
+            isControl: boolean;
+            isVariation: boolean;
+            isExcluded: boolean;
+        } | undefined;
     }>;
     brandPageType: import("vue").ComputedRef<"default" | "brandSite" | "brandContact">;
     isSubsequentPublish: import("vue").ComputedRef<boolean>;
@@ -125,6 +132,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         setHideBranding(payload: {
             hideBranding: boolean;
         }): void;
+        setSaveContactButtonTextStyle(payload: {
+            buttonTextStyle: import("../../brand-page").SaveContactOptions["buttonTextStyle"];
+        }): void;
         setSensitiveContent(payload: {
             sensitiveContent: string;
         }): void;
@@ -187,7 +197,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             brandPageType: import("../../brand-page").BrandPageType;
         }): void;
         initialiseStoresByBrandPageModelAsync(brandPageModel: import("../../brand-page").BrandPageModel): Promise<void>;
-        initialise({ brandPage, brandPageType, logoDraftDesignAttributes, unsplashApplicationName, templateCategories, personalisationData, isPersonalisationEnabled, userPromptContentKey, showAiTemplatesTab, businessName, industry, layout, logoVariationImageUrls, shopConfigData: _shopConfigData, isServerRenderOverride, }: import("@brand-page-maker/stores").InitialisePayload): Promise<void>;
+        initialise({ brandPage, brandPageType, logoDraftDesignAttributes, unsplashApplicationName, templateCategories, personalisationData, isPersonalisationEnabled, userPromptContentKey, showAiTemplatesTab, businessName, industry, layout, logoVariationImageUrls, shopConfigData: _shopConfigData, isServerRenderOverride, isBlankSite, }: import("@brand-page-maker/stores").InitialisePayload): Promise<void>;
         initialisePages({ pages, sections, }: {
             pages: import("../../brand-page").PageModel[];
             sections: import("../page-settings/store").PageSettingsStateSections;
@@ -287,6 +297,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     isVariation: boolean;
                     isExcluded: boolean;
                 } | undefined;
+                bp_6136_v2_ai_builder?: {
+                    key: string;
+                    value: string;
+                    isControl: boolean;
+                    isVariation: boolean;
+                    isExcluded: boolean;
+                } | undefined;
             };
             isSubsequentPublish: boolean;
             isContextualUpgradeModalVisible: boolean;
@@ -362,6 +379,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     isVariation: boolean;
                     isExcluded: boolean;
                 } | undefined;
+                bp_6136_v2_ai_builder?: {
+                    key: string;
+                    value: string;
+                    isControl: boolean;
+                    isVariation: boolean;
+                    isExcluded: boolean;
+                } | undefined;
             };
             isSubsequentPublish: boolean;
             isContextualUpgradeModalVisible: boolean;
@@ -437,6 +461,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     isVariation: boolean;
                     isExcluded: boolean;
                 } | undefined;
+                bp_6136_v2_ai_builder?: {
+                    key: string;
+                    value: string;
+                    isControl: boolean;
+                    isVariation: boolean;
+                    isExcluded: boolean;
+                } | undefined;
             };
             isSubsequentPublish: boolean;
             isContextualUpgradeModalVisible: boolean;

package/lib/src/shared/rte-extensions/AutoLink.d.ts

@@ -0,0 +1,17 @@
+import { Extension } from '@tiptap/core';
+import type { EditorState } from 'prosemirror-state';
+import type { Mark } from 'prosemirror-model';
+/** A transaction carrying this meta skips the new-link styling pass below: a clipboard paste
+ * brings its own look (a copied link keeps its colour; a text-only paste brings no links), so
+ * neither wants AutoLink's "force blue + underline" treatment for a newly-created link. */
+export declare const AUTO_LINK_SKIP_STYLING_META = "autoLinkSkipStyling";
+/**
+ * The end-of-link detach a typed character gets right after a link's last position: the link
+ * mark (and its auto-blue colour, unless the user manually added an underline) drops from what
+ * comes next, so continuing to type doesn't extend the link. `null` when `pos` isn't at the end
+ * of a link — mid-link, or no link at all — so the caller keeps its own marks unchanged.
+ * Exported for `RteClipboard.ts`'s text-only paste, which takes the same detach a typed
+ * character would.
+ */
+export declare const linkDetachMarksAt: (state: EditorState, pos: number) => Mark[] | null;
+export declare const AutoLink: Extension<any, any>;

package/lib/src/{brand-page-maker/composables/rich-text-editor/extensions → shared/rte-extensions}/AutoLink.js

@@ -1,6 +1,10 @@
 import { Extension } from '@tiptap/core';
 import { Plugin, PluginKey } from 'prosemirror-state';
 import { DEFAULT_LINK_COLOR as LINK_COLOR } from '@src/constants/rich-text-editor.constants';
+/** A transaction carrying this meta skips the new-link styling pass below: a clipboard paste
+ * brings its own look (a copied link keeps its colour; a text-only paste brings no links), so
+ * neither wants AutoLink's "force blue + underline" treatment for a newly-created link. */
+export const AUTO_LINK_SKIP_STYLING_META = 'autoLinkSkipStyling';
 const isLinkMark = (mark) => mark.type.name === 'link';
 const isUnderlineMark = (mark) => mark.type.name === 'underline';
 const isTextStyleMark = (mark) => mark.type.name === 'textStyle';
@@ -38,6 +42,45 @@ const applyDefaultLinkStyling = (tr, schema, node, pos) => {
     }
     return modified;
 };
+/**
+ * The end-of-link detach a typed character gets right after a link's last position: the link
+ * mark (and its auto-blue colour, unless the user manually added an underline) drops from what
+ * comes next, so continuing to type doesn't extend the link. `null` when `pos` isn't at the end
+ * of a link — mid-link, or no link at all — so the caller keeps its own marks unchanged.
+ * Exported for `RteClipboard.ts`'s text-only paste, which takes the same detach a typed
+ * character would.
+ */
+export const linkDetachMarksAt = (state, pos) => {
+    const currentMarks = state.doc.resolve(pos).marks();
+    const linkMark = currentMarks.find(isLinkMark);
+    if (!linkMark)
+        return null;
+    const nextPos = pos + 1;
+    const hasLinkAfter = nextPos <= state.doc.content.size &&
+        state.doc
+            .resolve(Math.min(nextPos, state.doc.content.size))
+            .marks()
+            .some((mark) => isLinkMark(mark) && mark.eq(linkMark));
+    if (hasLinkAfter)
+        return null;
+    return currentMarks
+        .filter((mark) => {
+        if (isLinkMark(mark))
+            return false;
+        // Only preserve underlines if there's no blue color (manually added underlines)
+        // Remove underlines that were part of link styling (with blue color)
+        if (isUnderlineMark(mark)) {
+            const hasBlueColor = currentMarks.some(isBlueColorMark);
+            return !hasBlueColor;
+        }
+        // Remove blue color styling but preserve other text styles
+        if (isBlueColorMark(mark)) {
+            return createStylesWithoutColor(state.schema, mark);
+        }
+        return true;
+    })
+        .filter(Boolean);
+};
 const removeHyperlinkStyles = (tr, schema, node, pos) => {
     const range = { from: pos, to: pos + node.nodeSize };
     let modified = false;
@@ -70,52 +113,19 @@ export const AutoLink = Extension.create({
                 props: {
                     handleTextInput(view, from, to, text) {
                         const { state } = view;
-                        const { selection } = state;
-                        const { $anchor } = selection;
                         // Only handle when typing at a cursor position (from === to)
                         if (from !== to) {
                             return false;
                         }
-                        // Check if we have link marks at cursor position
-                        const currentMarks = $anchor.marks();
-                        const linkMark = currentMarks.find(isLinkMark);
-                        if (linkMark) {
-                            // Check if we're at the end of the link
-                            const currentPos = $anchor.pos;
-                            const nextPos = currentPos + 1;
-                            const hasLinkAfter = nextPos <= state.doc.content.size &&
-                                state.doc
-                                    .resolve(Math.min(nextPos, state.doc.content.size))
-                                    .marks()
-                                    .some((mark) => isLinkMark(mark) && mark.eq(linkMark));
-                            if (!hasLinkAfter) {
-                                // detach the link after the attached link mark
-                                const preservedMarks = currentMarks
-                                    .filter((mark) => {
-                                    if (isLinkMark(mark))
-                                        return false;
-                                    // Only preserve underlines if there's no blue color (manually added underlines)
-                                    // Remove underlines that were part of link styling (with blue color)
-                                    if (isUnderlineMark(mark)) {
-                                        const hasBlueColor = currentMarks.some(isBlueColorMark);
-                                        return !hasBlueColor; // Keep underline only if no blue color
-                                    }
-                                    // Remove blue color styling but preserve other text styles
-                                    if (isBlueColorMark(mark)) {
-                                        return createStylesWithoutColor(state.schema, mark);
-                                    }
-                                    return true;
-                                })
-                                    .filter(Boolean); // Insert text with only preserved marks
-                                let tr = state.tr;
-                                tr = tr.setStoredMarks(preservedMarks);
-                                tr = tr.insertText(text, from, to);
-                                tr = tr.setMeta('autoLinkDetached', true);
-                                view.dispatch(tr);
-                                return true;
-                            }
-                        }
-                        return false;
+                        const detached = linkDetachMarksAt(state, state.selection.$anchor.pos);
+                        if (!detached)
+                            return false;
+                        let tr = state.tr;
+                        tr = tr.setStoredMarks(detached);
+                        tr = tr.insertText(text, from, to);
+                        tr = tr.setMeta('autoLinkDetached', true);
+                        view.dispatch(tr);
+                        return true;
                     },
                 },
                 appendTransaction(transactions, oldState, newState) {
@@ -125,24 +135,30 @@ export const AutoLink = Extension.create({
                     if (!hasDocChanges)
                         return null;
                     const wasDetached = transactions.some((transaction) => transaction.getMeta('autoLinkDetached'));
-                    // Apply default styling to links (unless just detached)
-                    if (!wasDetached) {
+                    const skipsNewLinkStyling = transactions.some((transaction) => transaction.getMeta(AUTO_LINK_SKIP_STYLING_META));
+                    // Apply default styling to links (unless just detached, or the transaction brings its
+                    // own look — a clipboard paste)
+                    if (!wasDetached && !skipsNewLinkStyling) {
+                        // A link is new when its text wasn't a link before these transactions. Map each
+                        // position back through them: an edit earlier in the doc shifts every later link, so
+                        // the same raw position in the old doc lands on other text.
+                        const toOldPos = transactions
+                            .map((transaction) => transaction.mapping.invert())
+                            .reverse();
                         newState.doc.descendants((node, pos) => {
                             if (!node.isText || !node.text || !hasLinkMark(node.marks))
                                 return;
-                            // Check if this is a newly created link by comparing with old state
-                            const oldNode = pos < oldState.doc.nodeSize ? oldState.doc.nodeAt(pos) : null;
+                            const oldPos = toOldPos.reduce((mapped, mapping) => mapping.map(mapped, 1), pos);
+                            const oldNode = oldPos < oldState.doc.content.size
+                                ? oldState.doc.nodeAt(oldPos)
+                                : null;
                             const wasAlreadyLink = oldNode && hasLinkMark(oldNode.marks);
-                            // Only apply full styling (including underline) to newly created links
+                            // An existing link keeps the colour and underline it has now.
                             if (wasAlreadyLink === false) {
                                 if (applyDefaultLinkStyling(tr, newState.schema, node, pos)) {
                                     modified = true;
                                 }
                             }
-                            else {
-                                // For existing links, preserve their current color and underline choices
-                                // Don't override user customizations on existing links
-                            }
                         });
                     }
                     // Clean up hyperlink styling from text without link marks

package/lib/src/{brand-page-maker/composables/rich-text-editor/extensions → shared/rte-extensions}/MaxLength.js

@@ -18,7 +18,10 @@ export const MaxLength = Extension.create({
                         const { maxLength } = this.options;
                         const { state } = view;
                         const { from, to } = view.state.selection;
-                        const selectionSize = to - from;
+                        // The selected TEXT being replaced, not its position span: a selection crossing a
+                        // paragraph boundary spans 2 extra positions (the closing/opening block nodes) that
+                        // aren't characters.
+                        const selectionSize = state.doc.textBetween(from, to).length;
                         const currentTextLength = state.doc.textContent.length - selectionSize;
                         const incomingText = slice.content.textBetween(0, slice.content.size, '\n');
                         const allowed = maxLength - currentTextLength;

package/lib/src/shared/rte-extensions/TextEffects.d.ts

@@ -0,0 +1,28 @@
+import { Extension } from '@tiptap/core';
+export type TextEffectsOptions = {
+    types: string[];
+    renderTextDecorationClasses?: boolean;
+};
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        textEffects: {
+            setFontWeight: (value: string) => ReturnType;
+            unsetFontWeight: () => ReturnType;
+            setFontStyle: (value: string) => ReturnType;
+            unsetFontStyle: () => ReturnType;
+            setTextDecoration: (value: string) => ReturnType;
+            unsetTextDecoration: () => ReturnType;
+        };
+    }
+}
+/**
+ * BP-5969 — weight / style / decoration as `textStyle` mark ATTRIBUTES, not semantic marks.
+ *
+ * Every typography property now lives on the run's `textStyle` mark, each defaulting to its role
+ * `var(--role-*)` (or a raw override) — identical to family/size/line-height/letter-spacing. So
+ * editing a role's font-weight / font-style / text-decoration changes one CSS custom-property
+ * declaration and repaints every linked run through the cascade, with no doc rewrite. (The
+ * container applies nothing, so a per-run `font-weight: normal` / `text-decoration: none` override
+ * cleanly wins — the reason these can leave the semantic `<strong>`/`<u>` model.)
+ */
+export declare const TextEffects: Extension<TextEffectsOptions, any>;

package/lib/src/shared/rte-extensions/TextEffects.js

@@ -0,0 +1,96 @@
+import { Extension } from '@tiptap/core';
+import { composeTextDecoration, roleVarRef, rteTextDecorationClassName, } from '@shared/text-role-typography.util';
+/**
+ * BP-5969 — weight / style / decoration as `textStyle` mark ATTRIBUTES, not semantic marks.
+ *
+ * Every typography property now lives on the run's `textStyle` mark, each defaulting to its role
+ * `var(--role-*)` (or a raw override) — identical to family/size/line-height/letter-spacing. So
+ * editing a role's font-weight / font-style / text-decoration changes one CSS custom-property
+ * declaration and repaints every linked run through the cascade, with no doc rewrite. (The
+ * container applies nothing, so a per-run `font-weight: normal` / `text-decoration: none` override
+ * cleanly wins — the reason these can leave the semantic `<strong>`/`<u>` model.)
+ */
+export const TextEffects = Extension.create({
+    name: 'textEffects',
+    addOptions() {
+        return {
+            types: ['textStyle'],
+            renderTextDecorationClasses: false,
+        };
+    },
+    addGlobalAttributes() {
+        return [
+            {
+                types: this.options.types,
+                attributes: {
+                    fontWeight: {
+                        default: null,
+                        parseHTML: (element) => element.style.fontWeight || null,
+                        renderHTML: (attributes) => attributes.fontWeight
+                            ? { style: `font-weight: ${attributes.fontWeight}` }
+                            : {},
+                    },
+                    fontStyle: {
+                        default: null,
+                        parseHTML: (element) => element.style.fontStyle || null,
+                        renderHTML: (attributes) => attributes.fontStyle
+                            ? { style: `font-style: ${attributes.fontStyle}` }
+                            : {},
+                    },
+                    textDecoration: {
+                        default: null,
+                        parseHTML: (element) => element.style.textDecoration || null,
+                        renderHTML: (attributes) => {
+                            if (!attributes.textDecoration)
+                                return {};
+                            const className = this.options.renderTextDecorationClasses
+                                ? rteTextDecorationClassName(attributes.textDecoration, attributes.textDecorationReset === true)
+                                : undefined;
+                            if (this.options.renderTextDecorationClasses)
+                                return className ? { class: className } : {};
+                            const value = attributes.textDecoration === roleVarRef('textDecoration')
+                                ? attributes.textDecoration
+                                : composeTextDecoration(undefined, attributes.textDecoration);
+                            return value ? { style: `text-decoration: ${value}` } : {};
+                        },
+                    },
+                    textDecorationReset: {
+                        default: null,
+                        parseHTML: (element) => element.getAttribute('data-bp-text-decoration-reset') === 'true'
+                            ? true
+                            : null,
+                        renderHTML: (attributes) => attributes.textDecorationReset
+                            ? { 'data-bp-text-decoration-reset': 'true' }
+                            : {},
+                    },
+                },
+            },
+        ];
+    },
+    addCommands() {
+        return {
+            setFontWeight: (fontWeight) => ({ chain }) => chain().setMark('textStyle', { fontWeight }).run(),
+            unsetFontWeight: () => ({ chain }) => chain()
+                .setMark('textStyle', { fontWeight: null })
+                .removeEmptyTextStyle()
+                .run(),
+            setFontStyle: (fontStyle) => ({ chain }) => chain().setMark('textStyle', { fontStyle }).run(),
+            unsetFontStyle: () => ({ chain }) => chain()
+                .setMark('textStyle', { fontStyle: null })
+                .removeEmptyTextStyle()
+                .run(),
+            // A reset marker qualifies only the value it was written with; setMark merges attrs, so a
+            // new value must clear it or the run would drop its role's lines.
+            setTextDecoration: (textDecoration) => ({ chain }) => chain()
+                .setMark('textStyle', { textDecoration, textDecorationReset: null })
+                .run(),
+            unsetTextDecoration: () => ({ chain }) => chain()
+                .setMark('textStyle', {
+                textDecoration: null,
+                textDecorationReset: null,
+            })
+                .removeEmptyTextStyle()
+                .run(),
+        };
+    },
+});

package/lib/src/shared/rte-extensions/ViewDomParser.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@tiptap/core';
+export declare const ViewDomParser: Extension<any, any>;

package/lib/src/shared/rte-extensions/ViewDomParser.js

@@ -0,0 +1,21 @@
+import { Extension } from '@tiptap/core';
+import { DOMParser } from 'prosemirror-model';
+import { Plugin, PluginKey } from 'prosemirror-state';
+// The legacy bold/italic/underline/strike style rules misread the textStyle span's own styles on the
+// per-keystroke DOM read-back, so the whole run is retyped with the armed format — see
+// rich-text-editor.md. Paste keeps them: foreign HTML may carry bold only as a style.
+export const ViewDomParser = Extension.create({
+    name: 'viewDomParser',
+    addProseMirrorPlugins() {
+        const schemaParser = DOMParser.fromSchema(this.editor.schema);
+        return [
+            new Plugin({
+                key: new PluginKey('viewDomParser'),
+                props: {
+                    domParser: new DOMParser(this.editor.schema, schemaParser.rules.filter((rule) => 'tag' in rule)),
+                    clipboardParser: schemaParser,
+                },
+            }),
+        ];
+    },
+});

package/lib/src/shared/rte-extensions.util.d.ts

@@ -0,0 +1,25 @@
+import type { Extensions } from '@tiptap/vue-3';
+/**
+ * The schema generation a requested version resolves to: the highest change point at or below it
+ * (0 = the base schema). `undefined` = latest → the newest generation. So versions in the same
+ * range share one schema — asking for 5 or 20 both give the base — and callers cache one built
+ * schema per generation rather than per exact number.
+ */
+export declare const rteSchemaGeneration: (schemaVersion?: number) => number;
+export interface RteExtensionOptions {
+    /** Disable StarterKit nodes the editor doesn't use (lists, hr, code). */
+    restrictStarterKit?: boolean;
+    /** When present, add the live-editing-only plugins (Placeholder, MaxLength, ViewDomParser). */
+    editing?: {
+        placeholder?: string;
+        maxLength?: number;
+    };
+    /**
+     * Pin the schema to a model version's extension set. A migration passes its own version so the
+     * parse reproduces that era's schema (see `rteSchemaGeneration`); omit for the latest (runtime).
+     */
+    schemaVersion?: number;
+    /** Render text-decoration marks as role-aware classes instead of inline styles. */
+    renderTextDecorationClasses?: boolean;
+}
+export declare const getRteExtensions: (options?: RteExtensionOptions) => Extensions;

package/lib/src/{brand-page-maker/composables/rich-text-editor/getRteExtensions.js → shared/rte-extensions.util.js}

@@ -6,13 +6,55 @@ import ColorExtension from '@tiptap/extension-color';
 import Highlight from '@tiptap/extension-highlight';
 import Placeholder from '@tiptap/extension-placeholder';
 import Link from '@tiptap/extension-link';
-import { FontFamily } from './extensions/FontFamily';
-import { LetterSpacing } from './extensions/LetterSpacing';
-import { MaxLength } from './extensions/MaxLength';
-import { AutoLink } from './extensions/AutoLink';
-import { isHrefPageId } from './hyperlink';
+import { FontFamily } from './rte-extensions/FontFamily';
+import { LetterSpacing } from './rte-extensions/LetterSpacing';
+import { TextEffects } from './rte-extensions/TextEffects';
+import { MaxLength } from './rte-extensions/MaxLength';
+import { ViewDomParser } from './rte-extensions/ViewDomParser';
+import { AutoLink } from './rte-extensions/AutoLink';
+import { isHrefPageId } from './rte-link.util';
+/**
+ * Single source of truth for the Tiptap extension set (BP-5787).
+ *
+ * The live editor, the headless serialiser (useExternalRichTextEditor), and
+ * the upcoming render-from-JSON path must all use the SAME extensions, or
+ * rendered output drifts from what the user authored. This factory removes the
+ * previous duplication while preserving each consumer's exact configuration.
+ *
+ * Known, intentional differences are parameterised:
+ *  - `restrictStarterKit` — the live editor disables list/hr/code nodes.
+ *  - `editing` — only the live editor carries the Placeholder, MaxLength and
+ *    ViewDomParser plugins (none affects serialised output; they are editing-time only).
+ *
+ * Link target/rel are NOT parameterised: they are a pure function of the href
+ * applied in the Link mark's renderHTML (below), so every consumer — live
+ * editor, static renderer, schema check — emits identical link markup.
+ */
+/**
+ * The RTE schema is piecewise-constant across model-version ranges: it only changes when an
+ * extension is added, so every version between two change points shares one schema. Today the one
+ * change point is v22 — where `TextEffects` (weight/style/decoration on the `textStyle` mark) was
+ * added — giving two generations: below 22 is the pre-BP-5969 schema, 22-and-later (and the latest)
+ * carries TextEffects. Add the next version here if the schema grows.
+ *
+ * MIGRATION-22 SNAPSHOT DEPENDENCY: B1 parses v21 plain RTE strings with generation 22, so the
+ * extensions' `parseHTML` rules shape its output. Pinning the generation does not freeze those rules;
+ * after migration-22 releases, pin them in the migration before changing them.
+ */
+const RTE_SCHEMA_CHANGE_VERSIONS = [22];
+/**
+ * The schema generation a requested version resolves to: the highest change point at or below it
+ * (0 = the base schema). `undefined` = latest → the newest generation. So versions in the same
+ * range share one schema — asking for 5 or 20 both give the base — and callers cache one built
+ * schema per generation rather than per exact number.
+ */
+export const rteSchemaGeneration = (schemaVersion) => RTE_SCHEMA_CHANGE_VERSIONS.reduce((generation, changeVersion) => 
+// undefined = latest → reaches every change point → the newest generation.
+schemaVersion === undefined || schemaVersion >= changeVersion
+    ? changeVersion
+    : generation, 0);
 export const getRteExtensions = (options = {}) => {
-    const { restrictStarterKit = false, editing } = options;
+    const { restrictStarterKit = false, editing, schemaVersion, renderTextDecorationClasses = false, } = options;
     const extensions = [
         // v3 StarterKit bundles Link + Underline; we register both separately (with
         // custom Link config), so disable the bundled copies to avoid duplicate
@@ -61,6 +103,19 @@ export const getRteExtensions = (options = {}) => {
         FontSize.configure({ types: ['textStyle'] }),
         LetterSpacing,
         LineHeight.configure({ types: ['textStyle'] }),
+        // BP-5969: weight / style / decoration as textStyle attrs (role var or literal override), so a
+        // role edit to any of them repaints linked RTE via the cascade — like family/size already do.
+        // TextEffects entered at v22 (RTE_SCHEMA_CHANGE_VERSIONS). Gated in place — not appended — so the
+        // latest schema's extension order is byte-unchanged; a parse resolving below 22 omits it,
+        // reproducing the pre-BP-5969 schema.
+        ...(rteSchemaGeneration(schemaVersion) >= 22
+            ? [
+                TextEffects.configure({
+                    types: ['textStyle'],
+                    renderTextDecorationClasses,
+                }),
+            ]
+            : []),
         ColorExtension.configure({
             types: ['textStyle'],
         }),
@@ -70,7 +125,7 @@ export const getRteExtensions = (options = {}) => {
     ];
     // Live-editing-only plugins sit between Highlight and Link (original order).
     if (editing) {
-        extensions.push(Placeholder.configure({ placeholder: editing.placeholder }), MaxLength.configure({ maxLength: editing.maxLength }));
+        extensions.push(Placeholder.configure({ placeholder: editing.placeholder }), MaxLength.configure({ maxLength: editing.maxLength }), ViewDomParser);
     }
     extensions.push(Link.extend({
         // External-link policy lives at the serialisation boundary: target/rel are

package/lib/src/shared/rte-link.util.d.ts

@@ -0,0 +1 @@
+export declare const isHrefPageId: (href: string) => boolean;

package/lib/src/shared/rte-link.util.js

@@ -0,0 +1 @@
+export const isHrefPageId = (href) => !!href && href.startsWith('pageid:');