@riverbankcms/sdk 0.81.0 → 0.82.0

package/dist/server/page-converter.mjs

@@ -936,6 +936,22 @@ var behaviourSchema = z2.object({
   // Block manages its own wrapper (for sticky/fixed positioning)
   managesOwnWrapper: z2.boolean().optional()
 });
+var quickFieldPrioritySchema = z2.array(z2.string().min(1)).min(1).superRefine((fieldIds, ctx) => {
+  const seenFieldIds = /* @__PURE__ */ new Set();
+  for (const [index, fieldId] of fieldIds.entries()) {
+    if (seenFieldIds.has(fieldId)) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: [index],
+        message: `Duplicate quick-field priority "${fieldId}"`
+      });
+    }
+    seenFieldIds.add(fieldId);
+  }
+});
+var previewCustomizeManifestCurationSchema = z2.object({
+  quickFieldPriority: quickFieldPrioritySchema
+});
 var blockCategoryEnum = z2.enum([
   "marketing",
   "content",
@@ -955,6 +971,7 @@ var manifestSchema = z2.object({
   slots: slotSchema.array().default([]),
   styleTokens: styleTokenSchema.optional(),
   behaviours: behaviourSchema.optional(),
+  previewCustomize: previewCustomizeManifestCurationSchema.optional(),
   layout: NodeTreeSchema.optional(),
   /**
    * Optional list of nested field paths that should be surfaced in the main form body
@@ -1144,6 +1161,7 @@ function defineBlockDesignCapability(capability) {
     tileTreatments: capability.tileTreatments ?? ["default"],
     eventListTreatments: capability.eventListTreatments ?? ["plain"],
     eyebrowTreatments: capability.eyebrowTreatments ?? ["plain"],
+    ...capability.headingDecorations ? { headingDecorations: capability.headingDecorations } : {},
     headingDecorationCapability: capability.headingDecorationCapability ?? {
       kind: "unsupported"
     },
@@ -2008,256 +2026,1282 @@ function assertUniqueLayoutProfileKeys(profiles) {
   }
 }
 
-// ../theme-core/src/site-styles/pageDesignIntent.ts
-import { z as z3 } from "zod";
-
-// ../theme-core/src/site-styles/sectionTransitions.ts
-var noneBoundaryOption = {
-  id: asBoundaryOptionId("break:none"),
-  label: "None",
-  transitionAfter: "none",
-  treatment: { kind: "none" }
-};
-var softBoundaryOption = {
-  id: asBoundaryOptionId("break:soft"),
-  label: "Soft",
-  transitionAfter: "soft-fade-short",
-  treatment: { kind: "soft-fade", height: "medium", curve: "soft" }
-};
-var spaciousBoundaryOption = {
-  id: asBoundaryOptionId("break:spacious"),
-  label: "Spacious",
-  transitionAfter: "soft-fade-long",
-  treatment: { kind: "soft-fade", height: "large", curve: "spacious" }
-};
-var expansiveBoundaryOption = {
-  id: asBoundaryOptionId("break:expansive"),
-  label: "Expansive",
-  transitionAfter: "soft-fade-expansive",
-  treatment: { kind: "soft-fade", height: "expansive", curve: "expansive" }
+// ../theme-core/src/mock-themes/components/swatch.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+
+// ../theme-core/src/mock-themes/components/PaletteCard.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+
+// ../../node_modules/.pnpm/@vibrant+image@4.0.4/node_modules/@vibrant/image/dist/esm/histogram.js
+var Histogram = class {
+  constructor(pixels, opts) {
+    this.pixels = pixels;
+    this.opts = opts;
+    const { sigBits } = opts;
+    const getColorIndex = (r2, g2, b2) => (r2 << 2 * sigBits) + (g2 << sigBits) + b2;
+    this.getColorIndex = getColorIndex;
+    const rshift = 8 - sigBits;
+    const hn = 1 << 3 * sigBits;
+    const hist = new Uint32Array(hn);
+    let rmax;
+    let rmin;
+    let gmax;
+    let gmin;
+    let bmax;
+    let bmin;
+    let r;
+    let g;
+    let b;
+    let a;
+    rmax = gmax = bmax = 0;
+    rmin = gmin = bmin = Number.MAX_VALUE;
+    const n = pixels.length / 4;
+    let i = 0;
+    while (i < n) {
+      const offset = i * 4;
+      i++;
+      r = pixels[offset + 0];
+      g = pixels[offset + 1];
+      b = pixels[offset + 2];
+      a = pixels[offset + 3];
+      if (a === 0) continue;
+      r = r >> rshift;
+      g = g >> rshift;
+      b = b >> rshift;
+      const index = getColorIndex(r, g, b);
+      if (hist[index] === void 0) hist[index] = 0;
+      hist[index] += 1;
+      if (r > rmax) rmax = r;
+      if (r < rmin) rmin = r;
+      if (g > gmax) gmax = g;
+      if (g < gmin) gmin = g;
+      if (b > bmax) bmax = b;
+      if (b < bmin) bmin = b;
+    }
+    this._colorCount = hist.reduce(
+      (total, c) => c > 0 ? total + 1 : total,
+      0
+    );
+    this.hist = hist;
+    this.rmax = rmax;
+    this.rmin = rmin;
+    this.gmax = gmax;
+    this.gmin = gmin;
+    this.bmax = bmax;
+    this.bmin = bmin;
+  }
+  get colorCount() {
+    return this._colorCount;
+  }
 };
-var waveBoundaryOption = {
-  id: asBoundaryOptionId("break:wave"),
-  label: "Classic wave",
-  transitionAfter: "wave-edge",
-  treatment: {
-    kind: "wave-edge",
-    height: "medium",
-    amplitude: "balanced",
-    rhythm: "double",
-    symmetry: "asymmetrical"
+
+// ../../node_modules/.pnpm/@vibrant+image@4.0.4/node_modules/@vibrant/image/dist/esm/index.js
+var ImageBase = class {
+  scaleDown(opts) {
+    const width = this.getWidth();
+    const height = this.getHeight();
+    let ratio = 1;
+    if (opts.maxDimension > 0) {
+      const maxSide = Math.max(width, height);
+      if (maxSide > opts.maxDimension) ratio = opts.maxDimension / maxSide;
+    } else {
+      ratio = 1 / opts.quality;
+    }
+    if (ratio < 1) this.resize(width * ratio, height * ratio, ratio);
   }
 };
-var balancedWaveBoundaryOption = {
-  id: asBoundaryOptionId("break:wave-balanced"),
-  label: "Balanced wave",
-  transitionAfter: "wave-edge-balanced",
-  treatment: {
-    kind: "wave-edge",
-    height: "medium",
-    amplitude: "balanced",
-    rhythm: "double",
-    symmetry: "symmetrical"
+function applyFilters(imageData, filters) {
+  if (filters.length > 0) {
+    const pixels = imageData.data;
+    const n = pixels.length / 4;
+    let offset;
+    let r;
+    let g;
+    let b;
+    let a;
+    for (let i = 0; i < n; i++) {
+      offset = i * 4;
+      r = pixels[offset + 0];
+      g = pixels[offset + 1];
+      b = pixels[offset + 2];
+      a = pixels[offset + 3];
+      for (let j = 0; j < filters.length; j++) {
+        if (!filters[j]?.(r, g, b, a)) {
+          pixels[offset + 3] = 0;
+          break;
+        }
+      }
+    }
+  }
+  return imageData;
+}
+
+// ../../node_modules/.pnpm/@vibrant+image-browser@4.0.4/node_modules/@vibrant/image-browser/dist/esm/index.js
+function isRelativeUrl(url) {
+  const u = new URL(url, location.href);
+  return u.protocol === location.protocol && u.host === location.host && u.port === location.port;
+}
+function isSameOrigin(a, b) {
+  const ua = new URL(a);
+  const ub = new URL(b);
+  return ua.protocol === ub.protocol && ua.hostname === ub.hostname && ua.port === ub.port;
+}
+var BrowserImage = class extends ImageBase {
+  _getCanvas() {
+    if (!this._canvas) {
+      throw new Error("Canvas is not initialized");
+    }
+    return this._canvas;
+  }
+  _getContext() {
+    if (!this._context) {
+      throw new Error("Context is not initialized");
+    }
+    return this._context;
+  }
+  _getWidth() {
+    if (!this._width) {
+      throw new Error("Width is not initialized");
+    }
+    return this._width;
+  }
+  _getHeight() {
+    if (!this._height) {
+      throw new Error("Height is not initialized");
+    }
+    return this._height;
+  }
+  _initCanvas() {
+    const img = this.image;
+    if (!img) {
+      throw new Error("Image is not initialized");
+    }
+    const canvas = this._canvas = document.createElement("canvas");
+    const context = canvas.getContext("2d");
+    if (!context) throw new ReferenceError("Failed to create canvas context");
+    this._context = context;
+    canvas.className = "@vibrant/canvas";
+    canvas.style.display = "none";
+    this._width = canvas.width = img.width;
+    this._height = canvas.height = img.height;
+    context.drawImage(img, 0, 0);
+    document.body.appendChild(canvas);
+  }
+  load(image) {
+    let img;
+    let src;
+    if (typeof image === "string") {
+      img = document.createElement("img");
+      src = image;
+      if (!isRelativeUrl(src) && !isSameOrigin(window.location.href, src)) {
+        img.crossOrigin = "anonymous";
+      }
+      img.src = src;
+    } else if (image instanceof HTMLImageElement) {
+      img = image;
+      src = image.src;
+    } else {
+      return Promise.reject(
+        new Error(`Cannot load buffer as an image in browser`)
+      );
+    }
+    this.image = img;
+    return new Promise((resolve, reject) => {
+      const onImageLoad = () => {
+        this._initCanvas();
+        resolve(this);
+      };
+      if (img.complete) {
+        onImageLoad();
+      } else {
+        img.onload = onImageLoad;
+        img.onerror = (_e) => reject(new Error(`Fail to load image: ${src}`));
+      }
+    });
+  }
+  clear() {
+    this._getContext().clearRect(0, 0, this._getWidth(), this._getHeight());
+  }
+  update(imageData) {
+    this._getContext().putImageData(imageData, 0, 0);
+  }
+  getWidth() {
+    return this._getWidth();
+  }
+  getHeight() {
+    return this._getHeight();
+  }
+  resize(targetWidth, targetHeight, ratio) {
+    if (!this.image) {
+      throw new Error("Image is not initialized");
+    }
+    this._width = this._getCanvas().width = targetWidth;
+    this._height = this._getCanvas().height = targetHeight;
+    this._getContext().scale(ratio, ratio);
+    this._getContext().drawImage(this.image, 0, 0);
+  }
+  getPixelCount() {
+    return this._getWidth() * this._getHeight();
+  }
+  getImageData() {
+    return this._getContext().getImageData(
+      0,
+      0,
+      this._getWidth(),
+      this._getHeight()
+    );
+  }
+  remove() {
+    if (this._canvas && this._canvas.parentNode) {
+      this._canvas.parentNode.removeChild(this._canvas);
+    }
   }
 };
-var gentleWaveBoundaryOption = {
-  id: asBoundaryOptionId("break:wave-gentle"),
-  label: "Gentle wave",
-  transitionAfter: "wave-edge-gentle",
-  treatment: {
-    kind: "wave-edge",
-    height: "compact",
-    amplitude: "subtle",
-    rhythm: "single",
-    symmetry: "symmetrical"
+
+// ../../node_modules/.pnpm/@vibrant+core@4.0.4/node_modules/@vibrant/core/dist/esm/utils.js
+function assignDeep(target, ...sources) {
+  sources.forEach((s) => {
+    if (!s) return;
+    for (const key in s) {
+      if (s.hasOwnProperty(key)) {
+        const v = s[key];
+        if (Array.isArray(v)) {
+          target[key] = v.slice(0);
+        } else if (typeof v === "object") {
+          if (!target[key]) target[key] = {};
+          assignDeep(target[key], v);
+        } else {
+          target[key] = v;
+        }
+      }
+    }
+  });
+  return target;
+}
+
+// ../../node_modules/.pnpm/@vibrant+core@4.0.4/node_modules/@vibrant/core/dist/esm/options.js
+function buildProcessOptions(opts, override) {
+  const { colorCount, quantizer, generators, filters } = opts;
+  const commonQuantizerOpts = { colorCount };
+  const q = typeof quantizer === "string" ? { name: quantizer, options: {} } : quantizer;
+  q.options = assignDeep({}, commonQuantizerOpts, q.options);
+  return assignDeep(
+    {},
+    {
+      quantizer: q,
+      generators,
+      filters
+    },
+    override
+  );
+}
+
+// ../../node_modules/.pnpm/@vibrant+core@4.0.4/node_modules/@vibrant/core/dist/esm/builder.js
+var Builder = class {
+  /**
+   * Arguments are the same as `Vibrant.constructor`.
+   */
+  constructor(src, opts = {}) {
+    this._src = src;
+    this._opts = assignDeep({}, Vibrant.DefaultOpts, opts);
+  }
+  /**
+   * Sets `opts.colorCount` to `n`.
+   * @returns this `Builder` instance.
+   */
+  maxColorCount(n) {
+    this._opts.colorCount = n;
+    return this;
+  }
+  /**
+   * Sets `opts.maxDimension` to `d`.
+   * @returns this `Builder` instance.
+   */
+  maxDimension(d) {
+    this._opts.maxDimension = d;
+    return this;
+  }
+  /**
+   * Adds a filter function
+   * @returns this `Builder` instance.
+   */
+  addFilter(name) {
+    if (!this._opts.filters) {
+      this._opts.filters = [name];
+    } else {
+      this._opts.filters.push(name);
+    }
+    return this;
+  }
+  /**
+   * Removes a filter function.
+   * @returns this `Builder` instance.
+   */
+  removeFilter(name) {
+    if (this._opts.filters) {
+      const i = this._opts.filters.indexOf(name);
+      if (i > 0) this._opts.filters.splice(i);
+    }
+    return this;
+  }
+  /**
+   * Clear all filters.
+   * @returns this `Builder` instance.
+   */
+  clearFilters() {
+    this._opts.filters = [];
+    return this;
+  }
+  /**
+   * Sets `opts.quality` to `q`.
+   * @returns this `Builder` instance.
+   */
+  quality(q) {
+    this._opts.quality = q;
+    return this;
+  }
+  /**
+   * Specifies which `Image` implementation class to use.
+   * @returns this `Builder` instance.
+   */
+  useImageClass(imageClass) {
+    this._opts.ImageClass = imageClass;
+    return this;
+  }
+  /**
+   * Sets `opts.generator` to `generator`
+   * @returns this `Builder` instance.
+   */
+  useGenerator(generator, options) {
+    if (!this._opts.generators) this._opts.generators = [];
+    this._opts.generators.push(
+      options ? { name: generator, options } : generator
+    );
+    return this;
+  }
+  /**
+   * Specifies which `Quantizer` implementation class to use
+   * @returns this `Builder` instance.
+   */
+  useQuantizer(quantizer, options) {
+    this._opts.quantizer = options ? { name: quantizer, options } : quantizer;
+    return this;
+  }
+  /**
+   * Builds and returns a `Vibrant` instance as configured.
+   */
+  build() {
+    return new Vibrant(this._src, this._opts);
+  }
+  /**
+   * Builds a `Vibrant` instance as configured and calls its `getPalette` method.
+   */
+  getPalette() {
+    return this.build().getPalette();
   }
 };
-var boldWaveBoundaryOption = {
-  id: asBoundaryOptionId("break:wave-bold"),
-  label: "Bold wave",
-  transitionAfter: "wave-edge-bold",
-  treatment: {
-    kind: "wave-edge",
-    height: "large",
-    amplitude: "bold",
-    rhythm: "double",
-    symmetry: "symmetrical"
+
+// ../../node_modules/.pnpm/@vibrant+core@4.0.4/node_modules/@vibrant/core/dist/esm/pipeline/index.js
+var Stage = class {
+  constructor(pipeline2) {
+    this.pipeline = pipeline2;
+    this._map = {};
+  }
+  names() {
+    return Object.keys(this._map);
+  }
+  has(name) {
+    return !!this._map[name];
+  }
+  get(name) {
+    return this._map[name];
+  }
+  register(name, stageFn) {
+    this._map[name] = stageFn;
+    return this.pipeline;
   }
 };
-var driftWaveBoundaryOption = {
-  id: asBoundaryOptionId("break:wave-drift"),
-  label: "Drift wave",
-  transitionAfter: "wave-edge-drift",
-  treatment: {
-    kind: "wave-edge",
-    height: "medium",
-    amplitude: "balanced",
-    rhythm: "double",
-    symmetry: "drift"
+var BasicPipeline = class {
+  constructor() {
+    this.filter = new Stage(this);
+    this.quantizer = new Stage(this);
+    this.generator = new Stage(this);
+  }
+  _buildProcessTasks({
+    filters,
+    quantizer,
+    generators
+  }) {
+    if (generators.length === 1 && generators[0] === "*") {
+      generators = this.generator.names();
+    }
+    return {
+      filters: filters.map((f) => createTask(this.filter, f)),
+      quantizer: createTask(this.quantizer, quantizer),
+      generators: generators.map((g) => createTask(this.generator, g))
+    };
+    function createTask(stage, o) {
+      let name;
+      let options;
+      if (typeof o === "string") {
+        name = o;
+      } else {
+        name = o.name;
+        options = o.options;
+      }
+      return {
+        name,
+        fn: stage.get(name),
+        options
+      };
+    }
+  }
+  async process(imageData, opts) {
+    const { filters, quantizer, generators } = this._buildProcessTasks(opts);
+    const imageFilterData = await this._filterColors(filters, imageData);
+    const colors = await this._generateColors(quantizer, imageFilterData);
+    const palettes = await this._generatePalettes(generators, colors);
+    return {
+      colors,
+      palettes
+    };
+  }
+  _filterColors(filters, imageData) {
+    return Promise.resolve(
+      applyFilters(
+        imageData,
+        filters.map(({ fn }) => fn)
+      )
+    );
+  }
+  _generateColors(quantizer, imageData) {
+    return Promise.resolve(quantizer.fn(imageData.data, quantizer.options));
+  }
+  async _generatePalettes(generators, colors) {
+    const promiseArr = await Promise.all(
+      generators.map(({ fn, options }) => Promise.resolve(fn(colors, options)))
+    );
+    return Promise.resolve(
+      promiseArr.reduce(
+        (promises, promiseVal, i) => {
+          promises[generators[i].name] = promiseVal;
+          return promises;
+        },
+        {}
+      )
+    );
   }
 };
-var subtleAngleBoundaryOption = {
-  id: asBoundaryOptionId("break:angle-subtle"),
-  label: "Subtle angle",
-  transitionAfter: "angle-edge-subtle",
-  treatment: {
-    kind: "angle-edge",
-    height: "compact",
-    slope: "subtle",
-    direction: "forward"
+
+// ../../node_modules/.pnpm/@vibrant+color@4.0.4/node_modules/@vibrant/color/dist/esm/converter.js
+function rgbToHex(r, g, b) {
+  return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1, 7);
+}
+function rgbToHsl(r, g, b) {
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      case g:
+        h = (b - r) / d + 2;
+        break;
+      case b:
+        h = (r - g) / d + 4;
+        break;
+    }
+    h /= 6;
+  }
+  return [h, s, l];
+}
+function hslToRgb(h, s, l) {
+  let r;
+  let g;
+  let b;
+  function hue2rgb(p, q, t) {
+    if (t < 0) t += 1;
+    if (t > 1) t -= 1;
+    if (t < 1 / 6) return p + (q - p) * 6 * t;
+    if (t < 1 / 2) return q;
+    if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+    return p;
+  }
+  if (s === 0) {
+    r = g = b = l;
+  } else {
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  return [r * 255, g * 255, b * 255];
+}
+
+// ../../node_modules/.pnpm/@vibrant+color@4.0.4/node_modules/@vibrant/color/dist/esm/index.js
+var Swatch2 = class _Swatch {
+  static applyFilters(colors, filters) {
+    return filters.length > 0 ? colors.filter(({ r, g, b }) => {
+      for (let j = 0; j < filters.length; j++) {
+        if (!filters[j]?.(r, g, b, 255)) return false;
+      }
+      return true;
+    }) : colors;
+  }
+  /**
+   * Make a value copy of a swatch based on a previous one. Returns a new Swatch instance
+   * @param {Swatch} swatch
+   */
+  static clone(swatch) {
+    return new _Swatch(swatch._rgb, swatch._population);
+  }
+  /**
+   * The red value in the RGB value
+   */
+  get r() {
+    return this._rgb[0];
+  }
+  /**
+   * The green value in the RGB value
+   */
+  get g() {
+    return this._rgb[1];
+  }
+  /**
+   * The blue value in the RGB value
+   */
+  get b() {
+    return this._rgb[2];
+  }
+  /**
+   * The color value as a rgb value
+   */
+  get rgb() {
+    return this._rgb;
+  }
+  /**
+   * The color value as a hsl value
+   */
+  get hsl() {
+    if (!this._hsl) {
+      const [r, g, b] = this._rgb;
+      this._hsl = rgbToHsl(r, g, b);
+    }
+    return this._hsl;
+  }
+  /**
+   * The color value as a hex string
+   */
+  get hex() {
+    if (!this._hex) {
+      const [r, g, b] = this._rgb;
+      this._hex = rgbToHex(r, g, b);
+    }
+    return this._hex;
+  }
+  get population() {
+    return this._population;
+  }
+  /**
+   * Get the JSON object for the swatch
+   */
+  toJSON() {
+    return {
+      rgb: this.rgb,
+      population: this.population
+    };
+  }
+  getYiq() {
+    if (!this._yiq) {
+      const rgb = this._rgb;
+      this._yiq = (rgb[0] * 299 + rgb[1] * 587 + rgb[2] * 114) / 1e3;
+    }
+    return this._yiq;
+  }
+  /**
+   * Returns an appropriate color to use for any 'title' text which is displayed over this Swatch's color.
+   */
+  get titleTextColor() {
+    if (!this._titleTextColor) {
+      this._titleTextColor = this.getYiq() < 200 ? "#fff" : "#000";
+    }
+    return this._titleTextColor;
+  }
+  /**
+   * Returns an appropriate color to use for any 'body' text which is displayed over this Swatch's color.
+   */
+  get bodyTextColor() {
+    if (!this._bodyTextColor) {
+      this._bodyTextColor = this.getYiq() < 150 ? "#fff" : "#000";
+    }
+    return this._bodyTextColor;
+  }
+  /**
+   * Internal use.
+   * @param rgb `[r, g, b]`
+   * @param population Population of the color in an image
+   */
+  constructor(rgb, population) {
+    this._rgb = rgb;
+    this._population = population;
   }
 };
-var balancedAngleBoundaryOption = {
-  id: asBoundaryOptionId("break:angle-balanced"),
-  label: "Balanced angle",
-  transitionAfter: "angle-edge",
-  treatment: {
-    kind: "angle-edge",
-    height: "medium",
-    slope: "balanced",
-    direction: "forward"
+
+// ../../node_modules/.pnpm/@vibrant+core@4.0.4/node_modules/@vibrant/core/dist/esm/index.js
+var _Vibrant = class _Vibrant2 {
+  /**
+   *
+   * @param _src Path to image file (supports HTTP/HTTPs)
+   * @param opts Options (optional)
+   */
+  constructor(_src, opts) {
+    this._src = _src;
+    this.opts = assignDeep({}, _Vibrant2.DefaultOpts, opts);
+  }
+  static use(pipeline2) {
+    this._pipeline = pipeline2;
+  }
+  static from(src) {
+    return new Builder(src);
+  }
+  get result() {
+    return this._result;
+  }
+  _process(image, opts) {
+    image.scaleDown(this.opts);
+    const processOpts = buildProcessOptions(this.opts, opts);
+    return _Vibrant2._pipeline.process(image.getImageData(), processOpts);
+  }
+  async getPalette() {
+    const image = new this.opts.ImageClass();
+    try {
+      const image1 = await image.load(this._src);
+      const result1 = await this._process(image1, {
+        generators: ["default"]
+      });
+      this._result = result1;
+      const res = result1.palettes["default"];
+      if (!res) {
+        throw new Error(
+          `Something went wrong and a palette was not found, please file a bug against our GitHub repo: https://github.com/vibrant-Colors/node-vibrant/`
+        );
+      }
+      image.remove();
+      return res;
+    } catch (err) {
+      image.remove();
+      return Promise.reject(err);
+    }
+  }
+  async getPalettes() {
+    const image = new this.opts.ImageClass();
+    try {
+      const image1 = await image.load(this._src);
+      const result1 = await this._process(image1, {
+        generators: ["*"]
+      });
+      this._result = result1;
+      const res = result1.palettes;
+      image.remove();
+      return res;
+    } catch (err) {
+      image.remove();
+      return Promise.reject(err);
+    }
   }
 };
-var steepAngleBoundaryOption = {
-  id: asBoundaryOptionId("break:angle-steep"),
-  label: "Steep angle",
-  transitionAfter: "angle-edge-steep",
-  treatment: {
-    kind: "angle-edge",
-    height: "large",
-    slope: "steep",
-    direction: "forward"
+_Vibrant.DefaultOpts = {
+  colorCount: 64,
+  quality: 5,
+  filters: []
+};
+var Vibrant = _Vibrant;
+
+// ../../node_modules/.pnpm/node-vibrant@4.0.4/node_modules/node-vibrant/dist/esm/configs/config.js
+Vibrant.DefaultOpts.quantizer = "mmcq";
+Vibrant.DefaultOpts.generators = ["default"];
+Vibrant.DefaultOpts.filters = ["default"];
+
+// ../../node_modules/.pnpm/node-vibrant@4.0.4/node_modules/node-vibrant/dist/esm/configs/browser.js
+Vibrant.DefaultOpts.ImageClass = BrowserImage;
+
+// ../../node_modules/.pnpm/@vibrant+quantizer-mmcq@4.0.4/node_modules/@vibrant/quantizer-mmcq/dist/esm/vbox.js
+var SIGBITS = 5;
+var RSHIFT = 8 - SIGBITS;
+var VBox = class _VBox {
+  constructor(r1, r2, g1, g2, b1, b2, histogram) {
+    this.histogram = histogram;
+    this._volume = -1;
+    this._avg = null;
+    this._count = -1;
+    this.dimension = { r1, r2, g1, g2, b1, b2 };
+  }
+  static build(pixels) {
+    const h = new Histogram(pixels, { sigBits: SIGBITS });
+    const { rmin, rmax, gmin, gmax, bmin, bmax } = h;
+    return new _VBox(rmin, rmax, gmin, gmax, bmin, bmax, h);
+  }
+  invalidate() {
+    this._volume = this._count = -1;
+    this._avg = null;
+  }
+  volume() {
+    if (this._volume < 0) {
+      const { r1, r2, g1, g2, b1, b2 } = this.dimension;
+      this._volume = (r2 - r1 + 1) * (g2 - g1 + 1) * (b2 - b1 + 1);
+    }
+    return this._volume;
+  }
+  count() {
+    if (this._count < 0) {
+      const { hist, getColorIndex } = this.histogram;
+      const { r1, r2, g1, g2, b1, b2 } = this.dimension;
+      let c = 0;
+      for (let r = r1; r <= r2; r++) {
+        for (let g = g1; g <= g2; g++) {
+          for (let b = b1; b <= b2; b++) {
+            const index = getColorIndex(r, g, b);
+            if (!hist[index]) {
+              continue;
+            }
+            c += hist[index];
+          }
+        }
+      }
+      this._count = c;
+    }
+    return this._count;
+  }
+  clone() {
+    const { histogram } = this;
+    const { r1, r2, g1, g2, b1, b2 } = this.dimension;
+    return new _VBox(r1, r2, g1, g2, b1, b2, histogram);
+  }
+  avg() {
+    if (!this._avg) {
+      const { hist, getColorIndex } = this.histogram;
+      const { r1, r2, g1, g2, b1, b2 } = this.dimension;
+      let ntot = 0;
+      const mult = 1 << 8 - SIGBITS;
+      let rsum;
+      let gsum;
+      let bsum;
+      rsum = gsum = bsum = 0;
+      for (let r = r1; r <= r2; r++) {
+        for (let g = g1; g <= g2; g++) {
+          for (let b = b1; b <= b2; b++) {
+            const index = getColorIndex(r, g, b);
+            const h = hist[index];
+            if (!h) continue;
+            ntot += h;
+            rsum += h * (r + 0.5) * mult;
+            gsum += h * (g + 0.5) * mult;
+            bsum += h * (b + 0.5) * mult;
+          }
+        }
+      }
+      if (ntot) {
+        this._avg = [~~(rsum / ntot), ~~(gsum / ntot), ~~(bsum / ntot)];
+      } else {
+        this._avg = [
+          ~~(mult * (r1 + r2 + 1) / 2),
+          ~~(mult * (g1 + g2 + 1) / 2),
+          ~~(mult * (b1 + b2 + 1) / 2)
+        ];
+      }
+    }
+    return this._avg;
+  }
+  contains(rgb) {
+    let [r, g, b] = rgb;
+    const { r1, r2, g1, g2, b1, b2 } = this.dimension;
+    r >>= RSHIFT;
+    g >>= RSHIFT;
+    b >>= RSHIFT;
+    return r >= r1 && r <= r2 && g >= g1 && g <= g2 && b >= b1 && b <= b2;
+  }
+  split() {
+    const { hist, getColorIndex } = this.histogram;
+    const { r1, r2, g1, g2, b1, b2 } = this.dimension;
+    const count = this.count();
+    if (!count) return [];
+    if (count === 1) return [this.clone()];
+    const rw = r2 - r1 + 1;
+    const gw = g2 - g1 + 1;
+    const bw = b2 - b1 + 1;
+    const maxw = Math.max(rw, gw, bw);
+    let accSum = null;
+    let sum;
+    let total;
+    sum = total = 0;
+    let maxd = null;
+    if (maxw === rw) {
+      maxd = "r";
+      accSum = new Uint32Array(r2 + 1);
+      for (let r = r1; r <= r2; r++) {
+        sum = 0;
+        for (let g = g1; g <= g2; g++) {
+          for (let b = b1; b <= b2; b++) {
+            const index = getColorIndex(r, g, b);
+            if (!hist[index]) continue;
+            sum += hist[index];
+          }
+        }
+        total += sum;
+        accSum[r] = total;
+      }
+    } else if (maxw === gw) {
+      maxd = "g";
+      accSum = new Uint32Array(g2 + 1);
+      for (let g = g1; g <= g2; g++) {
+        sum = 0;
+        for (let r = r1; r <= r2; r++) {
+          for (let b = b1; b <= b2; b++) {
+            const index = getColorIndex(r, g, b);
+            if (!hist[index]) continue;
+            sum += hist[index];
+          }
+        }
+        total += sum;
+        accSum[g] = total;
+      }
+    } else {
+      maxd = "b";
+      accSum = new Uint32Array(b2 + 1);
+      for (let b = b1; b <= b2; b++) {
+        sum = 0;
+        for (let r = r1; r <= r2; r++) {
+          for (let g = g1; g <= g2; g++) {
+            const index = getColorIndex(r, g, b);
+            if (!hist[index]) continue;
+            sum += hist[index];
+          }
+        }
+        total += sum;
+        accSum[b] = total;
+      }
+    }
+    let splitPoint = -1;
+    const reverseSum = new Uint32Array(accSum.length);
+    for (let i = 0; i < accSum.length; i++) {
+      const d = accSum[i];
+      if (!d) continue;
+      if (splitPoint < 0 && d > total / 2) splitPoint = i;
+      reverseSum[i] = total - d;
+    }
+    const vbox = this;
+    function doCut(d) {
+      const dim1 = d + "1";
+      const dim2 = d + "2";
+      const d1 = vbox.dimension[dim1];
+      let d2 = vbox.dimension[dim2];
+      const vbox1 = vbox.clone();
+      const vbox2 = vbox.clone();
+      const left = splitPoint - d1;
+      const right = d2 - splitPoint;
+      if (left <= right) {
+        d2 = Math.min(d2 - 1, ~~(splitPoint + right / 2));
+        d2 = Math.max(0, d2);
+      } else {
+        d2 = Math.max(d1, ~~(splitPoint - 1 - left / 2));
+        d2 = Math.min(vbox.dimension[dim2], d2);
+      }
+      while (!accSum[d2]) d2++;
+      let c2 = reverseSum[d2];
+      while (!c2 && accSum[d2 - 1]) c2 = reverseSum[--d2];
+      vbox1.dimension[dim2] = d2;
+      vbox2.dimension[dim1] = d2 + 1;
+      return [vbox1, vbox2];
+    }
+    return doCut(maxd);
   }
 };
 
-// ../theme-core/src/site-styles/pageDesignIntent.ts
-var pageDesignIntentSchemaVersion = 2;
-var legacyPageDesignIntentSchemaVersion = 1;
-var unknownBoundaryOptionId = asBoundaryOptionId("break:unknown");
-var pageDesignUserPinnedAppearanceChoiceSchema = z3.object({
-  kind: z3.literal("user-pinned"),
-  value: z3.string().min(1).transform(asAppearancePresetId)
-}).strict();
-var pageDesignUserPinnedBoundaryChoiceSchema = z3.object({
-  kind: z3.literal("user-pinned"),
-  value: z3.string().min(1).transform(asBoundaryOptionId)
-}).strict();
-var pageDesignBoundaryTreatmentSchema = z3.discriminatedUnion("kind", [
-  z3.object({ kind: z3.literal("none") }).strict(),
-  z3.object({
-    kind: z3.literal("soft-fade"),
-    height: z3.enum(["compact", "medium", "large", "expansive"]),
-    curve: z3.enum(["soft", "spacious", "expansive"])
-  }).strict(),
-  z3.object({
-    kind: z3.literal("wave-edge"),
-    height: z3.enum(["compact", "medium", "large"]),
-    amplitude: z3.enum(["subtle", "balanced", "bold"]),
-    rhythm: z3.enum(["single", "double"]),
-    symmetry: z3.enum(["symmetrical", "asymmetrical", "drift"])
-  }).strict(),
-  z3.object({
-    kind: z3.literal("angle-edge"),
-    height: z3.enum(["compact", "medium", "large"]),
-    slope: z3.enum(["subtle", "balanced", "steep"]),
-    direction: z3.enum(["forward", "reverse"])
-  }).strict(),
-  z3.object({
-    kind: z3.literal("legacy-unsupported"),
-    boundaryOptionId: z3.string().min(1).transform(asBoundaryOptionId)
-  }).strict()
-]);
-var pageDesignUserPinnedBoundaryTreatmentChoiceSchema = z3.object({
-  kind: z3.literal("user-pinned"),
-  value: pageDesignBoundaryTreatmentSchema
-}).strict();
-var pageDesignBlockLookPinSchema = z3.object({
-  blockId: z3.string().min(1).transform(asDesignBlockId),
-  blockKind: z3.string().min(1),
-  choice: pageDesignUserPinnedAppearanceChoiceSchema
-}).strict();
-var pageDesignBoundaryPinSchema = z3.object({
-  boundaryId: z3.string().min(1).transform(asDesignBoundaryId),
-  previousBlockId: z3.string().min(1).transform(asDesignBlockId),
-  nextBlockId: z3.string().min(1).transform(asDesignBlockId),
-  choice: pageDesignUserPinnedBoundaryTreatmentChoiceSchema
-}).strict().superRefine(validateBoundaryPinIdMatchesBlocks);
-var legacyPageDesignBoundaryPinSchema = z3.object({
-  boundaryId: z3.string().min(1).transform(asDesignBoundaryId),
-  previousBlockId: z3.string().min(1).transform(asDesignBlockId),
-  nextBlockId: z3.string().min(1).transform(asDesignBlockId),
-  choice: pageDesignUserPinnedBoundaryChoiceSchema
-}).strict().superRefine(validateBoundaryPinIdMatchesBlocks);
-var pageDesignIntentV1Schema = z3.object({
-  schemaVersion: z3.literal(legacyPageDesignIntentSchemaVersion),
-  siteStyleId: z3.string().min(1).transform(asSiteStyleId),
-  pageFlowPresetId: z3.string().min(1).transform(asPageFlowPresetId),
-  blockLookPins: z3.array(pageDesignBlockLookPinSchema),
-  boundaryPins: z3.array(legacyPageDesignBoundaryPinSchema)
-}).strict().superRefine(validateUniquePageDesignPins);
-var pageDesignIntentV2Schema = z3.object({
-  schemaVersion: z3.literal(pageDesignIntentSchemaVersion),
-  siteStyleId: z3.string().min(1).transform(asSiteStyleId),
-  pageFlowPresetId: z3.string().min(1).transform(asPageFlowPresetId),
-  blockLookPins: z3.array(pageDesignBlockLookPinSchema),
-  boundaryPins: z3.array(pageDesignBoundaryPinSchema)
-}).strict().superRefine(validateUniquePageDesignPins);
-function addDuplicateStringIssues(ctx, input) {
-  const seen = /* @__PURE__ */ new Set();
-  const duplicates = /* @__PURE__ */ new Set();
-  for (const value of input.values) {
-    if (seen.has(value)) {
-      duplicates.add(value);
+// ../../node_modules/.pnpm/@vibrant+quantizer-mmcq@4.0.4/node_modules/@vibrant/quantizer-mmcq/dist/esm/pqueue.js
+var PQueue = class {
+  _sort() {
+    if (!this._sorted) {
+      this.contents.sort(this._comparator);
+      this._sorted = true;
     }
-    seen.add(value);
   }
-  for (const duplicate of duplicates) {
-    ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
-      path: [...input.path],
-      message: `Duplicate ${input.label}: ${duplicate}.`
-    });
+  constructor(comparator) {
+    this._comparator = comparator;
+    this.contents = [];
+    this._sorted = false;
+  }
+  push(item) {
+    this.contents.push(item);
+    this._sorted = false;
+  }
+  peek(index) {
+    this._sort();
+    index = typeof index === "number" ? index : this.contents.length - 1;
+    return this.contents[index];
+  }
+  pop() {
+    this._sort();
+    return this.contents.pop();
+  }
+  size() {
+    return this.contents.length;
+  }
+  map(mapper) {
+    this._sort();
+    return this.contents.map(mapper);
+  }
+};
+
+// ../../node_modules/.pnpm/@vibrant+quantizer-mmcq@4.0.4/node_modules/@vibrant/quantizer-mmcq/dist/esm/index.js
+var fractByPopulations = 0.75;
+function _splitBoxes(pq, target) {
+  let lastSize = pq.size();
+  while (pq.size() < target) {
+    const vbox = pq.pop();
+    if (vbox && vbox.count() > 0) {
+      const [vbox1, vbox2] = vbox.split();
+      if (!vbox1) break;
+      pq.push(vbox1);
+      if (vbox2 && vbox2.count() > 0) pq.push(vbox2);
+      if (pq.size() === lastSize) {
+        break;
+      } else {
+        lastSize = pq.size();
+      }
+    } else {
+      break;
+    }
   }
 }
-function validateBoundaryPinIdMatchesBlocks(pin, ctx) {
-  const expectedBoundaryId = makeBoundaryId(
-    pin.previousBlockId,
-    pin.nextBlockId
-  );
-  if (pin.boundaryId !== expectedBoundaryId) {
-    ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
-      path: ["boundaryId"],
-      message: `Boundary id must match previousBlockId and nextBlockId. Expected ${expectedBoundaryId}.`
-    });
+var MMCQ = (pixels, opts) => {
+  if (pixels.length === 0 || opts.colorCount < 2 || opts.colorCount > 256) {
+    throw new Error("Wrong MMCQ parameters");
   }
-}
-function validateUniquePageDesignPins(intent, ctx) {
-  addDuplicateStringIssues(ctx, {
-    values: intent.blockLookPins.map((pin) => pin.blockId),
-    path: ["blockLookPins"],
-    label: "block Look pin"
-  });
-  addDuplicateStringIssues(ctx, {
-    values: intent.boundaryPins.map(
-      (pin) => boundaryKey(pin.previousBlockId, pin.nextBlockId)
-    ),
-    path: ["boundaryPins"],
-    label: "boundary pin"
+  const vbox = VBox.build(pixels);
+  vbox.histogram.colorCount;
+  const pq = new PQueue((a, b) => a.count() - b.count());
+  pq.push(vbox);
+  _splitBoxes(pq, fractByPopulations * opts.colorCount);
+  const pq2 = new PQueue(
+    (a, b) => a.count() * a.volume() - b.count() * b.volume()
+  );
+  pq2.contents = pq.contents;
+  _splitBoxes(pq2, opts.colorCount - pq2.size());
+  return generateSwatches(pq2);
+};
+function generateSwatches(pq) {
+  const swatches = [];
+  while (pq.size()) {
+    const v = pq.pop();
+    const color = v.avg();
+    const [r, g, b] = color;
+    swatches.push(new Swatch2(color, v.count()));
+  }
+  return swatches;
+}
+
+// ../../node_modules/.pnpm/@vibrant+generator-default@4.0.4/node_modules/@vibrant/generator-default/dist/esm/index.js
+var DefaultOpts = {
+  targetDarkLuma: 0.26,
+  maxDarkLuma: 0.45,
+  minLightLuma: 0.55,
+  targetLightLuma: 0.74,
+  minNormalLuma: 0.3,
+  targetNormalLuma: 0.5,
+  maxNormalLuma: 0.7,
+  targetMutesSaturation: 0.3,
+  maxMutesSaturation: 0.4,
+  targetVibrantSaturation: 1,
+  minVibrantSaturation: 0.35,
+  weightSaturation: 3,
+  weightLuma: 6.5,
+  weightPopulation: 0.5
+};
+function _findMaxPopulation(swatches) {
+  let p = 0;
+  swatches.forEach((s) => {
+    p = Math.max(p, s.population);
   });
+  return p;
+}
+function _isAlreadySelected(palette, s) {
+  return palette.Vibrant === s || palette.DarkVibrant === s || palette.LightVibrant === s || palette.Muted === s || palette.DarkMuted === s || palette.LightMuted === s;
+}
+function _createComparisonValue(saturation, targetSaturation, luma, targetLuma, population, maxPopulation, opts) {
+  function weightedMean(...values) {
+    let sum = 0;
+    let weightSum = 0;
+    for (let i = 0; i < values.length; i += 2) {
+      const value = values[i];
+      const weight = values[i + 1];
+      if (!value || !weight) continue;
+      sum += value * weight;
+      weightSum += weight;
+    }
+    return sum / weightSum;
+  }
+  function invertDiff(value, targetValue) {
+    return 1 - Math.abs(value - targetValue);
+  }
+  return weightedMean(
+    invertDiff(saturation, targetSaturation),
+    opts.weightSaturation,
+    invertDiff(luma, targetLuma),
+    opts.weightLuma,
+    population / maxPopulation,
+    opts.weightPopulation
+  );
 }
-function boundaryKey(previousBlockId, nextBlockId) {
-  return makeBoundaryId(previousBlockId, nextBlockId);
-}
+function _findColorVariation(palette, swatches, maxPopulation, targetLuma, minLuma, maxLuma, targetSaturation, minSaturation, maxSaturation, opts) {
+  let max = null;
+  let maxValue = 0;
+  swatches.forEach((swatch) => {
+    const [, s, l] = swatch.hsl;
+    if (s >= minSaturation && s <= maxSaturation && l >= minLuma && l <= maxLuma && !_isAlreadySelected(palette, swatch)) {
+      const value = _createComparisonValue(
+        s,
+        targetSaturation,
+        l,
+        targetLuma,
+        swatch.population,
+        maxPopulation,
+        opts
+      );
+      if (max === null || value > maxValue) {
+        max = swatch;
+        maxValue = value;
+      }
+    }
+  });
+  return max;
+}
+function _generateVariationColors(swatches, maxPopulation, opts) {
+  const palette = {
+    Vibrant: null,
+    DarkVibrant: null,
+    LightVibrant: null,
+    Muted: null,
+    DarkMuted: null,
+    LightMuted: null
+  };
+  palette.Vibrant = _findColorVariation(
+    palette,
+    swatches,
+    maxPopulation,
+    opts.targetNormalLuma,
+    opts.minNormalLuma,
+    opts.maxNormalLuma,
+    opts.targetVibrantSaturation,
+    opts.minVibrantSaturation,
+    1,
+    opts
+  );
+  palette.LightVibrant = _findColorVariation(
+    palette,
+    swatches,
+    maxPopulation,
+    opts.targetLightLuma,
+    opts.minLightLuma,
+    1,
+    opts.targetVibrantSaturation,
+    opts.minVibrantSaturation,
+    1,
+    opts
+  );
+  palette.DarkVibrant = _findColorVariation(
+    palette,
+    swatches,
+    maxPopulation,
+    opts.targetDarkLuma,
+    0,
+    opts.maxDarkLuma,
+    opts.targetVibrantSaturation,
+    opts.minVibrantSaturation,
+    1,
+    opts
+  );
+  palette.Muted = _findColorVariation(
+    palette,
+    swatches,
+    maxPopulation,
+    opts.targetNormalLuma,
+    opts.minNormalLuma,
+    opts.maxNormalLuma,
+    opts.targetMutesSaturation,
+    0,
+    opts.maxMutesSaturation,
+    opts
+  );
+  palette.LightMuted = _findColorVariation(
+    palette,
+    swatches,
+    maxPopulation,
+    opts.targetLightLuma,
+    opts.minLightLuma,
+    1,
+    opts.targetMutesSaturation,
+    0,
+    opts.maxMutesSaturation,
+    opts
+  );
+  palette.DarkMuted = _findColorVariation(
+    palette,
+    swatches,
+    maxPopulation,
+    opts.targetDarkLuma,
+    0,
+    opts.maxDarkLuma,
+    opts.targetMutesSaturation,
+    0,
+    opts.maxMutesSaturation,
+    opts
+  );
+  return palette;
+}
+function _generateEmptySwatches(palette, _maxPopulation, opts) {
+  if (!palette.Vibrant && !palette.DarkVibrant && !palette.LightVibrant) {
+    if (!palette.DarkVibrant && palette.DarkMuted) {
+      let [h, s, l] = palette.DarkMuted.hsl;
+      l = opts.targetDarkLuma;
+      palette.DarkVibrant = new Swatch2(hslToRgb(h, s, l), 0);
+    }
+    if (!palette.LightVibrant && palette.LightMuted) {
+      let [h, s, l] = palette.LightMuted.hsl;
+      l = opts.targetDarkLuma;
+      palette.DarkVibrant = new Swatch2(hslToRgb(h, s, l), 0);
+    }
+  }
+  if (!palette.Vibrant && palette.DarkVibrant) {
+    let [h, s, l] = palette.DarkVibrant.hsl;
+    l = opts.targetNormalLuma;
+    palette.Vibrant = new Swatch2(hslToRgb(h, s, l), 0);
+  } else if (!palette.Vibrant && palette.LightVibrant) {
+    let [h, s, l] = palette.LightVibrant.hsl;
+    l = opts.targetNormalLuma;
+    palette.Vibrant = new Swatch2(hslToRgb(h, s, l), 0);
+  }
+  if (!palette.DarkVibrant && palette.Vibrant) {
+    let [h, s, l] = palette.Vibrant.hsl;
+    l = opts.targetDarkLuma;
+    palette.DarkVibrant = new Swatch2(hslToRgb(h, s, l), 0);
+  }
+  if (!palette.LightVibrant && palette.Vibrant) {
+    let [h, s, l] = palette.Vibrant.hsl;
+    l = opts.targetLightLuma;
+    palette.LightVibrant = new Swatch2(hslToRgb(h, s, l), 0);
+  }
+  if (!palette.Muted && palette.Vibrant) {
+    let [h, s, l] = palette.Vibrant.hsl;
+    l = opts.targetMutesSaturation;
+    palette.Muted = new Swatch2(hslToRgb(h, s, l), 0);
+  }
+  if (!palette.DarkMuted && palette.DarkVibrant) {
+    let [h, s, l] = palette.DarkVibrant.hsl;
+    l = opts.targetMutesSaturation;
+    palette.DarkMuted = new Swatch2(hslToRgb(h, s, l), 0);
+  }
+  if (!palette.LightMuted && palette.LightVibrant) {
+    let [h, s, l] = palette.LightVibrant.hsl;
+    l = opts.targetMutesSaturation;
+    palette.LightMuted = new Swatch2(hslToRgb(h, s, l), 0);
+  }
+}
+var DefaultGenerator = ((swatches, opts) => {
+  opts = Object.assign({}, DefaultOpts, opts);
+  const maxPopulation = _findMaxPopulation(swatches);
+  const palette = _generateVariationColors(swatches, maxPopulation, opts);
+  _generateEmptySwatches(palette, maxPopulation, opts);
+  return palette;
+});
+
+// ../../node_modules/.pnpm/node-vibrant@4.0.4/node_modules/node-vibrant/dist/esm/pipeline/index.js
+var pipeline = new BasicPipeline().filter.register(
+  "default",
+  (r, g, b, a) => a >= 125 && !(r > 250 && g > 250 && b > 250)
+).quantizer.register("mmcq", MMCQ).generator.register("default", DefaultGenerator);
 
-// ../theme-core/src/buttons/personalities/types.ts
-import { z as z7 } from "zod";
+// ../../node_modules/.pnpm/node-vibrant@4.0.4/node_modules/node-vibrant/dist/esm/browser.js
+Vibrant.use(pipeline);
+
+// ../theme-core/src/palette/variants/types.ts
+import { z as z20 } from "zod";
+
+// ../theme-core/src/site-styles/styleTags.ts
+import { z as z3 } from "zod";
+var STYLE_AXIS_VALUES = {
+  tone: ["minimal", "classic", "bold"],
+  energy: ["calm", "vibrant"],
+  motion: ["subtle", "standard", "expressive"],
+  era: ["editorial", "modern", "organic", "technical", "retro"]
+};
+var styleTagsSchema = z3.object({
+  tone: z3.enum(STYLE_AXIS_VALUES.tone).optional(),
+  energy: z3.enum(STYLE_AXIS_VALUES.energy).optional(),
+  motion: z3.enum(STYLE_AXIS_VALUES.motion).optional(),
+  era: z3.enum(STYLE_AXIS_VALUES.era).optional()
+});
+
+// ../theme-core/src/schema.ts
+import { z as z19 } from "zod";
+
+// ../theme-core/src/lib/media.ts
+import z4 from "zod";
+var hotspotSchema = z4.object({
+  x: z4.number().min(0).max(1),
+  y: z4.number().min(0).max(1),
+  radius: z4.number().optional()
+});
+var rotationSchema = z4.union([z4.literal(0), z4.literal(90), z4.literal(180), z4.literal(270)]);
+var rectSchema = z4.tuple([z4.number(), z4.number(), z4.number(), z4.number()]);
+var aspectCropSchema = z4.object({
+  aspect: z4.preprocess((value) => value == null ? void 0 : value, z4.string().optional()),
+  rect: z4.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
+  hotspot: z4.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
+  rotation: z4.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
+});
+var transformSchema = z4.object({
+  aspectCrops: z4.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return void 0;
+    }
+    return value;
+  }, z4.record(z4.string(), aspectCropSchema.catch({}))).optional(),
+  rect: rectSchema.optional(),
+  hotspot: hotspotSchema.optional(),
+  rotation: rotationSchema.optional()
+});
+var mediaSchema = z4.object({
+  type: z4.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
+  purpose: z4.string().optional(),
+  placeholder: z4.boolean().default(true).optional(),
+  assetId: z4.string().optional(),
+  identifier: z4.string().optional(),
+  src: z4.string().optional(),
+  alt: z4.string().optional(),
+  filename: z4.string().optional(),
+  mimeType: z4.string().optional(),
+  width: z4.number().optional(),
+  height: z4.number().optional(),
+  storageBucket: z4.string().optional(),
+  storagePath: z4.string().optional(),
+  transform: transformSchema.optional()
+});
 
 // ../theme-core/src/buttons/types.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // ../theme-core/src/tokens/themeColorTokens.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../theme-core/src/tokens/colorTokenParts.ts
 function parseOpacityPercent(source) {
@@ -2338,7 +3382,7 @@ var PALETTE_TOKEN_NAMES = [
   "text",
   "border"
 ];
-var paletteTokenNameSchema = z4.enum(PALETTE_TOKEN_NAMES);
+var paletteTokenNameSchema = z5.enum(PALETTE_TOKEN_NAMES);
 var themeColorBaseTokenNames = [
   ...PALETTE_TOKEN_NAMES,
   ...blockColorTokenNames,
@@ -2383,7 +3427,11 @@ function isThemeColorToken(value) {
   const parts = parseColorTokenParts(value);
   return parts.kind === "token" && isThemeColorTokenBase(parts.token);
 }
-var themeColorTokenSchema = z4.string().min(1).refine((value) => Boolean(isThemeColorToken(value)), "Expected a known Theme V2 color token");
+function parseThemeColorToken(value) {
+  if (!isThemeColorToken(value)) return null;
+  return value.trim();
+}
+var themeColorTokenSchema = z5.string().min(1).refine((value) => Boolean(isThemeColorToken(value)), "Expected a known Theme V2 color token");
 
 // ../theme-core/src/buttons/types.ts
 var VARIANT_ROLES = [
@@ -2395,22 +3443,22 @@ var VARIANT_ROLES = [
   "tertiary",
   "accent"
 ];
-var cornerStyleSchema = z5.enum(["square", "rounded", "pill"]);
-var shadowSizeSchema = z5.enum(["none", "low", "medium", "high"]);
-var textTransformSchema = z5.enum(["none", "uppercase", "lowercase", "capitalize"]);
-var fontWeightSchema = z5.union([z5.literal(500), z5.literal(600), z5.literal(700)]);
-var buttonTypographySchema = z5.enum(["body", "heading"]);
-var letterSpacingSchema = z5.enum(["tight", "normal", "loose"]);
-var hoverTransformSchema = z5.enum(["none", "lift", "scale", "press"]);
-var hoverColorSchema = z5.enum(["none", "brighten", "darken", "saturate", "token"]);
-var buttonPaddingPresetSchema = z5.enum(["compact", "default", "spacious"]);
-var gradientStyleSchema = z5.enum(["linear", "radial", "conic"]);
-var gradientSharpnessSchema = z5.enum(["smooth", "medium", "hard"]);
-var prioritySchema = z5.union([z5.literal(1), z5.literal(2), z5.literal(3)]);
-var variantRoleSchema = z5.enum(VARIANT_ROLES);
-var buttonSizeNameSchema = z5.enum(["sm", "md", "lg", "xl"]);
+var cornerStyleSchema = z6.enum(["square", "rounded", "pill"]);
+var shadowSizeSchema = z6.enum(["none", "low", "medium", "high"]);
+var textTransformSchema = z6.enum(["none", "uppercase", "lowercase", "capitalize"]);
+var fontWeightSchema = z6.union([z6.literal(500), z6.literal(600), z6.literal(700)]);
+var buttonTypographySchema = z6.enum(["body", "heading"]);
+var letterSpacingSchema = z6.enum(["tight", "normal", "loose"]);
+var hoverTransformSchema = z6.enum(["none", "lift", "scale", "press"]);
+var hoverColorSchema = z6.enum(["none", "brighten", "darken", "saturate", "token"]);
+var buttonPaddingPresetSchema = z6.enum(["compact", "default", "spacious"]);
+var gradientStyleSchema = z6.enum(["linear", "radial", "conic"]);
+var gradientSharpnessSchema = z6.enum(["smooth", "medium", "hard"]);
+var prioritySchema = z6.union([z6.literal(1), z6.literal(2), z6.literal(3)]);
+var variantRoleSchema = z6.enum(VARIANT_ROLES);
+var buttonSizeNameSchema = z6.enum(["sm", "md", "lg", "xl"]);
 var PADDING_TOKEN_PATTERN = /^(?:0|\d+(?:\.\d+)?(?:rem|em|px|%))$/;
-var paddingShorthandSchema = z5.string().refine(
+var paddingShorthandSchema = z6.string().refine(
   (value) => {
     const parts = value.split(/\s+/).filter(Boolean);
     return parts.length === 2 && parts.every((token) => PADDING_TOKEN_PATTERN.test(token));
@@ -2419,11 +3467,11 @@ var paddingShorthandSchema = z5.string().refine(
     message: 'Padding must be two space-separated CSS length tokens (e.g. "0.5rem 1rem"). Use `0` for zero.'
   }
 );
-var buttonSizeConfigSchema = z5.object({
+var buttonSizeConfigSchema = z6.object({
   padding: paddingShorthandSchema,
-  fontSize: z5.string().optional()
+  fontSize: z6.string().optional()
 });
-var buttonSizesSchema = z5.object({
+var buttonSizesSchema = z6.object({
   sm: buttonSizeConfigSchema,
   md: buttonSizeConfigSchema,
   lg: buttonSizeConfigSchema,
@@ -2434,9 +3482,9 @@ var buttonSizesSchema = z5.object({
   lg,
   xl: xl ?? lg
 }));
-var buttonGlobalSettingsSchema = z5.object({
+var buttonGlobalSettingsSchema = z6.object({
   cornerStyle: cornerStyleSchema,
-  cornerRadius: z5.number().min(0).max(24).optional(),
+  cornerRadius: z6.number().min(0).max(24).optional(),
   shadow: shadowSizeSchema,
   textTransform: textTransformSchema,
   fontWeight: fontWeightSchema,
@@ -2446,18 +3494,18 @@ var buttonGlobalSettingsSchema = z5.object({
    * by the current generator and will be removed once the legacy
    * `primitives/content/components/Button.tsx` slot exports are deleted.
    */
-  borderWidth: z5.union([z5.literal(1), z5.literal(2), z5.literal(3)]),
+  borderWidth: z6.union([z6.literal(1), z6.literal(2), z6.literal(3)]),
   // === Family-level typography ===
   // Typography source (body or heading) — selects which theme typography pool to inherit
   typography: buttonTypographySchema.optional(),
   // Font size for all variants in the family (Tailwind token, e.g. "text-xs", "text-sm")
   // Sized variants get this as default; fixed variants inherit unless they override.
   // Size class CSS may still override at run time for sized variants.
-  fontSize: z5.string().optional(),
+  fontSize: z6.string().optional(),
   // Letter spacing applied to all variants
   letterSpacing: letterSpacingSchema.optional(),
   // Italic style
-  italic: z5.boolean().optional(),
+  italic: z6.boolean().optional(),
   // Padding preset (applies to sized variants without a sizes config)
   paddingPreset: buttonPaddingPresetSchema.optional(),
   hoverTransform: hoverTransformSchema,
@@ -2466,89 +3514,78 @@ var buttonGlobalSettingsSchema = z5.object({
   hoverColorToken: themeColorTokenSchema.optional(),
   // Gradient settings (if any variant uses gradients)
   gradientStyle: gradientStyleSchema.optional(),
-  gradientAngle: z5.number().min(0).max(360).optional(),
+  gradientAngle: z6.number().min(0).max(360).optional(),
   gradientSharpness: gradientSharpnessSchema.optional()
 });
-var gradientDirectionSchema = z5.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
-var buttonBackgroundSchema = z5.discriminatedUnion("type", [
-  z5.object({ type: z5.literal("solid"), colorToken: themeColorTokenSchema }),
-  z5.object({
-    type: z5.literal("gradient"),
-    stops: z5.array(themeColorTokenSchema).min(2),
+var gradientDirectionSchema = z6.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
+var buttonBackgroundSchema = z6.discriminatedUnion("type", [
+  z6.object({ type: z6.literal("solid"), colorToken: themeColorTokenSchema }),
+  z6.object({
+    type: z6.literal("gradient"),
+    stops: z6.array(themeColorTokenSchema).min(2),
     direction: gradientDirectionSchema
   }),
-  z5.object({ type: z5.literal("transparent") })
+  z6.object({ type: z6.literal("transparent") })
 ]);
-var effectApplicationSchema = z5.object({
-  effectId: z5.string(),
-  options: z5.record(z5.string(), z5.any()).optional()
+var effectApplicationSchema = z6.object({
+  effectId: z6.string(),
+  options: z6.record(z6.string(), z6.any()).optional()
 });
-var buttonBorderSchema = z5.object({
-  widthClass: z5.string(),
+var buttonBorderSchema = z6.object({
+  widthClass: z6.string(),
   colorToken: themeColorTokenSchema
 });
-var variantShadowSchema = z5.object({
-  elevation: z5.enum(["none", "low", "medium", "high"]),
-  softness: z5.enum(["crisp", "soft", "hard"]).nullable(),
-  position: z5.enum(["bottom", "bottom-right"]).default("bottom"),
+var variantShadowSchema = z6.object({
+  elevation: z6.enum(["none", "low", "medium", "high"]),
+  softness: z6.enum(["crisp", "soft", "hard"]).nullable(),
+  position: z6.enum(["bottom", "bottom-right"]).default("bottom"),
   // Optional palette token for a coloured offset shadow; omit for neutral black.
   colorToken: themeColorTokenSchema.optional()
 });
-var variantEffectsSchema = z5.object({
-  base: z5.array(effectApplicationSchema).optional(),
-  hover: z5.array(effectApplicationSchema).optional(),
-  active: z5.array(effectApplicationSchema).optional(),
-  focus: z5.array(effectApplicationSchema).optional()
+var variantEffectsSchema = z6.object({
+  base: z6.array(effectApplicationSchema).optional(),
+  hover: z6.array(effectApplicationSchema).optional(),
+  active: z6.array(effectApplicationSchema).optional(),
+  focus: z6.array(effectApplicationSchema).optional()
 });
-var variantSizeOverridesSchema = z5.object({
+var variantSizeOverridesSchema = z6.object({
   sm: buttonSizeConfigSchema.optional(),
   md: buttonSizeConfigSchema.optional(),
   lg: buttonSizeConfigSchema.optional(),
   xl: buttonSizeConfigSchema.optional()
 });
-var buttonVariantSchema = z5.object({
-  id: z5.string(),
-  name: z5.string().min(1).max(20),
-  enabled: z5.boolean(),
+var buttonVariantSchema = z6.object({
+  id: z6.string(),
+  name: z6.string().min(1).max(20),
+  enabled: z6.boolean(),
   priority: prioritySchema,
   // Base appearance (token-based)
   background: buttonBackgroundSchema,
   textColorToken: themeColorTokenSchema,
   /** Tailwind radius token (e.g. `'rounded-md'`). Omit to inherit from `global.cornerStyle`. */
-  borderRadius: z5.string().optional(),
+  borderRadius: z6.string().optional(),
   // Optional shadow override (uses theme.shadow if not specified)
   shadow: variantShadowSchema.optional(),
   // Border (optional)
   border: buttonBorderSchema.optional(),
   // Hover background token (per-variant override, takes precedence over global hoverColorToken)
-  hoverBackgroundToken: z5.string().optional(),
+  hoverBackgroundToken: z6.string().optional(),
   // Effect composition
   effects: variantEffectsSchema.optional(),
   // Per-variant size overrides — see VariantSizeOverrides
   sizes: variantSizeOverridesSchema.optional()
 });
-var buttonSystemSchema = z5.object({
+var buttonSystemSchema = z6.object({
   global: buttonGlobalSettingsSchema,
-  variants: z5.array(buttonVariantSchema).min(1).max(6),
+  variants: z6.array(buttonVariantSchema).min(1).max(6),
   sizes: buttonSizesSchema.optional()
 });
 
-// ../theme-core/src/site-styles/styleTags.ts
-import { z as z6 } from "zod";
-var STYLE_AXIS_VALUES = {
-  tone: ["minimal", "classic", "bold"],
-  energy: ["calm", "vibrant"],
-  motion: ["subtle", "standard", "expressive"],
-  era: ["editorial", "modern", "organic", "technical", "retro"]
-};
-var styleTagsSchema = z6.object({
-  tone: z6.enum(STYLE_AXIS_VALUES.tone).optional(),
-  energy: z6.enum(STYLE_AXIS_VALUES.energy).optional(),
-  motion: z6.enum(STYLE_AXIS_VALUES.motion).optional(),
-  era: z6.enum(STYLE_AXIS_VALUES.era).optional()
-});
+// ../theme-core/src/buttons/generateButtonCss.ts
+var BUTTON_SIZE_NAMES = buttonSizeNameSchema.options;
 
 // ../theme-core/src/buttons/personalities/types.ts
+import { z as z7 } from "zod";
 function asButtonPersonalityId(value) {
   if (value.length === 0) {
     throw new Error("ButtonPersonalityId must be a non-empty string");
@@ -3079,7 +4116,7 @@ var joyStamp = defineButtonPersonality({
 var pebble = defineButtonPersonality({
   id: "pebble",
   name: "Pebble",
-  description: "Generous pill buttons with a soft hover lift.",
+  description: "Generous pill buttons with a quiet colour-softening hover.",
   tags: { tone: "classic", energy: "calm", motion: "standard", era: "organic" },
   buttonSystem: {
     global: {
@@ -3108,8 +4145,7 @@ var pebble = defineButtonPersonality({
         borderRadius: "rounded-full",
         effects: {
           hover: [
-            { effectId: "scale-up", options: { scale: "1.03" } },
-            { effectId: "drop-shadow", options: { intensity: "medium" } }
+            { effectId: "background-on-hover-alpha", options: { colorToken: "primary", opacity: 88 } }
           ]
         }
       },
@@ -3355,70 +4391,18 @@ var personalitiesById = new Map(
   buttonPersonalities.map((p) => [p.id, p])
 );
 
-// ../theme-core/src/palette/variants/types.ts
-import { z as z21 } from "zod";
-
-// ../theme-core/src/schema.ts
-import { z as z20 } from "zod";
-
-// ../theme-core/src/lib/media.ts
-import z8 from "zod";
-var hotspotSchema = z8.object({
-  x: z8.number().min(0).max(1),
-  y: z8.number().min(0).max(1),
-  radius: z8.number().optional()
-});
-var rotationSchema = z8.union([z8.literal(0), z8.literal(90), z8.literal(180), z8.literal(270)]);
-var rectSchema = z8.tuple([z8.number(), z8.number(), z8.number(), z8.number()]);
-var aspectCropSchema = z8.object({
-  aspect: z8.preprocess((value) => value == null ? void 0 : value, z8.string().optional()),
-  rect: z8.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
-  hotspot: z8.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
-  rotation: z8.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
-});
-var transformSchema = z8.object({
-  aspectCrops: z8.preprocess((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      return void 0;
-    }
-    return value;
-  }, z8.record(z8.string(), aspectCropSchema.catch({}))).optional(),
-  rect: rectSchema.optional(),
-  hotspot: hotspotSchema.optional(),
-  rotation: rotationSchema.optional()
-});
-var mediaSchema = z8.object({
-  type: z8.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
-  purpose: z8.string().optional(),
-  placeholder: z8.boolean().default(true).optional(),
-  assetId: z8.string().optional(),
-  identifier: z8.string().optional(),
-  src: z8.string().optional(),
-  alt: z8.string().optional(),
-  filename: z8.string().optional(),
-  mimeType: z8.string().optional(),
-  width: z8.number().optional(),
-  height: z8.number().optional(),
-  storageBucket: z8.string().optional(),
-  storagePath: z8.string().optional(),
-  transform: transformSchema.optional()
-});
-
-// ../theme-core/src/buttons/generateButtonCss.ts
-var BUTTON_SIZE_NAMES = buttonSizeNameSchema.options;
-
 // ../theme-core/src/cards/types.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 var cardVariantRoleValues = ["default", "alternative"];
 var boxlessCardVariantValue = "none";
 var legacyCardVariantRoleAliases = {
   variant1: "alternative",
   variant2: "alternative"
 };
-var cardSpacingSchema = z9.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
-var gradientDirectionSchema2 = z9.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
-var cardVariantRoleSchema = z9.enum(cardVariantRoleValues);
-var boxStylesCardVariantSchema = z9.enum([
+var cardSpacingSchema = z8.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
+var gradientDirectionSchema2 = z8.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
+var cardVariantRoleSchema = z8.enum(cardVariantRoleValues);
+var boxStylesCardVariantSchema = z8.enum([
   ...cardVariantRoleValues,
   boxlessCardVariantValue
 ]);
@@ -3430,55 +4414,55 @@ function normalizeCardVariantRole(value) {
   if (typeof value !== "string") return null;
   return legacyCardVariantRoleAliases[value] ?? null;
 }
-var cardBackgroundSchema = z9.discriminatedUnion("type", [
-  z9.object({ type: z9.literal("solid"), colorToken: themeColorTokenSchema }),
-  z9.object({
-    type: z9.literal("gradient"),
+var cardBackgroundSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("solid"), colorToken: themeColorTokenSchema }),
+  z8.object({
+    type: z8.literal("gradient"),
     fromToken: themeColorTokenSchema,
     toToken: themeColorTokenSchema,
     direction: gradientDirectionSchema2
   }),
-  z9.object({ type: z9.literal("transparent") })
+  z8.object({ type: z8.literal("transparent") })
 ]);
-var cardBorderSchema = z9.object({
-  widthClass: z9.string(),
+var cardBorderSchema = z8.object({
+  widthClass: z8.string(),
   colorToken: themeColorTokenSchema
 });
-var cardCornerValueSchema = z9.enum([
+var cardCornerValueSchema = z8.enum([
   "square",
   "soft",
   "rounded",
   "pill",
   "expressive"
 ]);
-var cardAccentEdgeSchema = z9.object({
-  edge: z9.enum(["left", "top", "right", "bottom"]),
+var cardAccentEdgeSchema = z8.object({
+  edge: z8.enum(["left", "top", "right", "bottom"]),
   colorToken: themeColorTokenSchema,
-  width: z9.enum(["thin", "medium", "thick", "heavy"])
+  width: z8.enum(["thin", "medium", "thick", "heavy"])
 });
-var cardCornerRadiiSchema = z9.object({
+var cardCornerRadiiSchema = z8.object({
   topLeft: cardCornerValueSchema.optional(),
   topRight: cardCornerValueSchema.optional(),
   bottomLeft: cardCornerValueSchema.optional(),
   bottomRight: cardCornerValueSchema.optional()
 });
-var cardVariantSchema = z9.object({
-  id: z9.string(),
-  name: z9.string().min(1).max(20),
-  enabled: z9.boolean(),
-  priority: z9.union([z9.literal(1), z9.literal(2), z9.literal(3)]),
+var cardVariantSchema = z8.object({
+  id: z8.string(),
+  name: z8.string().min(1).max(20),
+  enabled: z8.boolean(),
+  priority: z8.union([z8.literal(1), z8.literal(2), z8.literal(3)]),
   // Appearance (token-based)
   background: cardBackgroundSchema,
   spacing: cardSpacingSchema,
   // Optional foreground (card text) color, for cards on a strong fill.
   foregroundToken: themeColorTokenSchema.optional(),
   // Optional overrides (uses theme defaults if not specified)
-  shadow: z9.object({
-    elevation: z9.enum(["none", "low", "medium", "high"]),
-    softness: z9.enum(["crisp", "soft", "hard"]).nullable(),
-    position: z9.enum(["bottom", "bottom-right"]).default("bottom")
+  shadow: z8.object({
+    elevation: z8.enum(["none", "low", "medium", "high"]),
+    softness: z8.enum(["crisp", "soft", "hard"]).nullable(),
+    position: z8.enum(["bottom", "bottom-right"]).default("bottom")
   }).optional(),
-  corners: z9.enum(["square", "soft", "rounded", "pill"]).optional(),
+  corners: z8.enum(["square", "soft", "rounded", "pill"]).optional(),
   // Per-corner radius override; wins over `corners` when set.
   cornerRadii: cardCornerRadiiSchema.optional(),
   // Border (optional)
@@ -3486,13 +4470,13 @@ var cardVariantSchema = z9.object({
   // Single accent edge; replaces `border` when set.
   accentEdge: cardAccentEdgeSchema.optional()
 });
-var cardSystemSchema = z9.object({
-  variants: z9.array(cardVariantSchema).min(1).max(3)
+var cardSystemSchema = z8.object({
+  variants: z8.array(cardVariantSchema).min(1).max(3)
 });
 
 // ../theme-core/src/accordions/types.ts
-import { z as z10 } from "zod";
-var accordionIconSchema = z10.enum([
+import { z as z9 } from "zod";
+var accordionIconSchema = z9.enum([
   "plus-minus",
   // + becomes - (swap or rotate 90°)
   "chevron",
@@ -3504,192 +4488,192 @@ var accordionIconSchema = z10.enum([
   "circle-plus-minus"
   // ⊕ becomes ⊖ (swap with fade)
 ]);
-var accordionSystemSchema = z10.object({
+var accordionSystemSchema = z9.object({
   // Visual styling (solid color only - gradients can be added later if needed).
   // null = no fill, so the accordion sits transparently on the section
   // surface (used by open, boxless "divided" looks).
-  background: z10.object({
-    type: z10.literal("solid"),
+  background: z9.object({
+    type: z9.literal("solid"),
     colorToken: themeColorTokenSchema
   }).nullable(),
   // Spacing (padding inside items)
-  spacing: z10.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
+  spacing: z9.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
   // Border radius (null = inherit from theme.corners)
-  corners: z10.enum(["square", "soft", "rounded", "pill"]).nullable(),
+  corners: z9.enum(["square", "soft", "rounded", "pill"]).nullable(),
   // Border styling (null = inherit from theme.border)
-  border: z10.object({
-    widthClass: z10.string(),
+  border: z9.object({
+    widthClass: z9.string(),
     // e.g., 'border', 'border-2', 'border-0'
     colorToken: themeColorTokenSchema
   }).nullable(),
   // Shadow (null = inherit from theme.shadow)
-  shadow: z10.object({
-    elevation: z10.enum(["none", "low", "medium", "high"]),
-    softness: z10.enum(["soft", "crisp", "hard"]).nullable(),
-    position: z10.enum(["bottom", "bottom-right"])
+  shadow: z9.object({
+    elevation: z9.enum(["none", "low", "medium", "high"]),
+    softness: z9.enum(["soft", "crisp", "hard"]).nullable(),
+    position: z9.enum(["bottom", "bottom-right"])
   }).nullable(),
   // Icon style and animation
-  icon: z10.object({
+  icon: z9.object({
     style: accordionIconSchema,
-    position: z10.enum(["left", "right"]),
-    size: z10.enum(["sm", "md", "lg"]),
+    position: z9.enum(["left", "right"]),
+    size: z9.enum(["sm", "md", "lg"]),
     colorToken: themeColorTokenSchema.optional()
   }),
   // Trigger (question) styling
-  trigger: z10.object({
+  trigger: z9.object({
     textColorToken: themeColorTokenSchema,
-    fontWeight: z10.enum(["regular", "medium", "semibold", "bold"]).nullable(),
+    fontWeight: z9.enum(["regular", "medium", "semibold", "bold"]).nullable(),
     // null = inherit from theme
     // Question typography. Defaults keep the historical body-font look; set
     // fontFamily 'heading' + a larger scale to give questions real presence.
-    fontFamily: z10.enum(["body", "heading"]).optional(),
+    fontFamily: z9.enum(["body", "heading"]).optional(),
     // default 'body'
-    fontScale: z10.enum(["body", "md", "lg"]).optional(),
+    fontScale: z9.enum(["body", "md", "lg"]).optional(),
     // default 'body'
-    letterSpacing: z10.enum(["normal", "tight", "wide"]).optional(),
-    textTransform: z10.enum(["none", "uppercase"]).optional()
+    letterSpacing: z9.enum(["normal", "tight", "wide"]).optional(),
+    textTransform: z9.enum(["none", "uppercase"]).optional()
   }),
   // Hover state styling
-  hover: z10.object({
+  hover: z9.object({
     backgroundColorToken: themeColorTokenSchema.optional(),
     textColorToken: themeColorTokenSchema.optional(),
     borderColorToken: themeColorTokenSchema.optional()
   }),
   // Open-state emphasis: how an expanded item is visually rewarded. All
   // optional; omit for the historical "only the text recolors" behaviour.
-  openState: z10.object({
+  openState: z9.object({
     backgroundColorToken: themeColorTokenSchema.optional(),
     triggerColorToken: themeColorTokenSchema.optional(),
-    accent: z10.object({
-      edge: z10.enum(["left", "top", "bottom"]),
+    accent: z9.object({
+      edge: z9.enum(["left", "top", "bottom"]),
       colorToken: themeColorTokenSchema,
-      thickness: z10.enum(["thin", "medium", "thick"])
+      thickness: z9.enum(["thin", "medium", "thick"])
     }).optional()
   }).optional(),
   // Content (answer) styling
-  content: z10.object({
+  content: z9.object({
     textColorToken: themeColorTokenSchema
   })
 });
 
 // ../theme-core/src/inputs/types.ts
-import { z as z11 } from "zod";
-var inputSystemSchema = z11.object({
+import { z as z10 } from "zod";
+var inputSystemSchema = z10.object({
   // Base styling (applied to all inputs)
-  base: z11.object({
-    background: z11.union([
-      z11.object({
-        type: z11.literal("solid"),
+  base: z10.object({
+    background: z10.union([
+      z10.object({
+        type: z10.literal("solid"),
         colorToken: themeColorTokenSchema
       }),
-      z11.object({
-        type: z11.literal("transparent")
+      z10.object({
+        type: z10.literal("transparent")
       })
     ]),
     textColorToken: themeColorTokenSchema,
-    border: z11.object({
-      widthClass: z11.string(),
+    border: z10.object({
+      widthClass: z10.string(),
       // e.g., 'border', 'border-2'
       colorToken: themeColorTokenSchema,
-      style: z11.enum(["all", "underline"]).optional()
+      style: z10.enum(["all", "underline"]).optional()
     }),
-    corners: z11.enum(["square", "soft", "rounded", "pill"]).nullable(),
+    corners: z10.enum(["square", "soft", "rounded", "pill"]).nullable(),
     // null = inherit from theme.corners
-    shadow: z11.object({
-      elevation: z11.enum(["none", "low", "medium"]),
-      softness: z11.enum(["soft", "crisp", "hard"]).nullable()
+    shadow: z10.object({
+      elevation: z10.enum(["none", "low", "medium"]),
+      softness: z10.enum(["soft", "crisp", "hard"]).nullable()
     }).nullable(),
-    spacing: z11.enum(["compact", "cozy", "medium", "comfortable"]),
+    spacing: z10.enum(["compact", "cozy", "medium", "comfortable"]),
     // padding inside inputs
-    fontSize: z11.enum(["sm", "base", "lg"])
+    fontSize: z10.enum(["sm", "base", "lg"])
   }),
   // Label styling
-  label: z11.object({
+  label: z10.object({
     textColorToken: themeColorTokenSchema,
-    fontWeight: z11.enum(["regular", "medium", "semibold", "bold", "black"]),
-    fontSize: z11.enum(["2xs", "xs", "sm", "base"]),
-    textTransform: z11.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
-    letterSpacing: z11.enum(["normal", "wide", "wider", "widest"]).optional(),
-    opacity: z11.number().min(0.2).max(1).optional()
+    fontWeight: z10.enum(["regular", "medium", "semibold", "bold", "black"]),
+    fontSize: z10.enum(["2xs", "xs", "sm", "base"]),
+    textTransform: z10.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
+    letterSpacing: z10.enum(["normal", "wide", "wider", "widest"]).optional(),
+    opacity: z10.number().min(0.2).max(1).optional()
   }),
   // Focus state
-  focus: z11.object({
+  focus: z10.object({
     ringColorToken: themeColorTokenSchema,
-    ringWidth: z11.enum(["0", "1", "2", "3"]),
+    ringWidth: z10.enum(["0", "1", "2", "3"]),
     borderColorToken: themeColorTokenSchema.optional()
     // Change border color on focus
   }),
   // Error state (for validation feedback)
-  error: z11.object({
+  error: z10.object({
     borderColorToken: themeColorTokenSchema,
     textColorToken: themeColorTokenSchema
   }),
   // Disabled state
-  disabled: z11.object({
+  disabled: z10.object({
     backgroundColorToken: themeColorTokenSchema,
     textColorToken: themeColorTokenSchema,
-    opacity: z11.number().min(0.3).max(0.7)
+    opacity: z10.number().min(0.3).max(0.7)
   })
 });
 
 // ../theme-core/src/gradients/types.ts
-import { z as z12 } from "zod";
-var gradientStopSchema = z12.object({
+import { z as z11 } from "zod";
+var gradientStopSchema = z11.object({
   color: themeColorTokenSchema,
-  position: z12.number().min(0).max(100)
+  position: z11.number().min(0).max(100)
   // Percentage 0-100
 });
-var gradientConfigSchema = z12.object({
-  type: z12.enum(["linear", "radial"]),
-  angle: z12.number().min(0).max(360).optional(),
+var gradientConfigSchema = z11.object({
+  type: z11.enum(["linear", "radial"]),
+  angle: z11.number().min(0).max(360).optional(),
   // For linear gradients (degrees)
-  position: z12.string().optional(),
+  position: z11.string().optional(),
   // For radial gradients ('center', 'top left', etc.)
-  stops: z12.array(gradientStopSchema).min(2)
+  stops: z11.array(gradientStopSchema).min(2)
 });
 
 // ../theme-core/src/navigation/types.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 
 // ../theme-core/src/interactive/baseSchema.ts
-import { z as z13 } from "zod";
-var interactiveTypographySchema = z13.object({
+import { z as z12 } from "zod";
+var interactiveTypographySchema = z12.object({
   /** Font family source */
-  typography: z13.enum(["body", "heading"]).default("body"),
+  typography: z12.enum(["body", "heading"]).default("body"),
   /** Font weight */
-  fontWeight: z13.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
+  fontWeight: z12.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
   /** Text transform */
-  textTransform: z13.enum(["none", "uppercase", "capitalize"]).default("none"),
+  textTransform: z12.enum(["none", "uppercase", "capitalize"]).default("none"),
   /** Italic style */
-  italic: z13.boolean().default(false)
+  italic: z12.boolean().default(false)
 });
-var effectApplicationSchema2 = z13.object({
+var effectApplicationSchema2 = z12.object({
   /** Effect preset ID */
-  effectId: z13.string(),
+  effectId: z12.string(),
   /** User-provided customization options */
-  options: z13.record(z13.string(), z13.any()).optional()
+  options: z12.record(z12.string(), z12.any()).optional()
 });
-var effectCompositionSchema = z13.object({
+var effectCompositionSchema = z12.object({
   /** Effects always applied */
-  base: z13.array(effectApplicationSchema2).optional(),
+  base: z12.array(effectApplicationSchema2).optional(),
   /** Effects applied on hover */
-  hover: z13.array(effectApplicationSchema2).optional(),
+  hover: z12.array(effectApplicationSchema2).optional(),
   /** Effects applied on active/pressed */
-  active: z13.array(effectApplicationSchema2).optional(),
+  active: z12.array(effectApplicationSchema2).optional(),
   /** Effects applied on focus */
-  focus: z13.array(effectApplicationSchema2).optional()
+  focus: z12.array(effectApplicationSchema2).optional()
 });
 
 // ../theme-core/src/navigation/types.ts
-var navLinkPaddingSchema = z14.enum(["none", "compact", "default"]);
-var navLinkPaddingXSchema = z14.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var navLinkBorderRadiusSchema = z14.enum(["none", "sm", "md", "full"]);
-var navLinkTextSizeSchema = z14.enum(["xs", "sm", "base", "lg"]);
-var navLinkLetterSpacingSchema = z14.enum(["normal", "wide", "wider", "widest"]);
-var navLinkContrastTreatmentSchema = z14.enum(["none", "soft-glow"]);
-var navLinkStyleSchema = z14.object({
+var navLinkPaddingSchema = z13.enum(["none", "compact", "default"]);
+var navLinkPaddingXSchema = z13.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var navLinkBorderRadiusSchema = z13.enum(["none", "sm", "md", "full"]);
+var navLinkTextSizeSchema = z13.enum(["xs", "sm", "base", "lg"]);
+var navLinkLetterSpacingSchema = z13.enum(["normal", "wide", "wider", "widest"]);
+var navLinkContrastTreatmentSchema = z13.enum(["none", "soft-glow"]);
+var navLinkStyleSchema = z13.object({
   /** Display name for the style */
-  name: z14.string().min(1).max(30).optional(),
+  name: z13.string().min(1).max(30).optional(),
   /** Typography settings (inherited from interactive base) */
   ...interactiveTypographySchema.shape,
   /** Text color token */
@@ -3713,7 +4697,7 @@ var navLinkStyleSchema = z14.object({
 });
 
 // ../theme-core/src/customCss/validation.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 var FORBIDDEN_SELECTORS = [":root", "html", "body"];
 var UNIVERSAL_SELECTOR = "*";
 var REMOTE_URL_PATTERN = /url\s*\(\s*['"]?(https?:|\/\/)/i;
@@ -3755,7 +4739,7 @@ function containsForbiddenSelector(selector) {
   }
   return false;
 }
-var selectorSchema = z15.string().min(1, "Selector cannot be empty").max(200, "Selector too long (max 200 characters)").refine(
+var selectorSchema = z14.string().min(1, "Selector cannot be empty").max(200, "Selector too long (max 200 characters)").refine(
   (s) => !containsForbiddenSelector(s),
   { message: "Global selectors (:root, html, body, *) are not allowed" }
 );
@@ -3765,38 +4749,38 @@ function containsRemoteUrl(value) {
 function containsJavascriptUrl(value) {
   return JAVASCRIPT_URL_PATTERN.test(value);
 }
-var declarationValueSchema = z15.string().max(500, "Declaration value too long (max 500 characters)").refine(
+var declarationValueSchema = z14.string().max(500, "Declaration value too long (max 500 characters)").refine(
   (v) => !containsRemoteUrl(v),
   { message: "Remote url() references are not allowed. Use local paths, data URIs, or fragment IDs." }
 ).refine(
   (v) => !containsJavascriptUrl(v),
   { message: "javascript: URLs are not allowed" }
 );
-var declarationsSchema = z15.record(
-  z15.string().min(1).max(100),
+var declarationsSchema = z14.record(
+  z14.string().min(1).max(100),
   // property name
   declarationValueSchema
   // property value
 );
-var customCssRuleSchema = z15.object({
-  id: z15.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
+var customCssRuleSchema = z14.object({
+  id: z14.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
   selector: selectorSchema,
   declarations: declarationsSchema
 });
 var blockCustomCssRuleSchema = customCssRuleSchema.extend({
-  blockKind: z15.string().min(1, "Block kind is required").max(50, "Block kind too long")
+  blockKind: z14.string().min(1, "Block kind is required").max(50, "Block kind too long")
 });
-var customCssRulesSchema = z15.array(customCssRuleSchema).optional();
-var blockCustomCssRulesSchema = z15.array(blockCustomCssRuleSchema).optional();
+var customCssRulesSchema = z14.array(customCssRuleSchema).optional();
+var blockCustomCssRulesSchema = z14.array(blockCustomCssRuleSchema).optional();
 
 // ../theme-core/src/customCss/atRuleValidation.ts
-import { z as z16 } from "zod";
+import { z as z15 } from "zod";
 var KEYFRAME_OFFSET_PATTERN = /^(from|to|\d{1,3}%)$/i;
 var ANIMATION_NAME_PATTERN = /^[a-zA-Z_-][a-zA-Z0-9_-]*$/;
 var BLOCKED_AT_RULES = ["@import", "@charset"];
 var BLOCKED_AT_RULE_PATTERN = /@(?:import|charset)\b/i;
-var ruleIdSchema = z16.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
-var nestedRuleSchema = z16.object({
+var ruleIdSchema = z15.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
+var nestedRuleSchema = z15.object({
   selector: selectorSchema,
   declarations: declarationsSchema
 });
@@ -3808,88 +4792,88 @@ function isValidKeyframeOffset(offset) {
   const value = parseInt(match[1], 10);
   return value >= 0 && value <= 100;
 }
-var keyframeOffsetSchema = z16.string().transform((offset) => offset.trim()).refine(
+var keyframeOffsetSchema = z15.string().transform((offset) => offset.trim()).refine(
   (offset) => KEYFRAME_OFFSET_PATTERN.test(offset),
   { message: 'Invalid keyframe offset. Use percentages (0%, 50%, 100%) or "from"/"to"' }
 ).refine(
   isValidKeyframeOffset,
   { message: "Keyframe offset must be between 0% and 100%" }
 );
-var animationNameSchema = z16.string().min(1, "Animation name is required").max(50, "Animation name too long").refine(
+var animationNameSchema = z15.string().min(1, "Animation name is required").max(50, "Animation name too long").refine(
   (name) => ANIMATION_NAME_PATTERN.test(name),
   { message: "Invalid animation name. Use letters, numbers, dashes, underscores (start with letter, dash, or underscore)" }
 );
-var keyframeSchema = z16.object({
+var keyframeSchema = z15.object({
   offset: keyframeOffsetSchema,
   declarations: declarationsSchema
 });
-var keyframesAtRuleSchema = z16.object({
+var keyframesAtRuleSchema = z15.object({
   id: ruleIdSchema,
-  type: z16.literal("keyframes"),
+  type: z15.literal("keyframes"),
   name: animationNameSchema,
-  frames: z16.array(keyframeSchema).min(1, "At least one keyframe is required")
+  frames: z15.array(keyframeSchema).min(1, "At least one keyframe is required")
 });
-var fontFaceDeclarationsSchema = z16.record(z16.string().min(1).max(100), declarationValueSchema).refine(
+var fontFaceDeclarationsSchema = z15.record(z15.string().min(1).max(100), declarationValueSchema).refine(
   (decls) => "fontFamily" in decls || "font-family" in decls,
   { message: "font-family is required in @font-face" }
 );
-var fontFaceAtRuleSchema = z16.object({
+var fontFaceAtRuleSchema = z15.object({
   id: ruleIdSchema,
-  type: z16.literal("font-face"),
+  type: z15.literal("font-face"),
   declarations: fontFaceDeclarationsSchema
 });
-var mediaQuerySchema = z16.string().min(1, "Media query is required").max(200, "Media query too long");
-var mediaAtRuleSchema = z16.object({
+var mediaQuerySchema = z15.string().min(1, "Media query is required").max(200, "Media query too long");
+var mediaAtRuleSchema = z15.object({
   id: ruleIdSchema,
-  type: z16.literal("media"),
+  type: z15.literal("media"),
   query: mediaQuerySchema,
-  rules: z16.array(nestedRuleSchema).min(1, "At least one rule is required")
+  rules: z15.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
-var supportsConditionSchema = z16.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
-var supportsAtRuleSchema = z16.object({
+var supportsConditionSchema = z15.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
+var supportsAtRuleSchema = z15.object({
   id: ruleIdSchema,
-  type: z16.literal("supports"),
+  type: z15.literal("supports"),
   condition: supportsConditionSchema,
-  rules: z16.array(nestedRuleSchema).min(1, "At least one rule is required")
+  rules: z15.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
 function containsBlockedAtRule(css) {
   return BLOCKED_AT_RULE_PATTERN.test(css);
 }
-var rawCssSchema = z16.string().min(1, "CSS is required").max(5e3, "Raw CSS too long (max 5000 characters)").refine(
+var rawCssSchema = z15.string().min(1, "CSS is required").max(5e3, "Raw CSS too long (max 5000 characters)").refine(
   (css) => css.trim().startsWith("@"),
   { message: "Raw at-rule must start with @" }
 ).refine(
   (css) => !containsBlockedAtRule(css),
   { message: `Blocked at-rules: ${BLOCKED_AT_RULES.join(", ")}. Use typed at-rules or local assets instead.` }
 );
-var rawAtRuleSchema = z16.object({
+var rawAtRuleSchema = z15.object({
   id: ruleIdSchema,
-  type: z16.literal("raw"),
+  type: z15.literal("raw"),
   css: rawCssSchema
 });
-var customCssAtRuleSchema = z16.discriminatedUnion("type", [
+var customCssAtRuleSchema = z15.discriminatedUnion("type", [
   keyframesAtRuleSchema,
   fontFaceAtRuleSchema,
   mediaAtRuleSchema,
   supportsAtRuleSchema,
   rawAtRuleSchema
 ]);
-var customCssAtRulesSchema = z16.array(customCssAtRuleSchema).optional();
+var customCssAtRulesSchema = z15.array(customCssAtRuleSchema).optional();
 
 // ../theme-core/src/shared/componentStyles.ts
-import { z as z17 } from "zod";
-var componentBorderSchema = z17.object({
-  width: z17.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
-  style: z17.enum(["solid", "dashed"]).default("solid"),
+import { z as z16 } from "zod";
+var componentBorderSchema = z16.object({
+  width: z16.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
+  style: z16.enum(["solid", "dashed"]).default("solid"),
   colorToken: themeColorTokenSchema.optional()
   // defaults to "border" if not set
 });
-var componentShadowSchema = z17.object({
-  elevation: z17.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
+var componentShadowSchema = z16.object({
+  elevation: z16.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
 });
 
 // ../theme-core/src/site-styles/logoBranding.ts
-import { z as z18 } from "zod";
+import { z as z17 } from "zod";
 var logoTextConfidenceValues = ["low", "medium", "high"];
 var logoAssetShapeValues = [
   "none",
@@ -3907,43 +4891,43 @@ var logoKindValues = [
   "unknown"
 ];
 var logoDensityValues = ["simple", "detailed", "unknown"];
-var logoContainsTextSchema = z18.discriminatedUnion("kind", [
-  z18.object({
-    kind: z18.literal("contains-text"),
-    confidence: z18.enum(logoTextConfidenceValues),
-    text: z18.string().trim().min(1).max(200).optional()
+var logoContainsTextSchema = z17.discriminatedUnion("kind", [
+  z17.object({
+    kind: z17.literal("contains-text"),
+    confidence: z17.enum(logoTextConfidenceValues),
+    text: z17.string().trim().min(1).max(200).optional()
   }),
-  z18.object({
-    kind: z18.literal("no-text"),
-    confidence: z18.enum(logoTextConfidenceValues)
+  z17.object({
+    kind: z17.literal("no-text"),
+    confidence: z17.enum(logoTextConfidenceValues)
   }),
-  z18.object({
-    kind: z18.literal("unknown"),
-    reason: z18.enum([
+  z17.object({
+    kind: z17.literal("unknown"),
+    reason: z17.enum([
       "analysis-unavailable",
       "unsupported-file",
       "low-confidence"
     ])
   })
 ]);
-var logoAnalysisSourceSchema = z18.discriminatedUnion("kind", [
-  z18.object({ kind: z18.literal("none") }),
-  z18.object({
-    kind: z18.literal("deterministic"),
-    reason: z18.enum(["dimensions", "fallback"])
+var logoAnalysisSourceSchema = z17.discriminatedUnion("kind", [
+  z17.object({ kind: z17.literal("none") }),
+  z17.object({
+    kind: z17.literal("deterministic"),
+    reason: z17.enum(["dimensions", "fallback"])
   }),
-  z18.object({
-    kind: z18.literal("llm"),
-    model: z18.literal("gpt-5.4-mini"),
-    analyzedAt: z18.string().trim().min(1).max(80).optional()
+  z17.object({
+    kind: z17.literal("llm"),
+    model: z17.literal("gpt-5.4-mini"),
+    analyzedAt: z17.string().trim().min(1).max(80).optional()
   }),
-  z18.object({ kind: z18.literal("manual-override") })
+  z17.object({ kind: z17.literal("manual-override") })
 ]);
-var logoFactsSchema = z18.object({
-  shape: z18.enum(logoAssetShapeValues),
+var logoFactsSchema = z17.object({
+  shape: z17.enum(logoAssetShapeValues),
   containsText: logoContainsTextSchema,
-  kind: z18.enum(logoKindValues),
-  density: z18.enum(logoDensityValues),
+  kind: z17.enum(logoKindValues),
+  density: z17.enum(logoDensityValues),
   source: logoAnalysisSourceSchema
 });
 var brandDisplayModeValues = [
@@ -3998,9 +4982,10 @@ var themeV2CompilerOwnedFieldNames = [
   ...themeV2BlockSpecificRawStyleFieldNames
 ];
 var pageDesignEditorBackgroundOverrideOwner = "page-design-editor";
+var siteChromeBackgroundOverrideOwner = "site-chrome-editor";
 
 // ../theme-core/src/utils/tokenOrColor.ts
-import { z as z19 } from "zod";
+import { z as z18 } from "zod";
 
 // ../theme-core/src/utils/colorStyles.ts
 var COLOR_VAR_PREFIX = "--tb-";
@@ -4047,77 +5032,77 @@ function mergeStyles(...styles) {
 }
 
 // ../theme-core/src/utils/tokenOrColor.ts
-var tokenOrCssColorValueSchema = z19.string();
+var tokenOrCssColorValueSchema = z18.string();
 
 // ../theme-core/src/schema.ts
-var axesSchema = z20.object({
-  tone: z20.enum(["minimal", "classic", "bold"]),
-  energy: z20.enum(["calm", "vibrant"]),
-  density: z20.enum(["airy", "regular", "compact"]),
-  mediaBias: z20.enum(["text", "media", "mixed"]),
-  conversionBias: z20.enum(["low", "med", "high"]),
-  motion: z20.enum(["subtle", "standard", "expressive"])
-});
-var colourHexString = z20.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
-var paletteColorSchema = z20.object({
-  name: z20.string().min(1),
+var axesSchema = z19.object({
+  tone: z19.enum(["minimal", "classic", "bold"]),
+  energy: z19.enum(["calm", "vibrant"]),
+  density: z19.enum(["airy", "regular", "compact"]),
+  mediaBias: z19.enum(["text", "media", "mixed"]),
+  conversionBias: z19.enum(["low", "med", "high"]),
+  motion: z19.enum(["subtle", "standard", "expressive"])
+});
+var colourHexString = z19.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
+var paletteColorSchema = z19.object({
+  name: z19.string().min(1),
   hex: colourHexString
 });
-var paletteMetaSchema = z20.object({
-  mode: z20.enum(["light", "dark"])
+var paletteMetaSchema = z19.object({
+  mode: z19.enum(["light", "dark"])
 });
-var paletteSchema = z20.object({
-  colors: z20.array(paletteColorSchema),
+var paletteSchema = z19.object({
+  colors: z19.array(paletteColorSchema),
   meta: paletteMetaSchema
 });
-var typographyStyleSchema = z20.object({
-  family: z20.string().min(1),
-  weight: z20.enum(["light", "regular", "medium", "semibold", "bold"]),
-  letterSpacing: z20.enum(["tight", "normal", "loose"]),
-  lineHeight: z20.enum(["normal", "relaxed", "loose"])
+var typographyStyleSchema = z19.object({
+  family: z19.string().min(1),
+  weight: z19.enum(["light", "regular", "medium", "semibold", "bold"]),
+  letterSpacing: z19.enum(["tight", "normal", "loose"]),
+  lineHeight: z19.enum(["normal", "relaxed", "loose"])
 });
 var bodyTypographyStyleSchema = typographyStyleSchema.extend({
-  size: z20.enum(["md", "lg", "xl"])
+  size: z19.enum(["md", "lg", "xl"])
 });
-var headingSizeSchema = z20.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
-var headingTypographyOverridesSchema = z20.object({
-  weight: z20.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
-  letterSpacing: z20.enum(["tight", "normal", "loose"]).nullable().optional(),
+var headingSizeSchema = z19.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
+var headingTypographyOverridesSchema = z19.object({
+  weight: z19.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
+  letterSpacing: z19.enum(["tight", "normal", "loose"]).nullable().optional(),
   size: headingSizeSchema.nullable().optional(),
-  lineHeight: z20.enum(["normal", "relaxed", "loose"]).nullable().optional(),
-  italic: z20.boolean().nullable().optional(),
+  lineHeight: z19.enum(["normal", "relaxed", "loose"]).nullable().optional(),
+  italic: z19.boolean().nullable().optional(),
   colorToken: themeColorTokenSchema.nullable().optional()
 });
 var headingTypographyStyleSchema = typographyStyleSchema.extend({
-  case: z20.enum(["uppercase", "normal", "smallCaps"]).nullable(),
-  italic: z20.boolean().nullable(),
+  case: z19.enum(["uppercase", "normal", "smallCaps"]).nullable(),
+  italic: z19.boolean().nullable(),
   colorToken: themeColorTokenSchema.nullable().optional()
 });
-var proseLinkUnderlineStyleSchema = z20.enum(["solid", "dotted", "dashed"]);
-var proseLinkUnderlineThicknessSchema = z20.enum([
+var proseLinkUnderlineStyleSchema = z19.enum(["solid", "dotted", "dashed"]);
+var proseLinkUnderlineThicknessSchema = z19.enum([
   "auto",
   "fromFont",
   "thin",
   "medium",
   "thick"
 ]);
-var proseLinkUnderlineOffsetSchema = z20.enum([
+var proseLinkUnderlineOffsetSchema = z19.enum([
   "auto",
   "tight",
   "normal",
   "loose"
 ]);
-var proseLinkStyleSchema = z20.object({
+var proseLinkStyleSchema = z19.object({
   colorToken: themeColorTokenSchema.optional(),
   hoverColorToken: themeColorTokenSchema.optional(),
-  underline: z20.boolean().optional(),
+  underline: z19.boolean().optional(),
   decorationColorToken: themeColorTokenSchema.optional(),
   hoverDecorationColorToken: themeColorTokenSchema.optional(),
   underlineStyle: proseLinkUnderlineStyleSchema.optional(),
   underlineThickness: proseLinkUnderlineThicknessSchema.optional(),
   underlineOffset: proseLinkUnderlineOffsetSchema.optional()
 });
-var semanticSpacingSchema = z20.enum([
+var semanticSpacingSchema = z19.enum([
   "none",
   "compact",
   "cozy",
@@ -4125,61 +5110,61 @@ var semanticSpacingSchema = z20.enum([
   "comfortable",
   "spacious"
 ]);
-var boxRoundedSchema = z20.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
-var boxBackgroundOverlaySchema = z20.object({
-  type: z20.enum(["none", "color", "gradient"]).nullable().optional(),
+var boxRoundedSchema = z19.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
+var boxBackgroundOverlaySchema = z19.object({
+  type: z19.enum(["none", "color", "gradient"]).nullable().optional(),
   color: tokenOrCssColorValueSchema.nullable().optional(),
-  gradient: z20.string().nullable().optional(),
-  opacity: z20.number().min(0).max(1).nullable().optional()
+  gradient: z19.string().nullable().optional(),
+  opacity: z19.number().min(0).max(1).nullable().optional()
 });
-var boxBackgroundSchema = z20.object({
-  type: z20.enum(["color", "gradient", "image"]).optional(),
-  contentOwner: z20.literal(pageDesignEditorBackgroundOverrideOwner).optional(),
+var boxBackgroundSchema = z19.object({
+  type: z19.enum(["color", "gradient", "image"]).optional(),
+  contentOwner: z19.literal(pageDesignEditorBackgroundOverrideOwner).optional(),
   color: tokenOrCssColorValueSchema.nullable().optional(),
-  gradient: z20.string().nullable().optional(),
-  gradientPresetId: z20.string().min(1).nullable().optional(),
+  gradient: z19.string().nullable().optional(),
+  gradientPresetId: z19.string().min(1).nullable().optional(),
   image: mediaSchema.nullable().optional(),
-  objectFit: z20.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
-  scale: z20.string().nullable().optional(),
-  position: z20.string().nullable().optional(),
-  opacity: z20.number().min(0).max(1).nullable().optional(),
-  motion: z20.enum(["static", "fixed-frame"]).nullable().optional(),
+  objectFit: z19.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
+  scale: z19.string().nullable().optional(),
+  position: z19.string().nullable().optional(),
+  opacity: z19.number().min(0).max(1).nullable().optional(),
+  motion: z19.enum(["static", "fixed-frame"]).nullable().optional(),
   overlay: boxBackgroundOverlaySchema.nullable().optional(),
   textColor: tokenOrCssColorValueSchema.nullable().optional(),
   headingColor: tokenOrCssColorValueSchema.nullable().optional(),
   linkColor: tokenOrCssColorValueSchema.nullable().optional(),
   supportingColor: tokenOrCssColorValueSchema.nullable().optional()
 });
-var noHeadingDecorationSchema = z20.object({
-  family: z20.literal("none")
+var noHeadingDecorationSchema = z19.object({
+  family: z19.literal("none")
 });
-var visibleHeadingDecorationSchema = z20.object({
-  family: z20.enum(visibleHeadingDecorationFamilyValues),
-  colorToken: z20.enum(headingDecorationColorTokenValues).optional()
+var visibleHeadingDecorationSchema = z19.object({
+  family: z19.enum(visibleHeadingDecorationFamilyValues),
+  colorToken: z19.enum(headingDecorationColorTokenValues).optional()
 });
-var headingDecorationSchema = z20.union([
+var headingDecorationSchema = z19.union([
   noHeadingDecorationSchema,
   visibleHeadingDecorationSchema
 ]);
-var headingDecorationOverrideSchema = z20.union([
-  z20.enum(headingDecorationOverrideValues),
+var headingDecorationOverrideSchema = z19.union([
+  z19.enum(headingDecorationOverrideValues),
   // Legacy authoring value from the earlier model. In the render-time model
   // "on" cannot force a fragment into a block, so it is equivalent to default.
-  z20.literal("on").transform(() => "site-default")
+  z19.literal("on").transform(() => "site-default")
 ]);
-var accordionIconTreatmentSchema = z20.object({
-  iconSet: z20.enum(accordionIconSetValues),
-  colorToken: z20.enum(accordionIconColorTokenValues),
-  openColorToken: z20.enum(accordionIconColorTokenValues).optional(),
-  motion: z20.enum(accordionIconMotionValues)
+var accordionIconTreatmentSchema = z19.object({
+  iconSet: z19.enum(accordionIconSetValues),
+  colorToken: z19.enum(accordionIconColorTokenValues),
+  openColorToken: z19.enum(accordionIconColorTokenValues).optional(),
+  motion: z19.enum(accordionIconMotionValues)
 });
-var sectionStylesOverrideSchema = z20.object({
+var sectionStylesOverrideSchema = z19.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  minHeight: z20.enum(["none", "banner", "hero", "immersive"]).nullable().optional(),
-  tileTreatment: z20.enum(tileTreatmentValues).nullable().optional(),
-  eventListTreatment: z20.enum(eventListTreatmentValues).nullable().optional(),
-  eyebrowTreatment: z20.enum(eyebrowTreatmentValues).nullable().optional(),
+  minHeight: z19.enum(["none", "banner", "hero", "immersive"]).nullable().optional(),
+  tileTreatment: z19.enum(tileTreatmentValues).nullable().optional(),
+  eventListTreatment: z19.enum(eventListTreatmentValues).nullable().optional(),
+  eyebrowTreatment: z19.enum(eyebrowTreatmentValues).nullable().optional(),
   headingDecoration: headingDecorationSchema.nullable().optional(),
   // Author-level opt-out consumed by render-time theme projection. Persisted
   // content may also carry legacy `headingDecoration` / `on` values; those are
@@ -4188,25 +5173,25 @@ var sectionStylesOverrideSchema = z20.object({
   headingDecorationOverride: headingDecorationOverrideSchema.nullable().optional(),
   accordionIconTreatment: accordionIconTreatmentSchema.nullable().optional()
 });
-var containerStylesOverrideSchema = z20.object({
+var containerStylesOverrideSchema = z19.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z20.boolean().nullable().optional(),
+  raised: z19.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional(),
-  fullWidth: z20.boolean().nullable().optional()
+  fullWidth: z19.boolean().nullable().optional()
 });
-var cardBorderOverrideSchema = z20.object({
-  enabled: z20.boolean().nullable().optional(),
-  width: z20.enum(["none", "1", "2", "3"]).nullable().optional(),
+var cardBorderOverrideSchema = z19.object({
+  enabled: z19.boolean().nullable().optional(),
+  width: z19.enum(["none", "1", "2", "3"]).nullable().optional(),
   colorToken: themeColorTokenSchema.nullable().optional()
 });
-var cardStylesOverrideSchema = z20.object({
+var cardStylesOverrideSchema = z19.object({
   background: boxBackgroundSchema.nullable().optional(),
   border: cardBorderOverrideSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z20.boolean().nullable().optional(),
+  raised: z19.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional(),
-  treatment: z20.enum([
+  treatment: z19.enum([
     "accent-quote",
     "editorial-rule",
     "soft-panel",
@@ -4218,18 +5203,18 @@ var cardStylesOverrideSchema = z20.object({
   // 'none' is boxless. Driven by the block look via testimonialCardTreatment.
   cardVariant: boxStylesCardVariantSchema.nullable().optional()
 });
-var blockStyleOverridesSchema = z20.object({
+var blockStyleOverridesSchema = z19.object({
   sectionStyles: sectionStylesOverrideSchema.nullable().optional(),
   containerStyles: containerStylesOverrideSchema.nullable().optional(),
   cardStyles: cardStylesOverrideSchema.nullable().optional()
 });
-var blockThemeOverrideSchema = z20.object({
-  typography: z20.object({
+var blockThemeOverrideSchema = z19.object({
+  typography: z19.object({
     proseLinkStyle: proseLinkStyleSchema.optional()
   }).optional(),
   styles: blockStyleOverridesSchema.optional()
 });
-var typographyScaleSchema = z20.enum([
+var typographyScaleSchema = z19.enum([
   // New intuitive names
   "compact",
   // ratio 1.2 (was minorThird)
@@ -4242,9 +5227,9 @@ var typographyScaleSchema = z20.enum([
   "majorThird",
   "perfectFourth"
 ]);
-var typographySchema = z20.object({
+var typographySchema = z19.object({
   body: bodyTypographyStyleSchema,
-  headings: z20.object({
+  headings: z19.object({
     default: headingTypographyStyleSchema,
     h1: headingTypographyOverridesSchema,
     h2: headingTypographyOverridesSchema,
@@ -4257,41 +5242,41 @@ var typographySchema = z20.object({
   scale: typographyScaleSchema,
   proseLinkStyle: proseLinkStyleSchema.optional()
 });
-var spaceSchema = z20.enum(["comfortable", "standard", "dense"]);
-var corners = z20.enum(["square", "soft", "rounded", "pill"]);
-var shadow = z20.object({
-  elevation: z20.enum(["none", "low", "medium", "high"]),
-  softness: z20.enum(["crisp", "soft", "hard"]).nullable(),
-  position: z20.enum(["bottom", "bottom-right"]).default("bottom")
+var spaceSchema = z19.enum(["comfortable", "standard", "dense"]);
+var corners = z19.enum(["square", "soft", "rounded", "pill"]);
+var shadow = z19.object({
+  elevation: z19.enum(["none", "low", "medium", "high"]),
+  softness: z19.enum(["crisp", "soft", "hard"]).nullable(),
+  position: z19.enum(["bottom", "bottom-right"]).default("bottom")
 });
-var border = z20.object({
-  width: z20.enum(["none", "hairline", "thin", "thick"]),
-  style: z20.enum(["solid", "dashed"])
+var border = z19.object({
+  width: z19.enum(["none", "hairline", "thin", "thick"]),
+  style: z19.enum(["solid", "dashed"])
 });
-var motion = z20.object({
-  level: z20.enum(["off", "low", "medium", "high"]),
-  easing: z20.enum(["standard", "snappy", "gentle"]).nullable()
+var motion = z19.object({
+  level: z19.enum(["off", "low", "medium", "high"]),
+  easing: z19.enum(["standard", "snappy", "gentle"]).nullable()
 });
-var buttonStyle = z20.object({
+var buttonStyle = z19.object({
   shape: corners
   // Used for --radius-control CSS variable
 });
-var cardStyle = z20.object({
-  elevation: z20.enum(["none", "low", "medium", "high"]),
-  border: z20.enum(["none", "subtle", "defined"]),
+var cardStyle = z19.object({
+  elevation: z19.enum(["none", "low", "medium", "high"]),
+  border: z19.enum(["none", "subtle", "defined"]),
   shape: corners,
-  headerStyle: z20.enum(["plain", "accentBar", "subtleBg"]).nullable(),
-  mediaTreatment: z20.enum(["square", "rounded", "bleed"]).nullable()
+  headerStyle: z19.enum(["plain", "accentBar", "subtleBg"]).nullable(),
+  mediaTreatment: z19.enum(["square", "rounded", "bleed"]).nullable()
 });
-var inputStyle = z20.object({
+var inputStyle = z19.object({
   shape: corners,
-  border: z20.enum(["subtle", "defined", "underline"]),
-  focus: z20.enum(["glow", "ring", "underline"]),
-  label: z20.enum(["inside", "above"])
+  border: z19.enum(["subtle", "defined", "underline"]),
+  focus: z19.enum(["glow", "ring", "underline"]),
+  label: z19.enum(["inside", "above"])
 });
-var headerVariant = z20.enum(["classic", "centered", "transparent", "floating"]);
-var headerPositioning = z20.enum(["static", "sticky", "fixed"]);
-var headerNavStyle = z20.enum([
+var headerVariant = z19.enum(["classic", "centered", "transparent", "floating"]);
+var headerPositioning = z19.enum(["static", "sticky", "fixed"]);
+var headerNavStyle = z19.enum([
   "minimal",
   "underline",
   "underline-grow",
@@ -4300,57 +5285,57 @@ var headerNavStyle = z20.enum([
   "frosted",
   "solid"
 ]);
-var navFontWeight = z20.enum(["regular", "medium", "semibold", "bold"]);
-var headerMaxWidth = z20.enum(["container", "full"]);
-var headerContainerSchema = z20.object({
-  rounded: z20.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
-  border: z20.boolean().default(true),
-  shadow: z20.boolean().default(true),
-  padding: z20.enum(["sm", "md", "lg"]).default("md"),
-  tint: z20.string().nullable().optional(),
-  opacity: z20.number().min(0).max(1).default(0.12)
+var navFontWeight = z19.enum(["regular", "medium", "semibold", "bold"]);
+var headerMaxWidth = z19.enum(["container", "full"]);
+var headerContainerSchema = z19.object({
+  rounded: z19.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
+  border: z19.boolean().default(true),
+  shadow: z19.boolean().default(true),
+  padding: z19.enum(["sm", "md", "lg"]).default("md"),
+  tint: z19.string().nullable().optional(),
+  opacity: z19.number().min(0).max(1).default(0.12)
 }).optional();
 var headerBorderSchema = componentBorderSchema.extend({
-  position: z20.enum(["bottom", "top", "both", "none"]).default("bottom")
+  position: z19.enum(["bottom", "top", "both", "none"]).default("bottom")
 }).optional();
-var logoStyleSchema = z20.object({
-  fontFamily: z20.enum(["heading", "body"]).default("heading"),
-  letterSpacing: z20.enum(["normal", "wide", "wider", "widest"]).default("normal"),
-  gradient: z20.boolean().default(false),
-  brandDisplay: z20.enum(brandDisplayModeValues).optional(),
-  size: z20.enum(logoSizePolicyValues).optional(),
-  accommodation: z20.enum(logoAccommodationPatternValues).optional()
+var logoStyleSchema = z19.object({
+  fontFamily: z19.enum(["heading", "body"]).default("heading"),
+  letterSpacing: z19.enum(["normal", "wide", "wider", "widest"]).default("normal"),
+  gradient: z19.boolean().default(false),
+  brandDisplay: z19.enum(brandDisplayModeValues).optional(),
+  size: z19.enum(logoSizePolicyValues).optional(),
+  accommodation: z19.enum(logoAccommodationPatternValues).optional()
 }).optional();
-var headerLogoTextSchema = z20.object({
-  mobileWrapLines: z20.union([z20.literal(1), z20.literal(2)]).optional(),
-  mobileMaxWidth: z20.enum(["xs", "sm", "md"]).optional(),
-  hideOnShrink: z20.boolean().optional()
+var headerLogoTextSchema = z19.object({
+  mobileWrapLines: z19.union([z19.literal(1), z19.literal(2)]).optional(),
+  mobileMaxWidth: z19.enum(["xs", "sm", "md"]).optional(),
+  hideOnShrink: z19.boolean().optional()
 }).optional();
-var navEffectsSchema = z20.object({
-  underlineGradient: z20.boolean().default(false),
-  glow: z20.boolean().default(false),
-  glowColor: z20.string().optional(),
-  neumorphic: z20.boolean().default(false)
+var navEffectsSchema = z19.object({
+  underlineGradient: z19.boolean().default(false),
+  glow: z19.boolean().default(false),
+  glowColor: z19.string().optional(),
+  neumorphic: z19.boolean().default(false)
 }).optional();
-var dropdownStyleSchema = z20.object({
+var dropdownStyleSchema = z19.object({
   // Container styling
   background: themeColorTokenSchema.default("surface"),
   textColor: themeColorTokenSchema.default("text"),
   borderColor: themeColorTokenSchema.nullable().default("border"),
-  shadow: z20.enum(["none", "sm", "md", "lg"]).default("md"),
-  borderRadius: z20.enum(["none", "sm", "md", "lg"]).default("md"),
+  shadow: z19.enum(["none", "sm", "md", "lg"]).default("md"),
+  borderRadius: z19.enum(["none", "sm", "md", "lg"]).default("md"),
   // Link hover states (explicit control)
   hoverBackground: themeColorTokenSchema.nullable().optional(),
   hoverTextColor: themeColorTokenSchema.nullable().optional(),
   // Typography
-  textTransform: z20.enum(["none", "uppercase", "capitalize"]).default("none"),
-  letterSpacing: z20.enum(["normal", "wide", "wider"]).default("normal"),
-  fontWeight: z20.enum(["regular", "medium", "semibold", "bold"]).optional(),
+  textTransform: z19.enum(["none", "uppercase", "capitalize"]).default("none"),
+  letterSpacing: z19.enum(["normal", "wide", "wider"]).default("normal"),
+  fontWeight: z19.enum(["regular", "medium", "semibold", "bold"]).optional(),
   // optional = inherit from navWeight
-  textSize: z20.enum(["xs", "sm", "base", "lg"]).optional()
+  textSize: z19.enum(["xs", "sm", "base", "lg"]).optional()
   // optional = no override (browser default)
 }).optional();
-var headerCtaGapSchema = z20.enum([
+var headerCtaGapSchema = z19.enum([
   "none",
   "tight",
   "compact",
@@ -4358,7 +5343,7 @@ var headerCtaGapSchema = z20.enum([
   "relaxed",
   "spacious"
 ]);
-var headerCtaTreatmentSchema = z20.enum([
+var headerCtaTreatmentSchema = z19.enum([
   "default",
   "primary",
   "secondary",
@@ -4366,22 +5351,23 @@ var headerCtaTreatmentSchema = z20.enum([
   "outline",
   "ghost"
 ]);
-var navContainerSchema = z20.object({
-  type: z20.enum(["none", "pill", "glass"]).default("none"),
-  tint: z20.string().nullable().optional(),
-  opacity: z20.number().min(0).max(1).default(0.15)
+var navContainerSchema = z19.object({
+  type: z19.enum(["none", "pill", "glass"]).default("none"),
+  tint: z19.string().nullable().optional(),
+  opacity: z19.number().min(0).max(1).default(0.15)
 }).default({ type: "none", tint: null, opacity: 0.15 });
-var headerBackgroundSchema = z20.object({
-  type: z20.enum(["color", "gradient", "image"]),
+var headerBackgroundSchema = z19.object({
+  type: z19.enum(["color", "gradient", "image"]),
+  contentOwner: z19.literal(siteChromeBackgroundOverrideOwner).optional(),
   color: tokenOrCssColorValueSchema.nullable().optional(),
   gradient: gradientConfigSchema.nullable().optional(),
   image: mediaSchema.nullable().optional(),
   textColor: tokenOrCssColorValueSchema.nullable().optional()
 });
-var headerSchema = z20.object({
+var headerSchema = z19.object({
   variant: headerVariant,
   positioning: headerPositioning,
-  shrinkOnScroll: z20.boolean(),
+  shrinkOnScroll: z19.boolean(),
   maxWidth: headerMaxWidth,
   logoOverride: mediaSchema.nullable().optional(),
   background: headerBackgroundSchema.default({
@@ -4411,16 +5397,16 @@ var headerSchema = z20.object({
   // Optional theme-level CTA variant for header/nav CTA buttons.
   // Internal runtime bridge for the block renderer; prefer ctaTreatment in
   // authored Theme V2 concepts.
-  ctaVariant: z20.string().min(1).optional(),
+  ctaVariant: z19.string().min(1).optional(),
   // Dropdown menu styling (nav dropdowns and mobile drawer)
   dropdownStyle: dropdownStyleSchema
 });
-var footerVariant = z20.enum(["simple", "columns", "split"]);
-var footerMaxWidth = z20.enum(["container", "full"]);
-var footerMode = z20.enum(["default", "blocks", "default+blocks", "none"]);
-var footerNavLayoutMode = z20.enum(["stack", "inline", "inline-wrap"]);
-var footerNavLayoutAlign = z20.enum(["start", "center", "end", "space-between"]);
-var footerSpacing = z20.enum([
+var footerVariant = z19.enum(["simple", "columns", "split"]);
+var footerMaxWidth = z19.enum(["container", "full"]);
+var footerMode = z19.enum(["default", "blocks", "default+blocks", "none"]);
+var footerNavLayoutMode = z19.enum(["stack", "inline", "inline-wrap"]);
+var footerNavLayoutAlign = z19.enum(["start", "center", "end", "space-between"]);
+var footerSpacing = z19.enum([
   "none",
   "tight",
   "compact",
@@ -4428,44 +5414,44 @@ var footerSpacing = z20.enum([
   "relaxed",
   "spacious"
 ]);
-var footerLogoPlacement = z20.enum(["left", "right", "above", "below"]);
-var footerLogoSize = z20.enum(["sm", "md", "lg", "xl"]);
-var footerLogoMaxHeight = z20.enum(["sm", "md", "lg", "xl"]);
-var footerBottomTextLinkStyleSchema = z20.object({
+var footerLogoPlacement = z19.enum(["left", "right", "above", "below"]);
+var footerLogoSize = z19.enum(["sm", "md", "lg", "xl"]);
+var footerLogoMaxHeight = z19.enum(["sm", "md", "lg", "xl"]);
+var footerBottomTextLinkStyleSchema = z19.object({
   colorToken: themeColorTokenSchema.optional(),
   hoverColorToken: themeColorTokenSchema.nullable().optional(),
   decorationColorToken: themeColorTokenSchema.nullable().optional(),
-  underline: z20.boolean().optional()
+  underline: z19.boolean().optional()
 });
-var footerBottomBarSchema = z20.object({
-  enabled: z20.boolean().optional(),
-  fullBleed: z20.boolean().optional(),
+var footerBottomBarSchema = z19.object({
+  enabled: z19.boolean().optional(),
+  fullBleed: z19.boolean().optional(),
   background: headerBackgroundSchema.optional(),
   textColor: themeColorTokenSchema.nullable().optional(),
-  textAlign: z20.enum(["left", "center", "right"]).optional(),
+  textAlign: z19.enum(["left", "center", "right"]).optional(),
   paddingY: footerSpacing.optional(),
   paddingX: footerSpacing.optional(),
-  borderTop: z20.object({
+  borderTop: z19.object({
     colorToken: themeColorTokenSchema.nullable().optional(),
-    width: z20.enum(["none", "thin", "medium", "thick"]).optional()
+    width: z19.enum(["none", "thin", "medium", "thick"]).optional()
   }).optional()
 });
-var footerNavLayoutSchema = z20.object({
+var footerNavLayoutSchema = z19.object({
   layout: footerNavLayoutMode.optional(),
   align: footerNavLayoutAlign.optional(),
   gapX: footerSpacing.optional(),
   gapY: footerSpacing.optional(),
-  columns: z20.number().int().min(1).max(6).optional()
+  columns: z19.number().int().min(1).max(6).optional()
 });
-var footerLogoSchema = z20.object({
-  showLogo: z20.boolean().default(true),
-  showLogoText: z20.boolean().optional(),
+var footerLogoSchema = z19.object({
+  showLogo: z19.boolean().default(true),
+  showLogoText: z19.boolean().optional(),
   placement: footerLogoPlacement.optional(),
   size: footerLogoSize.optional(),
   maxHeight: footerLogoMaxHeight.optional(),
-  align: z20.enum(["start", "center", "end"]).optional()
+  align: z19.enum(["start", "center", "end"]).optional()
 });
-var footerSchema = z20.object({
+var footerSchema = z19.object({
   /**
    * SDK-only footer rendering mode.
    *
@@ -4474,7 +5460,7 @@ var footerSchema = z20.object({
   mode: footerMode.optional(),
   variant: footerVariant,
   maxWidth: footerMaxWidth,
-  showLogoText: z20.boolean().optional(),
+  showLogoText: z19.boolean().optional(),
   background: headerBackgroundSchema.default({
     type: "color",
     color: "surface"
@@ -4492,20 +5478,20 @@ var footerSchema = z20.object({
   logo: footerLogoSchema.optional(),
   bottomBar: footerBottomBarSchema.optional()
 });
-var containerPaddingPresetSchema = z20.enum([
+var containerPaddingPresetSchema = z19.enum([
   "tight",
   "compact",
   "default",
   "relaxed"
 ]);
-var layoutSchema = z20.object({
-  containerPadding: z20.object({
+var layoutSchema = z19.object({
+  containerPadding: z19.object({
     mobile: containerPaddingPresetSchema.optional(),
     tablet: containerPaddingPresetSchema.optional(),
     desktop: containerPaddingPresetSchema.optional()
   }).optional()
 }).optional();
-var heroTypographySizeSchema = z20.enum([
+var heroTypographySizeSchema = z19.enum([
   "sm",
   "base",
   "lg",
@@ -4517,19 +5503,19 @@ var heroTypographySizeSchema = z20.enum([
   "6xl",
   "editorial"
 ]);
-var heroTypographyLineHeightSchema = z20.enum([
+var heroTypographyLineHeightSchema = z19.enum([
   "tight",
   "snug",
   "normal",
   "relaxed"
 ]);
-var heroResponsiveTypographySchema = z20.object({
+var heroResponsiveTypographySchema = z19.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
   subheadlineLineHeight: heroTypographyLineHeightSchema.optional()
 });
-var heroTypographySchema = z20.object({
+var heroTypographySchema = z19.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
@@ -4538,38 +5524,38 @@ var heroTypographySchema = z20.object({
   microHeadlineLineHeight: heroTypographyLineHeightSchema.optional(),
   microSubheadlineSize: heroTypographySizeSchema.optional(),
   microSubheadlineLineHeight: heroTypographyLineHeightSchema.optional(),
-  responsive: z20.object({
+  responsive: z19.object({
     tablet: heroResponsiveTypographySchema.optional(),
     mobile: heroResponsiveTypographySchema.optional()
   }).optional()
 });
-var heroSchema = z20.object({
+var heroSchema = z19.object({
   typography: heroTypographySchema.optional()
 }).optional();
-var bodyTextIntroTypographySizeSchema = z20.enum(["default", "editorial"]);
-var bodyTextSchema = z20.object({
-  intro: z20.object({
+var bodyTextIntroTypographySizeSchema = z19.enum(["default", "editorial"]);
+var bodyTextSchema = z19.object({
+  intro: z19.object({
     paragraphSize: bodyTextIntroTypographySizeSchema.optional(),
     headingSize: bodyTextIntroTypographySizeSchema.optional()
   }).optional()
 }).optional();
-var gradientsSchema = z20.object({
-  button: z20.string().min(1).nullable().optional(),
-  hero: z20.string().min(1).nullable().optional(),
-  background: z20.string().min(1).nullable().optional()
-});
-var testimonialQuoteTreatmentSchema = z20.object({
-  style: z20.enum(["serif-display", "accent-glyph", "none"]),
-  fontFamily: z20.enum(["heading", "body"]).optional(),
-  scale: z20.enum(["sm", "md", "lg", "xl"]).optional(),
+var gradientsSchema = z19.object({
+  button: z19.string().min(1).nullable().optional(),
+  hero: z19.string().min(1).nullable().optional(),
+  background: z19.string().min(1).nullable().optional()
+});
+var testimonialQuoteTreatmentSchema = z19.object({
+  style: z19.enum(["serif-display", "accent-glyph", "none"]),
+  fontFamily: z19.enum(["heading", "body"]).optional(),
+  scale: z19.enum(["sm", "md", "lg", "xl"]).optional(),
   colorToken: themeColorTokenSchema.optional(),
-  opacity: z20.number().min(0).max(1).optional()
+  opacity: z19.number().min(0).max(1).optional()
 });
-var themeSchema = z20.object({
-  name: z20.string().min(1).max(30),
-  description: z20.string().min(1).max(400),
-  rationale: z20.string().min(1).max(400),
-  siteStyleId: z20.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
+var themeSchema = z19.object({
+  name: z19.string().min(1).max(30),
+  description: z19.string().min(1).max(400),
+  rationale: z19.string().min(1).max(400),
+  siteStyleId: z19.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
   axes: axesSchema,
   palette: paletteSchema,
   typography: typographySchema,
@@ -4599,15 +5585,15 @@ var themeSchema = z20.object({
   // Block-specific customization (Tier 3)
   // blockCustomVars: Per-block CSS variable overrides as bare values
   // Example: { "event-registration": { "--step-color": "#6d28d9" } }
-  blockCustomVars: z20.record(
-    z20.string(),
+  blockCustomVars: z19.record(
+    z19.string(),
     // block kind (matches data-block attribute)
-    z20.record(z20.string(), z20.string())
+    z19.record(z19.string(), z19.string())
     // { '--var-name': 'value' }
   ).optional(),
   // Structured block-kind theme overrides (v1: typography prose-link style only)
   // Keyed by block kind (usually data-block value like "hero"; "block.hero" also accepted)
-  blockOverrides: z20.record(z20.string(), blockThemeOverrideSchema).optional(),
+  blockOverrides: z19.record(z19.string(), blockThemeOverrideSchema).optional(),
   // Site-wide heading decoration signature (family + colour). Set once per Look
   // and projected transiently onto eligible block headings at render time.
   // Alignment is inherited from the heading, so no placement is stored.
@@ -4645,11 +5631,11 @@ var themeSchema = z20.object({
    * }
    * ```
    */
-  styleGroups: z20.record(z20.string(), z20.array(z20.string())).optional()
+  styleGroups: z19.record(z19.string(), z19.array(z19.string())).optional()
 });
-var themesTurnSchema = z20.object({
-  message: z20.string().min(1),
-  themes: z20.array(themeSchema).length(3)
+var themesTurnSchema = z19.object({
+  message: z19.string().min(1),
+  themes: z19.array(themeSchema).length(3)
 });
 
 // ../theme-core/src/palette/variants/types.ts
@@ -4659,19 +5645,19 @@ function asPaletteVariantId(value) {
   }
   return value;
 }
-var paletteVariantIdSchema = z21.string().min(1).transform((value) => asPaletteVariantId(value));
+var paletteVariantIdSchema = z20.string().min(1).transform((value) => asPaletteVariantId(value));
 var HEX_COLOR_REGEX = /^#[0-9a-f]{6}$/;
-var hexColorSchema = z21.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
+var hexColorSchema = z20.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
 var variantPaletteColorSchema = paletteColorSchema.extend({
   name: paletteTokenNameSchema
 });
-var paletteVariantSchema = z21.object({
+var paletteVariantSchema = z20.object({
   id: paletteVariantIdSchema,
-  name: z21.string().min(1),
-  description: z21.string().min(1),
+  name: z20.string().min(1),
+  description: z20.string().min(1),
   tags: styleTagsSchema,
-  mode: z21.enum(["light", "dark"]),
-  colors: z21.array(variantPaletteColorSchema).min(1)
+  mode: z20.enum(["light", "dark"]),
+  colors: z20.array(variantPaletteColorSchema).min(1)
 });
 function definePaletteVariant(input) {
   return {
@@ -4683,7 +5669,7 @@ function definePaletteVariant(input) {
     colors: input.colors
   };
 }
-var paletteOverridesSchema = z21.object({
+var paletteOverridesSchema = z20.object({
   primary: hexColorSchema.optional(),
   primaryForeground: hexColorSchema.optional(),
   secondary: hexColorSchema.optional(),
@@ -5061,33 +6047,324 @@ var warmDarkEmber = definePaletteVariant({
   ]
 });
 
-// ../theme-core/src/palette/variants/index.ts
-var paletteVariants = [
-  // Brand-led family
-  brandLedCool,
-  brandLedWarm,
-  brandLedJewel,
-  brandLedBurgundyGold,
-  // Warm-neutral family
-  warmNeutralClay,
-  warmNeutralCream,
-  warmNeutralSoftEarth,
-  warmNeutralForest,
-  // High-contrast family
-  highContrastInk,
-  highContrastCharcoal,
-  highContrastMonochrome,
-  // Soft-natural family
-  softNaturalSage,
-  softNaturalStone,
-  softNaturalWatercolor,
-  softNaturalLilac,
-  // Warm-dark family (dark mode)
-  warmDarkEmber
-];
-var paletteVariantsById = new Map(
-  paletteVariants.map((v) => [v.id, v])
-);
+// ../theme-core/src/palette/variants/index.ts
+var paletteVariants = [
+  // Brand-led family
+  brandLedCool,
+  brandLedWarm,
+  brandLedJewel,
+  brandLedBurgundyGold,
+  // Warm-neutral family
+  warmNeutralClay,
+  warmNeutralCream,
+  warmNeutralSoftEarth,
+  warmNeutralForest,
+  // High-contrast family
+  highContrastInk,
+  highContrastCharcoal,
+  highContrastMonochrome,
+  // Soft-natural family
+  softNaturalSage,
+  softNaturalStone,
+  softNaturalWatercolor,
+  softNaturalLilac,
+  // Warm-dark family (dark mode)
+  warmDarkEmber
+];
+var paletteVariantsById = new Map(
+  paletteVariants.map((v) => [v.id, v])
+);
+
+// ../theme-core/src/site-styles/backgroundAppearance.ts
+var backgroundAppearanceQuickColorTokenNames = [
+  "background",
+  "surface",
+  "muted",
+  "primary",
+  "secondary",
+  "accent"
+];
+var backgroundAppearanceBaseColorTokenNames = [
+  "background",
+  "surface",
+  "surfaceAlt",
+  "muted",
+  "primary",
+  "secondary",
+  "accent",
+  "neutral"
+];
+var backgroundAppearanceShadeableColorTokenNames = [
+  "primary",
+  "secondary",
+  "accent",
+  "neutral"
+];
+var backgroundAppearanceColorTokenNames = uniqueStrings([
+  ...backgroundAppearanceBaseColorTokenNames,
+  ...backgroundAppearanceShadeableColorTokenNames.flatMap(
+    (name) => themeColorShadeSteps.map((shade) => `${name}-${shade}`)
+  )
+]);
+var backgroundAppearanceAdvancedColorTokenNames = backgroundAppearanceColorTokenNames.filter(
+  (tokenName) => !backgroundAppearanceQuickColorTokenNames.includes(
+    tokenName
+  )
+);
+var backgroundAppearanceColorTokenNameSet = new Set(
+  backgroundAppearanceColorTokenNames
+);
+function parseBackgroundAppearanceColorToken(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  if (!backgroundAppearanceColorTokenNameSet.has(normalized)) return null;
+  return parseThemeColorToken(normalized);
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values));
+}
+
+// ../theme-core/src/site-styles/pageDesignIntent.ts
+import { z as z21 } from "zod";
+
+// ../theme-core/src/site-styles/sectionTransitions.ts
+var noneBoundaryOption = {
+  id: asBoundaryOptionId("break:none"),
+  label: "None",
+  transitionAfter: "none",
+  treatment: { kind: "none" }
+};
+var softBoundaryOption = {
+  id: asBoundaryOptionId("break:soft"),
+  label: "Soft",
+  transitionAfter: "soft-fade-short",
+  treatment: { kind: "soft-fade", height: "medium", curve: "soft" }
+};
+var spaciousBoundaryOption = {
+  id: asBoundaryOptionId("break:spacious"),
+  label: "Spacious",
+  transitionAfter: "soft-fade-long",
+  treatment: { kind: "soft-fade", height: "large", curve: "spacious" }
+};
+var expansiveBoundaryOption = {
+  id: asBoundaryOptionId("break:expansive"),
+  label: "Expansive",
+  transitionAfter: "soft-fade-expansive",
+  treatment: { kind: "soft-fade", height: "expansive", curve: "expansive" }
+};
+var waveBoundaryOption = {
+  id: asBoundaryOptionId("break:wave"),
+  label: "Classic wave",
+  transitionAfter: "wave-edge",
+  treatment: {
+    kind: "wave-edge",
+    height: "medium",
+    amplitude: "balanced",
+    rhythm: "double",
+    symmetry: "asymmetrical"
+  }
+};
+var balancedWaveBoundaryOption = {
+  id: asBoundaryOptionId("break:wave-balanced"),
+  label: "Balanced wave",
+  transitionAfter: "wave-edge-balanced",
+  treatment: {
+    kind: "wave-edge",
+    height: "medium",
+    amplitude: "balanced",
+    rhythm: "double",
+    symmetry: "symmetrical"
+  }
+};
+var gentleWaveBoundaryOption = {
+  id: asBoundaryOptionId("break:wave-gentle"),
+  label: "Gentle wave",
+  transitionAfter: "wave-edge-gentle",
+  treatment: {
+    kind: "wave-edge",
+    height: "compact",
+    amplitude: "subtle",
+    rhythm: "single",
+    symmetry: "symmetrical"
+  }
+};
+var boldWaveBoundaryOption = {
+  id: asBoundaryOptionId("break:wave-bold"),
+  label: "Bold wave",
+  transitionAfter: "wave-edge-bold",
+  treatment: {
+    kind: "wave-edge",
+    height: "large",
+    amplitude: "bold",
+    rhythm: "double",
+    symmetry: "symmetrical"
+  }
+};
+var driftWaveBoundaryOption = {
+  id: asBoundaryOptionId("break:wave-drift"),
+  label: "Drift wave",
+  transitionAfter: "wave-edge-drift",
+  treatment: {
+    kind: "wave-edge",
+    height: "medium",
+    amplitude: "balanced",
+    rhythm: "double",
+    symmetry: "drift"
+  }
+};
+var subtleAngleBoundaryOption = {
+  id: asBoundaryOptionId("break:angle-subtle"),
+  label: "Subtle angle",
+  transitionAfter: "angle-edge-subtle",
+  treatment: {
+    kind: "angle-edge",
+    height: "compact",
+    slope: "subtle",
+    direction: "forward"
+  }
+};
+var balancedAngleBoundaryOption = {
+  id: asBoundaryOptionId("break:angle-balanced"),
+  label: "Balanced angle",
+  transitionAfter: "angle-edge",
+  treatment: {
+    kind: "angle-edge",
+    height: "medium",
+    slope: "balanced",
+    direction: "forward"
+  }
+};
+var steepAngleBoundaryOption = {
+  id: asBoundaryOptionId("break:angle-steep"),
+  label: "Steep angle",
+  transitionAfter: "angle-edge-steep",
+  treatment: {
+    kind: "angle-edge",
+    height: "large",
+    slope: "steep",
+    direction: "forward"
+  }
+};
+
+// ../theme-core/src/site-styles/pageDesignIntent.ts
+var pageDesignIntentSchemaVersion = 2;
+var legacyPageDesignIntentSchemaVersion = 1;
+var unknownBoundaryOptionId = asBoundaryOptionId("break:unknown");
+var pageDesignUserPinnedAppearanceChoiceSchema = z21.object({
+  kind: z21.literal("user-pinned"),
+  value: z21.string().min(1).transform(asAppearancePresetId)
+}).strict();
+var pageDesignUserPinnedBoundaryChoiceSchema = z21.object({
+  kind: z21.literal("user-pinned"),
+  value: z21.string().min(1).transform(asBoundaryOptionId)
+}).strict();
+var pageDesignBoundaryTreatmentSchema = z21.discriminatedUnion("kind", [
+  z21.object({ kind: z21.literal("none") }).strict(),
+  z21.object({
+    kind: z21.literal("soft-fade"),
+    height: z21.enum(["compact", "medium", "large", "expansive"]),
+    curve: z21.enum(["soft", "spacious", "expansive"])
+  }).strict(),
+  z21.object({
+    kind: z21.literal("wave-edge"),
+    height: z21.enum(["compact", "medium", "large"]),
+    amplitude: z21.enum(["subtle", "balanced", "bold"]),
+    rhythm: z21.enum(["single", "double"]),
+    symmetry: z21.enum(["symmetrical", "asymmetrical", "drift"])
+  }).strict(),
+  z21.object({
+    kind: z21.literal("angle-edge"),
+    height: z21.enum(["compact", "medium", "large"]),
+    slope: z21.enum(["subtle", "balanced", "steep"]),
+    direction: z21.enum(["forward", "reverse"])
+  }).strict(),
+  z21.object({
+    kind: z21.literal("legacy-unsupported"),
+    boundaryOptionId: z21.string().min(1).transform(asBoundaryOptionId)
+  }).strict()
+]);
+var pageDesignUserPinnedBoundaryTreatmentChoiceSchema = z21.object({
+  kind: z21.literal("user-pinned"),
+  value: pageDesignBoundaryTreatmentSchema
+}).strict();
+var pageDesignBlockLookPinSchema = z21.object({
+  blockId: z21.string().min(1).transform(asDesignBlockId),
+  blockKind: z21.string().min(1),
+  choice: pageDesignUserPinnedAppearanceChoiceSchema
+}).strict();
+var pageDesignBoundaryPinSchema = z21.object({
+  boundaryId: z21.string().min(1).transform(asDesignBoundaryId),
+  previousBlockId: z21.string().min(1).transform(asDesignBlockId),
+  nextBlockId: z21.string().min(1).transform(asDesignBlockId),
+  choice: pageDesignUserPinnedBoundaryTreatmentChoiceSchema
+}).strict().superRefine(validateBoundaryPinIdMatchesBlocks);
+var legacyPageDesignBoundaryPinSchema = z21.object({
+  boundaryId: z21.string().min(1).transform(asDesignBoundaryId),
+  previousBlockId: z21.string().min(1).transform(asDesignBlockId),
+  nextBlockId: z21.string().min(1).transform(asDesignBlockId),
+  choice: pageDesignUserPinnedBoundaryChoiceSchema
+}).strict().superRefine(validateBoundaryPinIdMatchesBlocks);
+var pageDesignIntentV1Schema = z21.object({
+  schemaVersion: z21.literal(legacyPageDesignIntentSchemaVersion),
+  siteStyleId: z21.string().min(1).transform(asSiteStyleId),
+  pageFlowPresetId: z21.string().min(1).transform(asPageFlowPresetId),
+  blockLookPins: z21.array(pageDesignBlockLookPinSchema),
+  boundaryPins: z21.array(legacyPageDesignBoundaryPinSchema)
+}).strict().superRefine(validateUniquePageDesignPins);
+var pageDesignIntentV2Schema = z21.object({
+  schemaVersion: z21.literal(pageDesignIntentSchemaVersion),
+  siteStyleId: z21.string().min(1).transform(asSiteStyleId),
+  pageFlowPresetId: z21.string().min(1).transform(asPageFlowPresetId),
+  blockLookPins: z21.array(pageDesignBlockLookPinSchema),
+  boundaryPins: z21.array(pageDesignBoundaryPinSchema)
+}).strict().superRefine(validateUniquePageDesignPins);
+function addDuplicateStringIssues(ctx, input) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const value of input.values) {
+    if (seen.has(value)) {
+      duplicates.add(value);
+    }
+    seen.add(value);
+  }
+  for (const duplicate of duplicates) {
+    ctx.addIssue({
+      code: z21.ZodIssueCode.custom,
+      path: [...input.path],
+      message: `Duplicate ${input.label}: ${duplicate}.`
+    });
+  }
+}
+function validateBoundaryPinIdMatchesBlocks(pin, ctx) {
+  const expectedBoundaryId = makeBoundaryId(
+    pin.previousBlockId,
+    pin.nextBlockId
+  );
+  if (pin.boundaryId !== expectedBoundaryId) {
+    ctx.addIssue({
+      code: z21.ZodIssueCode.custom,
+      path: ["boundaryId"],
+      message: `Boundary id must match previousBlockId and nextBlockId. Expected ${expectedBoundaryId}.`
+    });
+  }
+}
+function validateUniquePageDesignPins(intent, ctx) {
+  addDuplicateStringIssues(ctx, {
+    values: intent.blockLookPins.map((pin) => pin.blockId),
+    path: ["blockLookPins"],
+    label: "block Look pin"
+  });
+  addDuplicateStringIssues(ctx, {
+    values: intent.boundaryPins.map(
+      (pin) => boundaryKey(pin.previousBlockId, pin.nextBlockId)
+    ),
+    path: ["boundaryPins"],
+    label: "boundary pin"
+  });
+}
+function boundaryKey(previousBlockId, nextBlockId) {
+  return makeBoundaryId(previousBlockId, nextBlockId);
+}
 
 // ../theme-core/src/accordions/siteStyleDefaults.ts
 var editorialDividedAccordionSystem = {
@@ -8541,6 +9818,23 @@ function collectBlockSequenceIssues(snapshots) {
   return issues;
 }
 
+// ../theme-core/src/site-styles/siteChromeBackgrounds.ts
+var siteChromeBackgroundColorTokens = toSiteChromeBackgroundColorTokens(backgroundAppearanceColorTokenNames);
+var quickSiteChromeBackgroundColorTokens = toSiteChromeBackgroundColorTokens(backgroundAppearanceQuickColorTokenNames);
+var advancedSiteChromeBackgroundColorTokens = siteChromeBackgroundColorTokens.filter(
+  (token) => !quickSiteChromeBackgroundColorTokens.includes(token)
+);
+function parseSiteChromeBackgroundColorToken(value) {
+  const token = parseBackgroundAppearanceColorToken(value);
+  return token ? token : null;
+}
+function toSiteChromeBackgroundColorTokens(tokenNames) {
+  return tokenNames.flatMap((name) => {
+    const token = parseSiteChromeBackgroundColorToken(name);
+    return token ? [token] : [];
+  });
+}
+
 // ../theme-core/src/site-styles/tokenRecipes.ts
 import { z as z25 } from "zod";
 var themeTokenRecipeOptions = {
@@ -12706,6 +14000,7 @@ function createBlockManifest(config) {
     // Always empty
     styleTokens: config.styleTokens,
     behaviours,
+    previewCustomize: config.previewCustomize,
     category: config.category,
     contentTypes: config.contentTypes ? [...config.contentTypes] : void 0,
     tags: config.tags ? [...config.tags] : [],
@@ -12834,7 +14129,7 @@ function splitLayoutWith(children) {
         type: "grid",
         props: {
           cols: { base: 1, md: 2 },
-          gap: "lg",
+          gap: "comfortable",
           className: {
             $bind: {
               from: "content",
@@ -15276,6 +16571,15 @@ var testimonialsManifest = createBlockManifest({
   title: "Testimonials",
   category: "marketing",
   includeContainerStyles: true,
+  previewCustomize: {
+    quickFieldPriority: [
+      "avatarLayout",
+      "gridColumns",
+      "slidesToShow",
+      "maxEntries",
+      "autoplay"
+    ]
+  },
   // Default layout (used when no variant specified)
   layout: carouselLayout,
   // Variant system - enables the variant switcher control in the editor
@@ -16700,6 +18004,7 @@ var publicCoursesArraySchema = z34.array(publicCourseSchema);
 // ../blocks/src/system/blocks/events/shared/schemas.ts
 var eventPresetSchema = z35.enum(["event", "class", "workshop", "retreat", "performance"]);
 var eventScheduleScopeSchema = z35.enum(["recurring", "oneOff"]);
+var eventDestinationModeSchema = z35.enum(["cms-managed", "system-managed"]);
 var eventVenueSchema = z35.object({
   id: z35.string(),
   name: z35.string(),
@@ -16714,7 +18019,7 @@ var eventCategorySchema = z35.object({
   name: z35.string(),
   color: z35.string().nullable()
 });
-var pricingTypeSchema = z35.enum(["free", "paid", "pass_only", "membership_only"]);
+var pricingTypeSchema = z35.enum(["free", "paid"]);
 var accessRestrictionSchema = z35.enum(["none", "category"]);
 var eventPricingModeSchema = z35.enum(["single", "ticket_types"]);
 var publicCoursePriceDisplaySchema = z35.discriminatedUnion("kind", [
@@ -16728,11 +18033,16 @@ var publicEventPriceDisplaySchema = z35.discriminatedUnion("kind", [
   z35.object({ kind: z35.literal("exact"), amount: z35.number(), currency: z35.string() }),
   z35.object({ kind: z35.literal("from"), amount: z35.number(), currency: z35.string() }),
   z35.object({ kind: z35.literal("mixed"), paidFromAmount: z35.number(), currency: z35.string() }),
-  z35.object({ kind: z35.literal("pass_only") }),
-  z35.object({ kind: z35.literal("membership_only") }),
   z35.object({ kind: z35.literal("unavailable"), currency: z35.string() }),
   z35.object({ kind: z35.literal("course"), display: publicCoursePriceDisplaySchema })
 ]);
+var publicEventTicketTypePriceDisplaySchema = z35.union([
+  z35.object({ kind: z35.literal("free"), currency: z35.string() }),
+  z35.object({ kind: z35.literal("exact"), amount: z35.number(), currency: z35.string() }),
+  z35.object({ kind: z35.literal("from"), amount: z35.number(), currency: z35.string() }),
+  z35.object({ kind: z35.literal("mixed"), paidFromAmount: z35.number(), currency: z35.string() }),
+  z35.object({ kind: z35.literal("unavailable"), currency: z35.string() })
+]);
 var publicEventAttendanceModeSchema = z35.enum(["in_person", "online"]);
 var publicEventAttendanceModeAvailabilitySchema = z35.object({
   mode: publicEventAttendanceModeSchema,
@@ -16770,6 +18080,34 @@ var publicEventTicketTypeSchema = z35.object({
   createdAt: z35.string(),
   updatedAt: z35.string()
 });
+var publicEventPricingSchema = z35.discriminatedUnion("kind", [
+  z35.object({
+    kind: z35.literal("drop_in"),
+    currency: z35.string(),
+    display: z35.object({ kind: z35.literal("free"), currency: z35.string() })
+  }),
+  z35.object({
+    kind: z35.literal("free_registration"),
+    currency: z35.string(),
+    display: z35.object({ kind: z35.literal("free"), currency: z35.string() })
+  }),
+  z35.object({
+    kind: z35.literal("single_paid"),
+    amount: z35.number(),
+    currency: z35.string(),
+    display: z35.object({ kind: z35.literal("exact"), amount: z35.number(), currency: z35.string() })
+  }),
+  z35.object({
+    kind: z35.literal("ticket_types"),
+    currency: z35.string(),
+    ticketTypes: z35.array(publicEventTicketTypeSchema),
+    display: publicEventTicketTypePriceDisplaySchema
+  }),
+  z35.object({
+    kind: z35.literal("course"),
+    display: z35.object({ kind: z35.literal("course"), display: publicCoursePriceDisplaySchema })
+  })
+]);
 var publicTeamMemberSummarySchema = z35.object({
   id: z35.string(),
   name: z35.string(),
@@ -16780,6 +18118,7 @@ var publicTeamMemberSummarySchema = z35.object({
 var publicEventSchema = z35.object({
   kind: z35.enum(["event", "course_session"]).optional(),
   eventPreset: eventPresetSchema.optional(),
+  eventDestinationMode: eventDestinationModeSchema.optional(),
   scheduleScope: eventScheduleScopeSchema.optional(),
   id: z35.string(),
   occurrenceId: z35.string(),
@@ -16789,10 +18128,7 @@ var publicEventSchema = z35.object({
   presentation: z35.object({
     cardTitleOverride: z35.string().nullable().optional(),
     summary: z35.string().nullable().optional(),
-    image: mediaSchema2.nullable().optional(),
-    tags: z35.array(z35.string()).optional(),
-    ctaLabel: z35.string().nullable().optional(),
-    badges: z35.array(z35.string()).optional()
+    image: mediaSchema2.nullable().optional()
   }).optional(),
   slug: z35.string(),
   path: z35.string(),
@@ -16810,14 +18146,8 @@ var publicEventSchema = z35.object({
   teamMembers: z35.array(publicTeamMemberSummarySchema).optional(),
   status: z35.enum(["active", "draft", "archived"]).optional(),
   timeZone: z35.string(),
-  // Pricing & access fields
-  pricingType: pricingTypeSchema,
-  price: z35.number().nullable(),
-  currency: z35.string(),
-  priceDisplay: publicEventPriceDisplaySchema,
+  pricing: publicEventPricingSchema,
   paymentTerms: blockBookingPaymentTermsSchema,
-  pricingMode: eventPricingModeSchema.optional(),
-  ticketTypes: z35.array(publicEventTicketTypeSchema).optional(),
   accessRestriction: accessRestrictionSchema,
   allowedCategoryIds: z35.array(z35.string()),
   requireGuestDetails: z35.boolean().optional(),
@@ -17088,6 +18418,7 @@ var eventRegistrationSourceSchema = z38.object({
   siteId: z38.string().optional(),
   apiBaseUrl: z38.string().optional(),
   portalToken: z38.string().nullable().optional(),
+  previewToken: z38.string().nullable().optional(),
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
   events: z38.array(publicEventSchema).nullable().optional(),
@@ -17130,12 +18461,14 @@ var eventRegistrationIslandMetaCodec = createZodCodec(z38.object({
   siteId: z38.string().optional(),
   apiBaseUrl: z38.string().optional(),
   portalToken: z38.string().nullable().optional(),
+  previewToken: z38.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var eventRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
   "siteId",
   "apiBaseUrl",
   "portalToken",
+  "previewToken",
   "stage"
 );
 function buildEventRegistrationDisplay(source) {
@@ -17178,6 +18511,7 @@ var eventRegistrationInteractiveIslandPropsCodec = createInteractiveIslandCodec(
     siteId: value.siteId,
     apiBaseUrl: value.apiBaseUrl,
     portalToken: value.portalToken,
+    previewToken: value.previewToken,
     stage: value.stage
   })
 });
@@ -18228,7 +19562,8 @@ function getContainerClass(layout, columns) {
   if (layout === "stack") {
     return "rb-flex rb-flex-col rb-gap-6";
   }
-  return `rb-grid rb-items-stretch rb-grid-cols-1 rb-gap-6 ${COLUMN_CLASSES[columns] || COLUMN_CLASSES["3"]}`;
+  const fallbackColumnClass = COLUMN_CLASSES["3"] ?? "";
+  return `rb-grid rb-items-stretch rb-grid-cols-1 rb-gap-6 ${COLUMN_CLASSES[columns] ?? fallbackColumnClass}`;
 }
 function getCardOrientation(layout) {
   switch (layout) {
@@ -18688,6 +20023,14 @@ var eventListingConfig = {
   category: "interactive",
   tags: ["events", "listing", "paginated", "archive", "all-events"],
   icon: "List",
+  previewCustomize: {
+    quickFieldPriority: [
+      "layout",
+      "columns",
+      "eventsPerPage",
+      "eventSurface"
+    ]
+  },
   layout: eventListingLayout
 };
 var eventListingManifest = createBlockManifestWithContentShape(
@@ -19461,6 +20804,14 @@ var eventCalendarConfig = {
     "filter"
   ],
   icon: "CalendarDays",
+  previewCustomize: {
+    quickFieldPriority: [
+      "listLayout",
+      "eventsPerPage",
+      "showFilters",
+      "eventSurface"
+    ]
+  },
   layout: eventCalendarLayout,
   variants: eventCalendarVariants,
   defaultVariant: "combined",
@@ -19550,12 +20901,59 @@ var OFFERINGS_PREVIEW_AUTHORABLE_SOURCE_KEYS = [
   ...OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS.map((definition) => definition.sourceKey),
   "course"
 ];
+var OFFERINGS_PREVIEW_SOURCE_KEYS = OFFERINGS_PREVIEW_AUTHORABLE_SOURCE_KEYS;
 var eventPresetSourceByKey = Object.fromEntries(
   OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS.map((definition) => [
     definition.sourceKey,
     { kind: "eventPreset", preset: definition.preset }
   ])
 );
+function isOfferingsPreviewSourceKey(value) {
+  return typeof value === "string" && OFFERINGS_PREVIEW_SOURCE_KEYS.includes(value);
+}
+function normalizeOfferingsPreviewGroupOrder(value) {
+  if (value == null) return { kind: "legacy" };
+  if (value.length === 0) return { kind: "default" };
+  const keys = uniqueOfferingsPreviewSourceKeys(value);
+  return keys.length > 0 ? { kind: "custom", keys } : { kind: "default" };
+}
+function inferLegacyOfferingsPreviewGroupOrder(overrides) {
+  const keys = uniqueOfferingsPreviewSourceKeys(
+    (overrides ?? []).map((override) => override.sourceKey)
+  );
+  return keys.length >= 2 ? keys : [];
+}
+function normalizeOfferingsPreviewContentForWrite(value) {
+  if (!isRecord2(value)) return null;
+  const groupOrderValue = value.groupOrder;
+  if (Array.isArray(groupOrderValue)) {
+    const normalized = normalizeOfferingsPreviewGroupOrder(groupOrderValue);
+    return {
+      ...value,
+      groupOrder: normalized.kind === "custom" ? normalized.keys : []
+    };
+  }
+  if (groupOrderValue != null) {
+    return { ...value, groupOrder: [] };
+  }
+  const legacyOrder = inferLegacyOfferingsPreviewGroupOrder(
+    Array.isArray(value.groupOverrides) ? value.groupOverrides.filter(isRecord2) : []
+  );
+  return legacyOrder.length > 0 ? { ...value, groupOrder: legacyOrder } : value;
+}
+function uniqueOfferingsPreviewSourceKeys(values) {
+  const keys = [];
+  for (const value of values) {
+    if (!isOfferingsPreviewSourceKey(value)) continue;
+    if (!keys.includes(value)) {
+      keys.push(value);
+    }
+  }
+  return keys;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // ../blocks/src/system/blocks/offerings-preview/index.ts
 var publicRouteCandidatesSchema = z46.object({
@@ -19674,11 +21072,24 @@ var offeringsPreviewFields = [
     ],
     ui: { intent: "display" }
   },
+  {
+    id: "groupOrder",
+    type: "select",
+    label: "Offering card order",
+    description: "Reorder enabled offering cards for this block.",
+    required: false,
+    multiple: true,
+    options: OFFERINGS_PREVIEW_AUTHORABLE_SOURCE_KEYS.map((sourceKey) => ({
+      value: sourceKey,
+      label: labelForOfferingPreviewSourceKey(sourceKey)
+    })),
+    ui: { intent: "display", widget: "offeringGroupOrder" }
+  },
   {
     id: "groupOverrides",
     type: "repeater",
     label: "Card overrides",
-    description: "Edit card copy, order, or visibility for enabled offering presets.",
+    description: "Edit card copy, presentation, links, or visibility for enabled offering presets.",
     required: false,
     maxItems: 5,
     itemLabel: "Offering card",
@@ -19756,6 +21167,7 @@ var offeringsPreviewLayout = [
           $bind: { from: "$root.bookingOfferingPresets", fallback: [] }
         },
         groupOverrides: { $bind: { from: "content.groupOverrides", fallback: [] } },
+        groupOrder: { $bind: { from: "content.groupOrder" } },
         cardStyles: { $bind: { from: "content._cardStyles" } },
         itemLimit: { $bind: { from: "content.itemLimit", fallback: OFFERINGS_PREVIEW_DEFAULT_ITEM_LIMIT } },
         buttonVariant: { $bind: { from: "content.buttonVariant", fallback: "primary" } },
@@ -19812,6 +21224,7 @@ var offeringsPreviewEventDataLoaders = Object.fromEntries(
 );
 var offeringsPreviewBlockDefinition = {
   manifest: offeringsPreviewManifest,
+  normalizeContent: normalizeOfferingsPreviewBlockContent,
   dataSchemas: {
     ...offeringsPreviewEventDataSchemas,
     routeCandidates: publicRouteCandidatesSchema.optional(),
@@ -19850,6 +21263,101 @@ function eventPresetLoader(preset) {
     mode: "server"
   };
 }
+function labelForOfferingPreviewSourceKey(sourceKey) {
+  const eventDefinition = OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS.find(
+    (definition) => definition.sourceKey === sourceKey
+  );
+  if (eventDefinition) return eventDefinition.label;
+  return "Courses";
+}
+function normalizeOfferingsPreviewBlockContent(value) {
+  const record = normalizeOfferingsPreviewContentForWrite(value);
+  if (!record) return {};
+  const normalized = {};
+  if (typeof record.heading === "string" || record.heading === null) {
+    normalized.heading = record.heading;
+  }
+  if ("description" in record) {
+    normalized.description = record.description;
+  }
+  if (isOfferingsPreviewItemLimit(record.itemLimit)) {
+    normalized.itemLimit = record.itemLimit;
+  }
+  if (Array.isArray(record.groupOrder)) {
+    normalized.groupOrder = record.groupOrder.filter(isOfferingsPreviewSourceKey);
+  } else if (record.groupOrder === null) {
+    normalized.groupOrder = null;
+  }
+  if (Array.isArray(record.groupOverrides)) {
+    normalized.groupOverrides = record.groupOverrides.flatMap(
+      normalizeOfferingsPreviewGroupOverride
+    );
+  } else if (record.groupOverrides === null) {
+    normalized.groupOverrides = null;
+  }
+  const cardStyles = normalizeCardStylesContent(record._cardStyles);
+  if (cardStyles !== void 0) {
+    normalized._cardStyles = cardStyles;
+  }
+  if (isButtonVariant(record.buttonVariant)) {
+    normalized.buttonVariant = record.buttonVariant;
+  }
+  if (typeof record.buttonText === "string" || record.buttonText === null) {
+    normalized.buttonText = record.buttonText;
+  }
+  if (typeof record.emptyMessage === "string" || record.emptyMessage === null) {
+    normalized.emptyMessage = record.emptyMessage;
+  }
+  const sectionStyles = normalizeSectionStylesContent(record._sectionStyles);
+  if (sectionStyles !== void 0) {
+    normalized._sectionStyles = sectionStyles;
+  }
+  return normalized;
+}
+function isOfferingsPreviewItemLimit(value) {
+  return value === "1" || value === "2" || value === "3" || value === "4" || value === "5" || value === "6" || value === null;
+}
+function normalizeOfferingsPreviewGroupOverride(value) {
+  if (!isRecord3(value)) return [];
+  const override = {};
+  if (isOfferingsPreviewSourceKey(value.sourceKey) || value.sourceKey === null) {
+    override.sourceKey = value.sourceKey;
+  }
+  if (typeof value.title === "string" || value.title === null) {
+    override.title = value.title;
+  }
+  if (typeof value.intro === "string" || value.intro === null) {
+    override.intro = value.intro;
+  }
+  if (typeof value.hidden === "boolean" || value.hidden === null) {
+    override.hidden = value.hidden;
+  }
+  if (value.presentation === "compact-list" || value.presentation === "single-card" || value.presentation === null) {
+    override.presentation = value.presentation;
+  }
+  if (value.ctaMode === "auto" || value.ctaMode === "custom" || value.ctaMode === "hidden" || value.ctaMode === null) {
+    override.ctaMode = value.ctaMode;
+  }
+  if (typeof value.ctaHref === "string" || value.ctaHref === null) {
+    override.ctaHref = value.ctaHref;
+  }
+  if (typeof value.ctaLabel === "string" || value.ctaLabel === null) {
+    override.ctaLabel = value.ctaLabel;
+  }
+  return [override];
+}
+function isButtonVariant(value) {
+  return value === "primary" || value === "secondary" || value === "outline" || value === "link" || value === null;
+}
+function normalizeCardStylesContent(value) {
+  return isRecord3(value) || value === null ? value : void 0;
+}
+function normalizeSectionStylesContent(value) {
+  return isRecord3(value) || value === null ? value : void 0;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // ../blocks/src/system/blocks/embed.ts
 import { z as z47 } from "zod";
@@ -20750,6 +22258,15 @@ var baseImageGalleryManifest = createBlockManifest({
   id: "block.image-gallery",
   title: "Image Gallery",
   category: "content",
+  previewCustomize: {
+    quickFieldPriority: [
+      "aspectRatio",
+      "slidesToShow",
+      "fullBleed",
+      "marqueeSpeed",
+      "marqueePauseOnHover"
+    ]
+  },
   additionalFields: fields,
   layout: wrapVariant2(gridLayout3),
   variants: {
@@ -21304,8 +22821,6 @@ var publicProductSchema = z48.object({
     slug: z48.string()
   }).nullable(),
   summary: z48.string().nullable(),
-  badges: z48.array(z48.string()),
-  ctaLabel: z48.string().nullable(),
   body: z48.unknown().nullable(),
   gallery: z48.array(
     z48.object({
@@ -21465,7 +22980,6 @@ function buildProductCardDisplay(product, options, selectedVariantId) {
     path: product.path ?? null,
     summary: options.showSummary ? product.summary : null,
     priceLabel,
-    badges: options.showBadges ? product.badges : [],
     image: product.gallery[0] ? { url: product.gallery[0].url, alt: product.gallery[0].alt ?? null } : null,
     variantOptions: product.variants.map((variant) => ({
       id: variant.id,
@@ -21474,7 +22988,7 @@ function buildProductCardDisplay(product, options, selectedVariantId) {
     })),
     selectedVariantId: selectedVariant?.id ?? null,
     selectionLabel,
-    actionLabel: product.ctaLabel || options.addButtonText,
+    actionLabel: options.addButtonText,
     soldOut
   };
 }
@@ -21511,7 +23025,6 @@ function buildProductDetailDisplay(product, options, selectedVariantId) {
     title: product.title,
     priceLabel: formatCommercePrice(selectedVariant?.priceCents ?? product.priceCents, product.currency),
     summary: options.showSummary ? product.summary : null,
-    badges: options.showBadges ? product.badges : [],
     categoryLabel: product.category?.name ?? null,
     gallery: product.gallery.map((image) => ({ url: image.url, alt: image.alt ?? null })),
     variantOptions: product.variants.map((variant) => ({
@@ -21521,7 +23034,7 @@ function buildProductDetailDisplay(product, options, selectedVariantId) {
     })),
     selectedVariantId: selectedVariant?.id ?? null,
     selectionLabel: selectedVariant ? `${product.title} \u2013 ${selectedVariant.title}` : product.title,
-    actionLabel: product.ctaLabel || options.addButtonText,
+    actionLabel: options.addButtonText,
     soldOut,
     body: product.body
   };
@@ -21656,7 +23169,6 @@ var shopSourceSchema = z50.object({
   showDescriptions: z50.boolean().optional(),
   showSummary: z50.boolean().optional(),
   showBody: z50.boolean().optional(),
-  showBadges: z50.boolean().optional(),
   showPrices: z50.boolean().optional(),
   showValidityPeriod: z50.boolean().optional(),
   showPricePerCredit: z50.boolean().nullable().optional(),
@@ -21689,7 +23201,6 @@ var productCardDisplaySchema = z50.object({
   path: z50.string().nullable(),
   summary: z50.string().nullable(),
   priceLabel: z50.string().nullable(),
-  badges: z50.array(z50.string()),
   image: z50.object({
     url: z50.string(),
     alt: z50.string().nullable()
@@ -21726,7 +23237,6 @@ var productDetailDisplaySchema = z50.discriminatedUnion("state", [
     title: z50.string(),
     priceLabel: z50.string(),
     summary: z50.string().nullable(),
-    badges: z50.array(z50.string()),
     categoryLabel: z50.string().nullable(),
     gallery: z50.array(z50.object({
       url: z50.string(),
@@ -21805,7 +23315,6 @@ var passesMembershipsHydrationSchema = z50.object({
 var productListHydrationSchema = z50.object({
   products: z50.array(publicProductSchema),
   showSummary: z50.boolean(),
-  showBadges: z50.boolean(),
   showPrices: z50.boolean(),
   addButtonText: z50.string()
 });
@@ -21813,7 +23322,6 @@ var productDetailHydrationSchema = z50.object({
   products: z50.array(publicProductSchema),
   productId: z50.string().nullable(),
   showSummary: z50.boolean(),
-  showBadges: z50.boolean(),
   showBody: z50.boolean(),
   addButtonText: z50.string()
 });
@@ -21909,14 +23417,12 @@ var productListBlockRuntime = defineProgressiveBlockRuntime({
       columns: source.columns,
       emptyMessage: source.emptyStateText,
       showSummary: source.showSummary !== false,
-      showBadges: source.showBadges !== false,
       showPrices: source.showPrices !== false,
       addButtonText: source.addButtonText ?? "Add to cart"
     }),
     hydration: {
       products: source.products ?? [],
       showSummary: source.showSummary !== false,
-      showBadges: source.showBadges !== false,
       showPrices: source.showPrices !== false,
       addButtonText: source.addButtonText ?? "Add to cart"
     }
@@ -21940,14 +23446,12 @@ var productDetailBlockRuntime = defineProgressiveBlockRuntime({
         className: source.className,
         emptyMessage: source.emptyStateText,
         showSummary: source.showSummary !== false,
-        showBadges: source.showBadges !== false,
         addButtonText: source.addButtonText ?? "Add to cart"
       }),
       hydration: {
         products: source.products ?? [],
         productId: product?.id ?? null,
         showSummary: source.showSummary !== false,
-        showBadges: source.showBadges !== false,
         showBody: source.showBody !== false,
         addButtonText: source.addButtonText ?? "Add to cart"
       }
@@ -22311,14 +23815,6 @@ var productListManifest = createBlockManifest({
       defaultValue: true,
       ui: { intent: "display" }
     },
-    {
-      id: "showBadges",
-      type: "boolean",
-      label: "Show badges",
-      required: false,
-      defaultValue: true,
-      ui: { intent: "display" }
-    },
     {
       id: "showPrices",
       type: "boolean",
@@ -22369,7 +23865,6 @@ var productListManifest = createBlockManifest({
           layout: { $bind: { from: "content.layout", fallback: "grid" } },
           columns: { $bind: { from: "content.columns", fallback: "3" } },
           showSummary: { $bind: { from: "content.showSummary", fallback: true } },
-          showBadges: { $bind: { from: "content.showBadges", fallback: true } },
           showPrices: { $bind: { from: "content.showPrices", fallback: true } },
           addButtonText: { $bind: { from: "content.addButtonText", fallback: "Add to cart" } },
           emptyStateText: { $bind: { from: "content.emptyStateText", fallback: "No products available right now." } },
@@ -22446,14 +23941,6 @@ var productDetailManifest = createBlockManifest({
       defaultValue: true,
       ui: { intent: "display" }
     },
-    {
-      id: "showBadges",
-      type: "boolean",
-      label: "Show badges",
-      required: false,
-      defaultValue: true,
-      ui: { intent: "display" }
-    },
     {
       id: "addButtonText",
       type: "text",
@@ -22496,7 +23983,6 @@ var productDetailManifest = createBlockManifest({
           productSlug: { $bind: { from: "content.productSlug", fallback: null } },
           showSummary: { $bind: { from: "content.showSummary", fallback: true } },
           showBody: { $bind: { from: "content.showBody", fallback: true } },
-          showBadges: { $bind: { from: "content.showBadges", fallback: true } },
           addButtonText: { $bind: { from: "content.addButtonText", fallback: "Add to cart" } },
           emptyStateText: { $bind: { from: "content.emptyStateText", fallback: "Product unavailable." } },
           contentEntry: { $bind: { from: "$root.contentEntry", fallback: null } },
@@ -22946,8 +24432,7 @@ function getPresetFields(preset, options) {
         includePhone
       );
     default: {
-      const _exhaustive = preset;
-      throw new Error(`Unknown newsletter preset: ${_exhaustive}`);
+      throw new Error("Unknown newsletter preset");
     }
   }
 }
@@ -24520,9 +26005,6 @@ function getBuiltInContentTypes() {
       fields: [
         { id: "summary", type: "text", label: "Summary", required: false },
         { id: "image", type: "media", label: "Listing image", required: false },
-        { id: "tags", type: "text", label: "Tags", required: false },
-        { id: "badges", type: "text", label: "Badges", required: false },
-        { id: "ctaLabel", type: "text", label: "CTA label", required: false },
         { id: "body", type: "richText", label: "Details", required: false }
       ]
     },
@@ -24534,9 +26016,6 @@ function getBuiltInContentTypes() {
       fields: [
         { id: "summary", type: "text", label: "Summary", required: false },
         { id: "image", type: "media", label: "Listing image", required: false },
-        { id: "tags", type: "text", label: "Tags", required: false },
-        { id: "badges", type: "text", label: "Badges", required: false },
-        { id: "ctaLabel", type: "text", label: "CTA label", required: false },
         { id: "body", type: "richText", label: "Details", required: false }
       ]
     },
@@ -25310,7 +26789,7 @@ function collectValidationErrors(output) {
       errors.push({
         path: `blocks["${block.id}"].fields`,
         message: `Block "${block.id}": Fields defined but never used in layout: ${unusedTopLevelFields.join(", ")}`,
-        suggestion: `Every field should be bound to a layout node. Add $bind: { from: "content.${unusedTopLevelFields[0]}" } to an appropriate node, or remove unused fields.`
+        suggestion: `Every field should be bound to a layout node. Add $bind: { from: "content.${unusedTopLevelFields[0] ?? "fieldId"}" } to an appropriate node, or remove unused fields.`
       });
     }
     for (const [
@@ -25327,7 +26806,7 @@ function collectValidationErrors(output) {
       errors.push({
         path: `blocks["${block.id}"].fields`,
         message: `Block "${block.id}": Repeater field "${repeaterFieldId}": nested fields defined but never used in repeated layout: ${missingNested.join(", ")}`,
-        suggestion: `Inside the $repeat subtree for content.${repeaterFieldId} (itemName "${itemName}"), add nodes with $bind.from like "${itemName}.${missingNested[0]}".`
+        suggestion: `Inside the $repeat subtree for content.${repeaterFieldId} (itemName "${itemName}"), add nodes with $bind.from like "${itemName}.${missingNested[0] ?? "fieldId"}".`
       });
     }
     const missingBindings = findMissingBindings(block.layout, block.id);
@@ -25755,7 +27234,7 @@ function buildClassHookAttachSuggestions(blockId, missingClassNames, nodes) {
     }
     if ((lower.includes("headline") || lower.includes("title")) && (headlineNode ?? firstStack)) {
       lines.push(
-        `- ${className} \u2192 add to ${headlineNode ?? firstStack}.props.className`
+        `- ${className} \u2192 add to ${headlineNode ?? firstStack ?? rootPath}.props.className`
       );
       continue;
     }
@@ -25765,7 +27244,7 @@ function buildClassHookAttachSuggestions(blockId, missingClassNames, nodes) {
     }
     if ((lower.includes("body") || lower.includes("copy") || lower.includes("paragraph")) && (paragraphNode ?? firstStack)) {
       lines.push(
-        `- ${className} \u2192 add to ${paragraphNode ?? firstStack}.props.className`
+        `- ${className} \u2192 add to ${paragraphNode ?? firstStack ?? rootPath}.props.className`
       );
       continue;
     }
@@ -26099,7 +27578,7 @@ function detectPotentialTruncation(node, maxAllowedDepth, currentDepth = 0, path
   const truncatedPaths = [];
   if (currentDepth === maxAllowedDepth && n.children === null) {
     if (CONTAINER_NODE_TYPES.includes(n.type || "")) {
-      truncatedPaths.push(`${path2} (${n.type} at depth ${currentDepth})`);
+      truncatedPaths.push(`${path2} (${n.type ?? "node"} at depth ${currentDepth})`);
     }
   }
   if (n.children && Array.isArray(n.children)) {
@@ -26607,7 +28086,7 @@ var combinedPassSchema = z60.object({
 function buildSystemPrompt(availableBlocks, matchThreshold) {
   const blockCatalog = availableBlocks.map((b) => {
     const fieldsPreview = b.fieldSummary.map((f) => {
-      let desc = `  - ${f.id} (${f.type}): ${f.label}`;
+      let desc = `  - ${f.id} (${f.type}): ${f.label ?? ""}`;
       if (f.required) desc += " [REQUIRED]";
       if (f.description) desc += ` - ${f.description}`;
       return desc;
@@ -26875,7 +28354,7 @@ function getCornerRadius(corners2) {
     case "pill":
       return "9999px";
     default: {
-      console.warn(`Unknown corner style "${corners2}", defaulting to soft (4px)`);
+      console.warn("Unknown corner style, defaulting to soft (4px)");
       return "4px";
     }
   }
@@ -28071,7 +29550,7 @@ function sanitizeExtractedContent(content) {
   }
   return result;
 }
-function isRecord2(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isBoxStylesField(fieldId) {
@@ -28101,7 +29580,7 @@ function getBoxStylesFieldDocs(fieldId) {
 }
 function buildBuiltinExtractionPrompt(block) {
   const fieldList = block.fieldSummary.map((f) => {
-    let fieldDesc = `- **${f.id}** (${f.type}): ${f.label}`;
+    let fieldDesc = `- **${f.id}** (${f.type}): ${f.label ?? ""}`;
     if (f.required) fieldDesc += " [REQUIRED]";
     if (f.options) {
       fieldDesc += `
@@ -28180,7 +29659,7 @@ async function populateBuiltinBlock(sectionIndex, section2, blockInfo, ctx) {
     await ctx.debug.writeText(`pass2-builtin-${sectionIndex}-raw.txt`, rawText);
     await ctx.debug.writeJson(`pass2-builtin-${sectionIndex}-output.json`, result);
     const rawContent = result.content;
-    const sanitizedContent = isRecord2(rawContent) ? sanitizeExtractedContent(rawContent) : {};
+    const sanitizedContent = isRecord4(rawContent) ? sanitizeExtractedContent(rawContent) : {};
     return {
       success: true,
       block: {