@designcrowd/library.brand-page 5.17.28 → 5.18.0

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

@@ -1,8 +1,29 @@
 import { type BrandPageModel } from '../brand-page/models';
+import type { EventTracker } from '../brand-page-maker/composables/useEventTracker';
+import type { UndoHandler } from './builders/undo-builder';
 import type { Logger } from './logger';
 import { type MetadataExecutorResult } from './models';
 import { type ParsedToolCall } from './parsers/ai-toolcall-parser';
 export declare const executeToolCallsAsync: (metadata: BrandPageModel, toolcalls: ParsedToolCall[], options: {
     logger?: Logger;
     maxCharacters?: number;
+    /**
+     * Callback invoked by the UndoBuilder at execution time to resolve the
+     * pre-prompt snapshot to restore to. The library is agnostic about where
+     * the snapshot lives — the caller decides (e.g. read from a Pinia store,
+     * IndexedDB, remote API). Return `null` when no snapshot is available;
+     * the UndoBuilder will surface a clear error.
+     *
+     * Required when the toolcalls include an `undo` call. If omitted, the
+     * library substitutes a `() => null` handler so undo produces a
+     * well-defined error rather than a cryptic failure.
+     */
+    undoHandler?: UndoHandler;
+    /**
+     * Optional AI-prompt-originated event tracker. When provided, builders
+     * that add or remove sections invoke the tracker at the mutation point.
+     * Passed by reference so thread/build IDs and user plan can be resolved
+     * fresh at fire time by the composable layer.
+     */
+    eventTracker?: EventTracker;
 }) => Promise<MetadataExecutorResult>;

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

@@ -3,7 +3,10 @@ import { buildUpdateTextRequest } from './builders/update-content-text-builder';
 import { buildUpdateTextStyleRequest } from './builders/update-content-text-style-builder';
 import { MetadataExecutor } from './metadata-executor';
 import { BUILDER_TYPES, } from './models';
