@designcrowd/library.brand-page 5.17.28 → 5.18.0

package/src/metadata-builder/builders/section-rules/header.rules.ts

@@ -0,0 +1,75 @@
+import { HEADER_DISPLAY_STYLE_CONFIGS } from '../../../brand-page/constants/sections/header-display.constants';
+import type { UpdateHeaderArguments } from '../../parsers/ai-toolcall-parser';
+import { validateLogoSize } from '../../sanitizers/section-args-validator';
+import { PAGE_RULES, STYLE_RULES } from '../../sanitizers/sanitizer-rules';
+
+type HeaderCheck = (args: UpdateHeaderArguments) => string | null;
+
+export const HEADER_CHECKS: HeaderCheck[] = [
+  // Display style + nav type compatibility per viewport
+  ...(['desktop', 'mobile'] as const).map(
+    (viewport): HeaderCheck =>
+      (args) => {
+        const overrides = args[viewport];
+
+        if (!overrides?.nav_display_type || !overrides?.display_style)
+          return null;
+
+        const compatible = HEADER_DISPLAY_STYLE_CONFIGS.some(
+          (c) =>
+            c.option.value === overrides.display_style &&
+            c.supportedNavTypes.includes(overrides.nav_display_type!),
+        );
+
+        return compatible
+          ? null
+          : `Incompatible ${viewport} combination: display_style "${overrides.display_style}" is not compatible with nav_display_type "${overrides.nav_display_type}".`;
+      },
+  ),
+
+  // Nav link font per viewport
+  ...(['desktop', 'mobile'] as const).map(
+    (viewport): HeaderCheck =>
+      (args) => {
+        const font = args[viewport]?.link_text_font;
+
+        if (font == null) return null;
+
+        return !STYLE_RULES.fontFamilyNames.has(font)
+          ? `"${viewport}.link_text_font" "${font}" is not a recognized font family`
+          : null;
+      },
+  ),
+
+  // Logo sizes per viewport
+  ...(['desktop', 'mobile'] as const).flatMap((viewport): HeaderCheck[] => [
+    (args) =>
+      validateLogoSize(
+        `${viewport}.logo_image_height`,
+        args[viewport]?.logo_image_height,
+        viewport,
+      ),
+    (args) =>
+      validateLogoSize(
+        `${viewport}.logo_image_width`,
+        args[viewport]?.logo_image_width,
+        viewport,
+      ),
+  ]),
+
+  // Nav route display name length (returns first violation — retry loop handles the rest)
+  (args) => {
+    for (let i = 0; i < (args.nav_routes ?? []).length; i++) {
+      const displayName = args.nav_routes![i].display_name;
+
+      if (
+        displayName != null &&
+        displayName.length > PAGE_RULES.navDisplayName
+      ) {
+        return `nav_routes[${i}].display_name exceeds the maximum length of ${PAGE_RULES.navDisplayName} characters (got ${displayName.length})`;
+      }
+    }
+
+    return null;
+  },
+];

package/src/metadata-builder/builders/section-rules/image-gallery.rules.ts

@@ -0,0 +1,22 @@
+import { MAX_TITLE_LENGTH } from '../../../brand-page/constants/font.constants';
+import {
+  enumCheck,
+  itemRteStyleCheck,
+  itemTextCheck,
+  runChecks,
+  type SectionCheck,
+  type ValidationContext,
+} from '../../sanitizers/section-args-validator';
+
+const CHECKS: SectionCheck[] = [
+  itemTextCheck('images', 'caption', MAX_TITLE_LENGTH),
+  itemRteStyleCheck('images', 'caption'),
+  enumCheck('gallery_type', ['grid', 'carousel', 'masonry'], 'image-gallery'),
+];
+
+export function validateImageGallery(
+  args: Record<string, unknown>,
+  ctx: ValidationContext,
+): string[] {
+  return runChecks(CHECKS, args, ctx);
+}

package/src/metadata-builder/builders/section-rules/images-section.rules.ts

