@designcrowd/library.brand-page 6.0.26-json-prereq-2 → 6.0.27-websitev2-dev-1

package/src/metadata-builder/builders/section-builders/mailing-list-section-builder.ts

@@ -3,6 +3,7 @@ import type {
   BrandPageModel,
   TextStyleDeclaration,
 } from '../../../brand-page/models';
+import { tiptapJsonToHtml } from '../../helpers/rte.helpers';
 import type { BuilderResult } from '../../models';
 import {
   isTiptapDocument,
@@ -47,7 +48,7 @@ export class MailingListSectionBuilder extends BaseSectionBuilder<MailingListCon
 
     if (mailingListArgs.title !== undefined) {
       if (isTiptapDocument(mailingListArgs.title)) {
-        resolved.content.title = mailingListArgs.title;
+        resolved.content.title = tiptapJsonToHtml(mailingListArgs.title);
         resolved.content.titleStyle = resolveGlobalPresetIntoStyle(
           resolved.content.titleStyle,
           textStyleOptions,

package/src/metadata-builder/builders/section-builders/profile-section-builder.ts

@@ -3,6 +3,7 @@ import type {
   BrandPageModel,
   TextStyleDeclaration,
 } from '../../../brand-page/models';
+import { tiptapJsonToHtml } from '../../helpers/rte.helpers';
 import type { BuilderResult } from '../../models';
 import {
   isTiptapDocument,
@@ -40,7 +41,7 @@ export class ProfileSectionBuilder extends BaseSectionBuilder<ProfileContent> {
 
     if (profileArgs.name !== undefined) {
       if (isTiptapDocument(profileArgs.name)) {
-        resolved.content.name = profileArgs.name;
+        resolved.content.name = tiptapJsonToHtml(profileArgs.name);
         resolved.content.nameStyle = resolveGlobalPresetIntoStyle(
           resolved.content.nameStyle,
           textStyleOptions,
@@ -52,7 +53,7 @@ export class ProfileSectionBuilder extends BaseSectionBuilder<ProfileContent> {
 
     if (profileArgs.title !== undefined) {
       if (isTiptapDocument(profileArgs.title)) {
-        resolved.content.title = profileArgs.title;
+        resolved.content.title = tiptapJsonToHtml(profileArgs.title);
         resolved.content.titleStyle = resolveGlobalPresetIntoStyle(
           resolved.content.titleStyle,
           textStyleOptions,
@@ -64,7 +65,9 @@ export class ProfileSectionBuilder extends BaseSectionBuilder<ProfileContent> {
 
     if (profileArgs.description !== undefined) {
       if (isTiptapDocument(profileArgs.description)) {
-        resolved.content.description = profileArgs.description;
+        resolved.content.description = tiptapJsonToHtml(
+          profileArgs.description,
+        );
         resolved.content.descriptionStyle = resolveGlobalPresetIntoStyle(
           resolved.content.descriptionStyle,
           textStyleOptions,

package/src/metadata-builder/builders/section-builders/shapes-section-builder.ts

@@ -5,6 +5,7 @@ import type {
   TextShapeItem,
   TextStyleDeclaration,
 } from '../../../brand-page/models';
+import { tiptapJsonToHtml } from '../../helpers/rte.helpers';
 import type { BuilderResult } from '../../models';
 import {
   isTiptapDocument,
@@ -194,7 +195,7 @@ export class ShapesSectionBuilder extends BaseSectionBuilder<ShapesSectionConten
 
     if (args.title !== undefined) {
       if (isTiptapDocument(args.title)) {
-        content.title = args.title;
+        content.title = tiptapJsonToHtml(args.title);
         content.titleStyle = resolveGlobalPresetIntoStyle(
           content.titleStyle,
           textStyleOptions,
@@ -206,7 +207,7 @@ export class ShapesSectionBuilder extends BaseSectionBuilder<ShapesSectionConten
 
     if (args.description !== undefined) {
       if (isTiptapDocument(args.description)) {
-        content.description = args.description;
+        content.description = tiptapJsonToHtml(args.description);
         content.descriptionStyle = resolveGlobalPresetIntoStyle(
           content.descriptionStyle,
           textStyleOptions,

package/src/metadata-builder/builders/section-builders/support-me-builder.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect } from 'vitest';
+import type {
+  BrandPageModel,
+  SupportMeContent,
+} from '../../../brand-page/models';
+import { BUILDER_TYPES } from '../../models';
+import type { SupportMeArguments } from '../../parsers/section-tool-arguments';
+import { SupportMeBuilder } from './support-me-builder';
+
+const makeModel = (contents: SupportMeContent[] = []): BrandPageModel =>
+  ({
+    brandPageType: 'brandSite',
+    styles: { textStyles: { textStyleOptions: {} } },
+    pages: [{ id: 'page-1', contents }],
+  }) as unknown as BrandPageModel;
+
+const seedContent = (): SupportMeContent =>
+  ({
+    id: 'sm-1',
+    type: 'support-me',
+    title: 'Existing title',
+    description: 'Existing description',
+    successMessage: 'Existing success',
+    displayStyle: 'preview',
+    supportMeConfig: {
+      paymentOptions: [{ amount: '0', id: 'po-1', name: 'Custom' }],
+      isCustomerMessageEnabled: true,
+    },
+    titleStyle: {},
+    headingStyle: {},
+    descriptionStyle: {},
+    buttonTextStyle: {},
+    itemTextStyle: {},
+  }) as unknown as SupportMeContent;
+
+const create = (args: SupportMeArguments, model: BrandPageModel) =>
+  new SupportMeBuilder({
+    id: 't-create',
+    type: BUILDER_TYPES.CREATE_SUPPORT_ME,
+    payload: { sectionType: 'support-me', arguments: args, pageId: 'page-1' },
+  }).buildAsync(model);
+
+const update = (
+  args: SupportMeArguments,
+  model: BrandPageModel,
+  contentId = 'sm-1',
+) =>
+  new SupportMeBuilder({
+    id: 't-update',
+    type: BUILDER_TYPES.UPDATE_SUPPORT_ME,
+    payload: { sectionType: 'support-me', arguments: args, contentId },
+  }).buildAsync(model);
+
+describe('SupportMeBuilder — create', () => {
+  it('creates a support-me section with factory defaults', async () => {
+    const model = makeModel();
+
+    const { model: out, errors } = await create({}, model);
+
+    expect(errors ?? []).toEqual([]);
+
+    const created = out.pages[0].contents[0] as SupportMeContent;
+
+    expect(created.type).toBe('support-me');
+    // display style default comes from the factory
+    expect(created.displayStyle).toBe('preview');
+    // supportMeConfig (payment options) comes free from the factory, never the AI
+    expect(created.supportMeConfig.paymentOptions.length).toBeGreaterThan(0);
+  });
+
+  it('applies AI-provided scalar fields over the defaults', async () => {
+    const model = makeModel();
+
+    const { model: out, errors } = await create(
+      {
+        title: 'Buy me a coffee',
+        description: 'Support my work',
+        success_message: 'Thanks!',
+        display_style: 'collapsed',
+      },
+      model,
+    );
+
+    expect(errors ?? []).toEqual([]);
+
+    const created = out.pages[0].contents[0] as SupportMeContent;
+
+    expect(created.title).toBe('Buy me a coffee');
+    expect(created.description).toBe('Support my work');
+    expect(created.successMessage).toBe('Thanks!');
+    expect(created.displayStyle).toBe('collapsed');
+  });
+});
+
+describe('SupportMeBuilder — update', () => {
+  it('updates scalar fields on an existing section', async () => {
+    const model = makeModel([seedContent()]);
+
+    const { model: out, errors } = await update(
+      {
+        title: 'New title',
+        success_message: 'New success',
+        display_style: 'collapsed',
+      },
+      model,
+    );
+
+    expect(errors ?? []).toEqual([]);
+
+    const updated = out.pages[0].contents[0] as SupportMeContent;
+
+    expect(updated.title).toBe('New title');
+    expect(updated.successMessage).toBe('New success');
+    expect(updated.displayStyle).toBe('collapsed');
+    // untouched fields survive
+    expect(updated.description).toBe('Existing description');
+    // supportMeConfig is never AI-editable
+    expect(updated.supportMeConfig.paymentOptions.length).toBe(1);
+  });
+
+  it('applies the five style fields to their model keys', async () => {
+    const model = makeModel([seedContent()]);
+
+    const { model: out, errors } = await update(
+      {
+        title_style: { textAlign: 'left' },
+        heading_style: { textAlign: 'right' },
+        description_style: { textAlign: 'center' },
+        item_text_style: { textAlign: 'justify' },
+        button_text_style: { color: '#123456' },
+      },
+      model,
+    );
+
+    expect(errors ?? []).toEqual([]);
+
+    const updated = out.pages[0].contents[0] as SupportMeContent;
+
+    expect(updated.titleStyle).toMatchObject({ textAlign: 'left' });
+    expect(updated.headingStyle).toMatchObject({ textAlign: 'right' });
+    expect(updated.descriptionStyle).toMatchObject({ textAlign: 'center' });
+    expect(updated.itemTextStyle).toMatchObject({ textAlign: 'justify' });
+    expect(updated.buttonTextStyle).toMatchObject({ color: '#123456' });
+  });
+});
+
+describe('SupportMeBuilder — validation', () => {
+  it('rejects an invalid display_style enum value', async () => {
+    const model = makeModel([seedContent()]);
+
+    const { errors } = await update({ display_style: 'fancy' as never }, model);
+
+    expect(errors?.length).toBeGreaterThan(0);
+    expect(errors!.join(' ')).toContain('display_style');
+  });
+
+  it('rejects an over-length title', async () => {
+    const model = makeModel([seedContent()]);
+
+    const { errors } = await update({ title: 'x'.repeat(201) }, model);
+
+    expect(errors?.length).toBeGreaterThan(0);
+    expect(errors!.join(' ')).toContain('title');
+  });
+
+  it('rejects an over-length success_message', async () => {
+    const model = makeModel([seedContent()]);
+
+    const { errors } = await update(
+      { success_message: 'x'.repeat(1001) },
+      model,
+    );
+
+    expect(errors?.length).toBeGreaterThan(0);
+    expect(errors!.join(' ')).toContain('success_message');
+  });
+});

package/src/metadata-builder/builders/section-builders/support-me-builder.ts

@@ -0,0 +1,43 @@
+import type {
+  BrandPageModel,
+  SupportMeContent,
+} from '../../../brand-page/models';
+import type { BuilderResult } from '../../models';
+import { applyScalarFields, applyStyleFields } from '../section-field-utils';
+import { BaseSectionBuilder } from './base-section-builder';
+import { validateSupportMe } from '../section-rules/support-me.rules';
+
+export class SupportMeBuilder extends BaseSectionBuilder<SupportMeContent> {
+  protected get sectionValidate() {
+    return validateSupportMe;
+  }
+
+  async buildAsync(model: BrandPageModel): Promise<BuilderResult> {
+    this.log('Build called');
+
+    const validation = await this.validateAsync();
+
+    if (validation.errors.length) {
+      return { request: this.request, model, errors: validation.errors };
+    }
+
+    const resolved = this.resolveAndRepositionContent(model);
+
+    if ('error' in resolved) return resolved.error;
+
+    const content = resolved.content;
+
+    // title/description/success_message are plain-text fields (no RTE support),
+    // so scalar application covers all content fields. supportMeConfig (payment
+    // options) is intentionally not AI-editable — it comes from the factory.
+    applyScalarFields(content, this.args, this.sectionType);
+    applyStyleFields(
+      content,
+      this.args,
+      this.sectionType,
+      this.getGlobalTextStyles(model),
+    );
+
+    return { request: this.request, model };
+  }
+}

package/src/metadata-builder/builders/section-builders/testimonial-section-builder.ts

@@ -4,6 +4,7 @@ import type {
   BrandPageModel,
   TextStyleDeclaration,
 } from '../../../brand-page/models';
+import { tiptapJsonToHtml } from '../../helpers/rte.helpers';
 import {
   isTiptapDocument,
   type TestimonialItem,
@@ -172,7 +173,7 @@ export class TestimonialSectionBuilder extends BaseSectionBuilder<TestimonialSec
 
     if (args.title !== undefined) {
       if (isTiptapDocument(args.title)) {
-        content.title = args.title;
+        content.title = tiptapJsonToHtml(args.title);
         content.titleStyle = resolveGlobalPresetIntoStyle(
           content.titleStyle,
           textStyleOptions,

package/src/metadata-builder/builders/section-builders/text-section-builder.ts

@@ -4,9 +4,9 @@ import type {
   TextItem,
   TextStyleDeclaration,
   BrandPageModel,
-  RichTextValue,
 } from '../../../brand-page/models';
 import type { TextStyleOptions } from '../../../brand-page/models/styles.model';
+import { tiptapJsonToHtml } from '../../helpers/rte.helpers';
 import {
   isTiptapDocument,
   type TextSectionArguments,
@@ -26,18 +26,12 @@ import {
   repositionItemByAnchor,
 } from '../item-id-utils';
 
-/**
- * Resolve a RichTextField to its stored RTE value. BP-5787: Tiptap JSON is
- * stored as-is (no JSON→HTML round-trip — migration-20 is now a one-time
- * legacy conversion), plain strings pass through. `wasTiptap` drives the
- * text-style preset resolution for rich content.
- */
-const resolveText = (
-  value: unknown,
-): { value: RichTextValue; wasTiptap: boolean } => {
-  if (isTiptapDocument(value)) return { value, wasTiptap: true };
+/** Resolve a RichTextField (string or TiptapDocument) to a plain HTML string. */
+const resolveText = (value: unknown): { html: string; wasTiptap: boolean } => {
+  if (isTiptapDocument(value))
+    return { html: tiptapJsonToHtml(value), wasTiptap: true };
 
-  return { value: typeof value === 'string' ? value : '', wasTiptap: false };
+  return { html: typeof value === 'string' ? value : '', wasTiptap: false };
 };
 
 const clearTextStyleTypeIfTiptap = (
@@ -61,11 +55,11 @@ const createTextItem = (
     item.text_style ? { ...baseStyle, ...item.text_style } : { ...baseStyle }
   ) as TextStyleDeclaration;
 
-  const { value, wasTiptap } = resolveText(item.text);
+  const { html, wasTiptap } = resolveText(item.text);
 
   return {
     id: item.item_id || generateItemId(),
-    text: value,
+    text: html,
     textStyle: clearTextStyleTypeIfTiptap(
       textStyle,
       wasTiptap,
@@ -117,9 +111,9 @@ const mergeTextItems = (
       if (!existing) continue;
 
       if (item.text !== undefined) {
-        const { value, wasTiptap } = resolveText(item.text);
+        const { html, wasTiptap } = resolveText(item.text);
 
-        existing.text = value;
+        existing.text = html;
         existing.textStyle = clearTextStyleTypeIfTiptap(
           existing.textStyle || {},
           wasTiptap,
@@ -166,12 +160,12 @@ const applySingleTextField = (
   textStyleOptions: TextStyleOptions | undefined,
 ): void => {
   if (args.text !== undefined) {
-    const { value, wasTiptap } = resolveText(args.text);
+    const { html, wasTiptap } = resolveText(args.text);
 
     if (Array.isArray(content.textItems) && content.textItems.length > 0) {
       content.textItems[0] = {
         ...content.textItems[0],
-        text: value,
+        text: html,
         textStyle: clearTextStyleTypeIfTiptap(
           content.textItems[0].textStyle || {},
           wasTiptap,
@@ -182,7 +176,7 @@ const applySingleTextField = (
       content.textItems = [
         {
           id: generateItemId(),
-          text: value,
+          text: html,
           textStyle: clearTextStyleTypeIfTiptap(
             { ...(content.textStyle || {}) },
             wasTiptap,
@@ -246,13 +240,16 @@ export class TextSectionBuilder extends BaseSectionBuilder<TextContent> {
       // Full replacement: discard existing items and rebuild from the payload.
       applyTextItems(content, args.items, textStyleOptions);
     } else if (this.mode === 'create') {
-      if (args.items && Array.isArray(args.items)) {
+      // An EMPTY items array must not shadow the single text field — the AI emits
+      // `items: []` alongside `text` and the section rendered blank (QA 2026-07-05,
+      // T06: items=[] set textItems=[] and `text` was silently discarded).
+      if (args.items && Array.isArray(args.items) && args.items.length > 0) {
         applyTextItems(content, args.items, textStyleOptions);
       } else {
         applySingleTextField(content, args, textStyleOptions);
       }
     } else if (
-      (args.items && Array.isArray(args.items)) ||
+      (args.items && Array.isArray(args.items) && args.items.length > 0) ||
       args._remove_item_ids?.length
     ) {
       // Update: id-based add / edit / move / remove in a single pass.

package/src/metadata-builder/builders/section-field-maps.ts

@@ -23,6 +23,7 @@ import type {
   ImageContent,
   ButtonContent,
   ImageGalleryContent,
+  SupportMeContent,
 } from '../../brand-page/models';
 
 export type SectionFieldMap = Record<string, string>;
@@ -175,9 +176,17 @@ const socialButtonFields = defineFieldMap<ButtonContent>({
   url: 'url',
 });
 
+const supportMeFields = defineFieldMap<SupportMeContent>({
+  title: 'title',
+  description: 'description',
+  success_message: 'successMessage',
+  display_style: 'displayStyle',
+});
+
 export const SECTION_FIELD_MAPS: Record<string, SectionFieldMap> = {
   'banner-section': bannerFields,
   'booking-section': bookingFields,
+  'support-me': supportMeFields,
   'about-section': aboutFields,
   'testimonial-section': testimonialFields,
   'images-section': imagesSectionFields,
@@ -265,6 +274,14 @@ const mailingListStyleFields = defineFieldMap<MailingListContent>({
   button_text_style: 'buttonTextStyle',
 });
 
+const supportMeStyleFields = defineFieldMap<SupportMeContent>({
+  title_style: 'titleStyle',
+  heading_style: 'headingStyle',
+  description_style: 'descriptionStyle',
+  item_text_style: 'itemTextStyle',
+  button_text_style: 'buttonTextStyle',
+});
+
 const socialLinksStyleFields = defineFieldMap<SocialLinksContent>({
   icon_fill_style: 'iconFillStyles',
   icon_background_style: 'iconBackgroundStyles',
@@ -273,6 +290,7 @@ const socialLinksStyleFields = defineFieldMap<SocialLinksContent>({
 export const STYLE_FIELD_MAPS: Record<string, SectionFieldMap> = {
   'banner-section': bannerStyleFields,
   'booking-section': bookingStyleFields,
+  'support-me': supportMeStyleFields,
   'about-section': aboutStyleFields,
   text: textStyleFields,
   'testimonial-section': testimonialStyleFields,

package/src/metadata-builder/builders/section-field-utils.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+import type { Content } from '../../brand-page/models';
+import { applyStyleFields } from './section-field-utils';
+
+/**
+ * Regression tests for the AI QA 2026-07-05 rerun P0: a colour-only *_style
+ * patch left the field's existing inline textStyle marks (old colour) in
+ * place — inline marks override the style layer at render, so recoloured
+ * bands showed invisible old-colour text. applyStyleFields now propagates a
+ * new style colour into the stored RTE HTML when the patch carries no new
+ * text for that field.
+ */
+describe('applyStyleFields inline-colour propagation', () => {
+  const makeContent = (): Content =>
+    ({
+      type: 'about-section',
+      title: '<h3><span style="color: #111111">Fine Grooming</span></h3>',
+      titleStyle: { color: '#111111', fontSize: '2.188em' },
+      paragraph: '<p><span style="color: #111111">Body copy</span></p>',
+      paragraphStyle: { color: '#111111' },
+    }) as unknown as Content;
+
+  const recolour = (html: string, color: string): string =>
+    html.replace(/color: #[0-9a-fA-F]{6}/g, `color: ${color}`);
+
+  it('colour-only patch recolours the existing inline marks', () => {
+    const content = makeContent();
+
+    applyStyleFields(
+      content,
+      { title_style: { color: '#f8f2e9' } },
+      'about-section',
+      undefined,
+      recolour,
+    );
+
+    const record = content as unknown as Record<string, unknown>;
+
+    expect(record.title).toContain('color: #f8f2e9');
+    expect((record.titleStyle as Record<string, unknown>).color).toBe(
+      '#f8f2e9',
+    );
+    // Untouched fields keep their marks.
+    expect(record.paragraph).toContain('color: #111111');
+  });
+
+  it('does NOT rewrite marks when the patch also carries new text for the field', () => {
+    const content = makeContent();
+
+    applyStyleFields(
+      content,
+      {
+        title: { type: 'doc', content: [] },
+        title_style: { color: '#f8f2e9' },
+      },
+      'about-section',
+      undefined,
+      recolour,
+    );
+
+    // The builder's own text path owns the rewrite — HTML left alone here.
+    expect((content as unknown as Record<string, unknown>).title).toContain(
+      'color: #111111',
+    );
+  });
+
+  it('merged style keeps non-colour properties from the current style', () => {
+    const content = makeContent();
+
+    applyStyleFields(
+      content,
+      { title_style: { color: '#f8f2e9' } },
+      'about-section',
+      undefined,
+      recolour,
+    );
+
+    const style = (content as unknown as Record<string, unknown>)
+      .titleStyle as Record<string, unknown>;
+
+    expect(style.fontSize).toBe('2.188em');
+  });
+});

package/src/metadata-builder/builders/section-field-utils.ts

@@ -9,6 +9,10 @@ import {
   isTiptapDocument,
   type SectionToolArguments,
 } from '../parsers/section-tool-arguments';
+import { hasRTEContent } from '../../brand-page-maker/utils';
+import { useExternalRichTextEditor } from '../../brand-page-maker/composables/rich-text-editor/useRichTextEditor';
+import { applyStyleToRTEText } from '../helpers/rte.helpers';
+import type { TextStyleDeclaration } from '../../brand-page/models';
 import { getSectionFieldMap, getStyleFieldMap } from './section-field-maps';
 
 /**
@@ -186,36 +190,83 @@ export const applyDetachedStyleOverride = <T extends object>(
     ...updates,
   }) as T;
 
+/**
+ * Rewrites the stored RTE HTML's inline colour marks. Injectable for tests;
+ * the default uses the external Tiptap editor (font-propagation precedent).
+ */
+export type ApplyColorToRTE = (html: string, color: string) => string;
+
 export const applyStyleFields = (
   content: Content,
   args: SectionToolArguments,
   sectionType: string,
   textStyleOptions?: TextStyleOptions,
+  applyColor?: ApplyColorToRTE,
 ): void => {
   const styleMap = getStyleFieldMap(sectionType);
 
   if (!styleMap) return;
 
   const record = content as IndexableContent;
+  let editor:
+    | ReturnType<typeof useExternalRichTextEditor>['externalEditor']
+    | undefined;
+  const applyColorToHtml: ApplyColorToRTE =
+    applyColor ??
+    ((html, color) => {
+      editor = editor ?? useExternalRichTextEditor().externalEditor;
+
+      return applyStyleToRTEText(editor, html, {
+        color,
+      } as TextStyleDeclaration);
+    });
 
-  for (const [aiKey, modelKey] of Object.entries(styleMap)) {
-    if (!(aiKey in args) || !args[aiKey] || typeof args[aiKey] !== 'object')
-      continue;
-
-    const aiStyle = args[aiKey] as Record<string, unknown>;
-    const filtered: Record<string, unknown> = {};
-
-    for (const [k, v] of Object.entries(aiStyle)) {
-      const normalized = normalizeStyleValue(k, v);
-
-      if (normalized !== undefined) filtered[k] = normalized;
+  try {
+    for (const [aiKey, modelKey] of Object.entries(styleMap)) {
+      if (!(aiKey in args) || !args[aiKey] || typeof args[aiKey] !== 'object')
+        continue;
+
+      const aiStyle = args[aiKey] as Record<string, unknown>;
+      const filtered: Record<string, unknown> = {};
+
+      for (const [k, v] of Object.entries(aiStyle)) {
+        const normalized = normalizeStyleValue(k, v);
+
+        if (normalized !== undefined) filtered[k] = normalized;
+      }
+
+      const resolved = resolveGlobalPresetIntoStyle(
+        content[modelKey] as object,
+        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 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] as string)
+      ) {
+        record[textKey] = applyColorToHtml(record[textKey] as string, newColor);
+      }
     }
-
-    const resolved = resolveGlobalPresetIntoStyle(
-      content[modelKey] as object,
-      textStyleOptions,
-    );
-
-    record[modelKey] = { ...resolved, ...filtered, textStyleType: undefined };
+  } finally {
+    editor?.destroy();
   }
 };