@designcrowd/library.brand-page 5.17.28 → 5.18.0

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

@@ -0,0 +1,31 @@
+import { MAX_TITLE_LENGTH, MAX_DESCRIPTION_LENGTH, } from '../../../brand-page/constants/font.constants';
+import { ASPECT_RATIOS } from '../../../brand-page/models';
+import { enumCheck, itemCapCheck, itemRteStyleCheck, itemTextCheck, runChecks, styleCheck, } from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+const CHECKS = [
+    ...textAndRteChecks('title', MAX_TITLE_LENGTH),
+    ...textAndRteChecks('description', MAX_DESCRIPTION_LENGTH),
+    styleCheck('title_style'),
+    styleCheck('description_style'),
+    styleCheck('heading_style'),
+    styleCheck('paragraph_style'),
+    itemTextCheck('items', 'heading', MAX_TITLE_LENGTH),
+    itemRteStyleCheck('items', 'heading'),
+    itemTextCheck('items', 'text', MAX_DESCRIPTION_LENGTH),
+    itemRteStyleCheck('items', 'text'),
+    itemTextCheck('items', 'button_text', MAX_TITLE_LENGTH),
+    itemRteStyleCheck('items', 'button_text'),
+    enumCheck('display_style', [
+        'left-aligned',
+        'right-aligned',
+        'centered',
+        'media-only',
+        'center-card-aligned-image',
+        'alternate-image',
+    ], 'images-section'),
+    enumCheck('aspect_ratio', Object.keys(ASPECT_RATIOS), 'images-section'),
+    itemCapCheck({ brandSite: 5, brandPage: 2, arrayField: 'items' }, 'images-section'),
+];
+export function validateImagesSection(args, ctx) {
+    return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,2 @@
+import { type ValidationContext } from '../../sanitizers/section-args-validator';
+export declare function validateMailingList(args: Record<string, unknown>, ctx: ValidationContext): string[];

package/lib/src/metadata-builder/builders/section-rules/mailing-list.rules.js

@@ -0,0 +1,11 @@
+import { MAX_TITLE_LENGTH } from '../../../brand-page/constants/font.constants';
+import { enumCheck, runChecks, } from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+const CHECKS = [
+    ...textAndRteChecks('title', MAX_TITLE_LENGTH),
+    ...textAndRteChecks('button_text', 25), // config-settings-constant.ts:1780 — field-specific limit
+    enumCheck('accepted_fields', ['emailOnly', 'nameAndEmail'], 'mailing-list'),
+];
+export function validateMailingList(args, ctx) {
+    return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,2 @@
+import { type ValidationContext } from '../../sanitizers/section-args-validator';
+export declare function validateProfile(args: Record<string, unknown>, ctx: ValidationContext): string[];

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

@@ -0,0 +1,14 @@
+import { MAX_TITLE_LENGTH, MAX_DESCRIPTION_LENGTH, } from '../../../brand-page/constants/font.constants';
+import { runChecks, styleCheck, } from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+const CHECKS = [
+    ...textAndRteChecks('name', MAX_TITLE_LENGTH),
+    ...textAndRteChecks('title', MAX_TITLE_LENGTH),
+    ...textAndRteChecks('description', MAX_DESCRIPTION_LENGTH),
+    styleCheck('name_style'),
+    styleCheck('title_style'),
+    styleCheck('description_style'),
+];
+export function validateProfile(args, ctx) {
+    return runChecks(CHECKS, args, ctx);
+}

package/lib/src/metadata-builder/builders/section-rules/rename-page.rules.d.ts

@@ -0,0 +1,7 @@
+export interface RenamePagePayload {
+    pageId: string;
+    pageName: string;
+}
+type PageCheck = (payload: RenamePagePayload | undefined) => string | null;
+export declare const RENAME_PAGE_CHECKS: PageCheck[];
+export {};

package/lib/src/metadata-builder/builders/section-rules/rename-page.rules.js

@@ -0,0 +1,8 @@
+import { PAGE_RULES } from '../../sanitizers/sanitizer-rules';
+export const RENAME_PAGE_CHECKS = [
+    (p) => (!p?.pageId ? 'page_id is required for rename_page' : null),
+    (p) => (!p?.pageName ? 'page_name is required for rename_page' : null),
+    (p) => p?.pageName && p.pageName.length > PAGE_RULES.pageName
+        ? `page_name exceeds the maximum length of ${PAGE_RULES.pageName} characters (got ${p.pageName.length})`
+        : null,
+];

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

@@ -0,0 +1,2 @@
+import { type ValidationContext } from '../../sanitizers/section-args-validator';
+export declare function validateShapesSection(args: Record<string, unknown>, ctx: ValidationContext): string[];

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

@@ -0,0 +1,27 @@
+import { MAX_TITLE_LENGTH, MAX_DESCRIPTION_LENGTH, } from '../../../brand-page/constants/font.constants';
+import { enumCheck, itemCapCheck, itemRteStyleCheck, itemTextCheck, runChecks, styleCheck, } from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+const CHECKS = [
+    ...textAndRteChecks('title', MAX_TITLE_LENGTH),
+    ...textAndRteChecks('description', MAX_DESCRIPTION_LENGTH),
+    styleCheck('title_style'),
+    styleCheck('description_style'),
+    styleCheck('heading_style'),
+    styleCheck('paragraph_style'),
+    itemTextCheck('items', 'heading', MAX_TITLE_LENGTH),
+    itemRteStyleCheck('items', 'heading'),
+    itemTextCheck('items', 'text', MAX_DESCRIPTION_LENGTH),
+    itemRteStyleCheck('items', 'text'),
+    enumCheck('display_style', [
+        'left-aligned',
+        'right-aligned',
+        'centered',
+        'media-only',
+        'center-card-aligned-image',
+        'alternate-image',
+    ], 'shapes-section'),
+    itemCapCheck({ brandSite: 5, brandPage: 2, arrayField: 'items' }, 'shapes-section'),
+];
+export function validateShapesSection(args, ctx) {
+    return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,2 @@
+import { type ValidationContext } from '../../sanitizers/section-args-validator';
+export declare function validateSocialLinks(args: Record<string, unknown>, ctx: ValidationContext): string[];

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

@@ -0,0 +1,9 @@
+import { SOCIAL_LINKS_ICON_DISPLAY_STYLES } from '../../../brand-page/models';
+import { enumCheck, itemCapCheck, runChecks, } from '../../sanitizers/section-args-validator';
+const CHECKS = [
+    enumCheck('icon_style', Object.keys(SOCIAL_LINKS_ICON_DISPLAY_STYLES), 'social-links'),
+    itemCapCheck({ brandSite: 4, brandPage: 4, arrayField: 'links' }, 'social-links'),
+];
+export function validateSocialLinks(args, ctx) {
+    return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,7 @@
+import { type ValidationContext } from '../../sanitizers/section-args-validator';
+export declare const TESTIMONIAL_ITEM_CAP: {
+    readonly brandSite: 3;
+    readonly brandPage: 3;
+    readonly arrayField: "items";
+};
+export declare function validateTestimonialSection(args: Record<string, unknown>, ctx: ValidationContext): string[];

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

@@ -0,0 +1,26 @@
+import { MAX_TITLE_LENGTH, MAX_DESCRIPTION_LENGTH, } from '../../../brand-page/constants/font.constants';
+import { enumCheck, itemCapCheck, itemRteStyleCheck, itemTextCheck, runChecks, styleCheck, } from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+export const TESTIMONIAL_ITEM_CAP = {
+    brandSite: 3,
+    brandPage: 3,
+    arrayField: 'items',
+};
+const CHECKS = [
+    ...textAndRteChecks('title', MAX_TITLE_LENGTH),
+    styleCheck('title_style'),
+    styleCheck('testimonial_style'),
+    styleCheck('name_style'),
+    styleCheck('position_style'),
+    itemTextCheck('items', 'testimonial', MAX_DESCRIPTION_LENGTH),
+    itemRteStyleCheck('items', 'testimonial'),
+    itemTextCheck('items', 'name', MAX_TITLE_LENGTH),
+    itemRteStyleCheck('items', 'name'),
+    itemTextCheck('items', 'position', MAX_TITLE_LENGTH),
+    itemRteStyleCheck('items', 'position'),
+    enumCheck('display_style', ['centered', 'big-image', 'columns'], 'testimonial-section'),
+    itemCapCheck(TESTIMONIAL_ITEM_CAP, 'testimonial-section'),
+];
+export function validateTestimonialSection(args, ctx) {
+    return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,2 @@
+import { type ValidationContext } from '../../sanitizers/section-args-validator';
+export declare function validateTextSection(args: Record<string, unknown>, ctx: ValidationContext): string[];

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

@@ -0,0 +1,14 @@
+import { MAX_TEXT_LENGTH } from '../../../brand-page/constants/font.constants';
+import { enumCheck, itemRteStyleCheck, itemStyleCheck, itemTextCheck, runChecks, styleCheck, } from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+const CHECKS = [
+    ...textAndRteChecks('text', MAX_TEXT_LENGTH),
+    styleCheck('text_style'),
+    itemTextCheck('items', 'text', MAX_TEXT_LENGTH),
+    itemRteStyleCheck('items', 'text'),
+    itemStyleCheck('items', 'text_style'),
+    enumCheck('column_style', ['1', '2', '3', '4'], 'text'),
+];
+export function validateTextSection(args, ctx) {
+    return runChecks(CHECKS, args, ctx);
+}

package/lib/src/metadata-builder/builders/shape-color-utils.d.ts

@@ -0,0 +1,26 @@
+import type { ColorReplacement } from '../../brand-page/models';
+/**
+ * Fetch a shape's SVG and return concrete identity-mapped `ColorReplacement`
+ * entries, one per unique fill. Caller applies `color_theme` via
+ * `applyColorThemeToReplacements` as a second step when re-shading is needed.
+ *
+ * Returns `[]` for proxy URLs — those are served through `/asset/shape?...`
+ * and cannot be fetched for colour enumeration (render path renders them via
+ * `<object>` instead of downloading the SVG).
+ *
+ * Uses the svg-parser-based server variant (not DOMParser) so this works
+ * unchanged in both browser and SSR/test environments. For AI-authored shapes
+ * with style/class/direct fills, this covers every case; CSS computed-style
+ * only matters for shapes authored outside the AI flow.
+ *
+ * Throws on network or HTTP failure — no silent fallback.
+ */
+export declare const resolveShapeColorReplacementsAsync: (shapeUrl: string) => Promise<ColorReplacement[]>;
+/**
+ * Re-shade each entry's `replacementColor` to a luminance-preserving variant
+ * of `colorTheme`. Pure transformation over the existing array — no network.
+ *
+ * An empty input returns an empty array by design; the caller is expected to
+ * populate concrete entries via `resolveShapeColorReplacementsAsync` first.
+ */
+export declare const applyColorThemeToReplacements: (replacements: ColorReplacement[], colorTheme: string) => ColorReplacement[];

package/lib/src/metadata-builder/builders/shape-color-utils.js

@@ -0,0 +1,52 @@
+import { PROXY_SHAPE_URL_REGEX } from '../../brand-page/constants';
+import { getNewColorBasedOnTargetColorTheme } from '../../brand-page/utils/color.util';
+import { getColorReplacementsFromSvgStringServer } from '../../brand-page/utils/svg-color.util';
+/**
+ * Fetch a shape's SVG and return concrete identity-mapped `ColorReplacement`
+ * entries, one per unique fill. Caller applies `color_theme` via
+ * `applyColorThemeToReplacements` as a second step when re-shading is needed.
+ *
+ * Returns `[]` for proxy URLs — those are served through `/asset/shape?...`
+ * and cannot be fetched for colour enumeration (render path renders them via
+ * `<object>` instead of downloading the SVG).
+ *
+ * Uses the svg-parser-based server variant (not DOMParser) so this works
+ * unchanged in both browser and SSR/test environments. For AI-authored shapes
+ * with style/class/direct fills, this covers every case; CSS computed-style
+ * only matters for shapes authored outside the AI flow.
+ *
+ * Throws on network or HTTP failure — no silent fallback.
+ */
+export const resolveShapeColorReplacementsAsync = async (shapeUrl) => {
+    if (!shapeUrl || shapeUrl.match(PROXY_SHAPE_URL_REGEX)) {
+        return [];
+    }
+    const response = await fetch(shapeUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch shape for colour enumeration (${response.status}): ${shapeUrl}`);
+    }
+    const svgText = await response.text();
+    const replacements = getColorReplacementsFromSvgStringServer(svgText);
+    // The server-side colour enumeration produces phantom #000000 entries from
+    // DEFAULT_FALLBACK_COLOR for elements whose class-based fill can't be
+    // resolved. Filter them out when real fill colours exist.
+    if (replacements.length > 1) {
+        const withoutPhantom = replacements.filter((r) => r.originalColor !== '#000000');
+        if (withoutPhantom.length > 0)
+            return withoutPhantom;
+    }
+    return replacements;
+};
+/**
+ * Re-shade each entry's `replacementColor` to a luminance-preserving variant
+ * of `colorTheme`. Pure transformation over the existing array — no network.
+ *
+ * An empty input returns an empty array by design; the caller is expected to
+ * populate concrete entries via `resolveShapeColorReplacementsAsync` first.
+ */
+export const applyColorThemeToReplacements = (replacements, colorTheme) => replacements.map((r) => ({
+    ...r,
+    replacementColor: replacements.length === 1
+        ? colorTheme
+        : getNewColorBasedOnTargetColorTheme(r.originalColor, colorTheme)?.toString() ?? colorTheme,
+}));

package/lib/src/metadata-builder/builders/undo-builder.d.ts

@@ -0,0 +1,48 @@
+import { type BrandPageModel } from '../../brand-page/models';
+import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../models';
+import type { Logger } from '../logger';
+/**
+ * Resolver called at undo-execution time to fetch the snapshot to restore to.
+ *
+ * Returning `null` means there is no snapshot available (e.g. fresh session,
+ * or the website has never been modified). The UndoBuilder surfaces this as
+ * a validation error so the caller can show a meaningful message.
+ *
+ * Async supported: the handler may return a `Promise<BrandPageModel | null>`
+ * if resolution involves I/O (IndexedDB, remote store, etc.). Sync returns
+ * work too — `await` is a no-op on non-promises.
+ */
+export type UndoHandler = () => BrandPageModel | null | Promise<BrandPageModel | null>;
+/**
+ * Payload for the UndoBuilder.
+ *
+ * The snapshot itself is not stored in the payload. Instead, the payload
+ * carries an {@link UndoHandler} callback that the builder invokes at
+ * execute time to lazily resolve the snapshot. This keeps the library
+ * agnostic about *how* snapshots are stored — the caller owns that concern.
+ */
+export interface UndoPayload {
+    undoHandler: UndoHandler;
+}
+/**
+ * UndoBuilder — executes the `undo` tool call by invoking the caller-supplied
+ * {@link UndoHandler} callback to resolve the snapshot, then replaces the
+ * current model with that snapshot. Also sets
+ * {@link BuilderResult.undoRequested} on the returned result so the caller
+ * can observe that an undo was executed (useful for telemetry, UI messaging,
+ * and audit logs).
+ *
+ * Contract guarantee from the AI pipeline (Website Planner WL9): the `undo`
+ * tool call is exclusive — it never co-occurs with build/update/delete tool
+ * calls in the same response. If that contract is ever violated upstream,
+ * fix the planner — do not add defensive ordering here. The sequential
+ * MetadataExecutor will apply any subsequent builders on top of the restored
+ * snapshot, which is the semantically correct "undo-then-apply" ordering.
+ */
+export declare class UndoBuilder extends BaseMetadataBuilder<UndoPayload> {
+    constructor(request: MetadataBuilderRequest<UndoPayload>, logger?: Logger);
+    validateAsync(): Promise<{
+        errors: string[];
+    }>;
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+}

package/lib/src/metadata-builder/builders/undo-builder.js

@@ -0,0 +1,58 @@
+import cloneDeep from 'lodash.clonedeep';
+import {} from '../../brand-page/models';
+import { BaseMetadataBuilder, } from '../models';
+/**
+ * UndoBuilder — executes the `undo` tool call by invoking the caller-supplied
+ * {@link UndoHandler} callback to resolve the snapshot, then replaces the
+ * current model with that snapshot. Also sets
+ * {@link BuilderResult.undoRequested} on the returned result so the caller
+ * can observe that an undo was executed (useful for telemetry, UI messaging,
+ * and audit logs).
+ *
+ * Contract guarantee from the AI pipeline (Website Planner WL9): the `undo`
+ * tool call is exclusive — it never co-occurs with build/update/delete tool
+ * calls in the same response. If that contract is ever violated upstream,
+ * fix the planner — do not add defensive ordering here. The sequential
+ * MetadataExecutor will apply any subsequent builders on top of the restored
+ * snapshot, which is the semantically correct "undo-then-apply" ordering.
+ */
+export class UndoBuilder extends BaseMetadataBuilder {
+    constructor(request, logger) {
+        super(request, logger);
+    }
+    async validateAsync() {
+        const errors = [];
+        const payload = this.request.payload;
+        if (typeof payload?.undoHandler !== 'function') {
+            errors.push('undo requires an `undoHandler` callback in the payload — caller must supply a function that resolves the pre-prompt snapshot');
+        }
+        return { errors };
+    }
+    async buildAsync(model) {
+        this.log('Build called');
+        const validation = await this.validateAsync();
+        if (validation.errors.length) {
+            return { request: this.request, model, errors: validation.errors };
+        }
+        const snapshot = await this.request.payload.undoHandler();
+        if (!snapshot) {
+            return {
+                request: this.request,
+                model,
+                errors: ['There are no previous snapshots to restore.'],
+            };
+        }
+        // Deep-clone the resolved snapshot so downstream builders (if any —
+        // exclusivity is enforced at the planner level but we don't rely on it
+        // here) mutate a fresh copy rather than the caller's stored snapshot.
+        const restored = cloneDeep(snapshot);
+        this.log({
+            message: 'Undo executed — model replaced with pre-prompt snapshot',
+        });
+        return {
+            request: this.request,
+            model: restored,
+            undoRequested: true,
+        };
+    }
+}

package/lib/src/metadata-builder/builders/update-content-text-style-builder.js

@@ -118,7 +118,7 @@ export class UpdateContentTextStyleBuilder extends BaseMetadataBuilder {
     validateAsync() {
         const { newStyles } = this.request.payload;
         const errors = [];
-        // Validate lineHeight: must be between 0 and 2.5 inclusive
+        // Validate lineHeight: must be between 0 and 2.5 inclusive, snap to 0.1 step
         if (newStyles.lineHeight !== undefined && newStyles.lineHeight !== null) {
             const lineHeightValue = parseFloat(String(newStyles.lineHeight));
             if (isNaN(lineHeightValue) ||
@@ -126,6 +126,10 @@ export class UpdateContentTextStyleBuilder extends BaseMetadataBuilder {
                 lineHeightValue > 2.5) {
                 errors.push('Line height must be a value between 0 and 2.5 inclusive.');
             }
+            else {
+                // Snap to 0.1 increments to match the UI slider step
+                newStyles.lineHeight = String(Math.floor(lineHeightValue * 10) / 10);
+            }
         }
         // Validate and normalize letterSpacing: AI sends unitless 0-100, convert to em
         if (newStyles.letterSpacing !== undefined &&

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

@@ -2,8 +2,19 @@ import type { TextStyleDeclaration } from '../../brand-page';
 import type { Editor } from '@tiptap/vue-3';
 export declare const applyStyleToRTEText: (externalEditor: Editor, contentText: string, newContentStyle: TextStyleDeclaration) => string;
 /**
- * If `text` contains RTE markup, re-applies `style` to the RTE content
- * so inline formatting matches the updated TextStyleDeclaration.
- * Returns the original text unchanged when it has no RTE content.
+ * Converts a Tiptap JSON document (ProseMirror document model) to an HTML
+ * string using a headless Tiptap Editor instance.
+ *
+ * Returns the value unchanged if it is already a string.
+ * Returns an empty string for null/undefined.
+ *
+ * Note: Tiptap's `setContent` does NOT throw on malformed input — it
+ * silently drops content and returns `<p></p>`. To prevent saved copy
+ * being wiped (BP-5669), structural validity of any AI-emitted Tiptap
+ * doc is checked upstream by `rteSchemaCheck` in
+ * `section-args-validator.ts` using the editor's real ProseMirror
+ * schema. The validator surfaces a clear error into
+ * `BuilderResult.errors`, which the AI-chat retry loop reads via
+ * `tool_result.errorMessage` and uses to re-emit a corrected payload.
  */
-export declare const updateRTEText: (text: string, style: TextStyleDeclaration) => string;
+export declare const tiptapJsonToHtml: (value: unknown) => string;

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

@@ -1,7 +1,8 @@
-import { getRTEColor, hasRTEContent } from '../../brand-page-maker/utils';
+import { getRTEColor } from '../../brand-page-maker/utils';
 import { useExternalRichTextEditor } from '../../brand-page-maker/composables/rich-text-editor/useRichTextEditor';
 import { getRenderText } from '../../brand-page/utils';
 import { ESCAPED_NEWLINE_CHARACTER } from '../../constants/ui';
+import { isTiptapDocument, } from '../parsers/section-tool-arguments';
 export const applyStyleToRTEText = (externalEditor, contentText, newContentStyle) => {
     if (!contentText) {
         return contentText;
@@ -56,16 +57,29 @@ export const applyStyleToRTEText = (externalEditor, contentText, newContentStyle
     return html;
 };
 /**
- * If `text` contains RTE markup, re-applies `style` to the RTE content
- * so inline formatting matches the updated TextStyleDeclaration.
- * Returns the original text unchanged when it has no RTE content.
+ * Converts a Tiptap JSON document (ProseMirror document model) to an HTML
+ * string using a headless Tiptap Editor instance.
+ *
+ * Returns the value unchanged if it is already a string.
+ * Returns an empty string for null/undefined.
+ *
+ * Note: Tiptap's `setContent` does NOT throw on malformed input — it
+ * silently drops content and returns `<p></p>`. To prevent saved copy
+ * being wiped (BP-5669), structural validity of any AI-emitted Tiptap
+ * doc is checked upstream by `rteSchemaCheck` in
+ * `section-args-validator.ts` using the editor's real ProseMirror
+ * schema. The validator surfaces a clear error into
+ * `BuilderResult.errors`, which the AI-chat retry loop reads via
+ * `tool_result.errorMessage` and uses to re-emit a corrected payload.
  */
-export const updateRTEText = (text, style) => {
-    if (!text || typeof text !== 'string' || !hasRTEContent(text)) {
-        return text;
-    }
+export const tiptapJsonToHtml = (value) => {
+    if (typeof value === 'string')
+        return value;
+    if (!isTiptapDocument(value))
+        return '';
     const { externalEditor } = useExternalRichTextEditor();
-    const updatedText = applyStyleToRTEText(externalEditor, text, style);
+    externalEditor.commands.setContent(value);
+    const html = externalEditor.getHTML();
     externalEditor.destroy();
-    return updatedText;
+    return html;
 };

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

@@ -1,6 +1,7 @@
 import { type BrandPageModel } from '../brand-page/models';
 import { type MetadataBuilderRequest, type MetadataExecutorResult } from './models';
+import type { EventTracker } from '../brand-page-maker/composables/useEventTracker';
 import type { Logger } from './logger';
 export declare class MetadataExecutor {
-    executeAsync(metadata: BrandPageModel, requests: MetadataBuilderRequest[], logger?: Logger): Promise<MetadataExecutorResult>;
+    executeAsync(metadata: BrandPageModel, requests: MetadataBuilderRequest[], logger?: Logger, eventTracker?: EventTracker): Promise<MetadataExecutorResult>;
 }

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

@@ -3,15 +3,21 @@ import {} from '../brand-page/models';
 import { BUILDER_TYPES, } from './models';
 import { UpdateContentTextBuilder } from './builders/update-content-text-builder';
 import { UpdateContentTextStyleBuilder } from './builders/update-content-text-style-builder';
-import { BannerSectionBuilder, AboutSectionBuilder, ContactFormBuilder, DividerSectionBuilder, TextSectionBuilder, TestimonialSectionBuilder, ImagesSectionBuilder, ShapesSectionBuilder, SocialLinksBuilder, ImageGalleryBuilder, ProfileSectionBuilder, MailingListSectionBuilder, ButtonSectionBuilder, DeleteSectionBuilder, MoveSectionBuilder, } from './builders/section-builders';
+import { BannerSectionBuilder, BookingSectionBuilder, 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';
 import { RemovePageBuilder } from './builders/remove-page-builder';
+import { RenamePageBuilder } from './builders/rename-page-builder';
+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';
 // Lazy initialization to avoid circular dependency issues
 const getBuilderRegistry = () => ({
     [BUILDER_TYPES.UPDATE_CONTENT_TEXT]: UpdateContentTextBuilder,
     [BUILDER_TYPES.UPDATE_CONTENT_TEXT_STYLE]: UpdateContentTextStyleBuilder,
     // Section builders (create)
     [BUILDER_TYPES.CREATE_BANNER_SECTION]: BannerSectionBuilder,
+    [BUILDER_TYPES.CREATE_BOOKING_SECTION]: BookingSectionBuilder,
     [BUILDER_TYPES.CREATE_ABOUT_SECTION]: AboutSectionBuilder,
     [BUILDER_TYPES.CREATE_CONTACT_FORM]: ContactFormBuilder,
     [BUILDER_TYPES.CREATE_DIVIDER_SECTION]: DividerSectionBuilder,
@@ -37,6 +43,7 @@ const getBuilderRegistry = () => ({
     [BUILDER_TYPES.CREATE_TIKTOK]: ButtonSectionBuilder,
     // Section builders (update)
     [BUILDER_TYPES.UPDATE_BANNER_SECTION]: BannerSectionBuilder,
+    [BUILDER_TYPES.UPDATE_BOOKING_SECTION]: BookingSectionBuilder,
     [BUILDER_TYPES.UPDATE_ABOUT_SECTION]: AboutSectionBuilder,
     [BUILDER_TYPES.UPDATE_CONTACT_FORM]: ContactFormBuilder,
     [BUILDER_TYPES.UPDATE_DIVIDER_SECTION]: DividerSectionBuilder,
@@ -66,9 +73,18 @@ const getBuilderRegistry = () => ({
     // Page-level operations
     [BUILDER_TYPES.ADD_PAGE]: AddPageBuilder,
     [BUILDER_TYPES.REMOVE_PAGE]: RemovePageBuilder,
+    [BUILDER_TYPES.RENAME_PAGE]: RenamePageBuilder,
+    // Footer operations
+    [BUILDER_TYPES.UPDATE_FOOTER]: FooterBuilder,
+    // Global styles operations
+    [BUILDER_TYPES.UPDATE_GLOBAL_STYLES]: GlobalStylesBuilder,
+    // Header operations
+    [BUILDER_TYPES.UPDATE_HEADER]: HeaderBuilder,
+    // Website-level operations
+    [BUILDER_TYPES.UNDO_WEBSITE]: UndoBuilder,
 });
 let builderRegistry = null;
-const resolveBuilder = (request, logger) => {
+const resolveBuilder = (request, logger, eventTracker) => {
     if (!builderRegistry) {
         builderRegistry = getBuilderRegistry();
     }
@@ -77,14 +93,14 @@ const resolveBuilder = (request, logger) => {
         console.error(`No builder registered for request type: "${request.type}"`);
         return null;
     }
-    return new BuilderClass(request, logger);
+    return new BuilderClass(request, logger, eventTracker);
 };
 export class MetadataExecutor {
-    async executeAsync(metadata, requests, logger) {
+    async executeAsync(metadata, requests, logger, eventTracker) {
         let model = cloneDeep(metadata);
         const results = [];
         for (const request of requests) {
-            const builder = resolveBuilder(request, logger);
+            const builder = resolveBuilder(request, logger, eventTracker);
             if (!builder) {
                 results.push({
                     request,
@@ -94,6 +110,17 @@ export class MetadataExecutor {
                 continue;
             }
             const result = await builder.buildAsync(model);
+            // Surface the section's resolved content id on the result. The AI-chat
+            // retry path uses this to fill its vacant-slot tracker so a previously
+            // failed CREATE can re-enter its planned position on the page. Done at
+            // the executor level so individual builders don't have to remember to
+            // populate the field on every code path.
+            const resolveContentId = builder.getResolvedContentId?.bind(builder);
+            if (resolveContentId && !result.contentId) {
+                const cid = resolveContentId();
+                if (cid)
+                    result.contentId = cid;
+            }
             results.push(result);
             model = result.model;
         }

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

@@ -1,4 +1,5 @@
 import { type BrandPageModel } from '../brand-page/models';
+import type { EventTracker } from '../brand-page-maker/composables/useEventTracker';
 import type { Logger } from './logger';
 export declare const BUILDER_TYPES: {
     readonly UPDATE_CONTENT_TEXT: "update-content-text";
@@ -27,6 +28,7 @@ export declare const BUILDER_TYPES: {
     readonly CREATE_PINTEREST: "create-pinterest";
     readonly CREATE_TWITCH: "create-twitch";
     readonly CREATE_TIKTOK: "create-tiktok";
+    readonly CREATE_BOOKING_SECTION: "create-booking-section";
     readonly UPDATE_BANNER_SECTION: "update-banner-section";
     readonly UPDATE_ABOUT_SECTION: "update-about-section";
     readonly UPDATE_CONTACT_FORM: "update-contact-form";
@@ -51,10 +53,16 @@ export declare const BUILDER_TYPES: {
     readonly UPDATE_PINTEREST: "update-pinterest";
     readonly UPDATE_TWITCH: "update-twitch";
     readonly UPDATE_TIKTOK: "update-tiktok";
+    readonly UPDATE_BOOKING_SECTION: "update-booking-section";
     readonly DELETE_SECTION: "delete-section";
     readonly MOVE_SECTION: "move-section";
     readonly ADD_PAGE: "add-page";
     readonly REMOVE_PAGE: "remove-page";
+    readonly RENAME_PAGE: "rename-page";
+    readonly UPDATE_FOOTER: "update-footer";
+    readonly UPDATE_GLOBAL_STYLES: "update-global-styles";
+    readonly UPDATE_HEADER: "update-header";
+    readonly UNDO_WEBSITE: "undo-website";
 };
 export type BuilderType = (typeof BUILDER_TYPES)[keyof typeof BUILDER_TYPES];
 export interface MetadataBuilderRequest<T = unknown> {
@@ -74,11 +82,28 @@ export interface BuilderResult {
     request: MetadataBuilderRequest;
     model: BrandPageModel;
     errors?: string[];
+    /**
+     * Set by the UndoBuilder to signal that the caller should restore the
+     * website to the snapshot taken before the most recent change-producing
+     * prompt. The model returned alongside this flag is unchanged — the actual
+     * snapshot restore happens outside this library.
+     */
+    undoRequested?: boolean;
+    /**
+     * The frontend-assigned content ID of the section this builder created or
+     * updated. Populated for section CREATE flows so callers can anchor
+     * downstream operations (notably the AI retry path's vacant-slot tracking)
+     * to the resolved content. Undefined on failure, on non-section builders
+     * (page-level ops, undo), and on builders that don't touch a single
+     * content (e.g. global-styles).
+     */
+    contentId?: string;
 }
 export declare abstract class BaseMetadataBuilder<T = unknown> {
     protected request: MetadataBuilderRequest<T>;
     protected logger?: Logger;
-    constructor(request: MetadataBuilderRequest<T>, logger?: Logger);
+    protected eventTracker?: EventTracker;
+    constructor(request: MetadataBuilderRequest<T>, logger?: Logger, eventTracker?: EventTracker);
     abstract validateAsync(): Promise<{
         errors: string[];
     }>;