-import { AI_ASSISTANT_TOOL_NAMES, SECTION_TOOL_MAP, } from './parsers/ai-toolcall-parser';
+import { AI_ASSISTANT_TOOL_NAMES, SECTION_TOOL_MAP,
+// UndoArguments intentionally not destructured here — the undo tool call has
+// no fields. Its presence is the entire signal.
+ } from './parsers/ai-toolcall-parser';
 export const executeToolCallsAsync = async (metadata, toolcalls, options) => {
     const requests = toolcalls
         .map((toolcall) => {
@@ -68,13 +71,62 @@ export const executeToolCallsAsync = async (metadata, toolcalls, options) => {
                     },
                 };
             }
+            case AI_ASSISTANT_TOOL_NAMES.RENAME_PAGE: {
+                const arg = toolcall.arguments;
+                return {
+                    id: toolcall.toolId,
+                    type: BUILDER_TYPES.RENAME_PAGE,
+                    payload: {
+                        pageId: arg.page_id,
+                        pageName: arg.page_name,
+                    },
+                };
+            }
+            case AI_ASSISTANT_TOOL_NAMES.UPDATE_FOOTER: {
+                const arg = toolcall.arguments;
+                return {
+                    id: toolcall.toolId,
+                    type: BUILDER_TYPES.UPDATE_FOOTER,
+                    payload: arg,
+                };
+            }
+            case AI_ASSISTANT_TOOL_NAMES.UPDATE_GLOBAL_STYLES: {
+                const arg = toolcall.arguments;
+                return {
+                    id: toolcall.toolId,
+                    type: BUILDER_TYPES.UPDATE_GLOBAL_STYLES,
+                    payload: arg,
+                };
+            }
+            case AI_ASSISTANT_TOOL_NAMES.UPDATE_HEADER: {
+                const arg = toolcall.arguments;
+                return {
+                    id: toolcall.toolId,
+                    type: BUILDER_TYPES.UPDATE_HEADER,
+                    payload: arg,
+                };
+            }
+            case AI_ASSISTANT_TOOL_NAMES.UNDO: {
+                // The undo tool has no wire arguments — the builder resolves the
+                // snapshot by invoking the caller-supplied undoHandler at execute
+                // time. If the caller didn't supply one, substitute a null-returning
+                // handler so the builder surfaces a clear "nothing to restore"
+                // error rather than a vaguer validation failure.
+                return {
+                    id: toolcall.toolId,
+                    type: BUILDER_TYPES.UNDO_WEBSITE,
+                    payload: {
+                        undoHandler: options.undoHandler ?? (() => null),
+                    },
+                };
+            }
             default: {
                 const sectionTool = SECTION_TOOL_MAP[toolcall.function];
                 if (!sectionTool) {
                     console.warn(`[executeToolCallsAsync] Skipping unsupported tool call: ${toolcall.function}`);
                     return null;
                 }
-                const { mode, content_id: contentId, page_id: pageId, arguments: sectionArgs, } = toolcall.arguments;
+                const { mode, content_id: contentId, page_id: pageId, move_before_content_id: moveBeforeContentId, arguments: sectionArgs, } = toolcall.arguments;
                 const builderType = `${mode}-${sectionTool.sectionType}`;
                 return {
                     id: toolcall.toolId,
@@ -84,6 +136,7 @@ export const executeToolCallsAsync = async (metadata, toolcalls, options) => {
                         contentId: contentId,
                         arguments: sectionArgs,
                         pageId: pageId,
+                        moveBeforeContentId: moveBeforeContentId,
                     },
                 };
             }
@@ -92,5 +145,5 @@ export const executeToolCallsAsync = async (metadata, toolcalls, options) => {
         .filter((r) => r !== null);
     options.logger?.log('executeToolCallsAsync', { requests });
     const executor = new MetadataExecutor();
-    return await executor.executeAsync(metadata, requests, options.logger);
+    return await executor.executeAsync(metadata, requests, options.logger, options.eventTracker);
 };

package/lib/src/metadata-builder/builders/add-page-builder.d.ts

@@ -1,10 +1,8 @@
 import { type BrandPageModel } from '../../brand-page/models';
 import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../models';
 import type { Logger } from '../logger';
-export interface AddPagePayload {
-    pageId: string;
-    pageName: string;
-}
+import { type AddPagePayload } from './section-rules/add-page.rules';
+export type { AddPagePayload };
 export declare class AddPageBuilder extends BaseMetadataBuilder<AddPagePayload> {
     constructor(request: MetadataBuilderRequest<AddPagePayload>, logger?: Logger);
     validateAsync(): Promise<{

package/lib/src/metadata-builder/builders/add-page-builder.js

@@ -1,19 +1,16 @@
 import { PageModel } from '../../brand-page/models';
 import { getPageSlugFromPageTitle } from '../../brand-page-maker/utils/slug.util';
 import { BaseMetadataBuilder, } from '../models';
+import { ADD_PAGE_CHECKS, } from './section-rules/add-page.rules';
 export class AddPageBuilder extends BaseMetadataBuilder {
     constructor(request, logger) {
         super(request, logger);
     }
     async validateAsync() {
-        const errors = [];
-        const payload = this.request.payload;
-        if (!payload?.pageId) {
-            errors.push('page_id is required for add_page');
-        }
-        if (!payload?.pageName) {
-            errors.push('page_name is required for add_page');
-        }
+        const errors = ADD_PAGE_CHECKS.flatMap((check) => {
+            const err = check(this.request.payload);
+            return err ? [err] : [];
+        });
         return { errors };
     }
     async buildAsync(model) {

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

@@ -0,0 +1,11 @@
+import { type BrandPageModel } from '../../brand-page/models';
+import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../models';
+import type { UpdateFooterArguments } from '../parsers/ai-toolcall-parser';
+import type { Logger } from '../logger';
+export declare class FooterBuilder extends BaseMetadataBuilder<UpdateFooterArguments> {
+    constructor(request: MetadataBuilderRequest<UpdateFooterArguments>, logger?: Logger);
+    validateAsync(): Promise<{
+        errors: string[];
+    }>;
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+}

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

@@ -0,0 +1,151 @@
+import {} from '../../brand-page/models';
+import { BaseMetadataBuilder, } from '../models';
+import { FOOTER_CHECKS } from './section-rules/footer.rules';
+import { applyDetachedStyleOverride } from './section-field-utils';
+const normaliseSocialUrl = (url) => {
+    for (const prefix of ['mailto:', 'tel:']) {
+        if (url.startsWith(prefix))
+            return url.slice(prefix.length);
+    }
+    return url;
+};
+const applyGlobalFooterChanges = (footer, args, textStyleOptions) => {
+    if (args.copyright_text !== undefined)
+        footer.copyrightText = args.copyright_text;
+    if (args.copyright_text_font_family !== undefined)
+        footer.copyrightStyle = applyDetachedStyleOverride(footer.copyrightStyle, { fontFamily: args.copyright_text_font_family }, textStyleOptions);
+    const links = args.social_links;
+    // _replace_social_links: replace entire list (empty/absent social_links = clear all).
+    // When replacing, all other social link mutations (remove, insert, reorder) are skipped —
+    // they are superseded by the replacement and running them would cause duplicates.
+    if (args._replace_social_links) {
+        footer.socialLinks = (links ?? []).map((l) => ({
+            imageUrl: l.social_link_icon || '',
+            url: normaliseSocialUrl(l.url || ''),
+            imageTitle: '',
+            width: 0,
+            height: 0,
+            imageLink: '',
+        }));
+    }
+    else {
+        // Targeted mutations — only run when NOT replacing the entire list.
+        // item_index-based updates for existing links
+        if (links?.length) {
+            for (const link of links) {
+                if (link.item_index === undefined)
+                    continue;
+                const existing = footer.socialLinks?.[link.item_index];
+                if (!existing)
+                    continue;
+                if (link.social_link_icon !== undefined)
+                    existing.imageUrl = link.social_link_icon;
+                if (link.url !== undefined)
+                    existing.url = normaliseSocialUrl(link.url);
+            }
+        }
+        // Remove by index (descending order to preserve indices during splice)
+        if (args._remove_social_link_indices?.length && footer.socialLinks) {
+            const sorted = [...args._remove_social_link_indices].sort((a, b) => b - a);
+            for (const idx of sorted) {
+                if (idx >= 0 && idx < footer.socialLinks.length)
+                    footer.socialLinks.splice(idx, 1);
+            }
+        }
+        // Insert new links (descending insert_at order to preserve positions during splice)
+        const insertLinks = (links ?? []).filter((l) => l.insert_at !== undefined && l.item_index === undefined);
+        const sortedInserts = [...insertLinks].sort((a, b) => b.insert_at - a.insert_at);
+        for (const link of sortedInserts) {
+            const pos = Math.max(0, Math.min(link.insert_at, footer.socialLinks?.length ?? 0));
+            footer.socialLinks = footer.socialLinks ?? [];
+            footer.socialLinks.splice(pos, 0, {
+                imageUrl: link.social_link_icon || '',
+                url: normaliseSocialUrl(link.url || ''),
+                imageTitle: '',
+                width: 0,
+                height: 0,
+                imageLink: '',
+            });
+        }
+        // Reorder (requires ALL indices — partial reorder is not supported)
+        if (args._reorder_social_links?.length && footer.socialLinks) {
+            const newOrder = args._reorder_social_links;
+            const unique = new Set(newOrder);
+            if (unique.size === newOrder.length &&
+                newOrder.every((idx) => idx >= 0 && idx < footer.socialLinks.length)) {
+                const reordered = newOrder.map((idx) => footer.socialLinks[idx]);
+                if (reordered.length === footer.socialLinks.length)
+                    footer.socialLinks = reordered;
+            }
+        }
+    }
+};
+const applyViewportFooterChanges = (footer, overrides) => {
+    if (overrides.display_style !== undefined)
+        footer.displayStyle = overrides.display_style;
+    if (overrides.background_color !== undefined) {
+        footer.backgroundStyle = {
+            ...footer.backgroundStyle,
+            backgroundColor: overrides.background_color ?? '',
+        };
+    }
+    if (overrides.icon_color !== undefined)
+        footer.iconStyle = {
+            ...footer.iconStyle,
+            color: overrides.icon_color,
+            fill: overrides.icon_color,
+        };
+    if (overrides.copyright_text_color !== undefined)
+        footer.copyrightStyle = {
+            ...footer.copyrightStyle,
+            color: overrides.copyright_text_color,
+        };
+    if (overrides.is_logo_visible !== undefined)
+        footer.isLogoVisible = overrides.is_logo_visible;
+    if (overrides.logo_image_height !== undefined)
+        footer.logoImageHeight = overrides.logo_image_height;
+    if (overrides.logo_image_width !== undefined)
+        footer.logoImageWidth = overrides.logo_image_width;
+};
+export class FooterBuilder extends BaseMetadataBuilder {
+    constructor(request, logger) {
+        super(request, logger);
+    }
+    async validateAsync() {
+        const args = this.request.payload ?? {};
+        try {
+            const errors = FOOTER_CHECKS.flatMap((check) => {
+                const err = check(args);
+                return err ? [err] : [];
+            });
+            return { errors };
+        }
+        catch (error) {
+            this.log({
+                message: 'Footer validation failed unexpectedly — skipping',
+                error,
+            });
+            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 args = this.request.payload ?? {};
+        const textStyleOptions = model.styles?.textStyles?.textStyleOptions;
+        // Global fields (copyright_text, social links) always apply to both viewports.
+        if (model.pageFooterDesktop)
+            applyGlobalFooterChanges(model.pageFooterDesktop, args, textStyleOptions);
+        if (model.pageFooterMobile)
+            applyGlobalFooterChanges(model.pageFooterMobile, args, textStyleOptions);
+        // Viewport-specific styling via explicit sub-objects.
+        if (args.desktop && model.pageFooterDesktop)
+            applyViewportFooterChanges(model.pageFooterDesktop, args.desktop);
+        if (args.mobile && model.pageFooterMobile)
+            applyViewportFooterChanges(model.pageFooterMobile, args.mobile);
+        return { request: this.request, model };
+    }
+}

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

@@ -0,0 +1,15 @@
+import { type BrandPageModel } from '../../brand-page/models';
+import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../models';
+import type { UpdateGlobalStylesArguments } from '../parsers/ai-toolcall-parser';
+import type { Logger } from '../logger';
+export declare class GlobalStylesBuilder extends BaseMetadataBuilder<UpdateGlobalStylesArguments> {
+    constructor(request: MetadataBuilderRequest<UpdateGlobalStylesArguments>, logger?: Logger);
+    validateAsync(): Promise<{
+        errors: string[];
+    }>;
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+    private applyTextStyles;
+    private applyButtonStyles;
+    private applyBackgroundStyles;
+    private mergeStyleOptionStyle;
+}

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

@@ -0,0 +1,129 @@
+import {} from '../../brand-page/models';
+import { BaseMetadataBuilder, } from '../models';
+import { GLOBAL_STYLE_CHECKS, TEXT_STYLE_OPTION_KEYS, } from './section-rules/global-styles.rules';
+export class GlobalStylesBuilder extends BaseMetadataBuilder {
+    constructor(request, logger) {
+        super(request, logger);
+    }
+    async validateAsync() {
+        const args = this.request.payload ?? {};
+        try {
+            const errors = GLOBAL_STYLE_CHECKS.flatMap((check) => {
+                const err = check(args);
+                return err ? [err] : [];
+            });
+            return { errors };
+        }
+        catch (error) {
+            this.log({
+                message: 'Global styles validation failed unexpectedly — skipping',
+                error,
+            });
+            return { errors: [] };
+        }
+    }
+    async buildAsync(model) {
+        this.log('Build called');
+        const args = this.request.payload ?? {};
+        if (args.backgroundStyles) {
+            this.applyBackgroundStyles(model, args.backgroundStyles);
+        }
+        if (args.textStyles) {
+            this.applyTextStyles(model, args.textStyles);
+        }
+        if (args.buttonStyles) {
+            this.applyButtonStyles(model, args.buttonStyles);
+        }
+        return { request: this.request, model };
+    }
+    applyTextStyles(model, textStyles) {
+        const ts = model.styles.textStyles;
+        // Deep-merge style (color)
+        if (textStyles.style) {
+            ts.style = { ...ts.style, ...textStyles.style };
+        }
+        // Merge textFontFamily
+        if (textStyles.textFontFamily !== undefined) {
+            ts.textFontFamily = textStyles.textFontFamily;
+        }
+        // Deep-merge textStyleOptions per category
+        if (textStyles.textStyleOptions) {
+            for (const key of TEXT_STYLE_OPTION_KEYS) {
+                const optionArgs = textStyles.textStyleOptions[key];
+                if (!optionArgs)
+                    continue;
+                const existing = ts.textStyleOptions[key];
+                if (!existing)
+                    continue;
+                if (optionArgs.style) {
+                    this.mergeStyleOptionStyle(existing.style, optionArgs.style);
+                    // Mark as modified when style properties change
+                    existing.isModified = true;
+                }
+                if (optionArgs.isModified !== undefined) {
+                    existing.isModified = optionArgs.isModified;
+                }
+            }
+        }
+    }
+    applyButtonStyles(model, buttonStyles) {
+        const bs = model.styles.buttonStyles;
+        // Deep-merge style (color, borderColor, backgroundColor)
+        if (buttonStyles.style) {
+            bs.style = { ...bs.style, ...buttonStyles.style };
+        }
+        // Deep-merge iconStyle (fill)
+        if (buttonStyles.iconStyle) {
+            bs.iconStyle = { ...bs.iconStyle, ...buttonStyles.iconStyle };
+        }
+        // Merge selectedButtonStyleId
+        if (buttonStyles.selectedButtonStyleId !== undefined) {
+            bs.selectedButtonStyleId = buttonStyles.selectedButtonStyleId;
+        }
+    }
+    applyBackgroundStyles(model, backgroundStyles) {
+        const bs = model.styles.backgroundStyles;
+        if (backgroundStyles.style) {
+            bs.style = { ...bs.style, ...backgroundStyles.style };
+        }
+        if (backgroundStyles.backgroundColor !== undefined) {
+            bs.style = { ...bs.style, background: backgroundStyles.backgroundColor };
+        }
+        if (backgroundStyles.shapeColor !== undefined) {
+            bs.backgroundShapeStyle = {
+                ...bs.backgroundShapeStyle,
+                color: backgroundStyles.shapeColor,
+            };
+            if (bs.backgroundShapes?.length) {
+                bs.backgroundShapes = bs.backgroundShapes.map((shape) => ({
+                    ...shape,
+                    style: { ...shape.style, color: backgroundStyles.shapeColor },
+                }));
+            }
+        }
+        if (backgroundStyles.backgroundImageUrl !== undefined) {
+            bs.backgroundImageUrl = backgroundStyles.backgroundImageUrl;
+        }
+        if (backgroundStyles.backgroundShapeUrl !== undefined) {
+            if (backgroundStyles.backgroundShapeUrl === '') {
+                bs.backgroundShapes = [];
+            }
+            else if (bs.backgroundShapes?.length) {
+                // Only update when shapes already exist — never add shapes to a site that has none.
+                // Update ALL shapes so every positional instance switches to the new shape type.
+                bs.backgroundShapes = bs.backgroundShapes.map((shape) => ({
+                    ...shape,
+                    name: backgroundStyles.backgroundShapeUrl,
+                }));
+            }
+            // If backgroundShapes is empty/absent: intentional no-op
+        }
+    }
+    mergeStyleOptionStyle(existing, incoming) {
+        for (const [key, value] of Object.entries(incoming)) {
+            if (value !== undefined) {
+                existing[key] = value;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import { type BrandPageModel } from '../../brand-page/models';
+import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../models';
+import type { UpdateHeaderArguments } from '../parsers/ai-toolcall-parser';
+import type { Logger } from '../logger';
+export declare class HeaderBuilder extends BaseMetadataBuilder<UpdateHeaderArguments> {
+    constructor(request: MetadataBuilderRequest<UpdateHeaderArguments>, logger?: Logger);
+    validateAsync(): Promise<{
+        errors: string[];
+    }>;
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+}

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

@@ -0,0 +1,167 @@
+import {} from '../../brand-page/models';
+import { BaseMetadataBuilder, } from '../models';
+import { getPageSlugFromPageTitle } from '../../brand-page-maker/utils/slug.util';
+import { HEADER_CHECKS } from './section-rules/header.rules';
+import { applyDetachedStyleOverride } from './section-field-utils';
+const applyViewportHeaderChanges = (header, overrides, textStyleOptions) => {
+    if (overrides.display_style !== undefined) {
+        header.displayStyle = overrides.display_style;
+    }
+    if (overrides.background_color !== undefined) {
+        header.backgroundStyle = {
+            ...header.backgroundStyle,
+            backgroundColor: overrides.background_color ?? '',
+        };
+    }
+    if (overrides.is_logo_visible !== undefined) {
+        header.isLogoVisible = overrides.is_logo_visible;
+    }
+    if (overrides.logo_image_height !== undefined) {
+        header.logoImageHeight = overrides.logo_image_height;
+    }
+    if (overrides.logo_image_width !== undefined) {
+        header.logoImageWidth = overrides.logo_image_width;
+    }
+    if (overrides.nav_display_type !== undefined && header.navigation) {
+        header.navigation.displayType = overrides.nav_display_type;
+    }
+    if (overrides.link_text_color !== undefined && header.navigation) {
+        header.navigation.defaultButtonStyle = {
+            ...header.navigation.defaultButtonStyle,
+            color: overrides.link_text_color,
+        };
+    }
+    if (overrides.link_text_font !== undefined && header.navigation) {
+        header.navigation.defaultButtonStyle = applyDetachedStyleOverride(header.navigation.defaultButtonStyle, { fontFamily: overrides.link_text_font }, textStyleOptions);
+    }
+    if (overrides.link_bg_color !== undefined && header.navigation) {
+        header.navigation.defaultButtonStyle = {
+            ...header.navigation.defaultButtonStyle,
+            backgroundColor: overrides.link_bg_color ?? '',
+        };
+    }
+    if (overrides.link_selected_color !== undefined && header.navigation) {
+        header.navigation.selectedButtonStyle = {
+            ...header.navigation.selectedButtonStyle,
+            color: overrides.link_selected_color,
+        };
+    }
+    if (overrides.link_selected_bg_color !== undefined && header.navigation) {
+        header.navigation.selectedButtonStyle = {
+            ...header.navigation.selectedButtonStyle,
+            backgroundColor: overrides.link_selected_bg_color ?? '',
+        };
+    }
+    if (overrides.link_selected_border_color !== undefined && header.navigation) {
+        header.navigation.selectedButtonStyle = {
+            ...header.navigation.selectedButtonStyle,
+            borderColor: overrides.link_selected_border_color,
+        };
+    }
+    if (overrides.link_default_border_color !== undefined && header.navigation) {
+        header.navigation.defaultButtonStyle = {
+            ...header.navigation.defaultButtonStyle,
+            borderColor: overrides.link_default_border_color ?? '',
+        };
+    }
+    if (overrides.hamburger_icon_color !== undefined &&
+        header.navigation?.hamburgerMenuStyle) {
+        header.navigation.hamburgerMenuStyle.iconStyle = {
+            ...header.navigation.hamburgerMenuStyle.iconStyle,
+            color: overrides.hamburger_icon_color,
+        };
+    }
+    if (overrides.hamburger_icon_bg_color !== undefined &&
+        header.navigation?.hamburgerMenuStyle) {
+        header.navigation.hamburgerMenuStyle.iconStyle = {
+            ...header.navigation.hamburgerMenuStyle.iconStyle,
+            backgroundColor: overrides.hamburger_icon_bg_color ?? '',
+        };
+    }
+    if (overrides.overlay_default_text_color !== undefined &&
+        header.navigation?.hamburgerMenuStyle) {
+        header.navigation.hamburgerMenuStyle.defaultButtonStyle = {
+            ...header.navigation.hamburgerMenuStyle.defaultButtonStyle,
+            color: overrides.overlay_default_text_color ?? '',
+        };
+    }
+    if (overrides.overlay_default_bg_color !== undefined &&
+        header.navigation?.hamburgerMenuStyle) {
+        header.navigation.hamburgerMenuStyle.defaultButtonStyle = {
+            ...header.navigation.hamburgerMenuStyle.defaultButtonStyle,
+            backgroundColor: overrides.overlay_default_bg_color ?? '',
+        };
+    }
+    if (overrides.overlay_selected_text_color !== undefined &&
+        header.navigation?.hamburgerMenuStyle) {
+        header.navigation.hamburgerMenuStyle.selectedButtonStyle = {
+            ...header.navigation.hamburgerMenuStyle.selectedButtonStyle,
+            color: overrides.overlay_selected_text_color ?? '',
+        };
+    }
+    if (overrides.overlay_selected_bg_color !== undefined &&
+        header.navigation?.hamburgerMenuStyle) {
+        header.navigation.hamburgerMenuStyle.selectedButtonStyle = {
+            ...header.navigation.hamburgerMenuStyle.selectedButtonStyle,
+            backgroundColor: overrides.overlay_selected_bg_color ?? '',
+        };
+    }
+};
+const applyNavRouteChanges = (model, routes) => {
+    for (const routeUpdate of routes) {
+        if (routeUpdate.route_index === undefined)
+            continue;
+        const target = model.nav?.routes?.[routeUpdate.route_index];
+        if (!target)
+            continue;
+        if (routeUpdate.display_name !== undefined) {
+            target.displayName = routeUpdate.display_name;
+            // Recalculate pageSlug based on new display name
+            const existingSlugs = (model.nav?.routes ?? []).map((r) => r.pageSlug);
+            target.pageSlug = getPageSlugFromPageTitle(routeUpdate.display_name, existingSlugs);
+        }
+    }
+};
+export class HeaderBuilder extends BaseMetadataBuilder {
+    constructor(request, logger) {
+        super(request, logger);
+    }
+    async validateAsync() {
+        const args = this.request.payload ?? {};
+        try {
+            const errors = HEADER_CHECKS.flatMap((check) => {
+                const err = check(args);
+                return err ? [err] : [];
+            });
+            return { errors };
+        }
+        catch (error) {
+            this.log({
+                message: 'Header validation failed unexpectedly — skipping',
+                error,
+            });
+            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 args = this.request.payload ?? {};
+        const textStyleOptions = model.styles?.textStyles?.textStyleOptions;
+        // Apply nav route changes first
+        if (args.nav_routes) {
+            applyNavRouteChanges(model, args.nav_routes);
+        }
+        // Apply viewport-specific styling via explicit sub-objects
+        if (args.desktop && model.pageHeaderDesktop) {
+            applyViewportHeaderChanges(model.pageHeaderDesktop, args.desktop, textStyleOptions);
+        }
+        if (args.mobile && model.pageHeaderMobile) {
+            applyViewportHeaderChanges(model.pageHeaderMobile, args.mobile, textStyleOptions);
+        }
+        return { request: this.request, model };
+    }
+}

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

@@ -0,0 +1,12 @@
+import { type BrandPageModel } from '../../brand-page/models';
+import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../models';
+import type { Logger } from '../logger';
+import { type RenamePagePayload } from './section-rules/rename-page.rules';
+export type { RenamePagePayload };
+export declare class RenamePageBuilder extends BaseMetadataBuilder<RenamePagePayload> {
+    constructor(request: MetadataBuilderRequest<RenamePagePayload>, logger?: Logger);
+    validateAsync(): Promise<{
+        errors: string[];
+    }>;
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+}