@@ -0,0 +1,55 @@
+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,
+  type SectionCheck,
+  type ValidationContext,
+} from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+
+const CHECKS: SectionCheck[] = [
+  ...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: Record<string, unknown>,
+  ctx: ValidationContext,
+): string[] {
+  return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,21 @@
+import { MAX_TITLE_LENGTH } from '../../../brand-page/constants/font.constants';
+import {
+  enumCheck,
+  runChecks,
+  type SectionCheck,
+  type ValidationContext,
+} from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+
+const CHECKS: SectionCheck[] = [
+  ...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: Record<string, unknown>,
+  ctx: ValidationContext,
+): string[] {
+  return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,27 @@
+import {
+  MAX_TITLE_LENGTH,
+  MAX_DESCRIPTION_LENGTH,
+} from '../../../brand-page/constants/font.constants';
+import {
+  runChecks,
+  styleCheck,
+  type SectionCheck,
+  type ValidationContext,
+} from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+
+const CHECKS: SectionCheck[] = [
+  ...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: Record<string, unknown>,
+  ctx: ValidationContext,
+): string[] {
+  return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,17 @@
+import { PAGE_RULES } from '../../sanitizers/sanitizer-rules';
+
+export interface RenamePagePayload {
+  pageId: string;
+  pageName: string;
+}
+
+type PageCheck = (payload: RenamePagePayload | undefined) => string | null;
+
+export const RENAME_PAGE_CHECKS: PageCheck[] = [
+  (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/src/metadata-builder/builders/section-rules/shapes-section.rules.ts

@@ -0,0 +1,51 @@
+import {
+  MAX_TITLE_LENGTH,
+  MAX_DESCRIPTION_LENGTH,
+} from '../../../brand-page/constants/font.constants';
+import {
+  enumCheck,
+  itemCapCheck,
+  itemRteStyleCheck,
+  itemTextCheck,
+  runChecks,
+  styleCheck,
+  type SectionCheck,
+  type ValidationContext,
+} from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+
+const CHECKS: SectionCheck[] = [
+  ...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: Record<string, unknown>,
+  ctx: ValidationContext,
+): string[] {
+  return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,27 @@
+import { SOCIAL_LINKS_ICON_DISPLAY_STYLES } from '../../../brand-page/models';
+import {
+  enumCheck,
+  itemCapCheck,
+  runChecks,
+  type SectionCheck,
+  type ValidationContext,
+} from '../../sanitizers/section-args-validator';
+
+const CHECKS: SectionCheck[] = [
+  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: Record<string, unknown>,
+  ctx: ValidationContext,
+): string[] {
+  return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,48 @@
+import {
+  MAX_TITLE_LENGTH,
+  MAX_DESCRIPTION_LENGTH,
+} from '../../../brand-page/constants/font.constants';
+import {
+  enumCheck,
+  itemCapCheck,
+  itemRteStyleCheck,
+  itemTextCheck,
+  runChecks,
+  styleCheck,
+  type SectionCheck,
+  type ValidationContext,
+} from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+
+export const TESTIMONIAL_ITEM_CAP = {
+  brandSite: 3,
+  brandPage: 3,
+  arrayField: 'items',
+} as const;
+
+const CHECKS: SectionCheck[] = [
+  ...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: Record<string, unknown>,
+  ctx: ValidationContext,
+): string[] {
+  return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,28 @@
+import { MAX_TEXT_LENGTH } from '../../../brand-page/constants/font.constants';
+import {
+  enumCheck,
+  itemRteStyleCheck,
+  itemStyleCheck,
+  itemTextCheck,
+  runChecks,
+  styleCheck,
+  type SectionCheck,
+  type ValidationContext,
+} from '../../sanitizers/section-args-validator';
+import { textAndRteChecks } from '../../sanitizers/rte-schema-check';
+
+const CHECKS: SectionCheck[] = [
+  ...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: Record<string, unknown>,
+  ctx: ValidationContext,
+): string[] {
+  return runChecks(CHECKS, args, ctx);
+}

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

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ColorReplacement } from '../../brand-page/models';
+import {
+  applyColorThemeToReplacements,
+  resolveShapeColorReplacementsAsync,
+} from './shape-color-utils';
+
+describe('shape-color-utils', () => {
+  describe('resolveShapeColorReplacementsAsync', () => {
+    beforeEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('returns [] for empty URL', async () => {
+      const result = await resolveShapeColorReplacementsAsync('');
+
+      expect(result).toEqual([]);
+    });
+
+    it('returns [] for proxy URL without fetching', async () => {
+      const fetchSpy = vi.spyOn(global, 'fetch');
+
+      const result = await resolveShapeColorReplacementsAsync(
+        'https://example.com/asset/shape?id=123',
+      );
+
+      expect(result).toEqual([]);
+      expect(fetchSpy).not.toHaveBeenCalled();
+    });
+
+    it('fetches SVG and returns concrete identity-mapped entries per unique fill', async () => {
+      vi.spyOn(global, 'fetch').mockResolvedValueOnce({
+        ok: true,
+        text: async () => `<svg xmlns="http://www.w3.org/2000/svg">
+<path style="fill: #111111" d="M10 10"/>
+<path style="fill: #EEEEEE" d="M20 20"/>
+</svg>`,
+      } as Response);
+
+      const result = await resolveShapeColorReplacementsAsync(
+        'https://shapes.com/icon.svg',
+      );
+
+      const origs = result.map((r) => r.originalColor.toUpperCase());
+
+      expect(origs).toContain('#111111');
+      expect(origs).toContain('#EEEEEE');
+      // Identity-mapped: replacementColor equals originalColor (case-insensitive)
+      result.forEach((r) => {
+        expect(r.replacementColor.toLowerCase()).toBe(
+          r.originalColor.toLowerCase(),
+        );
+        expect(r.attribute).toBe('fill');
+      });
+    });
+
+    it('throws on HTTP failure', async () => {
+      vi.spyOn(global, 'fetch').mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+      } as Response);
+
+      await expect(
+        resolveShapeColorReplacementsAsync('https://shapes.com/missing.svg'),
+      ).rejects.toThrow(/404/);
+    });
+  });
+
+  describe('applyColorThemeToReplacements', () => {
+    it('returns [] for empty input', () => {
+      expect(applyColorThemeToReplacements([], '#1D4ED8')).toEqual([]);
+    });
+
+    it('re-shades each entry preserving originalColor', () => {
+      const input: ColorReplacement[] = [
+        {
+          attribute: 'fill',
+          originalColor: '#808080',
+          replacementColor: '#808080',
+        },
+        {
+          attribute: 'fill',
+          originalColor: '#333333',
+          replacementColor: '#333333',
+        },
+      ];
+
+      const result = applyColorThemeToReplacements(input, '#1D4ED8');
+
+      expect(result).toHaveLength(2);
+      expect(result[0].originalColor).toBe('#808080');
+      expect(result[1].originalColor).toBe('#333333');
+      // replacementColor has been shifted — not equal to either original or raw theme
+      result.forEach((r, i) => {
+        expect(r.replacementColor).not.toBe(input[i].replacementColor);
+        expect(r.attribute).toBe('fill');
+      });
+    });
+
+    it('does not mutate the input array or its entries', () => {
+      const input: ColorReplacement[] = [
+        {
+          attribute: 'fill',
+          originalColor: '#808080',
+          replacementColor: '#808080',
+        },
+      ];
+      const originalReplacement = input[0].replacementColor;
+
+      applyColorThemeToReplacements(input, '#1D4ED8');
+
+      expect(input[0].replacementColor).toBe(originalReplacement);
+    });
+  });
+});

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

@@ -0,0 +1,75 @@
+import type { ColorReplacement } from '../../brand-page/models';
+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: string,
+): Promise<ColorReplacement[]> => {
+  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: ColorReplacement[],
+  colorTheme: string,
+): ColorReplacement[] =>
+  replacements.map((r) => ({
+    ...r,
+    replacementColor:
+      replacements.length === 1
+        ? colorTheme
+        : getNewColorBasedOnTargetColorTheme(
+            r.originalColor,
+            colorTheme,
+          )?.toString() ?? colorTheme,
+  }));

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

@@ -0,0 +1,105 @@
+import cloneDeep from 'lodash.clonedeep';
+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 class UndoBuilder extends BaseMetadataBuilder<UndoPayload> {
+  constructor(request: MetadataBuilderRequest<UndoPayload>, logger?: Logger) {
+    super(request, logger);
+  }
+
+  async validateAsync(): Promise<{ errors: string[] }> {
+    const errors: string[] = [];
+    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: 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 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,
+    };
+  }
+}