@riverbankcms/sdk 0.60.7 → 0.60.9

package/dist/client/rendering.mjs

@@ -8788,9 +8788,9 @@ function createZodCodec(schema) {
         return decodeSuccess(parsed.data);
       }
       return decodeFailure(
-        parsed.error.issues.map((issue) => ({
-          path: zodIssuePath(issue.path),
-          message: issue.message
+        parsed.error.issues.map((issue2) => ({
+          path: zodIssuePath(issue2.path),
+          message: issue2.message
         }))
       );
     }
@@ -8822,9 +8822,9 @@ function expectEncodedRecord(value, label) {
   throw new Error(`Expected ${label} codec to encode an object`);
 }
 function prefixIssues(prefix, issues) {
-  return issues.map((issue) => ({
-    path: [...prefix, ...issue.path],
-    message: issue.message
+  return issues.map((issue2) => ({
+    path: [...prefix, ...issue2.path],
+    message: issue2.message
   }));
 }
 function defineInteractiveIslandMetaKeys(...keys) {
@@ -28877,7 +28877,7 @@ var init_DatePicker = __esm({
       dateOptions,
       required = true,
       isLoading = false,
-      isEmpty: isEmpty2 = false,
+      isEmpty = false,
       hasMore = false,
       onLoadMore
     }) => {
@@ -28891,7 +28891,7 @@ var init_DatePicker = __esm({
           /* @__PURE__ */ jsx57("p", { className: "ab-text ab-text--muted ab-text--sm", children: "Loading available dates..." })
         ] });
       }
-      if (isEmpty2) {
+      if (isEmpty) {
         return /* @__PURE__ */ jsxs40("div", { className: "ab-stack--sm", children: [
           /* @__PURE__ */ jsxs40("label", { className: "ab-label", children: [
             "Select Date",
@@ -58609,7 +58609,7 @@ var DEFAULT_REQUIRED_ERROR_MESSAGE = "This section failed to load. Please refres
 var IslandPropsDecodeError = class extends Error {
   constructor(kind, issues) {
     super(
-      `[sdk:islands] Invalid props for island kind="${kind}": ${issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
+      `[sdk:islands] Invalid props for island kind="${kind}": ${issues.map((issue2) => `${issue2.path.join(".") || "<root>"}: ${issue2.message}`).join("; ")}`
     );
     this.name = "IslandPropsDecodeError";
     this.issues = issues;
@@ -58773,380 +58773,617 @@ function hydrateBlocksIslands(options = {}) {
 // ../blocks/src/PageRenderer.tsx
 import * as React38 from "react";
 
-// ../blocks/src/system/manifest/registry.ts
-var REGISTRY_SYMBOL = /* @__PURE__ */ Symbol.for("@riverbankcms/blocks/manifest-registry");
-var isVitest = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.VITEST === "true";
-var globalScope = globalThis;
-var manifestStore = isVitest ? /* @__PURE__ */ new Map() : globalScope[REGISTRY_SYMBOL] ?? (globalScope[REGISTRY_SYMBOL] = /* @__PURE__ */ new Map());
-function registerManifest(manifest) {
-  manifestStore.set(manifest.name, manifest);
-  return manifest;
-}
-
-// ../blocks/src/system/manifest/validation.ts
-init_schema2();
+// ../blocks/src/system/manifest/fieldValidation/index.ts
 import { z as z40 } from "zod";
 
-// ../blocks/src/system/manifest/richTextSchema.ts
-init_typeGuards2();
+// ../blocks/src/system/types/link.ts
 import { z as z39 } from "zod";
-var TipTapMarkSchema = z39.object({
-  type: z39.string(),
-  attrs: z39.record(z39.string(), z39.unknown()).optional()
-});
-var TipTapNodeSchema = z39.lazy(
-  () => z39.object({
-    type: z39.string(),
-    content: z39.array(TipTapNodeSchema).optional(),
-    text: z39.string().optional(),
-    attrs: z39.record(z39.string(), z39.unknown()).optional(),
-    marks: z39.array(TipTapMarkSchema).optional()
-  })
-);
-var RichTextValueSchema = z39.union([
-  // New format: TipTap document directly
-  TipTapNodeSchema,
-  // Legacy format: wrapped in { doc: {...} }
-  z39.object({
-    doc: TipTapNodeSchema
-  })
+var nullableString = z39.union([z39.string().min(1), z39.null()]);
+var resolvedInternalLinkKeys = ["entityId", "entityType", "href", "title", "typeLabel"];
+var internalRouteOnlyLinkSchema = z39.object({
+  kind: z39.literal("internal"),
+  routeId: z39.string().min(1)
+}).passthrough().superRefine((value, ctx) => {
+  const hasResolvedMetadata = resolvedInternalLinkKeys.some((key) => value[key] != null);
+  if (!hasResolvedMetadata) return;
+  ctx.addIssue({
+    code: "custom",
+    message: "Internal links with resolved metadata must include entityId, entityType, href, title, and typeLabel"
+  });
+});
+var internalResolvedLinkSchema = z39.object({
+  kind: z39.literal("internal"),
+  routeId: z39.string().min(1),
+  entityId: z39.string().min(1),
+  entityType: z39.enum(["page", "content"]),
+  href: z39.string().min(1),
+  title: z39.string().min(1),
+  typeLabel: z39.string().min(1),
+  contentTypeKey: nullableString.optional(),
+  contentTypeName: nullableString.optional(),
+  updatedAt: nullableString.optional()
+}).passthrough();
+var internalLinkSchema = z39.union([
+  internalResolvedLinkSchema,
+  internalRouteOnlyLinkSchema
+]);
+var externalLinkSchema = z39.object({
+  kind: z39.literal("external"),
+  href: z39.string().min(1)
+}).passthrough();
+var customLinkSchema = z39.object({
+  kind: z39.literal("url"),
+  href: z39.string().min(1)
+}).passthrough();
+var pageLinkSchema = z39.object({
+  kind: z39.literal("page"),
+  identifier: z39.string().min(1)
+}).passthrough();
+var entryLinkSchema = z39.object({
+  kind: z39.literal("entry"),
+  contentType: z39.string().min(1),
+  identifier: z39.string().min(1)
+}).passthrough();
+var linkSchema = z39.union([
+  internalLinkSchema,
+  externalLinkSchema,
+  customLinkSchema,
+  pageLinkSchema,
+  entryLinkSchema
 ]);
-function buildRichTextSchema(options) {
-  let schema = RichTextValueSchema;
-  if (options?.required) {
-    const label = options.label ?? "This field";
-    schema = schema.refine(
-      (val) => {
-        const doc = isRecord2(val) && "doc" in val ? val.doc : val;
-        const content = isRecord2(doc) ? doc.content : void 0;
-        if (!Array.isArray(content) || content.length === 0) return false;
-        const first = content[0];
-        if (content.length === 1 && isRecord2(first) && first.type === "paragraph" && (!("content" in first) || first.content == null)) {
-          return false;
-        }
-        return true;
-      },
-      {
-        message: `${label} is required`
-      }
-    );
-  }
-  return schema;
-}
 
-// ../blocks/src/system/manifest/validation.ts
-function isEmpty(value) {
-  if (typeof value === "string" && value.trim() === "") return true;
-  if (value === null || value === void 0) return true;
-  if (Array.isArray(value) && value.length === 0) return true;
-  if (isEmptyRichTextDoc(value)) return true;
-  return false;
+// ../blocks/src/system/manifest/fieldValidation/index.ts
+init_schema2();
+var TEL_RE = /^[+()0-9\s-]{3,}$/;
+var SLUG_PATTERN = /^(?:[a-z0-9]+(?:-[a-z0-9]+)*)(?:\/(?:[a-z0-9]+(?:-[a-z0-9]+)*))*$/;
+var ALLOWED_URL_PROTOCOLS = ["http:", "https:"];
+function assertNever6(value) {
+  throw new Error(`Unhandled field validation variant: ${JSON.stringify(value)}`);
 }
-function isEmptyRichTextDoc(value) {
-  if (!value || typeof value !== "object") return false;
-  const obj = value;
-  const doc = "doc" in obj ? obj.doc : obj;
-  if (!doc || typeof doc !== "object") return false;
-  const docObj = doc;
-  if (docObj.type !== "doc") return false;
-  const content = docObj.content;
-  if (!Array.isArray(content) || content.length === 0) return true;
-  if (content.length === 1) {
-    const first = content[0];
-    if (first.type === "paragraph" && (!first.content || first.content.length === 0)) {
-      return true;
-    }
-  }
-  return false;
+function validationContext(options = {}) {
+  const isDraft = options.mode === "draft";
+  return {
+    allowNull: options.allowNull ?? true,
+    allowIncomplete: isDraft || (options.allowIncomplete ?? false)
+  };
 }
-function preprocessEmptyValues(content) {
-  if (!content || typeof content !== "object" || Array.isArray(content)) {
-    return {};
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(content)) {
-    result[key] = isEmpty(value) ? void 0 : value;
+function fieldIssueToMessage(issue2) {
+  switch (issue2.kind) {
+    case "required":
+      return "This field is required";
+    case "wrongType":
+      return `${issue2.label} needs ${issue2.expected}`;
+    case "tooLong":
+      return `Use ${issue2.maximum} characters or fewer`;
+    case "invalidEmail":
+      return "Enter a valid email address";
+    case "invalidPhone":
+      return "Enter a valid phone number";
+    case "invalidPattern":
+      return "Check the format and try again";
+    case "invalidUrl":
+      return "Enter a valid web address";
+    case "invalidNumber":
+      return `${issue2.label} needs a number`;
+    case "tooSmall":
+      return `${issue2.label} must be ${issue2.minimum} or more`;
+    case "tooLarge":
+      return `${issue2.label} must be ${issue2.maximum} or less`;
+    case "invalidSlug":
+      return `${issue2.label} can only use lowercase letters, numbers, and dashes`;
+    case "invalidOption":
+      return `Choose one of the available options for ${issue2.label}`;
+    case "tooFewItems":
+      return `${issue2.label} must have at least ${issue2.minimum} ${pluralize(issue2.itemLabel, issue2.minimum)}`;
+    case "tooManyItems":
+      return `${issue2.label} must have at most ${issue2.maximum} ${pluralize(issue2.itemLabel, issue2.maximum)}`;
+    case "invalidRichText":
+      return `${issue2.label} must be valid rich text`;
+    case "invalidMedia":
+      return `${issue2.label} must be a valid media item`;
+    case "invalidLink":
+      return `${issue2.label} must be a valid link`;
+    case "invalidReference":
+      return `${issue2.label} must reference a valid item`;
+    default:
+      return assertNever6(issue2);
   }
-  return result;
 }
-function createManifestValidator(manifestOrFields, options = {}) {
-  const allowNull = options.allowNull ?? true;
-  const isDraft = options.mode === "draft";
-  const allowIncomplete = isDraft || (options.allowIncomplete ?? false);
-  const shape = {};
-  const fields3 = Array.isArray(manifestOrFields) ? manifestOrFields : manifestOrFields.fields ?? [];
-  for (const field of fields3) {
-    shape[field.id] = buildFieldSchema(field, allowNull, allowIncomplete);
-  }
-  const baseSchema = z40.object(shape).catchall(z40.unknown()).passthrough();
-  if (isDraft) {
-    return z40.preprocess(preprocessEmptyValues, baseSchema);
-  }
-  return baseSchema;
+function pluralize(label, count) {
+  if (count === 1) return label;
+  return label.endsWith("s") ? label : `${label}s`;
 }
-function buildFieldSchema(field, allowNull, allowIncomplete = false) {
+function deriveFieldValidationPlan(field, path = [field.id]) {
   const required = Boolean(field.required);
-  let schema;
   switch (field.type) {
-    case "text":
-      schema = buildTextSchema(field);
-      break;
-    case "richText":
-      schema = buildRichTextSchema2();
-      break;
-    case "media": {
-      const baseMediaSchema = z40.record(z40.string(), z40.unknown());
-      const isRequired = Boolean(field.required);
-      schema = isRequired ? baseMediaSchema : baseMediaSchema.nullable();
-      break;
+    case "text": {
+      const inputType = field.ui?.inputType;
+      if (inputType === "number") {
+        const constraints2 = commonConstraints(required, { kind: "numberType" });
+        if (typeof field.ui?.min === "number") constraints2.push({ kind: "numberMin", minimum: field.ui.min });
+        if (typeof field.ui?.max === "number") constraints2.push({ kind: "numberMax", maximum: field.ui.max });
+        return makePlan("number", "number", field, path, required, constraints2);
+      }
+      const constraints = commonConstraints(required, { kind: "textType" });
+      if (inputType === "email") constraints.push({ kind: "emailFormat" });
+      if (inputType === "tel") constraints.push({ kind: "phoneFormat" });
+      if (field.ui?.pattern) constraints.push({ kind: "patternFormat", pattern: field.ui.pattern });
+      if (typeof field.maxLength === "number") constraints.push({ kind: "maxLength", maximum: field.maxLength });
+      return makePlan("string", "string", field, path, required, constraints);
+    }
+    case "number": {
+      const constraints = commonConstraints(required, { kind: "numberType" });
+      if (typeof field.min === "number") constraints.push({ kind: "numberMin", minimum: field.min });
+      if (typeof field.max === "number") constraints.push({ kind: "numberMax", maximum: field.max });
+      return makePlan("number", "number", field, path, required, constraints);
+    }
+    case "slug": {
+      const constraints = commonConstraints(required, { kind: "textType" }, { kind: "slugFormat" });
+      if (typeof field.maxLength === "number") constraints.push({ kind: "maxLength", maximum: field.maxLength });
+      return makePlan("string", "string", field, path, required, constraints);
     }
-    case "boolean":
-      schema = z40.boolean();
-      break;
-    case "slug":
-      schema = buildSlugSchema(field);
-      break;
     case "url":
-      schema = buildUrlSchema(field);
-      break;
-    case "link":
-      schema = buildLinkSchema();
-      break;
-    case "select":
-      schema = buildSelectSchema(field);
-      break;
+      return makePlan("string", "string", field, path, required, commonConstraints(
+        required,
+        { kind: "textType" },
+        { kind: "urlFormat", allowRelative: Boolean(field.allowRelative) }
+      ));
     case "reference":
-      schema = buildReferenceSchema(field);
-      break;
+      return makePlan("string", "string", field, path, required, commonConstraints(required, { kind: "referenceText" }));
+    case "date":
+    case "time":
+    case "datetime":
+      return makePlan("string", "string", field, path, required, commonConstraints(required, { kind: "textType" }));
+    case "select":
+      return makePlan("select", "select", field, path, required, commonConstraints(required, {
+        kind: "selectOption",
+        source: resolveSelectConstraintSource(field),
+        multiple: Boolean(field.multiple)
+      }));
+    case "richText":
+      return makePlan("richText", "object", field, path, required, commonConstraints(required, { kind: "richTextDoc" }));
+    case "media":
+      return makePlan("media", "object", field, path, required, commonConstraints(required, { kind: "mediaObject" }));
+    case "link":
+      return makePlan("link", "object", field, path, required, commonConstraints(required, { kind: "linkObject" }));
+    case "boolean":
+      return makePlan("boolean", "boolean", field, path, required, requiredConstraints(required));
     case "repeater":
-      schema = buildRepeaterSchema(field, allowNull, allowIncomplete);
-      break;
+      return {
+        ...makePlan("repeater", "array", field, path, required, commonConstraints(required, { kind: "arrayType" })),
+        ...field.polymorphic && field.itemTypes ? { repeatedItemVariants: deriveRepeatedItemVariants(field, [...path, 0]) } : { repeatedItemPlan: deriveNestedFieldPlans(getRepeaterFields(field), [...path, 0]) },
+        constraints: withRepeaterItemConstraints(field, commonConstraints(required, { kind: "arrayType" }))
+      };
     case "group":
-      schema = buildGroupSchema(field, allowNull, allowIncomplete);
-      break;
+    case "modal":
+      return {
+        ...makePlan("group", "object", field, path, required, requiredConstraints(required)),
+        children: deriveNestedFieldPlans(field.schema?.fields ?? [], path),
+        allowNullChildren: field.type === "group" && field.ui?.widget === "locationPicker"
+      };
+    case "tabGroup":
+      return {
+        ...makePlan("group", "object", field, path, required, requiredConstraints(required)),
+        children: field.tabs.flatMap((tab) => deriveNestedFieldPlans(tab.fields, path))
+      };
+    case "presetOrCustom":
+    case "contentTypeSelect":
+    case "entryPicker":
+      return makePlan("passthrough", "unknown", field, path, false, []);
     default:
-      schema = z40.unknown();
-      break;
+      return assertNever6(field);
   }
-  return finalizeSchema(schema, required, allowNull, allowIncomplete);
 }
-function buildFriendlyStringSchema(field) {
-  return z40.string({
-    error: (issue) => issue.input === void 0 || issue.input === null ? "This field is required" : `${field.label} needs text`
-  });
+function commonConstraints(required, ...specific) {
+  return required ? [{ kind: "required" }, ...specific] : [...specific];
 }
-function buildTextSchema(field) {
-  const ui = field.ui ?? {};
-  const inputType = ui?.inputType;
-  let schema;
-  if (inputType === "number") {
-    schema = z40.coerce.number({
-      error: (issue) => issue.input === void 0 ? `${field.label} is required` : `${field.label} needs a number`
-    });
-    if (typeof ui?.min === "number") {
-      schema = schema.min(
-        ui.min,
-        `${field.label} must be ${ui.min} or more`
-      );
-    }
-    if (typeof ui?.max === "number") {
-      schema = schema.max(
-        ui.max,
-        `${field.label} must be ${ui.max} or less`
-      );
-    }
-  } else {
-    schema = buildFriendlyStringSchema(field);
-    if (inputType === "email") {
-      schema = schema.email("Enter a valid email address");
-    }
-    if (inputType === "tel") {
-      const TEL_RE = /^[+()0-9\s\-]{3,}$/;
-      schema = schema.regex(
-        TEL_RE,
-        "Enter a valid phone number"
-      );
-    }
-    if (ui?.pattern) {
-      try {
-        const re = new RegExp(ui.pattern);
-        schema = schema.regex(
-          re,
-          `${field.label} is not in the right format`
-        );
-      } catch {
-      }
-    }
-    if (field.maxLength) {
-      schema = schema.max(
-        field.maxLength,
-        `${field.label} must be ${field.maxLength} characters or less`
-      );
-    }
-    if (field.required) {
-      schema = schema.min(1, { message: `${field.label} is required` }).refine((v) => v.trim().length > 0, { message: `${field.label} is required` });
+function requiredConstraints(required) {
+  return required ? [{ kind: "required" }] : [];
+}
+function makePlan(kind, valueKind, field, path, required, constraints) {
+  return {
+    kind,
+    valueKind,
+    fieldId: field.id,
+    label: field.label,
+    fieldType: field.type,
+    path,
+    required,
+    constraints
+  };
+}
+function withRepeaterItemConstraints(field, constraints) {
+  const next = [...constraints];
+  if (typeof field.minItems === "number") next.push({ kind: "minItems", minimum: field.minItems });
+  if (typeof field.maxItems === "number") next.push({ kind: "maxItems", maximum: field.maxItems });
+  return next;
+}
+function deriveRepeatedItemVariants(field, parentPath) {
+  return Object.entries(field.itemTypes ?? {}).map(([typeId, itemType]) => ({
+    typeId,
+    fields: deriveNestedFieldPlans(getFlattenedRepeaterFields(itemType.fields), parentPath)
+  }));
+}
+function deriveNestedFieldPlans(fields3, parentPath) {
+  return fields3.map((field) => deriveFieldValidationPlan(field, [...parentPath, field.id]));
+}
+function getRepeaterFields(field) {
+  const fields3 = field.polymorphic && field.itemTypes ? Object.values(field.itemTypes).flatMap((itemType) => itemType.fields) : field.schema?.fields ?? [];
+  return getFlattenedRepeaterFields(fields3);
+}
+function getFlattenedRepeaterFields(fields3) {
+  return fields3.flatMap((child) => {
+    if (child.type === "group" && child.ui?.flattenInRepeater) {
+      return child.schema?.fields ?? [];
     }
+    return child;
+  });
+}
+function resolveSelectConstraintSource(field) {
+  const source = normalizeSelectSource(field);
+  switch (source.kind) {
+    case "static":
+      return { kind: "static", values: field.options.map((option) => option.value) };
+    case "site":
+    case "sdk":
+      return { kind: "runtime", source: source.kind };
+    default:
+      return assertNever6(source);
+  }
+}
+function normalizeFieldValue(plan, value, ctx) {
+  switch (plan.kind) {
+    case "number":
+      return normalizeNumberInput(value, ctx.allowNull);
+    case "string":
+      return acceptsOptionalBlankAsMissing(plan, value) ? void 0 : value;
+    case "group":
+      return normalizeObjectChildren(plan.children, value, childValidationContext(plan, ctx));
+    case "repeater":
+      return normalizeRepeaterItems(plan, value, ctx);
+    case "boolean":
+    case "richText":
+    case "media":
+    case "link":
+    case "select":
+    case "passthrough":
+      return value;
+    default:
+      return assertNever6(plan);
   }
-  return schema;
 }
-function buildRichTextSchema2() {
-  return buildRichTextSchema();
+function normalizeObjectChildren(children, value, ctx) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const normalized = { ...value };
+  for (const child of children) {
+    normalized[child.fieldId] = normalizeFieldValue(child, normalized[child.fieldId], ctx);
+  }
+  return normalized;
 }
-var SLUG_PATTERN = /^(?:[a-z0-9]+(?:-[a-z0-9]+)*)(?:\/(?:[a-z0-9]+(?:-[a-z0-9]+)*))*$/;
-function buildSlugSchema(field) {
-  const message = `${field.label} can only use lowercase letters, numbers, and dashes`;
-  let schema = buildFriendlyStringSchema(field).regex(SLUG_PATTERN, message);
-  if (field.maxLength) {
-    schema = schema.max(
-      field.maxLength,
-      `${field.label} must be ${field.maxLength} characters or less`
-    );
+function normalizeRepeaterItems(plan, value, ctx) {
+  if (!Array.isArray(value)) return value;
+  return value.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+    const itemRecord = item;
+    const fields3 = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === itemRecord._type)?.fields : plan.repeatedItemPlan;
+    if (!fields3) return item;
+    return normalizeObjectChildren(fields3, itemRecord, ctx);
+  });
+}
+function normalizeNumberInput(value, allowNull) {
+  if (value === "") return void 0;
+  if (typeof value === "string" && value.trim() !== "") return Number(value);
+  return value;
+}
+function acceptsOptionalBlankAsMissing(plan, value) {
+  if (plan.required || typeof value !== "string" || value.trim() !== "") return false;
+  return plan.constraints.some(
+    (constraint) => constraint.kind === "urlFormat" || constraint.kind === "slugFormat" || constraint.kind === "emailFormat" || constraint.kind === "phoneFormat" || constraint.kind === "patternFormat"
+  );
+}
+function validateNormalizedFieldValue(plan, value, ctx) {
+  if (value === null && (ctx.allowNull || acceptsOptionalNullValue(plan))) return [];
+  if (isMissingForPlan(plan, value)) {
+    return shouldRequireValue(plan, value, ctx) ? [requiredIssue(plan, value)] : [];
   }
-  if (field.required) {
-    schema = schema.min(1, { message: `${field.label} is required` });
+  switch (plan.kind) {
+    case "string":
+      return validateStringPlan(plan, value);
+    case "number":
+      return validateNumberPlan(plan, value);
+    case "boolean":
+      return typeof value === "boolean" ? [] : [issue(plan, "wrongType", { expected: "a true/false value" })];
+    case "select":
+      return validateSelectPlan(plan, value);
+    case "richText":
+      return isValidRichTextDoc(value) ? [] : [issue(plan, "invalidRichText")];
+    case "media":
+      return isPlainObject2(value) ? [] : [issue(plan, "invalidMedia")];
+    case "link":
+      return linkSchema.safeParse(value).success ? [] : [issue(plan, "invalidLink")];
+    case "repeater":
+      return validateRepeaterPlan(plan, value, ctx);
+    case "group":
+      return validateGroupPlan(plan, value, ctx);
+    case "passthrough":
+      return [];
+    default:
+      return assertNever6(plan);
   }
-  return schema;
 }
-var ALLOWED_URL_PROTOCOLS = ["http:", "https:"];
-function buildUrlSchema(field) {
-  const message = "Enter a valid web address";
-  const validate = (value) => {
-    if (!value) {
-      return !field.required;
-    }
-    if (field.allowRelative && value.startsWith("/")) {
-      return true;
-    }
-    try {
-      const parsed = new URL(value);
-      return ALLOWED_URL_PROTOCOLS.includes(
-        parsed.protocol
-      );
-    } catch {
-      return false;
-    }
-  };
-  let schema = buildFriendlyStringSchema(field).trim().refine(validate, message);
-  if (field.required) {
-    schema = schema.min(1, { message: `${field.label} is required` });
+function shouldRequireValue(plan, value, ctx) {
+  if (!plan.required || ctx.allowIncomplete) return false;
+  if (value === null && ctx.allowNull) return false;
+  return true;
+}
+function acceptsOptionalNullValue(plan) {
+  return !plan.required && (plan.kind === "media" || plan.kind === "number");
+}
+function isMissingForPlan(plan, value) {
+  if (value === void 0) return true;
+  if (value === null) return plan.required;
+  if (typeof value === "string" && value.trim() === "") return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  return false;
+}
+function validateStringPlan(plan, value) {
+  if (typeof value !== "string") return [issue(plan, "wrongType", { expected: "text" })];
+  return plan.constraints.flatMap((constraint) => validateStringConstraint(plan, constraint, value));
+}
+function validateStringConstraint(plan, constraint, value) {
+  switch (constraint.kind) {
+    case "required":
+    case "textType":
+    case "referenceText":
+      return [];
+    case "maxLength":
+      return value.length > constraint.maximum ? [issue(plan, "tooLong", { maximum: constraint.maximum })] : [];
+    case "emailFormat":
+      return z40.email().safeParse(value).success ? [] : [issue(plan, "invalidEmail")];
+    case "phoneFormat":
+      return TEL_RE.test(value) ? [] : [issue(plan, "invalidPhone")];
+    case "patternFormat": {
+      const re = compilePattern(constraint.pattern);
+      return re && !re.test(value) ? [issue(plan, "invalidPattern")] : [];
+    }
+    case "urlFormat":
+      return isValidUrl(value, constraint.allowRelative) ? [] : [issue(plan, "invalidUrl")];
+    case "slugFormat":
+      return SLUG_PATTERN.test(value) ? [] : [issue(plan, "invalidSlug")];
+    default:
+      return assertNever6(constraint);
   }
-  return schema;
 }
-var nullableString = z40.union([z40.string().min(1), z40.null()]);
-var internalLinkSchema = z40.object({
-  kind: z40.literal("internal"),
-  routeId: z40.string().min(1),
-  entityId: z40.string().min(1).optional(),
-  entityType: z40.enum(["page", "content"]).optional(),
-  href: nullableString.optional(),
-  title: nullableString.optional(),
-  typeLabel: nullableString.optional(),
-  contentTypeKey: nullableString.optional(),
-  contentTypeName: nullableString.optional(),
-  updatedAt: nullableString.optional()
-}).passthrough();
-var externalLinkSchema = z40.object({
-  kind: z40.literal("external"),
-  href: z40.string().min(1)
-}).passthrough();
-var customLinkSchema = z40.object({
-  kind: z40.literal("url"),
-  href: z40.string().min(1)
-}).passthrough();
-var pageLinkSchema = z40.object({
-  kind: z40.literal("page"),
-  identifier: z40.string().min(1)
-}).passthrough();
-var entryLinkSchema = z40.object({
-  kind: z40.literal("entry"),
-  contentType: z40.string().min(1),
-  identifier: z40.string().min(1)
-}).passthrough();
-var linkSchema = z40.union([
-  internalLinkSchema,
-  externalLinkSchema,
-  customLinkSchema,
-  pageLinkSchema,
-  entryLinkSchema
-]);
-function buildLinkSchema() {
-  return linkSchema;
+function validateNumberPlan(plan, value) {
+  if (!isValidNumber(value)) return [issue(plan, "invalidNumber")];
+  return plan.constraints.flatMap((constraint) => validateNumberConstraint(plan, constraint, Number(value)));
 }
-function assertNeverSelectSource2(value) {
-  throw new Error(`Unhandled select source: ${JSON.stringify(value)}`);
+function validateNumberConstraint(plan, constraint, value) {
+  switch (constraint.kind) {
+    case "required":
+    case "numberType":
+      return [];
+    case "numberMin":
+      return value < constraint.minimum ? [issue(plan, "tooSmall", { minimum: constraint.minimum })] : [];
+    case "numberMax":
+      return value > constraint.maximum ? [issue(plan, "tooLarge", { maximum: constraint.maximum })] : [];
+    default:
+      return assertNever6(constraint);
+  }
 }
-function buildSelectSchema(field) {
-  const source = normalizeSelectSource(field);
-  const singleValueSchema = (() => {
-    switch (source.kind) {
-      case "sdk":
-      case "site":
-        return buildFriendlyStringSchema(field);
-      case "static": {
-        const values = field.options.map((option) => option.value);
-        return buildFriendlyStringSchema(field).refine(
-          (value) => values.includes(value),
-          `Choose one of the available options for ${field.label}`
-        );
-      }
+function validateSelectPlan(plan, value) {
+  const constraint = plan.constraints.find((candidate) => candidate.kind === "selectOption");
+  if (!constraint || constraint.source.kind === "runtime") return [];
+  return isValidSelectValue(value, constraint.source.values, constraint.multiple) ? [] : [issue(plan, "invalidOption")];
+}
+function validateRepeaterPlan(plan, value, ctx) {
+  if (!Array.isArray(value)) return [issue(plan, "wrongType", { expected: "a list" })];
+  const constraintIssues = plan.constraints.flatMap((constraint) => {
+    switch (constraint.kind) {
+      case "required":
+      case "arrayType":
+        return [];
+      case "minItems":
+        return value.length < constraint.minimum ? [issue(plan, "tooFewItems", { minimum: constraint.minimum, itemLabel: "item" })] : [];
+      case "maxItems":
+        return value.length > constraint.maximum ? [issue(plan, "tooManyItems", { maximum: constraint.maximum, itemLabel: "item" })] : [];
       default:
-        return assertNeverSelectSource2(source);
+        return assertNever6(constraint);
     }
-  })();
-  if (field.multiple) {
-    const arraySchema = z40.array(singleValueSchema);
-    return field.required ? arraySchema.min(1, { message: "This field is required" }) : arraySchema.nullable();
-  }
-  return field.required ? singleValueSchema : singleValueSchema.nullable();
+  });
+  return [
+    ...constraintIssues,
+    ...value.flatMap((item, index) => validateRepeaterItem(plan, item, index, ctx))
+  ];
 }
-function buildReferenceSchema(field) {
-  let schema = z40.string({
-    error: (issue) => issue.input === void 0 || issue.input === null ? "This field is required" : `${field.label} needs text`
+function validateRepeaterItem(plan, item, index, ctx) {
+  if (!isPlainObject2(item)) return [];
+  const itemType = item._type;
+  const fields3 = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === itemType)?.fields : plan.repeatedItemPlan;
+  if (!fields3) return [];
+  return fields3.flatMap((childPlan) => {
+    const indexedPlan = withIndexedPath(childPlan, plan.path, index);
+    return validateNormalizedFieldValue(indexedPlan, item[childPlan.fieldId], ctx);
   });
-  if (field.required) {
-    schema = schema.min(1, { message: `${field.label} is required` });
-  }
-  return schema;
 }
-function buildRepeaterSchema(field, allowNull, allowIncomplete) {
-  const parsed = fieldSchema.array().parse(field.schema?.fields ?? []);
-  const childShape = {};
-  for (const child of parsed) {
-    if (child.type === "group" && child.ui?.flattenInRepeater) {
-      const groupParsed = fieldSchema.array().parse(child.schema?.fields ?? []);
-      for (const gc of groupParsed) {
-        childShape[gc.id] = buildFieldSchema(gc, allowNull, allowIncomplete);
-      }
-    } else {
-      childShape[child.id] = buildFieldSchema(child, allowNull, allowIncomplete);
+function validateGroupPlan(plan, value, ctx) {
+  if (!isPlainObject2(value)) return [issue(plan, "wrongType", { expected: "an object" })];
+  const childCtx = childValidationContext(plan, ctx);
+  return plan.children.flatMap((childPlan) => validateNormalizedFieldValue(childPlan, value[childPlan.fieldId], childCtx));
+}
+function childValidationContext(plan, ctx) {
+  return plan.allowNullChildren ? { ...ctx, allowNull: true } : ctx;
+}
+function withIndexedPath(plan, parentPath, index) {
+  const suffix = plan.path.slice(parentPath.length + 1);
+  return {
+    ...plan,
+    path: [...parentPath, index, plan.fieldId, ...suffix]
+  };
+}
+function issue(plan, kind, extra) {
+  return {
+    kind,
+    path: plan.path,
+    fieldId: plan.fieldId,
+    label: plan.label,
+    ...extra ?? {}
+  };
+}
+function requiredIssue(plan, value) {
+  if (typeof value === "string") return issue(plan, "required", { emptyOrigin: "string" });
+  if (Array.isArray(value)) return issue(plan, "required", { emptyOrigin: "array" });
+  return issue(plan, "required");
+}
+function fieldPlanToZod(plan, options = {}) {
+  const ctx = validationContext(options);
+  return z40.any().transform((value) => normalizeFieldValue(plan, value, ctx)).superRefine((value, zodCtx) => {
+    for (const validationIssue of validateNormalizedFieldValue(plan, value, ctx)) {
+      addFieldIssueToZodContext(zodCtx, validationIssue);
     }
+  });
+}
+function addFieldIssueToZodContext(zodCtx, validationIssue) {
+  const message = fieldIssueToMessage(validationIssue);
+  switch (validationIssue.kind) {
+    case "required":
+      if (validationIssue.emptyOrigin) {
+        zodCtx.addIssue({
+          code: "too_small",
+          origin: validationIssue.emptyOrigin,
+          minimum: 1,
+          inclusive: true,
+          message
+        });
+        return;
+      }
+      zodCtx.addIssue({ code: "invalid_type", expected: "nonoptional", message });
+      return;
+    case "tooLong":
+      zodCtx.addIssue({
+        code: "too_big",
+        origin: "string",
+        maximum: validationIssue.maximum,
+        inclusive: true,
+        message
+      });
+      return;
+    case "invalidOption":
+      zodCtx.addIssue({ code: "invalid_value", values: [], message });
+      return;
+    case "wrongType":
+    case "invalidEmail":
+    case "invalidPhone":
+    case "invalidPattern":
+    case "invalidUrl":
+    case "invalidNumber":
+    case "tooSmall":
+    case "tooLarge":
+    case "invalidSlug":
+    case "tooFewItems":
+    case "tooManyItems":
+    case "invalidRichText":
+    case "invalidMedia":
+    case "invalidLink":
+    case "invalidReference":
+      zodCtx.addIssue({ code: "custom", message });
+      return;
+    default:
+      assertNever6(validationIssue);
   }
-  let schema = z40.object(childShape).catchall(z40.unknown()).passthrough();
-  let arraySchema = z40.array(schema);
-  if (typeof field.minItems === "number") {
-    arraySchema = arraySchema.min(field.minItems);
+}
+function compilePattern(pattern) {
+  try {
+    return new RegExp(pattern);
+  } catch {
+    return null;
   }
-  if (typeof field.maxItems === "number") {
-    arraySchema = arraySchema.max(field.maxItems);
+}
+function isValidNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isValidUrl(value, allowRelative) {
+  if (!value) return false;
+  if (allowRelative && value.startsWith("/")) return true;
+  try {
+    const parsed = new URL(value);
+    return ALLOWED_URL_PROTOCOLS.includes(parsed.protocol);
+  } catch {
+    return false;
   }
-  return arraySchema;
 }
-function buildGroupSchema(field, allowNull, allowIncomplete) {
-  const parsed = fieldSchema.array().parse(field.schema?.fields ?? []);
-  const childShape = {};
-  for (const child of parsed) {
-    childShape[child.id] = buildFieldSchema(child, allowNull, allowIncomplete);
+function isValidSelectValue(value, values, multiple) {
+  if (multiple) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string" && values.includes(item));
   }
-  return z40.object(childShape).catchall(z40.unknown()).passthrough();
+  return typeof value === "string" && values.includes(value);
 }
-function finalizeSchema(schema, required, allowNull, allowIncomplete = false) {
-  if (required) {
-    if (allowIncomplete) {
-      return allowNull ? schema.or(z40.null()).optional() : schema.optional();
-    }
-    return allowNull ? schema.or(z40.null()) : schema;
+function isEmptyValue(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string" && value.trim() === "") return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  if (isEmptyRichTextDoc(value)) return true;
+  return false;
+}
+function isPlainObject2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isValidRichTextDoc(value) {
+  const doc = richTextDoc(value);
+  return Boolean(isPlainObject2(doc) && doc.type === "doc");
+}
+function isEmptyRichTextDoc(value) {
+  const doc = richTextDoc(value);
+  if (!isPlainObject2(doc)) return false;
+  if (doc.type !== "doc") return false;
+  const content = doc.content;
+  if (!Array.isArray(content) || content.length === 0) return true;
+  if (content.length !== 1) return false;
+  const first = content[0];
+  return first?.type === "paragraph" && (!Array.isArray(first.content) || first.content.length === 0);
+}
+function richTextDoc(value) {
+  if (!isPlainObject2(value)) return value;
+  return isPlainObject2(value.doc) ? value.doc : value;
+}
+
+// ../blocks/src/system/manifest/registry.ts
+var REGISTRY_SYMBOL = /* @__PURE__ */ Symbol.for("@riverbankcms/blocks/manifest-registry");
+var isVitest = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.VITEST === "true";
+var globalScope = globalThis;
+var manifestStore = isVitest ? /* @__PURE__ */ new Map() : globalScope[REGISTRY_SYMBOL] ?? (globalScope[REGISTRY_SYMBOL] = /* @__PURE__ */ new Map());
+function registerManifest(manifest) {
+  manifestStore.set(manifest.name, manifest);
+  return manifest;
+}
+
+// ../blocks/src/system/manifest/validation.ts
+import { z as z41 } from "zod";
+function preprocessEmptyValues(content) {
+  if (!content || typeof content !== "object" || Array.isArray(content)) {
+    return {};
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(content)) {
+    result[key] = isEmptyValue(value) ? void 0 : value;
+  }
+  return result;
+}
+function createManifestValidator(manifestOrFields, options = {}) {
+  const isDraft = options.mode === "draft";
+  const shape = {};
+  const fields3 = Array.isArray(manifestOrFields) ? manifestOrFields : manifestOrFields.fields ?? [];
+  for (const field of fields3) {
+    shape[field.id] = buildFieldSchema(field, options);
+  }
+  const baseSchema = z41.object(shape).catchall(z41.unknown()).passthrough();
+  if (isDraft) {
+    return z41.preprocess(preprocessEmptyValues, baseSchema);
   }
-  return allowNull ? schema.optional().nullable() : schema.optional();
+  return baseSchema;
+}
+function buildFieldSchema(field, options) {
+  return fieldPlanToZod(deriveFieldValidationPlan(field), options);
 }
 
 // ../blocks/src/system/manifest/variantKey.ts
@@ -59484,51 +59721,51 @@ init_personalities();
 
 // ../theme-core/src/palette/variants/types.ts
 init_styleTags();
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 
 // ../theme-core/src/schema.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 
 // ../theme-core/src/lib/media.ts
-import z41 from "zod";
-var hotspotSchema2 = z41.object({
-  x: z41.number().min(0).max(1),
-  y: z41.number().min(0).max(1),
-  radius: z41.number().optional()
-});
-var rotationSchema2 = z41.union([z41.literal(0), z41.literal(90), z41.literal(180), z41.literal(270)]);
-var rectSchema2 = z41.tuple([z41.number(), z41.number(), z41.number(), z41.number()]);
-var aspectCropSchema2 = z41.object({
-  aspect: z41.preprocess((value) => value == null ? void 0 : value, z41.string().optional()),
-  rect: z41.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
-  hotspot: z41.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
-  rotation: z41.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
-});
-var transformSchema2 = z41.object({
-  aspectCrops: z41.preprocess((value) => {
+import z42 from "zod";
+var hotspotSchema2 = z42.object({
+  x: z42.number().min(0).max(1),
+  y: z42.number().min(0).max(1),
+  radius: z42.number().optional()
+});
+var rotationSchema2 = z42.union([z42.literal(0), z42.literal(90), z42.literal(180), z42.literal(270)]);
+var rectSchema2 = z42.tuple([z42.number(), z42.number(), z42.number(), z42.number()]);
+var aspectCropSchema2 = z42.object({
+  aspect: z42.preprocess((value) => value == null ? void 0 : value, z42.string().optional()),
+  rect: z42.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
+  hotspot: z42.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
+  rotation: z42.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
+});
+var transformSchema2 = z42.object({
+  aspectCrops: z42.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       return void 0;
     }
     return value;
-  }, z41.record(z41.string(), aspectCropSchema2.catch({}))).optional(),
+  }, z42.record(z42.string(), aspectCropSchema2.catch({}))).optional(),
   rect: rectSchema2.optional(),
   hotspot: hotspotSchema2.optional(),
   rotation: rotationSchema2.optional()
 });
-var mediaSchema2 = z41.object({
-  type: z41.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
-  purpose: z41.string().optional(),
-  placeholder: z41.boolean().default(true).optional(),
-  assetId: z41.string().optional(),
-  identifier: z41.string().optional(),
-  src: z41.string().optional(),
-  alt: z41.string().optional(),
-  filename: z41.string().optional(),
-  mimeType: z41.string().optional(),
-  width: z41.number().optional(),
-  height: z41.number().optional(),
-  storageBucket: z41.string().optional(),
-  storagePath: z41.string().optional(),
+var mediaSchema2 = z42.object({
+  type: z42.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
+  purpose: z42.string().optional(),
+  placeholder: z42.boolean().default(true).optional(),
+  assetId: z42.string().optional(),
+  identifier: z42.string().optional(),
+  src: z42.string().optional(),
+  alt: z42.string().optional(),
+  filename: z42.string().optional(),
+  mimeType: z42.string().optional(),
+  width: z42.number().optional(),
+  height: z42.number().optional(),
+  storageBucket: z42.string().optional(),
+  storagePath: z42.string().optional(),
   transform: transformSchema2.optional()
 });
 
@@ -59536,43 +59773,43 @@ var mediaSchema2 = z41.object({
 init_buttons();
 
 // ../theme-core/src/cards/types.ts
-import { z as z42 } from "zod";
-var cardSpacingSchema = z42.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
-var gradientDirectionSchema2 = z42.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
-var cardBackgroundSchema = z42.discriminatedUnion("type", [
-  z42.object({ type: z42.literal("solid"), colorToken: z42.string() }),
-  z42.object({
-    type: z42.literal("gradient"),
-    fromToken: z42.string(),
-    toToken: z42.string(),
+import { z as z43 } from "zod";
+var cardSpacingSchema = z43.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
+var gradientDirectionSchema2 = z43.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
+var cardBackgroundSchema = z43.discriminatedUnion("type", [
+  z43.object({ type: z43.literal("solid"), colorToken: z43.string() }),
+  z43.object({
+    type: z43.literal("gradient"),
+    fromToken: z43.string(),
+    toToken: z43.string(),
     direction: gradientDirectionSchema2
   }),
-  z42.object({ type: z42.literal("transparent") })
+  z43.object({ type: z43.literal("transparent") })
 ]);
-var cardBorderSchema = z42.object({
-  widthClass: z42.string(),
-  colorToken: z42.string()
-});
-var cardVariantSchema2 = z42.object({
-  id: z42.string(),
-  name: z42.string().min(1).max(20),
-  enabled: z42.boolean(),
-  priority: z42.union([z42.literal(1), z42.literal(2), z42.literal(3)]),
+var cardBorderSchema = z43.object({
+  widthClass: z43.string(),
+  colorToken: z43.string()
+});
+var cardVariantSchema2 = z43.object({
+  id: z43.string(),
+  name: z43.string().min(1).max(20),
+  enabled: z43.boolean(),
+  priority: z43.union([z43.literal(1), z43.literal(2), z43.literal(3)]),
   // Appearance (token-based)
   background: cardBackgroundSchema,
   spacing: cardSpacingSchema,
   // Optional overrides (uses theme defaults if not specified)
-  shadow: z42.object({
-    elevation: z42.enum(["none", "low", "medium", "high"]),
-    softness: z42.enum(["crisp", "soft", "hard"]).nullable(),
-    position: z42.enum(["bottom", "bottom-right"]).default("bottom")
+  shadow: z43.object({
+    elevation: z43.enum(["none", "low", "medium", "high"]),
+    softness: z43.enum(["crisp", "soft", "hard"]).nullable(),
+    position: z43.enum(["bottom", "bottom-right"]).default("bottom")
   }).optional(),
-  corners: z42.enum(["square", "soft", "rounded", "pill"]).optional(),
+  corners: z43.enum(["square", "soft", "rounded", "pill"]).optional(),
   // Border (optional)
   border: cardBorderSchema.optional()
 });
-var cardSystemSchema = z42.object({
-  variants: z42.array(cardVariantSchema2).min(1).max(3)
+var cardSystemSchema = z43.object({
+  variants: z43.array(cardVariantSchema2).min(1).max(3)
 });
 
 // ../theme-core/src/cards/index.ts
@@ -59585,20 +59822,20 @@ init_types5();
 init_types12();
 
 // ../theme-core/src/gradients/types.ts
-import { z as z43 } from "zod";
-var gradientStopSchema = z43.object({
-  color: z43.string(),
+import { z as z44 } from "zod";
+var gradientStopSchema = z44.object({
+  color: z44.string(),
   // Theme color token name (e.g., 'primary-500')
-  position: z43.number().min(0).max(100)
+  position: z44.number().min(0).max(100)
   // Percentage 0-100
 });
-var gradientConfigSchema = z43.object({
-  type: z43.enum(["linear", "radial"]),
-  angle: z43.number().min(0).max(360).optional(),
+var gradientConfigSchema = z44.object({
+  type: z44.enum(["linear", "radial"]),
+  angle: z44.number().min(0).max(360).optional(),
   // For linear gradients (degrees)
-  position: z43.string().optional(),
+  position: z44.string().optional(),
   // For radial gradients ('center', 'top left', etc.)
-  stops: z43.array(gradientStopSchema).min(2)
+  stops: z44.array(gradientStopSchema).min(2)
 });
 
 // ../theme-core/src/schema.ts
@@ -59606,65 +59843,65 @@ init_types13();
 init_validation3();
 init_atRuleValidation();
 init_shared7();
-var axesSchema = z44.object({
-  tone: z44.enum(["minimal", "classic", "bold"]),
-  energy: z44.enum(["calm", "vibrant"]),
-  density: z44.enum(["airy", "regular", "compact"]),
-  mediaBias: z44.enum(["text", "media", "mixed"]),
-  conversionBias: z44.enum(["low", "med", "high"]),
-  motion: z44.enum(["subtle", "standard", "expressive"])
-});
-var colourHexString = z44.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
-var paletteColorSchema = z44.object({
-  name: z44.string().min(1),
+var axesSchema = z45.object({
+  tone: z45.enum(["minimal", "classic", "bold"]),
+  energy: z45.enum(["calm", "vibrant"]),
+  density: z45.enum(["airy", "regular", "compact"]),
+  mediaBias: z45.enum(["text", "media", "mixed"]),
+  conversionBias: z45.enum(["low", "med", "high"]),
+  motion: z45.enum(["subtle", "standard", "expressive"])
+});
+var colourHexString = z45.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
+var paletteColorSchema = z45.object({
+  name: z45.string().min(1),
   hex: colourHexString
 });
-var paletteMetaSchema = z44.object({
-  mode: z44.enum(["light", "dark"])
+var paletteMetaSchema = z45.object({
+  mode: z45.enum(["light", "dark"])
 });
-var paletteSchema = z44.object({
-  colors: z44.array(paletteColorSchema),
+var paletteSchema = z45.object({
+  colors: z45.array(paletteColorSchema),
   meta: paletteMetaSchema
 });
-var typographyStyleSchema = z44.object({
-  family: z44.string().min(1),
-  weight: z44.enum(["light", "regular", "medium", "semibold", "bold"]),
-  letterSpacing: z44.enum(["tight", "normal", "loose"]),
-  lineHeight: z44.enum(["normal", "relaxed", "loose"])
+var typographyStyleSchema = z45.object({
+  family: z45.string().min(1),
+  weight: z45.enum(["light", "regular", "medium", "semibold", "bold"]),
+  letterSpacing: z45.enum(["tight", "normal", "loose"]),
+  lineHeight: z45.enum(["normal", "relaxed", "loose"])
 });
 var bodyTypographyStyleSchema = typographyStyleSchema.extend({
-  size: z44.enum(["md", "lg", "xl"])
+  size: z45.enum(["md", "lg", "xl"])
 });
-var headingSizeSchema = z44.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
-var headingTypographyOverridesSchema = z44.object({
-  weight: z44.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
-  letterSpacing: z44.enum(["tight", "normal", "loose"]).nullable().optional(),
+var headingSizeSchema = z45.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
+var headingTypographyOverridesSchema = z45.object({
+  weight: z45.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
+  letterSpacing: z45.enum(["tight", "normal", "loose"]).nullable().optional(),
   size: headingSizeSchema.nullable().optional(),
-  lineHeight: z44.enum(["normal", "relaxed", "loose"]).nullable().optional(),
-  italic: z44.boolean().nullable().optional(),
-  colorToken: z44.string().min(1).nullable().optional()
+  lineHeight: z45.enum(["normal", "relaxed", "loose"]).nullable().optional(),
+  italic: z45.boolean().nullable().optional(),
+  colorToken: z45.string().min(1).nullable().optional()
   // Palette token name for heading color
 });
 var headingTypographyStyleSchema = typographyStyleSchema.extend({
-  case: z44.enum(["uppercase", "normal", "smallCaps"]).nullable(),
-  italic: z44.boolean().nullable(),
-  colorToken: z44.string().min(1).nullable().optional()
+  case: z45.enum(["uppercase", "normal", "smallCaps"]).nullable(),
+  italic: z45.boolean().nullable(),
+  colorToken: z45.string().min(1).nullable().optional()
   // Palette token name for heading color
 });
-var proseLinkUnderlineStyleSchema = z44.enum(["solid", "dotted", "dashed"]);
-var proseLinkUnderlineThicknessSchema = z44.enum(["auto", "fromFont", "thin", "medium", "thick"]);
-var proseLinkUnderlineOffsetSchema = z44.enum(["auto", "tight", "normal", "loose"]);
-var proseLinkStyleSchema = z44.object({
-  colorToken: z44.string().min(1).optional(),
-  hoverColorToken: z44.string().min(1).optional(),
-  underline: z44.boolean().optional(),
-  decorationColorToken: z44.string().min(1).optional(),
-  hoverDecorationColorToken: z44.string().min(1).optional(),
+var proseLinkUnderlineStyleSchema = z45.enum(["solid", "dotted", "dashed"]);
+var proseLinkUnderlineThicknessSchema = z45.enum(["auto", "fromFont", "thin", "medium", "thick"]);
+var proseLinkUnderlineOffsetSchema = z45.enum(["auto", "tight", "normal", "loose"]);
+var proseLinkStyleSchema = z45.object({
+  colorToken: z45.string().min(1).optional(),
+  hoverColorToken: z45.string().min(1).optional(),
+  underline: z45.boolean().optional(),
+  decorationColorToken: z45.string().min(1).optional(),
+  hoverDecorationColorToken: z45.string().min(1).optional(),
   underlineStyle: proseLinkUnderlineStyleSchema.optional(),
   underlineThickness: proseLinkUnderlineThicknessSchema.optional(),
   underlineOffset: proseLinkUnderlineOffsetSchema.optional()
 });
-var semanticSpacingSchema = z44.enum([
+var semanticSpacingSchema = z45.enum([
   "none",
   "compact",
   "cozy",
@@ -59672,62 +59909,62 @@ var semanticSpacingSchema = z44.enum([
   "comfortable",
   "spacious"
 ]);
-var boxRoundedSchema = z44.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
-var boxBackgroundOverlaySchema = z44.object({
-  type: z44.enum(["none", "color", "gradient"]).nullable().optional(),
-  color: z44.string().nullable().optional(),
-  gradient: z44.string().nullable().optional(),
-  opacity: z44.number().min(0).max(1).nullable().optional()
-});
-var boxBackgroundSchema = z44.object({
-  type: z44.enum(["color", "gradient", "image"]).optional(),
-  color: z44.string().nullable().optional(),
-  gradient: z44.string().nullable().optional(),
+var boxRoundedSchema = z45.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
+var boxBackgroundOverlaySchema = z45.object({
+  type: z45.enum(["none", "color", "gradient"]).nullable().optional(),
+  color: z45.string().nullable().optional(),
+  gradient: z45.string().nullable().optional(),
+  opacity: z45.number().min(0).max(1).nullable().optional()
+});
+var boxBackgroundSchema = z45.object({
+  type: z45.enum(["color", "gradient", "image"]).optional(),
+  color: z45.string().nullable().optional(),
+  gradient: z45.string().nullable().optional(),
   image: mediaSchema2.nullable().optional(),
-  objectFit: z44.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
-  scale: z44.string().nullable().optional(),
-  position: z44.string().nullable().optional(),
-  opacity: z44.number().min(0).max(1).nullable().optional(),
+  objectFit: z45.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
+  scale: z45.string().nullable().optional(),
+  position: z45.string().nullable().optional(),
+  opacity: z45.number().min(0).max(1).nullable().optional(),
   overlay: boxBackgroundOverlaySchema.nullable().optional(),
-  textColor: z44.string().nullable().optional(),
-  headingColor: z44.string().nullable().optional()
+  textColor: z45.string().nullable().optional(),
+  headingColor: z45.string().nullable().optional()
 });
-var sectionStylesOverrideSchema = z44.object({
+var sectionStylesOverrideSchema = z45.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  minHeight: z44.enum(["none", "hero", "immersive"]).nullable().optional()
+  minHeight: z45.enum(["none", "hero", "immersive"]).nullable().optional()
 });
-var containerStylesOverrideSchema = z44.object({
+var containerStylesOverrideSchema = z45.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z44.boolean().nullable().optional(),
+  raised: z45.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional(),
-  fullWidth: z44.boolean().nullable().optional()
+  fullWidth: z45.boolean().nullable().optional()
 });
-var cardBorderOverrideSchema = z44.object({
-  enabled: z44.boolean().nullable().optional(),
-  width: z44.enum(["none", "1", "2", "3"]).nullable().optional(),
-  colorToken: z44.string().nullable().optional()
+var cardBorderOverrideSchema = z45.object({
+  enabled: z45.boolean().nullable().optional(),
+  width: z45.enum(["none", "1", "2", "3"]).nullable().optional(),
+  colorToken: z45.string().nullable().optional()
 });
-var cardStylesOverrideSchema = z44.object({
+var cardStylesOverrideSchema = z45.object({
   background: boxBackgroundSchema.nullable().optional(),
   border: cardBorderOverrideSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z44.boolean().nullable().optional(),
+  raised: z45.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional()
 });
-var blockStyleOverridesSchema = z44.object({
+var blockStyleOverridesSchema = z45.object({
   sectionStyles: sectionStylesOverrideSchema.nullable().optional(),
   containerStyles: containerStylesOverrideSchema.nullable().optional(),
   cardStyles: cardStylesOverrideSchema.nullable().optional()
 });
-var blockThemeOverrideSchema = z44.object({
-  typography: z44.object({
+var blockThemeOverrideSchema = z45.object({
+  typography: z45.object({
     proseLinkStyle: proseLinkStyleSchema.optional()
   }).optional(),
   styles: blockStyleOverridesSchema.optional()
 });
-var typographyScaleSchema = z44.enum([
+var typographyScaleSchema = z45.enum([
   // New intuitive names
   "compact",
   // ratio 1.2 (was minorThird)
@@ -59740,9 +59977,9 @@ var typographyScaleSchema = z44.enum([
   "majorThird",
   "perfectFourth"
 ]);
-var typographySchema = z44.object({
+var typographySchema = z45.object({
   body: bodyTypographyStyleSchema,
-  headings: z44.object({
+  headings: z45.object({
     default: headingTypographyStyleSchema,
     h1: headingTypographyOverridesSchema,
     h2: headingTypographyOverridesSchema,
@@ -59755,41 +59992,41 @@ var typographySchema = z44.object({
   scale: typographyScaleSchema,
   proseLinkStyle: proseLinkStyleSchema.optional()
 });
-var spaceSchema = z44.enum(["comfortable", "standard", "dense"]);
-var corners = z44.enum(["square", "soft", "rounded", "pill"]);
-var shadow = z44.object({
-  elevation: z44.enum(["none", "low", "medium", "high"]),
-  softness: z44.enum(["crisp", "soft", "hard"]).nullable(),
-  position: z44.enum(["bottom", "bottom-right"]).default("bottom")
+var spaceSchema = z45.enum(["comfortable", "standard", "dense"]);
+var corners = z45.enum(["square", "soft", "rounded", "pill"]);
+var shadow = z45.object({
+  elevation: z45.enum(["none", "low", "medium", "high"]),
+  softness: z45.enum(["crisp", "soft", "hard"]).nullable(),
+  position: z45.enum(["bottom", "bottom-right"]).default("bottom")
 });
-var border = z44.object({
-  width: z44.enum(["none", "hairline", "thin", "thick"]),
-  style: z44.enum(["solid", "dashed"])
+var border = z45.object({
+  width: z45.enum(["none", "hairline", "thin", "thick"]),
+  style: z45.enum(["solid", "dashed"])
 });
-var motion = z44.object({
-  level: z44.enum(["off", "low", "medium", "high"]),
-  easing: z44.enum(["standard", "snappy", "gentle"]).nullable()
+var motion = z45.object({
+  level: z45.enum(["off", "low", "medium", "high"]),
+  easing: z45.enum(["standard", "snappy", "gentle"]).nullable()
 });
-var buttonStyle = z44.object({
+var buttonStyle = z45.object({
   shape: corners
   // Used for --radius-control CSS variable
 });
-var cardStyle = z44.object({
-  elevation: z44.enum(["none", "low", "medium", "high"]),
-  border: z44.enum(["none", "subtle", "defined"]),
+var cardStyle = z45.object({
+  elevation: z45.enum(["none", "low", "medium", "high"]),
+  border: z45.enum(["none", "subtle", "defined"]),
   shape: corners,
-  headerStyle: z44.enum(["plain", "accentBar", "subtleBg"]).nullable(),
-  mediaTreatment: z44.enum(["square", "rounded", "bleed"]).nullable()
+  headerStyle: z45.enum(["plain", "accentBar", "subtleBg"]).nullable(),
+  mediaTreatment: z45.enum(["square", "rounded", "bleed"]).nullable()
 });
-var inputStyle = z44.object({
+var inputStyle = z45.object({
   shape: corners,
-  border: z44.enum(["subtle", "defined", "underline"]),
-  focus: z44.enum(["glow", "ring", "underline"]),
-  label: z44.enum(["inside", "above"])
+  border: z45.enum(["subtle", "defined", "underline"]),
+  focus: z45.enum(["glow", "ring", "underline"]),
+  label: z45.enum(["inside", "above"])
 });
-var headerVariant = z44.enum(["classic", "centered", "transparent", "floating", "editorial"]);
-var headerPositioning = z44.enum(["static", "sticky", "fixed"]);
-var headerNavStyle = z44.enum([
+var headerVariant = z45.enum(["classic", "centered", "transparent", "floating", "editorial"]);
+var headerPositioning = z45.enum(["static", "sticky", "fixed"]);
+var headerNavStyle = z45.enum([
   "minimal",
   "underline",
   "underline-grow",
@@ -59798,82 +60035,82 @@ var headerNavStyle = z44.enum([
   "frosted",
   "solid"
 ]);
-var navFontWeight = z44.enum(["regular", "medium", "semibold", "bold"]);
-var headerMaxWidth = z44.enum(["container", "full"]);
-var headerContainerSchema = z44.object({
-  rounded: z44.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
-  border: z44.boolean().default(true),
-  shadow: z44.boolean().default(true),
-  padding: z44.enum(["sm", "md", "lg"]).default("md"),
-  tint: z44.string().nullable().optional(),
-  opacity: z44.number().min(0).max(1).default(0.12)
+var navFontWeight = z45.enum(["regular", "medium", "semibold", "bold"]);
+var headerMaxWidth = z45.enum(["container", "full"]);
+var headerContainerSchema = z45.object({
+  rounded: z45.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
+  border: z45.boolean().default(true),
+  shadow: z45.boolean().default(true),
+  padding: z45.enum(["sm", "md", "lg"]).default("md"),
+  tint: z45.string().nullable().optional(),
+  opacity: z45.number().min(0).max(1).default(0.12)
 }).optional();
 var headerBorderSchema = componentBorderSchema.extend({
-  position: z44.enum(["bottom", "top", "both", "none"]).default("bottom")
+  position: z45.enum(["bottom", "top", "both", "none"]).default("bottom")
 }).optional();
-var logoStyleSchema = z44.object({
-  fontFamily: z44.enum(["heading", "body"]).default("heading"),
-  letterSpacing: z44.enum(["normal", "wide", "wider", "widest"]).default("normal"),
-  gradient: z44.boolean().default(false)
+var logoStyleSchema = z45.object({
+  fontFamily: z45.enum(["heading", "body"]).default("heading"),
+  letterSpacing: z45.enum(["normal", "wide", "wider", "widest"]).default("normal"),
+  gradient: z45.boolean().default(false)
 }).optional();
-var headerLogoTextSchema = z44.object({
-  mobileWrapLines: z44.union([z44.literal(1), z44.literal(2)]).optional(),
-  mobileMaxWidth: z44.enum(["xs", "sm", "md"]).optional(),
-  hideOnShrink: z44.boolean().optional()
+var headerLogoTextSchema = z45.object({
+  mobileWrapLines: z45.union([z45.literal(1), z45.literal(2)]).optional(),
+  mobileMaxWidth: z45.enum(["xs", "sm", "md"]).optional(),
+  hideOnShrink: z45.boolean().optional()
 }).optional();
-var navEffectsSchema = z44.object({
-  underlineGradient: z44.boolean().default(false),
-  glow: z44.boolean().default(false),
-  glowColor: z44.string().optional(),
-  neumorphic: z44.boolean().default(false)
+var navEffectsSchema = z45.object({
+  underlineGradient: z45.boolean().default(false),
+  glow: z45.boolean().default(false),
+  glowColor: z45.string().optional(),
+  neumorphic: z45.boolean().default(false)
 }).optional();
-var dropdownStyleSchema = z44.object({
+var dropdownStyleSchema = z45.object({
   // Container styling
-  background: z44.string().default("surface"),
+  background: z45.string().default("surface"),
   // color token
-  textColor: z44.string().default("text"),
+  textColor: z45.string().default("text"),
   // color token
-  borderColor: z44.string().nullable().default("border"),
+  borderColor: z45.string().nullable().default("border"),
   // null = no border
-  shadow: z44.enum(["none", "sm", "md", "lg"]).default("md"),
-  borderRadius: z44.enum(["none", "sm", "md", "lg"]).default("md"),
+  shadow: z45.enum(["none", "sm", "md", "lg"]).default("md"),
+  borderRadius: z45.enum(["none", "sm", "md", "lg"]).default("md"),
   // Link hover states (explicit control)
-  hoverBackground: z44.string().nullable().optional(),
+  hoverBackground: z45.string().nullable().optional(),
   // color token, null = transparent
-  hoverTextColor: z44.string().nullable().optional(),
+  hoverTextColor: z45.string().nullable().optional(),
   // color token, null = inherit
   // Typography
-  textTransform: z44.enum(["none", "uppercase", "capitalize"]).default("none"),
-  letterSpacing: z44.enum(["normal", "wide", "wider"]).default("normal"),
-  fontWeight: z44.enum(["regular", "medium", "semibold", "bold"]).optional(),
+  textTransform: z45.enum(["none", "uppercase", "capitalize"]).default("none"),
+  letterSpacing: z45.enum(["normal", "wide", "wider"]).default("normal"),
+  fontWeight: z45.enum(["regular", "medium", "semibold", "bold"]).optional(),
   // optional = inherit from navWeight
-  textSize: z44.enum(["xs", "sm", "base", "lg"]).optional()
+  textSize: z45.enum(["xs", "sm", "base", "lg"]).optional()
   // optional = no override (browser default)
 }).optional();
-var headerCtaGapSchema = z44.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var navContainerSchema = z44.object({
-  type: z44.enum(["none", "pill", "glass"]).default("none"),
-  tint: z44.string().nullable().optional(),
-  opacity: z44.number().min(0).max(1).default(0.15)
+var headerCtaGapSchema = z45.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var navContainerSchema = z45.object({
+  type: z45.enum(["none", "pill", "glass"]).default("none"),
+  tint: z45.string().nullable().optional(),
+  opacity: z45.number().min(0).max(1).default(0.15)
 }).default({ type: "none", tint: null, opacity: 0.15 });
-var headerBackgroundSchema = z44.object({
-  type: z44.enum(["color", "gradient", "image"]),
-  color: z44.string().nullable().optional(),
+var headerBackgroundSchema = z45.object({
+  type: z45.enum(["color", "gradient", "image"]),
+  color: z45.string().nullable().optional(),
   gradient: gradientConfigSchema.nullable().optional(),
   image: mediaSchema2.nullable().optional(),
-  textColor: z44.string().nullable().optional()
+  textColor: z45.string().nullable().optional()
 });
-var headerSchema = z44.object({
+var headerSchema = z45.object({
   variant: headerVariant,
   positioning: headerPositioning,
-  shrinkOnScroll: z44.boolean(),
+  shrinkOnScroll: z45.boolean(),
   maxWidth: headerMaxWidth,
   logoOverride: mediaSchema2.nullable().optional(),
   background: headerBackgroundSchema.default({ type: "color", color: "surface" }),
-  textColor: z44.string().nullable().optional(),
+  textColor: z45.string().nullable().optional(),
   // Site title and general header text
   navStyle: headerNavStyle,
-  navColor: z44.string().nullable().optional(),
+  navColor: z45.string().nullable().optional(),
   // Nav links (inherits textColor if not set)
   navWeight: navFontWeight.default("medium"),
   // New fields for header system enhancement
@@ -59892,50 +60129,50 @@ var headerSchema = z44.object({
   // Dropdown menu styling (nav dropdowns and mobile drawer)
   dropdownStyle: dropdownStyleSchema
 });
-var footerVariant = z44.enum(["simple", "columns", "split"]);
-var footerMaxWidth = z44.enum(["container", "full"]);
-var footerMode = z44.enum(["default", "blocks", "default+blocks", "none"]);
-var footerNavLayoutMode = z44.enum(["stack", "inline", "inline-wrap"]);
-var footerNavLayoutAlign = z44.enum(["start", "center", "end", "space-between"]);
-var footerSpacing = z44.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var footerLogoPlacement = z44.enum(["left", "right", "above", "below"]);
-var footerLogoSize = z44.enum(["sm", "md", "lg", "xl"]);
-var footerLogoMaxHeight = z44.enum(["sm", "md", "lg", "xl"]);
-var footerBottomTextLinkStyleSchema = z44.object({
-  colorToken: z44.string().optional(),
-  hoverColorToken: z44.string().nullable().optional(),
-  decorationColorToken: z44.string().nullable().optional(),
-  underline: z44.boolean().optional()
-});
-var footerBottomBarSchema = z44.object({
-  enabled: z44.boolean().optional(),
-  fullBleed: z44.boolean().optional(),
+var footerVariant = z45.enum(["simple", "columns", "split"]);
+var footerMaxWidth = z45.enum(["container", "full"]);
+var footerMode = z45.enum(["default", "blocks", "default+blocks", "none"]);
+var footerNavLayoutMode = z45.enum(["stack", "inline", "inline-wrap"]);
+var footerNavLayoutAlign = z45.enum(["start", "center", "end", "space-between"]);
+var footerSpacing = z45.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var footerLogoPlacement = z45.enum(["left", "right", "above", "below"]);
+var footerLogoSize = z45.enum(["sm", "md", "lg", "xl"]);
+var footerLogoMaxHeight = z45.enum(["sm", "md", "lg", "xl"]);
+var footerBottomTextLinkStyleSchema = z45.object({
+  colorToken: z45.string().optional(),
+  hoverColorToken: z45.string().nullable().optional(),
+  decorationColorToken: z45.string().nullable().optional(),
+  underline: z45.boolean().optional()
+});
+var footerBottomBarSchema = z45.object({
+  enabled: z45.boolean().optional(),
+  fullBleed: z45.boolean().optional(),
   background: headerBackgroundSchema.optional(),
-  textColor: z44.string().nullable().optional(),
-  textAlign: z44.enum(["left", "center", "right"]).optional(),
+  textColor: z45.string().nullable().optional(),
+  textAlign: z45.enum(["left", "center", "right"]).optional(),
   paddingY: footerSpacing.optional(),
   paddingX: footerSpacing.optional(),
-  borderTop: z44.object({
-    colorToken: z44.string().nullable().optional(),
-    width: z44.enum(["none", "thin", "medium", "thick"]).optional()
+  borderTop: z45.object({
+    colorToken: z45.string().nullable().optional(),
+    width: z45.enum(["none", "thin", "medium", "thick"]).optional()
   }).optional()
 });
-var footerNavLayoutSchema = z44.object({
+var footerNavLayoutSchema = z45.object({
   layout: footerNavLayoutMode.optional(),
   align: footerNavLayoutAlign.optional(),
   gapX: footerSpacing.optional(),
   gapY: footerSpacing.optional(),
-  columns: z44.number().int().min(1).max(6).optional()
+  columns: z45.number().int().min(1).max(6).optional()
 });
-var footerLogoSchema = z44.object({
-  showLogo: z44.boolean().default(true),
-  showLogoText: z44.boolean().optional(),
+var footerLogoSchema = z45.object({
+  showLogo: z45.boolean().default(true),
+  showLogoText: z45.boolean().optional(),
   placement: footerLogoPlacement.optional(),
   size: footerLogoSize.optional(),
   maxHeight: footerLogoMaxHeight.optional(),
-  align: z44.enum(["start", "center", "end"]).optional()
+  align: z45.enum(["start", "center", "end"]).optional()
 });
-var footerSchema = z44.object({
+var footerSchema = z45.object({
   /**
    * SDK-only footer rendering mode.
    *
@@ -59944,11 +60181,11 @@ var footerSchema = z44.object({
   mode: footerMode.optional(),
   variant: footerVariant,
   maxWidth: footerMaxWidth,
-  showLogoText: z44.boolean().optional(),
+  showLogoText: z45.boolean().optional(),
   background: headerBackgroundSchema.default({ type: "color", color: "surface" }),
   // Footer nav styling (independent from header)
   navStyle: headerNavStyle.default("minimal"),
-  navColor: z44.string().nullable().optional(),
+  navColor: z45.string().nullable().optional(),
   navWeight: navFontWeight.default("medium"),
   // Full nav link customization (overrides navStyle if set)
   navLinkStyle: navLinkStyleSchema.optional(),
@@ -59959,15 +60196,15 @@ var footerSchema = z44.object({
   logo: footerLogoSchema.optional(),
   bottomBar: footerBottomBarSchema.optional()
 });
-var containerPaddingPresetSchema = z44.enum(["tight", "compact", "default", "relaxed"]);
-var layoutSchema = z44.object({
-  containerPadding: z44.object({
+var containerPaddingPresetSchema = z45.enum(["tight", "compact", "default", "relaxed"]);
+var layoutSchema = z45.object({
+  containerPadding: z45.object({
     mobile: containerPaddingPresetSchema.optional(),
     tablet: containerPaddingPresetSchema.optional(),
     desktop: containerPaddingPresetSchema.optional()
   }).optional()
 }).optional();
-var heroTypographySizeSchema = z44.enum([
+var heroTypographySizeSchema = z45.enum([
   "sm",
   "base",
   "lg",
@@ -59978,14 +60215,14 @@ var heroTypographySizeSchema = z44.enum([
   "5xl",
   "6xl"
 ]);
-var heroTypographyLineHeightSchema = z44.enum(["tight", "snug", "normal", "relaxed"]);
-var heroResponsiveTypographySchema = z44.object({
+var heroTypographyLineHeightSchema = z45.enum(["tight", "snug", "normal", "relaxed"]);
+var heroResponsiveTypographySchema = z45.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
   subheadlineLineHeight: heroTypographyLineHeightSchema.optional()
 });
-var heroTypographySchema = z44.object({
+var heroTypographySchema = z45.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
@@ -59994,24 +60231,24 @@ var heroTypographySchema = z44.object({
   microHeadlineLineHeight: heroTypographyLineHeightSchema.optional(),
   microSubheadlineSize: heroTypographySizeSchema.optional(),
   microSubheadlineLineHeight: heroTypographyLineHeightSchema.optional(),
-  responsive: z44.object({
+  responsive: z45.object({
     tablet: heroResponsiveTypographySchema.optional(),
     mobile: heroResponsiveTypographySchema.optional()
   }).optional()
 });
-var heroSchema = z44.object({
+var heroSchema = z45.object({
   typography: heroTypographySchema.optional()
 }).optional();
-var gradientsSchema = z44.object({
-  button: z44.string().min(1).nullable().optional(),
-  hero: z44.string().min(1).nullable().optional(),
-  background: z44.string().min(1).nullable().optional()
-});
-var themeSchema = z44.object({
-  name: z44.string().min(1).max(30),
-  description: z44.string().min(1).max(400),
-  rationale: z44.string().min(1).max(400),
-  siteStyleId: z44.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
+var gradientsSchema = z45.object({
+  button: z45.string().min(1).nullable().optional(),
+  hero: z45.string().min(1).nullable().optional(),
+  background: z45.string().min(1).nullable().optional()
+});
+var themeSchema = z45.object({
+  name: z45.string().min(1).max(30),
+  description: z45.string().min(1).max(400),
+  rationale: z45.string().min(1).max(400),
+  siteStyleId: z45.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
   axes: axesSchema,
   palette: paletteSchema,
   typography: typographySchema,
@@ -60038,16 +60275,16 @@ var themeSchema = z44.object({
   // Block-specific customization (Tier 3)
   // blockCustomVars: Per-block CSS variable overrides as bare values
   // Example: { "event-registration": { "--step-color": "#6d28d9" } }
-  blockCustomVars: z44.record(
-    z44.string(),
+  blockCustomVars: z45.record(
+    z45.string(),
     // block kind (matches data-block attribute)
-    z44.record(z44.string(), z44.string())
+    z45.record(z45.string(), z45.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: z44.record(
-    z44.string(),
+  blockOverrides: z45.record(
+    z45.string(),
     blockThemeOverrideSchema
   ).optional(),
   // Structured custom CSS rules
@@ -60083,11 +60320,11 @@ var themeSchema = z44.object({
    * }
    * ```
    */
-  styleGroups: z44.record(z44.string(), z44.array(z44.string())).optional()
+  styleGroups: z45.record(z45.string(), z45.array(z45.string())).optional()
 });
-var themesTurnSchema = z44.object({
-  message: z44.string().min(1),
-  themes: z44.array(themeSchema).length(3)
+var themesTurnSchema = z45.object({
+  message: z45.string().min(1),
+  themes: z45.array(themeSchema).length(3)
 });
 
 // ../theme-core/src/palette/variants/types.ts
@@ -60097,7 +60334,7 @@ function asPaletteVariantId(value) {
   }
   return value;
 }
-var paletteVariantIdSchema = z45.string().min(1).transform((value) => asPaletteVariantId(value));
+var paletteVariantIdSchema = z46.string().min(1).transform((value) => asPaletteVariantId(value));
 var PALETTE_TOKEN_NAMES = [
   "primary",
   "primaryForeground",
@@ -60113,19 +60350,19 @@ var PALETTE_TOKEN_NAMES = [
   "text",
   "border"
 ];
-var paletteTokenNameSchema = z45.enum(PALETTE_TOKEN_NAMES);
+var paletteTokenNameSchema = z46.enum(PALETTE_TOKEN_NAMES);
 var HEX_COLOR_REGEX = /^#[0-9a-f]{6}$/;
-var hexColorSchema = z45.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
+var hexColorSchema = z46.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
 var variantPaletteColorSchema = paletteColorSchema.extend({
   name: paletteTokenNameSchema
 });
-var paletteVariantSchema = z45.object({
+var paletteVariantSchema = z46.object({
   id: paletteVariantIdSchema,
-  name: z45.string().min(1),
-  description: z45.string().min(1),
+  name: z46.string().min(1),
+  description: z46.string().min(1),
   tags: styleTagsSchema,
-  mode: z45.enum(["light", "dark"]),
-  colors: z45.array(variantPaletteColorSchema).min(1)
+  mode: z46.enum(["light", "dark"]),
+  colors: z46.array(variantPaletteColorSchema).min(1)
 });
 function definePaletteVariant(input) {
   return {
@@ -60137,7 +60374,7 @@ function definePaletteVariant(input) {
     colors: input.colors
   };
 }
-var paletteOverridesSchema = z45.object({
+var paletteOverridesSchema = z46.object({
   primary: hexColorSchema.optional(),
   primaryForeground: hexColorSchema.optional(),
   secondary: hexColorSchema.optional(),
@@ -60814,7 +61051,7 @@ var curatedSiteStylesById = new Map(
 );
 
 // ../theme-core/src/site-styles/designState.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 
 // ../theme-core/src/site-styles/rawStyleFields.ts
 var themeV2RuntimeStyleFieldNames = [
@@ -60840,13 +61077,13 @@ var themeV2NormalEditorRawStyleFieldNameSet = new Set(
 
 // ../theme-core/src/site-styles/designState.ts
 var themeV2DesignStateSchemaVersion = 1;
-var designResolutionPolicySchema = z46.enum(["generated", "user", "admin", "sdk"]);
-var runtimeStyleFieldNameSchema = z46.enum(themeV2RuntimeStyleFieldNames);
-var nonEmptyRuntimeStyleFieldNamesSchema = z46.array(runtimeStyleFieldNameSchema).min(1).transform((fields3) => [
+var designResolutionPolicySchema = z47.enum(["generated", "user", "admin", "sdk"]);
+var runtimeStyleFieldNameSchema = z47.enum(themeV2RuntimeStyleFieldNames);
+var nonEmptyRuntimeStyleFieldNamesSchema = z47.array(runtimeStyleFieldNameSchema).min(1).transform((fields3) => [
   fields3[0],
   ...fields3.slice(1)
 ]);
-var heroLegibilityStrategySchema = z46.enum([
+var heroLegibilityStrategySchema = z47.enum([
   "none",
   "scrim-gradient",
   "solid-panel"
@@ -60868,66 +61105,66 @@ var userFlushTreatments = uniqueNonEmpty(
 var userFlushBleeds = uniqueNonEmpty(
   userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
 );
-var contentFrameIntentSchema = z46.discriminatedUnion("kind", [
-  z46.object({ kind: z46.literal("plain") }).strict(),
-  z46.object({
-    kind: z46.literal("panel"),
-    treatment: z46.enum(userPanelTreatments)
+var contentFrameIntentSchema = z47.discriminatedUnion("kind", [
+  z47.object({ kind: z47.literal("plain") }).strict(),
+  z47.object({
+    kind: z47.literal("panel"),
+    treatment: z47.enum(userPanelTreatments)
   }).strict(),
-  z46.object({
-    kind: z46.literal("flush-panel"),
-    treatment: z46.enum(userFlushTreatments),
-    bleed: z46.enum(userFlushBleeds)
+  z47.object({
+    kind: z47.literal("flush-panel"),
+    treatment: z47.enum(userFlushTreatments),
+    bleed: z47.enum(userFlushBleeds)
   }).strict()
 ]);
-var blockDesignPlanSchema = z46.object({
-  blockId: z46.string().min(1).transform(asDesignBlockId),
-  blockKind: z46.string().min(1),
-  purpose: z46.string().min(1),
-  sectionSurface: z46.enum(userDesignOptionCatalog.sectionSurfaces),
+var blockDesignPlanSchema = z47.object({
+  blockId: z47.string().min(1).transform(asDesignBlockId),
+  blockKind: z47.string().min(1),
+  purpose: z47.string().min(1),
+  sectionSurface: z47.enum(userDesignOptionCatalog.sectionSurfaces),
   contentFrame: contentFrameIntentSchema,
-  itemSurface: z46.enum(userDesignOptionCatalog.itemSurfaces),
-  transitionAfter: z46.enum(userDesignOptionCatalog.transitions),
-  emphasis: z46.enum(userDesignOptionCatalog.emphases),
+  itemSurface: z47.enum(userDesignOptionCatalog.itemSurfaces),
+  transitionAfter: z47.enum(userDesignOptionCatalog.transitions),
+  emphasis: z47.enum(userDesignOptionCatalog.emphases),
   heroLegibility: heroLegibilityStrategySchema.optional()
 }).strict();
-var styleAuthoritySchema = z46.discriminatedUnion("kind", [
-  z46.object({
-    kind: z46.literal("theme-v2"),
+var styleAuthoritySchema = z47.discriminatedUnion("kind", [
+  z47.object({
+    kind: z47.literal("theme-v2"),
     source: designResolutionPolicySchema,
-    siteStyleId: z46.string().min(1).transform(asSiteStyleId),
-    templateId: z46.string().min(1).transform(asDesignSystemTemplateId),
-    templateVersion: z46.number().int().nonnegative(),
-    resolverVersion: z46.number().int().nonnegative()
+    siteStyleId: z47.string().min(1).transform(asSiteStyleId),
+    templateId: z47.string().min(1).transform(asDesignSystemTemplateId),
+    templateVersion: z47.number().int().nonnegative(),
+    resolverVersion: z47.number().int().nonnegative()
   }).strict(),
-  z46.object({
-    kind: z46.literal("legacy-raw"),
-    reason: z46.enum(["pre-theme-v2", "manual-runtime-fields"])
+  z47.object({
+    kind: z47.literal("legacy-raw"),
+    reason: z47.enum(["pre-theme-v2", "manual-runtime-fields"])
   }).strict(),
-  z46.object({
-    kind: z46.literal("advanced-detached"),
-    reason: z46.literal("detached-custom-runtime-fields")
+  z47.object({
+    kind: z47.literal("advanced-detached"),
+    reason: z47.literal("detached-custom-runtime-fields")
   }).strict()
 ]);
-var blockRuntimeStyleAuthoritySchema = z46.object({
-  unit: z46.literal("block-runtime-fields"),
-  blockId: z46.string().min(1).transform(asDesignBlockId),
+var blockRuntimeStyleAuthoritySchema = z47.object({
+  unit: z47.literal("block-runtime-fields"),
+  blockId: z47.string().min(1).transform(asDesignBlockId),
   fields: nonEmptyRuntimeStyleFieldNamesSchema,
   authority: styleAuthoritySchema
 }).strict();
-var persistedPageDesignStateV1Schema = z46.object({
-  schemaVersion: z46.literal(themeV2DesignStateSchemaVersion),
-  siteStyleId: z46.string().min(1).transform(asSiteStyleId),
-  templateId: z46.string().min(1).transform(asDesignSystemTemplateId),
-  templateVersion: z46.number().int().nonnegative(),
-  resolverVersion: z46.number().int().nonnegative(),
-  rhythmPresetId: z46.string().min(1),
-  blocks: z46.array(blockDesignPlanSchema),
-  styleAuthorities: z46.array(blockRuntimeStyleAuthoritySchema)
+var persistedPageDesignStateV1Schema = z47.object({
+  schemaVersion: z47.literal(themeV2DesignStateSchemaVersion),
+  siteStyleId: z47.string().min(1).transform(asSiteStyleId),
+  templateId: z47.string().min(1).transform(asDesignSystemTemplateId),
+  templateVersion: z47.number().int().nonnegative(),
+  resolverVersion: z47.number().int().nonnegative(),
+  rhythmPresetId: z47.string().min(1),
+  blocks: z47.array(blockDesignPlanSchema),
+  styleAuthorities: z47.array(blockRuntimeStyleAuthoritySchema)
 }).strict();
 
 // ../theme-core/src/site-styles/generatedSchemas.ts
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 function uniqueNonEmpty2(values) {
   const uniqueValues = [...new Set(values)];
   const firstValue = uniqueValues[0];
@@ -60945,105 +61182,105 @@ var generatedFlushTreatments = uniqueNonEmpty2(
 var generatedFlushBleeds = uniqueNonEmpty2(
   generatedDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
 );
-var generatedPanelFrameSchema = z47.object({
-  kind: z47.literal("panel"),
-  treatment: z47.enum(generatedPanelTreatments)
+var generatedPanelFrameSchema = z48.object({
+  kind: z48.literal("panel"),
+  treatment: z48.enum(generatedPanelTreatments)
 }).strict();
-var generatedFlushPanelFrameSchema = z47.object({
-  kind: z47.literal("flush-panel"),
-  treatment: z47.enum(generatedFlushTreatments),
-  bleed: z47.enum(generatedFlushBleeds)
+var generatedFlushPanelFrameSchema = z48.object({
+  kind: z48.literal("flush-panel"),
+  treatment: z48.enum(generatedFlushTreatments),
+  bleed: z48.enum(generatedFlushBleeds)
 }).strict();
-var generatedContentFrameIntentSchema = z47.discriminatedUnion("kind", [
-  z47.object({ kind: z47.literal("plain") }).strict(),
+var generatedContentFrameIntentSchema = z48.discriminatedUnion("kind", [
+  z48.object({ kind: z48.literal("plain") }).strict(),
   generatedPanelFrameSchema,
   generatedFlushPanelFrameSchema
 ]);
-var generatedSiteStyleIdSchema = z47.enum(curatedSiteStyleIdValues).transform(asSiteStyleId);
+var generatedSiteStyleIdSchema = z48.enum(curatedSiteStyleIdValues).transform(asSiteStyleId);
 function generatedChoiceSchema(valueSchema) {
-  return z47.discriminatedUnion("kind", [
-    z47.object({
-      source: z47.literal("generated"),
-      kind: z47.literal("auto")
+  return z48.discriminatedUnion("kind", [
+    z48.object({
+      source: z48.literal("generated"),
+      kind: z48.literal("auto")
     }).strict(),
-    z47.object({
-      source: z47.literal("generated"),
-      kind: z47.literal("explicit"),
+    z48.object({
+      source: z48.literal("generated"),
+      kind: z48.literal("explicit"),
       value: valueSchema
     }).strict()
   ]);
 }
-var generatedBlockDesignIntentSchema = z47.object({
+var generatedBlockDesignIntentSchema = z48.object({
   sectionSurface: generatedChoiceSchema(
-    z47.enum(generatedDesignOptionCatalog.sectionSurfaces)
+    z48.enum(generatedDesignOptionCatalog.sectionSurfaces)
   ),
   contentFrame: generatedChoiceSchema(generatedContentFrameIntentSchema),
   itemSurface: generatedChoiceSchema(
-    z47.enum(generatedDesignOptionCatalog.itemSurfaces)
+    z48.enum(generatedDesignOptionCatalog.itemSurfaces)
   ),
   transitionAfter: generatedChoiceSchema(
-    z47.enum(generatedDesignOptionCatalog.transitions)
+    z48.enum(generatedDesignOptionCatalog.transitions)
   ),
   emphasis: generatedChoiceSchema(
-    z47.enum(generatedDesignOptionCatalog.emphases)
+    z48.enum(generatedDesignOptionCatalog.emphases)
   )
 }).strict();
-var generatedMediaCompositionIntentSchema = z47.enum([
+var generatedMediaCompositionIntentSchema = z48.enum([
   "none",
   "supporting",
   "dominant"
 ]);
-var generatedDecorativeCompositionIntentSchema = z47.enum([
+var generatedDecorativeCompositionIntentSchema = z48.enum([
   "none",
   "supporting"
 ]);
-var generatedHeroLegibilityStrategySchema = z47.enum([
+var generatedHeroLegibilityStrategySchema = z48.enum([
   "none",
   "scrim-gradient"
 ]);
-var generatedBlockMediaIntentSchema = z47.object({
+var generatedBlockMediaIntentSchema = z48.object({
   media: generatedMediaCompositionIntentSchema,
   decorative: generatedDecorativeCompositionIntentSchema,
   heroLegibility: generatedChoiceSchema(generatedHeroLegibilityStrategySchema)
 }).strict();
-var generatedBoundaryIntentSchema = z47.object({
+var generatedBoundaryIntentSchema = z48.object({
   transitionAfter: generatedChoiceSchema(
-    z47.enum(generatedDesignOptionCatalog.transitions)
+    z48.enum(generatedDesignOptionCatalog.transitions)
   )
 }).strict();
-var generatedPageDesignBlockIntentSchema = z47.object({
-  blockId: z47.string().min(1),
-  blockKind: z47.string().min(1),
-  purpose: z47.string().min(1),
+var generatedPageDesignBlockIntentSchema = z48.object({
+  blockId: z48.string().min(1),
+  blockKind: z48.string().min(1),
+  purpose: z48.string().min(1),
   design: generatedBlockDesignIntentSchema,
   mediaIntent: generatedBlockMediaIntentSchema,
   boundaryIntent: generatedBoundaryIntentSchema
 }).strict();
-var generatedPageDesignIntentSchema = z47.object({
+var generatedPageDesignIntentSchema = z48.object({
   siteStyleId: generatedSiteStyleIdSchema,
-  blocks: z47.array(generatedPageDesignBlockIntentSchema)
+  blocks: z48.array(generatedPageDesignBlockIntentSchema)
 }).strict();
 
 // ../theme-core/src/site-styles/pageDesignIntent.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 var pageDesignIntentSchemaVersion = 1;
-var pageDesignUserPinnedAppearanceChoiceSchema = z48.object({
-  kind: z48.literal("user-pinned"),
-  value: z48.string().min(1).transform(asAppearancePresetId)
+var pageDesignUserPinnedAppearanceChoiceSchema = z49.object({
+  kind: z49.literal("user-pinned"),
+  value: z49.string().min(1).transform(asAppearancePresetId)
 }).strict();
-var pageDesignUserPinnedBoundaryChoiceSchema = z48.object({
-  kind: z48.literal("user-pinned"),
-  value: z48.string().min(1).transform(asBoundaryOptionId)
+var pageDesignUserPinnedBoundaryChoiceSchema = z49.object({
+  kind: z49.literal("user-pinned"),
+  value: z49.string().min(1).transform(asBoundaryOptionId)
 }).strict();
-var pageDesignBlockLookPinSchema = z48.object({
-  blockId: z48.string().min(1).transform(asDesignBlockId),
-  blockKind: z48.string().min(1),
+var pageDesignBlockLookPinSchema = z49.object({
+  blockId: z49.string().min(1).transform(asDesignBlockId),
+  blockKind: z49.string().min(1),
   choice: pageDesignUserPinnedAppearanceChoiceSchema
 }).strict();
-var pageDesignBoundaryPinSchema = z48.object({
-  boundaryId: z48.string().min(1).transform(asDesignBoundaryId),
-  previousBlockId: z48.string().min(1).transform(asDesignBlockId),
-  nextBlockId: z48.string().min(1).transform(asDesignBlockId),
+var pageDesignBoundaryPinSchema = z49.object({
+  boundaryId: z49.string().min(1).transform(asDesignBoundaryId),
+  previousBlockId: z49.string().min(1).transform(asDesignBlockId),
+  nextBlockId: z49.string().min(1).transform(asDesignBlockId),
   choice: pageDesignUserPinnedBoundaryChoiceSchema
 }).strict().superRefine((pin, ctx) => {
   const expectedBoundaryId = makeBoundaryId(
@@ -61052,18 +61289,18 @@ var pageDesignBoundaryPinSchema = z48.object({
   );
   if (pin.boundaryId !== expectedBoundaryId) {
     ctx.addIssue({
-      code: z48.ZodIssueCode.custom,
+      code: z49.ZodIssueCode.custom,
       path: ["boundaryId"],
       message: `Boundary id must match previousBlockId and nextBlockId. Expected ${expectedBoundaryId}.`
     });
   }
 });
-var pageDesignIntentV1Schema = z48.object({
-  schemaVersion: z48.literal(pageDesignIntentSchemaVersion),
-  siteStyleId: z48.string().min(1).transform(asSiteStyleId),
-  pageFlowPresetId: z48.string().min(1).transform(asPageFlowPresetId),
-  blockLookPins: z48.array(pageDesignBlockLookPinSchema),
-  boundaryPins: z48.array(pageDesignBoundaryPinSchema)
+var pageDesignIntentV1Schema = z49.object({
+  schemaVersion: z49.literal(pageDesignIntentSchemaVersion),
+  siteStyleId: z49.string().min(1).transform(asSiteStyleId),
+  pageFlowPresetId: z49.string().min(1).transform(asPageFlowPresetId),
+  blockLookPins: z49.array(pageDesignBlockLookPinSchema),
+  boundaryPins: z49.array(pageDesignBoundaryPinSchema)
 }).strict().superRefine((intent, ctx) => {
   addDuplicateStringIssues(ctx, {
     values: intent.blockLookPins.map((pin) => pin.blockId),
@@ -61089,7 +61326,7 @@ function addDuplicateStringIssues(ctx, input) {
   }
   for (const duplicate of duplicates) {
     ctx.addIssue({
-      code: z48.ZodIssueCode.custom,
+      code: z49.ZodIssueCode.custom,
       path: [...input.path],
       message: `Duplicate ${input.label}: ${duplicate}.`
     });
@@ -61346,81 +61583,81 @@ var defaultComponentRuntimeRules = defineComponentRuntimeRules({
 });
 
 // ../theme-core/src/site-styles/pageDesignAuthority.ts
-import { z as z49 } from "zod";
-var nonEmptyStringSchema = z49.string().min(1);
+import { z as z50 } from "zod";
+var nonEmptyStringSchema = z50.string().min(1);
 var blockContentVersionIdSchema = nonEmptyStringSchema.transform(asBlockContentVersionId);
 var designBlockIdSchema = nonEmptyStringSchema.transform(asDesignBlockId);
 var designPageIdSchema = nonEmptyStringSchema.transform(asDesignPageId);
 var designEntryIdSchema = nonEmptyStringSchema.transform(asDesignEntryId);
-var blockOrderIndexSchema = z49.number().int().nonnegative().transform(asBlockOrderIndex);
-var publishedPageBlockSnapshotSchema = z49.object({
-  kind: z49.literal("published-block-content"),
+var blockOrderIndexSchema = z50.number().int().nonnegative().transform(asBlockOrderIndex);
+var publishedPageBlockSnapshotSchema = z50.object({
+  kind: z50.literal("published-block-content"),
   blockId: designBlockIdSchema,
   contentVersionId: blockContentVersionIdSchema,
-  identifier: z49.string().nullable(),
+  identifier: z50.string().nullable(),
   blockKind: nonEmptyStringSchema,
   orderIndex: blockOrderIndexSchema
 }).strict();
-var draftPageBlockSnapshotSchema = z49.object({
-  kind: z49.literal("draft-block-content"),
+var draftPageBlockSnapshotSchema = z50.object({
+  kind: z50.literal("draft-block-content"),
   blockId: designBlockIdSchema,
   contentVersionId: blockContentVersionIdSchema.nullable(),
-  identifier: z49.string().nullable(),
+  identifier: z50.string().nullable(),
   blockKind: nonEmptyStringSchema,
   orderIndex: blockOrderIndexSchema
 }).strict();
-var missingPageBlockSnapshotSchema = z49.object({
-  kind: z49.literal("missing-block-content"),
+var missingPageBlockSnapshotSchema = z50.object({
+  kind: z50.literal("missing-block-content"),
   blockId: designBlockIdSchema,
-  identifier: z49.string().nullable(),
+  identifier: z50.string().nullable(),
   blockKind: nonEmptyStringSchema,
   orderIndex: blockOrderIndexSchema,
-  reason: z49.enum([
+  reason: z50.enum([
     "new-block",
     "deleted-content-version",
     "unpublished-block"
   ])
 }).strict();
-var pageBlockSnapshotSchema = z49.discriminatedUnion("kind", [
+var pageBlockSnapshotSchema = z50.discriminatedUnion("kind", [
   publishedPageBlockSnapshotSchema,
   draftPageBlockSnapshotSchema,
   missingPageBlockSnapshotSchema
 ]);
-var publishedPageBlockSequenceSchema = z49.array(publishedPageBlockSnapshotSchema).superRefine(validateBlockSequence);
-var draftPageBlockSequenceSchema = z49.array(pageBlockSnapshotSchema).superRefine(validateBlockSequence);
-var publishedPageDesignVersionDataV1Schema = z49.object({
-  schemaVersion: z49.literal(1),
-  stage: z49.literal("published"),
+var publishedPageBlockSequenceSchema = z50.array(publishedPageBlockSnapshotSchema).superRefine(validateBlockSequence);
+var draftPageBlockSequenceSchema = z50.array(pageBlockSnapshotSchema).superRefine(validateBlockSequence);
+var publishedPageDesignVersionDataV1Schema = z50.object({
+  schemaVersion: z50.literal(1),
+  stage: z50.literal("published"),
   pageId: designPageIdSchema,
   blockSequence: publishedPageBlockSequenceSchema
 }).strict();
-var draftPageDesignVersionDataV1Schema = z49.object({
-  schemaVersion: z49.literal(1),
-  stage: z49.literal("draft"),
+var draftPageDesignVersionDataV1Schema = z50.object({
+  schemaVersion: z50.literal(1),
+  stage: z50.literal("draft"),
   pageId: designPageIdSchema,
   blockSequence: draftPageBlockSequenceSchema
 }).strict();
-var pageDesignVersionDataV1Schema = z49.discriminatedUnion("stage", [
+var pageDesignVersionDataV1Schema = z50.discriminatedUnion("stage", [
   publishedPageDesignVersionDataV1Schema,
   draftPageDesignVersionDataV1Schema
 ]);
-var contentVersionOwnerSchema = z49.discriminatedUnion("kind", [
-  z49.object({
-    kind: z49.literal("block"),
+var contentVersionOwnerSchema = z50.discriminatedUnion("kind", [
+  z50.object({
+    kind: z50.literal("block"),
     blockId: designBlockIdSchema
   }).strict(),
-  z49.object({
-    kind: z49.literal("entry"),
+  z50.object({
+    kind: z50.literal("entry"),
     entryId: designEntryIdSchema
   }).strict(),
-  z49.object({
-    kind: z49.literal("page"),
+  z50.object({
+    kind: z50.literal("page"),
     pageId: designPageIdSchema
   }).strict()
 ]);
 function validateBlockSequence(snapshots, ctx) {
-  for (const issue of collectBlockSequenceIssues(snapshots)) {
-    ctx.addIssue(issue);
+  for (const issue2 of collectBlockSequenceIssues(snapshots)) {
+    ctx.addIssue(issue2);
   }
 }
 function collectBlockSequenceIssues(snapshots) {
@@ -61431,7 +61668,7 @@ function collectBlockSequenceIssues(snapshots) {
   snapshots.forEach((snapshot, index) => {
     if (seenBlockIds.has(snapshot.blockId)) {
       issues.push({
-        code: z49.ZodIssueCode.custom,
+        code: z50.ZodIssueCode.custom,
         message: `Duplicate blockId in page design blockSequence: ${snapshot.blockId}`,
         path: [index, "blockId"]
       });
@@ -61440,7 +61677,7 @@ function collectBlockSequenceIssues(snapshots) {
     const orderIndex = snapshot.orderIndex;
     if (seenOrderIndexes.has(orderIndex)) {
       issues.push({
-        code: z49.ZodIssueCode.custom,
+        code: z50.ZodIssueCode.custom,
         message: `Duplicate orderIndex in page design blockSequence: ${String(orderIndex)}`,
         path: [index, "orderIndex"]
       });
@@ -61448,7 +61685,7 @@ function collectBlockSequenceIssues(snapshots) {
     seenOrderIndexes.add(orderIndex);
     if (previousOrderIndex !== null && orderIndex <= previousOrderIndex) {
       issues.push({
-        code: z49.ZodIssueCode.custom,
+        code: z50.ZodIssueCode.custom,
         message: `Expected orderIndex greater than ${String(previousOrderIndex)} for blockSequence position ${String(index)}; received ${String(orderIndex)}.`,
         path: [index, "orderIndex"]
       });
@@ -61504,7 +61741,7 @@ var pageFlowPresets = [
 init_styleTags();
 
 // ../theme-core/src/site-styles/tokenRecipes.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 var themeTokenRecipeOptions = {
   palette: ["brand-led", "warm-neutral", "high-contrast", "soft-natural"],
   contrast: ["standard", "strong", "maximum"],
@@ -61519,14 +61756,14 @@ var themeTokenRecipeOptions = {
   spacing: ["compact", "regular", "airy"],
   motion: ["none", "subtle", "expressive"]
 };
-var themeTokenRecipesSchema = z50.object({
-  palette: z50.enum(themeTokenRecipeOptions.palette),
-  contrast: z50.enum(themeTokenRecipeOptions.contrast),
-  radius: z50.enum(themeTokenRecipeOptions.radius),
-  shadow: z50.enum(themeTokenRecipeOptions.shadow),
-  typography: z50.enum(themeTokenRecipeOptions.typography),
-  spacing: z50.enum(themeTokenRecipeOptions.spacing),
-  motion: z50.enum(themeTokenRecipeOptions.motion)
+var themeTokenRecipesSchema = z51.object({
+  palette: z51.enum(themeTokenRecipeOptions.palette),
+  contrast: z51.enum(themeTokenRecipeOptions.contrast),
+  radius: z51.enum(themeTokenRecipeOptions.radius),
+  shadow: z51.enum(themeTokenRecipeOptions.shadow),
+  typography: z51.enum(themeTokenRecipeOptions.typography),
+  spacing: z51.enum(themeTokenRecipeOptions.spacing),
+  motion: z51.enum(themeTokenRecipeOptions.motion)
 });
 
 // ../blocks/src/system/designCapabilities.ts
@@ -61778,7 +62015,7 @@ var bodyTextBlockDefinition = {
 init_builder();
 init_fragments2();
 init_defineBlock();
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 var composition = composeFragments([{ fragment: blogFeaturedPostFragment }]);
 var blogPostLayout = section(
   { background: "background", className: "rb-px-6 rb-py-12" },
@@ -61807,17 +62044,17 @@ var blogPostManifest = createBlockManifest({
   additionalFields: composition.fields,
   layout: blogPostLayout
 });
-var blogPostDataSchema = z51.object({
-  id: z51.string(),
-  title: z51.string(),
-  slug: z51.string(),
-  path: z51.string(),
-  excerpt: z51.string().nullable().optional(),
-  image: z51.object({
-    url: z51.string().optional().nullable(),
-    alt: z51.string().optional().nullable()
+var blogPostDataSchema = z52.object({
+  id: z52.string(),
+  title: z52.string(),
+  slug: z52.string(),
+  path: z52.string(),
+  excerpt: z52.string().nullable().optional(),
+  image: z52.object({
+    url: z52.string().optional().nullable(),
+    alt: z52.string().optional().nullable()
   }).nullable().optional(),
-  publishedAt: z51.string().nullable().optional()
+  publishedAt: z52.string().nullable().optional()
 });
 var blogPostBlockDefinition = {
   manifest: blogPostManifest,
@@ -61832,7 +62069,7 @@ init_schema2();
 init_builder();
 init_fragments();
 init_colorStyles();
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 var blogListingDataLoader = {
   endpoint: "listPublishedEntries",
   params: {
@@ -62150,24 +62387,24 @@ var blogListingManifest = createBlockManifest({
     spacing: "lg"
   }
 });
-var blogPostListEntrySchema = z52.object({
-  id: z52.string(),
-  slug: z52.string(),
-  path: z52.string(),
-  title: z52.string(),
-  excerpt: z52.string().nullable().optional(),
-  publishedAt: z52.string().nullable().optional(),
-  updatedAt: z52.string(),
-  status: z52.string(),
-  image: z52.object({
-    url: z52.string(),
-    alt: z52.string().nullable().optional()
+var blogPostListEntrySchema = z53.object({
+  id: z53.string(),
+  slug: z53.string(),
+  path: z53.string(),
+  title: z53.string(),
+  excerpt: z53.string().nullable().optional(),
+  publishedAt: z53.string().nullable().optional(),
+  updatedAt: z53.string(),
+  status: z53.string(),
+  image: z53.object({
+    url: z53.string(),
+    alt: z53.string().nullable().optional()
   }).nullable().optional()
 });
 var blogListingBlockDefinition = {
   manifest: blogListingManifest,
   dataSchemas: {
-    posts: z52.array(blogPostListEntrySchema).optional()
+    posts: z53.array(blogPostListEntrySchema).optional()
   },
   dataLoaders: {
     posts: blogListingDataLoader
@@ -62288,7 +62525,7 @@ init_builder();
 init_fragments();
 
 // ../blocks/src/system/transforms/registry/formatting.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 var uppercaseTransform = {
   id: "string.uppercase",
   kind: "string",
@@ -62299,7 +62536,7 @@ var fallbackTransform = {
   id: "value.fallback",
   kind: "formatter",
   summary: "Provide fallback when value is null or undefined",
-  schema: z53.object({ fallback: z53.unknown() }),
+  schema: z54.object({ fallback: z54.unknown() }),
   run: (value, options) => value === null || value === void 0 || value === "" ? options.fallback : value
 };
 var dateFormatShort = {
@@ -62346,8 +62583,8 @@ var jsonArrayTransform = {
     return "";
   }
 };
-var marqueeLoopOptionsSchema = z53.object({
-  minItems: z53.number().int().min(1).default(10)
+var marqueeLoopOptionsSchema = z54.object({
+  minItems: z54.number().int().min(1).default(10)
 });
 var marqueeLoopTransform = {
   id: "array.marqueeLoop",
@@ -62379,7 +62616,7 @@ init_core2();
 init_colorStyles();
 init_blockColorTokens();
 init_sectionState_shared();
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 var joinClasses6 = (parts) => parts.filter(
   (part) => typeof part === "string" && part.trim().length > 0
 ).join(" ").replace(/\s+/g, " ").trim();
@@ -62439,8 +62676,8 @@ function getNavStyleClasses(navStyle) {
       return baseClasses;
   }
 }
-var headerNavClassOptionsSchema = z54.object({
-  base: z54.string().optional()
+var headerNavClassOptionsSchema = z55.object({
+  base: z55.string().optional()
 });
 var headerNavLinkClassTransform = {
   id: "ui.headerNavLinkClass",
@@ -62486,7 +62723,7 @@ var sectionStateToneTransform = {
   summary: "Map semantic section-state kind to feedback tone",
   run: (value) => sectionStateToneFromUnknown(value)
 };
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readString(obj, key) {
@@ -62523,8 +62760,8 @@ function resolveHeroContentMaxWidth(content) {
     return raw;
   return "default";
 }
-var heroContentWrapperClassSchema = z54.object({
-  base: z54.string().optional()
+var heroContentWrapperClassSchema = z55.object({
+  base: z55.string().optional()
 });
 var heroContentWrapperClassTransform = {
   id: "ui.heroContentWrapperClass",
@@ -62532,7 +62769,7 @@ var heroContentWrapperClassTransform = {
   summary: "Resolve hero content wrapper className from alignment + max width controls",
   schema: heroContentWrapperClassSchema,
   run: (value, options, context) => {
-    const content = isPlainObject2(value) ? value : isPlainObject2(context.data) ? context.data : {};
+    const content = isPlainObject3(value) ? value : isPlainObject3(context.data) ? context.data : {};
     const alignment = resolveHeroContentAlignment(content);
     const maxWidth = resolveHeroContentMaxWidth(content);
     const textAlignClass = alignment === "center" ? "rb-text-center" : alignment === "right" ? "rb-text-right" : "rb-text-left";
@@ -62551,7 +62788,7 @@ var heroCtaJustifyTransform = {
   kind: "string",
   summary: "Map hero contentAlignment to CTA row justify value",
   run: (value, _options, context) => {
-    const content = isPlainObject2(value) ? value : isPlainObject2(context.data) ? context.data : {};
+    const content = isPlainObject3(value) ? value : isPlainObject3(context.data) ? context.data : {};
     const alignment = resolveHeroContentAlignment(content);
     return alignment === "left" ? "start" : alignment === "right" ? "end" : "center";
   }
@@ -62561,13 +62798,13 @@ var heroStackJustifyFromVerticalAlignmentTransform = {
   kind: "string",
   summary: "Map hero verticalAlignment to stack justify value",
   run: (value, _options, context) => {
-    const content = isPlainObject2(value) ? value : isPlainObject2(context.data) ? context.data : {};
+    const content = isPlainObject3(value) ? value : isPlainObject3(context.data) ? context.data : {};
     const vertical = resolveHeroVerticalAlignment(content);
     return vertical === "top" ? "start" : vertical === "bottom" ? "end" : "center";
   }
 };
-var heroGridClassFromVerticalAlignmentSchema = z54.object({
-  base: z54.string()
+var heroGridClassFromVerticalAlignmentSchema = z55.object({
+  base: z55.string()
 });
 var heroGridClassFromVerticalAlignmentTransform = {
   id: "ui.heroGridClassFromVerticalAlignment",
@@ -62575,16 +62812,16 @@ var heroGridClassFromVerticalAlignmentTransform = {
   summary: "Append align-items class for hero split layouts based on verticalAlignment",
   schema: heroGridClassFromVerticalAlignmentSchema,
   run: (value, options, context) => {
-    const content = isPlainObject2(value) ? value : isPlainObject2(context.data) ? context.data : {};
+    const content = isPlainObject3(value) ? value : isPlainObject3(context.data) ? context.data : {};
     const vertical = resolveHeroVerticalAlignment(content);
     const itemsClass = vertical === "top" ? "rb-items-start" : vertical === "bottom" ? "rb-items-end" : "rb-items-center";
     return joinClasses6([options.base, itemsClass]);
   }
 };
-var imageFragmentClassOptionsSchema = z54.object({
-  base: z54.string(),
-  whenAuto: z54.string(),
-  whenFixed: z54.string()
+var imageFragmentClassOptionsSchema = z55.object({
+  base: z55.string(),
+  whenAuto: z55.string(),
+  whenFixed: z55.string()
 });
 var imageFragmentClassTransform = {
   id: "ui.imageFragmentClass",
@@ -62600,9 +62837,9 @@ var imageFragmentClassTransform = {
     ]);
   }
 };
-var imageFragmentSizeOptionsSchema = z54.object({
-  max: z54.number().int().positive().default(1920),
-  quality: z54.number().int().min(1).max(100).default(85)
+var imageFragmentSizeOptionsSchema = z55.object({
+  max: z55.number().int().positive().default(1920),
+  quality: z55.number().int().min(1).max(100).default(85)
 });
 var imageFragmentSizeTransform = {
   id: "ui.imageFragmentSize",
@@ -62622,9 +62859,9 @@ var imageFragmentSizeTransform = {
     return { width, height, quality, resize: "cover" };
   }
 };
-var conditionalClassOptionsSchema = z54.object({
-  whenTrue: z54.string(),
-  whenFalse: z54.string()
+var conditionalClassOptionsSchema = z55.object({
+  whenTrue: z55.string(),
+  whenFalse: z55.string()
 });
 var conditionalClassTransform = {
   id: "ui.conditionalClass",
@@ -62636,9 +62873,9 @@ var conditionalClassTransform = {
     return isTrue ? options.whenTrue : options.whenFalse;
   }
 };
-var twoColumnContainerClassOptionsSchema = z54.object({
-  base: z54.string(),
-  reverseClass: z54.string()
+var twoColumnContainerClassOptionsSchema = z55.object({
+  base: z55.string(),
+  reverseClass: z55.string()
 });
 var twoColumnContainerClassTransform = {
   id: "ui.twoColumnContainerClass",
@@ -62653,8 +62890,8 @@ var twoColumnContainerClassTransform = {
     ]);
   }
 };
-var twoColumnFlexBasisOptionsSchema = z54.object({
-  side: z54.enum(["image", "text"])
+var twoColumnFlexBasisOptionsSchema = z55.object({
+  side: z55.enum(["image", "text"])
 });
 var twoColumnFlexBasisTransform = {
   id: "ui.twoColumnFlexBasis",
@@ -62668,8 +62905,8 @@ var twoColumnFlexBasisTransform = {
     return `${percent}%`;
   }
 };
-var columnsDesktopSpanClassOptionsSchema = z54.object({
-  base: z54.string().optional()
+var columnsDesktopSpanClassOptionsSchema = z55.object({
+  base: z55.string().optional()
 });
 var columnsDesktopSpanClassTransform = {
   id: "ui.columnsDesktopSpanClass",
@@ -62711,8 +62948,8 @@ var columnsColsAtTransform = {
   id: "ui.columnsColsAt",
   kind: "formatter",
   summary: "Resolve columns count for a specific breakpoint",
-  schema: z54.object({
-    breakpoint: z54.enum(["mobile", "md", "lg", "xl"])
+  schema: z55.object({
+    breakpoint: z55.enum(["mobile", "md", "lg", "xl"])
   }),
   run: (value, options) => {
     const content = asPartialObject(value) ?? {};
@@ -62839,14 +63076,14 @@ var uiTransforms = [
 init_colorConversion();
 init_core2();
 init_colorStyles();
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 var joinClasses7 = (parts) => parts.filter(
   (part) => typeof part === "string" && part.trim().length > 0
 ).join(" ").replace(/\s+/g, " ").trim();
-var maxWidthClassSchema = z55.object({
-  base: z55.string().optional(),
-  container: z55.string().optional(),
-  full: z55.string().optional()
+var maxWidthClassSchema = z56.object({
+  base: z56.string().optional(),
+  container: z56.string().optional(),
+  full: z56.string().optional()
 });
 var maxWidthClassTransform = {
   id: "layout.maxWidthClass",
@@ -62862,11 +63099,11 @@ var maxWidthClassTransform = {
     return joinClasses7([base, chosen]);
   }
 };
-var headerRootClassSchema = z55.object({
-  base: z55.string().optional(),
-  sticky: z55.string().optional(),
-  stickyTransparent: z55.string().optional(),
-  invert: z55.string().optional()
+var headerRootClassSchema = z56.object({
+  base: z56.string().optional(),
+  sticky: z56.string().optional(),
+  stickyTransparent: z56.string().optional(),
+  invert: z56.string().optional()
 });
 function resolveBackgroundVisualStyles(backgroundColor, tokens, defaultToken = "surface") {
   const backgroundToken = typeof backgroundColor === "string" && backgroundColor.trim().length > 0 ? backgroundColor : defaultToken;
@@ -62987,11 +63224,11 @@ var headerRootClassTransform = {
     return joinClasses7(classes);
   }
 };
-var footerRootClassSchema = z55.object({
-  base: z55.string().optional(),
-  surface: z55.string().optional(),
-  tokenPrefix: z55.string().optional(),
-  transparent: z55.string().optional()
+var footerRootClassSchema = z56.object({
+  base: z56.string().optional(),
+  surface: z56.string().optional(),
+  tokenPrefix: z56.string().optional(),
+  transparent: z56.string().optional()
 });
 var footerRootClassTransform = {
   id: "layout.footerRootClass",
@@ -63095,8 +63332,8 @@ var footerAlignClassMap = {
   end: "rb-justify-end",
   "space-between": "rb-justify-between"
 };
-var footerBottomBarClassSchema = z55.object({
-  base: z55.string().optional()
+var footerBottomBarClassSchema = z56.object({
+  base: z56.string().optional()
 });
 var footerBottomBarClassTransform = {
   id: "layout.footerBottomBarClass",
@@ -63118,10 +63355,10 @@ var footerBottomBarClassTransform = {
     ]);
   }
 };
-var footerBottomBarContainerClassSchema = z55.object({
-  base: z55.string().optional(),
-  fullBleed: z55.string().optional(),
-  contained: z55.string().optional()
+var footerBottomBarContainerClassSchema = z56.object({
+  base: z56.string().optional(),
+  fullBleed: z56.string().optional(),
+  contained: z56.string().optional()
 });
 var footerBottomBarContainerClassTransform = {
   id: "layout.footerBottomBarContainerClass",
@@ -63206,8 +63443,8 @@ var footerSplitNavSingleClassTransform = {
     ]);
   }
 };
-var footerLogoClassSchema = z55.object({
-  base: z55.string().optional()
+var footerLogoClassSchema = z56.object({
+  base: z56.string().optional()
 });
 var footerLogoClassTransform = {
   id: "layout.footerLogoClass",
@@ -63229,8 +63466,8 @@ var footerLogoClassTransform = {
     ]);
   }
 };
-var footerLogoMediaClassSchema = z55.object({
-  base: z55.string().optional()
+var footerLogoMediaClassSchema = z56.object({
+  base: z56.string().optional()
 });
 var footerLogoMediaClassTransform = {
   id: "layout.footerLogoMediaClass",
@@ -63284,12 +63521,12 @@ var layoutTransforms = [
 ];
 
 // ../blocks/src/system/transforms/registry/media.ts
-import { z as z56 } from "zod";
-var mediaFromUrlOptionsSchema = z56.object({
-  width: z56.number().int().positive().optional(),
-  height: z56.number().int().positive().optional(),
-  quality: z56.number().int().min(1).max(100).optional(),
-  resize: z56.enum(["cover", "contain", "fill"]).optional()
+import { z as z57 } from "zod";
+var mediaFromUrlOptionsSchema = z57.object({
+  width: z57.number().int().positive().optional(),
+  height: z57.number().int().positive().optional(),
+  quality: z57.number().int().min(1).max(100).optional(),
+  resize: z57.enum(["cover", "contain", "fill"]).optional()
 });
 function maybeBuildSupabaseTransformUrl(inputUrl, options) {
   const width = options.width;
@@ -63338,10 +63575,10 @@ var mediaTransforms = [mediaFromUrl];
 
 // ../blocks/src/system/transforms/registry/content.ts
 init_typeGuards2();
-import { z as z57 } from "zod";
-var supportedRichTextTokenSchema = z57.enum(["year", "site_name"]);
-var interpolateRichTextTokensOptionsSchema = z57.object({
-  tokens: z57.array(supportedRichTextTokenSchema).default(["year", "site_name"])
+import { z as z58 } from "zod";
+var supportedRichTextTokenSchema = z58.enum(["year", "site_name"]);
+var interpolateRichTextTokensOptionsSchema = z58.object({
+  tokens: z58.array(supportedRichTextTokenSchema).default(["year", "site_name"])
 });
 var richTextTokenPattern = /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g;
 function getSiteName(context) {
@@ -65176,7 +65413,7 @@ init_fragments();
 init_boxStyles2();
 init_defineBlock();
 init_api_bindings();
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 var appointmentBookingManifest = createBlockManifest({
   id: "block.appointment-booking",
   version: "2.0.0",
@@ -65252,11 +65489,11 @@ var appointmentBookingManifest = createBlockManifest({
     })
   ]
 });
-var availabilityDataSchema = z58.object({
-  slots: z58.array(z58.object({
-    startAt: z58.string(),
-    endAt: z58.string(),
-    resourceId: z58.string()
+var availabilityDataSchema = z59.object({
+  slots: z59.array(z59.object({
+    startAt: z59.string(),
+    endAt: z59.string(),
+    resourceId: z59.string()
   }))
 });
 var appointmentBookingBlockDefinition = {
@@ -65292,7 +65529,7 @@ init_fragments();
 init_shared4();
 init_shop_shared();
 init_defineBlock();
-import { z as z59 } from "zod";
+import { z as z60 } from "zod";
 var eventDetailsManifest = createBlockManifest({
   id: "block.event-details",
   version: "1.0.0",
@@ -65421,22 +65658,22 @@ var eventDetailsManifest = createBlockManifest({
     })
   ]
 });
-var occurrenceContextSchema2 = z59.object({
-  id: z59.string(),
-  seriesId: z59.string(),
-  startsAt: z59.string(),
-  endsAt: z59.string(),
-  timeZone: z59.string(),
-  capacityOverride: z59.number().nullable().optional(),
-  overrides: z59.record(z59.string(), z59.unknown()).nullable().optional()
+var occurrenceContextSchema2 = z60.object({
+  id: z60.string(),
+  seriesId: z60.string(),
+  startsAt: z60.string(),
+  endsAt: z60.string(),
+  timeZone: z60.string(),
+  capacityOverride: z60.number().nullable().optional(),
+  overrides: z60.record(z60.string(), z60.unknown()).nullable().optional()
 }).nullable();
 var eventDetailsBlockDefinition = {
   manifest: eventDetailsManifest,
   dataSchemas: {
-    eventDetailsData: z59.object({
+    eventDetailsData: z60.object({
       events: publicEventsArraySchema,
-      sitePasses: z59.object({ passes: z59.array(publicPassProductSchema) }),
-      siteMemberships: z59.object({ memberships: z59.array(publicMembershipProductSchema) })
+      sitePasses: z60.object({ passes: z60.array(publicPassProductSchema) }),
+      siteMemberships: z60.object({ memberships: z60.array(publicMembershipProductSchema) })
     }).optional(),
     occurrenceContext: occurrenceContextSchema2.optional()
   },
@@ -65779,7 +66016,7 @@ init_builder();
 init_fragments();
 init_defineBlock();
 init_colorStyles();
-import { z as z60 } from "zod";
+import { z as z61 } from "zod";
 var embedFields = [
   // Section heading
   parseFieldDefinition({
@@ -66010,18 +66247,18 @@ var embedManifest = createBlockManifest({
     spacing: "lg"
   }
 });
-var embedEntrySchema = z60.object({
-  id: z60.string(),
-  identifier: z60.string(),
-  title: z60.string(),
-  slug: z60.string().nullable().optional(),
-  content: z60.record(z60.string(), z60.unknown()).optional(),
-  publishedAt: z60.string().nullable().optional()
+var embedEntrySchema = z61.object({
+  id: z61.string(),
+  identifier: z61.string(),
+  title: z61.string(),
+  slug: z61.string().nullable().optional(),
+  content: z61.record(z61.string(), z61.unknown()).optional(),
+  publishedAt: z61.string().nullable().optional()
 });
 var embedBlockDefinition = {
   manifest: embedManifest,
   dataSchemas: {
-    entries: z60.array(embedEntrySchema).optional()
+    entries: z61.array(embedEntrySchema).optional()
   },
   dataLoaders: {
     entries: {
@@ -67230,24 +67467,24 @@ init_schema2();
 init_defineBlock();
 init_builder();
 init_fragments();
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 init_media2();
 var ITEM_NAME2 = "member";
 var teamMemberPhotoSchema = mediaSchema.refine((media2) => media2.type === "image", {
   message: "Team member photos must be image media"
 }).nullable();
-var teamMemberDataSchema = z61.object({
-  _type: z61.literal("teamMember"),
-  id: z61.string(),
-  name: z61.string(),
-  role: z61.string().nullable(),
-  roleLabel: z61.string().nullable(),
-  bio: z61.string().nullable(),
-  summary: z61.string().nullable(),
+var teamMemberDataSchema = z62.object({
+  _type: z62.literal("teamMember"),
+  id: z62.string(),
+  name: z62.string(),
+  role: z62.string().nullable(),
+  roleLabel: z62.string().nullable(),
+  bio: z62.string().nullable(),
+  summary: z62.string().nullable(),
   photo: teamMemberPhotoSchema,
-  profilePath: z61.string().nullable()
+  profilePath: z62.string().nullable()
 });
-var teamMembersDataSchema = z61.array(teamMemberDataSchema);
+var teamMembersDataSchema = z62.array(teamMemberDataSchema);
 var dynamicSourceWhen = { equals: "site_staff" };
 var manualSourceWhen = { equals: "site_staff", not: true };
 var headingNode = text(
@@ -68779,7 +69016,7 @@ function readFromSource(source, segments) {
     return void 0;
   }, source);
 }
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseRouteEntry(routeId, value) {
@@ -68789,35 +69026,35 @@ function parseRouteEntry(routeId, value) {
   if (typeof value === "string") {
     return [routeId, value];
   }
-  if (isPlainObject3(value)) {
+  if (isPlainObject4(value)) {
     return [routeId, value];
   }
   return null;
 }
 function extractRouteMapFromViewModel(viewModel) {
-  if (!isPlainObject3(viewModel)) return void 0;
+  if (!isPlainObject4(viewModel)) return void 0;
   const root = viewModel.$root;
-  if (!isPlainObject3(root)) return void 0;
+  if (!isPlainObject4(root)) return void 0;
   const routes = root.routes;
-  if (!isPlainObject3(routes)) return void 0;
+  if (!isPlainObject4(routes)) return void 0;
   const entries = Object.entries(routes).map(([routeId, value]) => parseRouteEntry(routeId, value)).filter((entry) => entry !== null);
   if (entries.length === 0) return void 0;
   return Object.fromEntries(entries);
 }
 function extractPagesByIdentifierFromViewModel(viewModel) {
-  if (!isPlainObject3(viewModel)) return void 0;
+  if (!isPlainObject4(viewModel)) return void 0;
   const root = viewModel.$root;
-  if (!isPlainObject3(root)) return void 0;
+  if (!isPlainObject4(root)) return void 0;
   const pagesByIdentifier = root.pagesByIdentifier;
-  if (!isPlainObject3(pagesByIdentifier)) return void 0;
+  if (!isPlainObject4(pagesByIdentifier)) return void 0;
   return pagesByIdentifier;
 }
 function extractEntriesByIdentifierFromViewModel(viewModel) {
-  if (!isPlainObject3(viewModel)) return void 0;
+  if (!isPlainObject4(viewModel)) return void 0;
   const root = viewModel.$root;
-  if (!isPlainObject3(root)) return void 0;
+  if (!isPlainObject4(root)) return void 0;
   const entriesByIdentifier = root.entriesByIdentifier;
-  if (!isPlainObject3(entriesByIdentifier)) return void 0;
+  if (!isPlainObject4(entriesByIdentifier)) return void 0;
   return entriesByIdentifier;
 }
 function parseBinding(raw, origin) {
@@ -68833,7 +69070,7 @@ function applyTransformsAndFallback(value, binding, context) {
   const routeMap = context.routes ?? extractRouteMapFromViewModel(context.viewModel);
   const pagesByIdentifier = context.pagesByIdentifier ?? extractPagesByIdentifierFromViewModel(context.viewModel);
   const entriesByIdentifier = context.entriesByIdentifier ?? extractEntriesByIdentifierFromViewModel(context.viewModel);
-  const root = isPlainObject3(context.viewModel.$root) ? context.viewModel.$root : null;
+  const root = isPlainObject4(context.viewModel.$root) ? context.viewModel.$root : null;
   const stage = root?.previewStage === "preview" ? "preview" : "published";
   const transformed = runTransforms(
     value,
@@ -68870,21 +69107,21 @@ function resolveTransformData(context, bindingPath) {
   const [first] = segments;
   if (typeof first === "string" && first !== "$root") {
     const namedScope = context.scopes.find((entry) => entry.name === first);
-    if (namedScope && isPlainObject3(namedScope.value)) {
+    if (namedScope && isPlainObject4(namedScope.value)) {
       return namedScope.value;
     }
   }
   for (let i = context.scopes.length - 1; i >= 0; i -= 1) {
     const scope = context.scopes[i];
-    if (scope && isPlainObject3(scope.value)) {
+    if (scope && isPlainObject4(scope.value)) {
       return scope.value;
     }
   }
   const content = context.viewModel.content;
-  if (isPlainObject3(content)) {
+  if (isPlainObject4(content)) {
     return content;
   }
-  if (isPlainObject3(context.viewModel)) {
+  if (isPlainObject4(context.viewModel)) {
     return context.viewModel;
   }
   return void 0;
@@ -69019,7 +69256,7 @@ function getNestedBinding(bindings, path) {
   const segments = path.split(".");
   let current = bindings;
   for (const segment of segments) {
-    if (!isPlainObject3(current)) return void 0;
+    if (!isPlainObject4(current)) return void 0;
     current = current[segment];
   }
   return current;
@@ -69033,7 +69270,7 @@ function resolveBindingToEditorPath(fieldName, bindings, editableRouteMetadataFi
   };
   const binding = bindings[fieldName] ?? getNestedBinding(bindings, fieldName);
   if (!binding) return null;
-  if (isPlainObject3(binding) && "source" in binding) {
+  if (isPlainObject4(binding) && "source" in binding) {
     const source = binding.source;
     if (source === "field" && "path" in binding) {
       const path = binding.path;
@@ -69052,7 +69289,7 @@ function resolveBindingToEditorPath(fieldName, bindings, editableRouteMetadataFi
         if (typeof option === "string") {
           return `content.${option}`;
         }
-        if (isPlainObject3(option) && "source" in option) {
+        if (isPlainObject4(option) && "source" in option) {
           const optSource = option.source;
           if (optSource === "field" && "path" in option) {
             const path = option.path;
@@ -69097,7 +69334,7 @@ function injectEditorPath(props2, node, parsedBinding, context) {
     }
   }
   const root = context.viewModel?.$root;
-  const isEntryTemplatePage = isPlainObject3(root) && root.contentEntry != null;
+  const isEntryTemplatePage = isPlainObject4(root) && root.contentEntry != null;
   if (isEntryTemplatePage && context.pathBase) return props2;
   const prefix = context.pathBase ?? "";
   const injectedPath = `${prefix}${fieldPath}`;
@@ -69126,7 +69363,7 @@ function injectMediaSlotPath(props2, node, parsedBinding, context) {
     if (entryPath) return props2;
   }
   const root = context.viewModel?.$root;
-  const isEntryTemplatePage = isPlainObject3(root) && root.contentEntry != null;
+  const isEntryTemplatePage = isPlainObject4(root) && root.contentEntry != null;
   if (isEntryTemplatePage && context.pathBase) return props2;
   return {
     ...props2,
@@ -69230,7 +69467,7 @@ function getNodeProps(node) {
     if (key.startsWith("$")) continue;
     legacy[key] = value;
   }
-  const props2 = isPlainObject3(node.props) ? node.props : {};
+  const props2 = isPlainObject4(node.props) ? node.props : {};
   return { ...legacy, ...props2 };
 }
 function resolveTree(node, options) {
@@ -71365,35 +71602,35 @@ init_blocks();
 // ../blocks/src/system/runtime/bindings.ts
 init_node();
 var shouldLogWarnings = isNonProductionEnv();
-function isPlainObject4(value) {
+function isPlainObject5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isRouteMapEntry(value) {
   if (typeof value === "string") return true;
-  return isPlainObject4(value);
+  return isPlainObject5(value);
 }
 function isRouteMap(value) {
-  if (!isPlainObject4(value)) return false;
+  if (!isPlainObject5(value)) return false;
   return Object.values(value).every(isRouteMapEntry);
 }
 function isPageIdentifierMap(value) {
-  if (!isPlainObject4(value)) return false;
+  if (!isPlainObject5(value)) return false;
   return Object.values(value).every((v) => typeof v === "string");
 }
 function isEntryIdentifierMap(value) {
-  if (!isPlainObject4(value)) return false;
+  if (!isPlainObject5(value)) return false;
   for (const v of Object.values(value)) {
-    if (!isPlainObject4(v)) return false;
+    if (!isPlainObject5(v)) return false;
     if (!Object.values(v).every((inner) => typeof inner === "string")) return false;
   }
   return true;
 }
 function buildTransformContext(vm) {
   const root = vm.$root;
-  const stage = root && isPlainObject4(root) && root.previewStage === "preview" ? "preview" : "published";
-  const routes = root && isPlainObject4(root) && isRouteMap(root.routes) ? root.routes : void 0;
-  const pagesByIdentifier = root && isPlainObject4(root) && isPageIdentifierMap(root.pagesByIdentifier) ? root.pagesByIdentifier : void 0;
-  const entriesByIdentifier = root && isPlainObject4(root) && isEntryIdentifierMap(root.entriesByIdentifier) ? root.entriesByIdentifier : void 0;
+  const stage = root && isPlainObject5(root) && root.previewStage === "preview" ? "preview" : "published";
+  const routes = root && isPlainObject5(root) && isRouteMap(root.routes) ? root.routes : void 0;
+  const pagesByIdentifier = root && isPlainObject5(root) && isPageIdentifierMap(root.pagesByIdentifier) ? root.pagesByIdentifier : void 0;
+  const entriesByIdentifier = root && isPlainObject5(root) && isEntryIdentifierMap(root.entriesByIdentifier) ? root.entriesByIdentifier : void 0;
   return {
     theme: defaultThemeTokens,
     stage,
@@ -78201,60 +78438,60 @@ var ENDPOINT_DEFINITIONS = {
 };
 
 // ../api/src/navigation/contracts.ts
-import { z as z62 } from "zod";
-var portalLinkPayloadSchema = z62.object({
-  kind: z62.literal("portal"),
-  path: z62.string().trim().startsWith("/").optional(),
-  labels: z62.object({
-    loggedOut: z62.string().trim().min(1).optional(),
-    loggedIn: z62.string().trim().min(1).optional()
+import { z as z63 } from "zod";
+var portalLinkPayloadSchema = z63.object({
+  kind: z63.literal("portal"),
+  path: z63.string().trim().startsWith("/").optional(),
+  labels: z63.object({
+    loggedOut: z63.string().trim().min(1).optional(),
+    loggedIn: z63.string().trim().min(1).optional()
   }).optional()
 });
-var cartLinkLabelConfigSchema = z62.discriminatedUnion("kind", [
-  z62.object({
-    kind: z62.literal("icon-only")
+var cartLinkLabelConfigSchema = z63.discriminatedUnion("kind", [
+  z63.object({
+    kind: z63.literal("icon-only")
   }),
-  z62.object({
-    kind: z62.literal("icon-with-label"),
-    label: z62.string().trim().min(1)
+  z63.object({
+    kind: z63.literal("icon-with-label"),
+    label: z63.string().trim().min(1)
   })
 ]);
-var cartLinkPayloadSchema = z62.object({
-  kind: z62.literal("cart"),
-  badge: z62.enum(["show-count", "hidden"]),
+var cartLinkPayloadSchema = z63.object({
+  kind: z63.literal("cart"),
+  badge: z63.enum(["show-count", "hidden"]),
   label: cartLinkLabelConfigSchema
 });
-var internalLinkPayloadSchema = z62.object({
-  kind: z62.literal("internal"),
-  routeId: z62.string().uuid(),
-  entityId: z62.string().uuid(),
-  entityType: z62.enum(["page", "content"]),
-  href: z62.string().min(1),
-  title: z62.string().min(1),
-  typeLabel: z62.string().min(1),
-  contentTypeKey: z62.string().nullable().optional(),
-  contentTypeName: z62.string().nullable().optional(),
-  updatedAt: z62.string().nullable().optional()
+var internalLinkPayloadSchema = z63.object({
+  kind: z63.literal("internal"),
+  routeId: z63.string().uuid(),
+  entityId: z63.string().uuid(),
+  entityType: z63.enum(["page", "content"]),
+  href: z63.string().min(1),
+  title: z63.string().min(1),
+  typeLabel: z63.string().min(1),
+  contentTypeKey: z63.string().nullable().optional(),
+  contentTypeName: z63.string().nullable().optional(),
+  updatedAt: z63.string().nullable().optional()
 }).passthrough();
-var externalLinkSchema2 = z62.object({
-  kind: z62.literal("external"),
+var externalLinkSchema2 = z63.object({
+  kind: z63.literal("external"),
   // Navigation external links are expected to be absolute URLs.
-  href: z62.string().url()
+  href: z63.string().url()
 });
-var customLinkSchema2 = z62.object({
-  kind: z62.literal("url"),
-  href: z62.string().min(1)
+var customLinkSchema2 = z63.object({
+  kind: z63.literal("url"),
+  href: z63.string().min(1)
 });
-var pageLinkSchema2 = z62.object({
-  kind: z62.literal("page"),
-  identifier: z62.string().min(1)
+var pageLinkSchema2 = z63.object({
+  kind: z63.literal("page"),
+  identifier: z63.string().min(1)
 });
-var entryLinkSchema2 = z62.object({
-  kind: z62.literal("entry"),
-  contentType: z62.string().min(1),
-  identifier: z62.string().min(1)
+var entryLinkSchema2 = z63.object({
+  kind: z63.literal("entry"),
+  contentType: z63.string().min(1),
+  identifier: z63.string().min(1)
 });
-var linkPayloadSchema = z62.discriminatedUnion("kind", [
+var linkPayloadSchema = z63.discriminatedUnion("kind", [
   internalLinkPayloadSchema,
   pageLinkSchema2,
   entryLinkSchema2,
@@ -78271,7 +78508,7 @@ var navigationLinkInputSchemaOptions = [
   portalLinkPayloadSchema,
   cartLinkPayloadSchema
 ];
-var navigationLinkInputSchema = z62.discriminatedUnion(
+var navigationLinkInputSchema = z63.discriminatedUnion(
   "kind",
   navigationLinkInputSchemaOptions
 );
@@ -78279,21 +78516,21 @@ var navigationLinkInputSchema = z62.discriminatedUnion(
 // ../api/src/sdkConfig/contracts.ts
 init_schema2();
 init_schema();
-import { z as z63 } from "zod";
+import { z as z64 } from "zod";
 function unsafeRetypeZodSchema(schema) {
   return schema;
 }
-var navIdListSchema = z63.preprocess((value) => {
+var navIdListSchema = z64.preprocess((value) => {
   if (!Array.isArray(value)) return void 0;
   const filtered = value.filter((v) => typeof v === "string" && v.trim().length > 0);
   return filtered.length > 0 ? filtered : void 0;
-}, z63.array(z63.string()).max(200).optional());
-var dashboardNavVisibilityBaseSchema = z63.object({
-  mode: z63.enum(["augment", "restrict"]).optional(),
+}, z64.array(z64.string()).max(200).optional());
+var dashboardNavVisibilityBaseSchema = z64.object({
+  mode: z64.enum(["augment", "restrict"]).optional(),
   allowIds: navIdListSchema,
   denyIds: navIdListSchema
 }).strip();
-var dashboardNavVisibilityRolesSchema = z63.object({
+var dashboardNavVisibilityRolesSchema = z64.object({
   administrator: dashboardNavVisibilityBaseSchema.optional(),
   editor: dashboardNavVisibilityBaseSchema.optional(),
   team_member: dashboardNavVisibilityBaseSchema.optional(),
@@ -78302,57 +78539,57 @@ var dashboardNavVisibilityRolesSchema = z63.object({
 var dashboardNavVisibilitySchema = dashboardNavVisibilityBaseSchema.extend({
   roles: dashboardNavVisibilityRolesSchema
 }).strip();
-var dashboardNavigationConfigSchema = z63.object({
+var dashboardNavigationConfigSchema = z64.object({
   siteNav: dashboardNavVisibilitySchema.optional(),
   settingsNav: dashboardNavVisibilitySchema.optional()
 }).strip();
-var dashboardConfigSchema = z63.object({
-  previewEditingEnabled: z63.boolean().optional(),
+var dashboardConfigSchema = z64.object({
+  previewEditingEnabled: z64.boolean().optional(),
   navigation: dashboardNavigationConfigSchema.optional()
 }).strip();
 var fieldDefinitionInputSchema = unsafeRetypeZodSchema(fieldSchema);
 var nodeDefinitionSchema = unsafeRetypeZodSchema(NodeSchema);
-var sdkLoaderEndpointSchema = z63.enum(SUPPORTED_LOADER_ENDPOINTS);
-var loaderParamBindingSchema = z63.object({
-  $bind: z63.object({
-    from: z63.string().min(1, "Binding path is required"),
-    fallback: z63.string().optional()
+var sdkLoaderEndpointSchema = z64.enum(SUPPORTED_LOADER_ENDPOINTS);
+var loaderParamBindingSchema = z64.object({
+  $bind: z64.object({
+    from: z64.string().min(1, "Binding path is required"),
+    fallback: z64.string().optional()
   })
 });
-var loaderParamValueSchema = z63.union([
-  z63.string(),
-  z63.number(),
-  z63.boolean(),
+var loaderParamValueSchema = z64.union([
+  z64.string(),
+  z64.number(),
+  z64.boolean(),
   loaderParamBindingSchema
 ]);
-var sdkConfigLoaderSchema = z63.object({
+var sdkConfigLoaderSchema = z64.object({
   endpoint: sdkLoaderEndpointSchema,
-  params: z63.record(z63.string(), loaderParamValueSchema),
-  mode: z63.enum(["server", "client"]).default("server")
+  params: z64.record(z64.string(), loaderParamValueSchema),
+  mode: z64.enum(["server", "client"]).default("server")
 });
-var sdkDataLoadersSchema = z63.record(z63.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
-var sdkCustomBlockIdSchema = z63.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
+var sdkDataLoadersSchema = z64.record(z64.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
+var sdkCustomBlockIdSchema = z64.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
   message: "Block ID must start with 'custom.' followed by lowercase letters, numbers, or hyphens"
 }).transform((value) => value);
-var sdkCustomBlockInputSchema = z63.object({
+var sdkCustomBlockInputSchema = z64.object({
   id: sdkCustomBlockIdSchema,
-  title: z63.string().min(1),
-  titleSource: z63.union([z63.string().min(1), z63.array(z63.string().min(1)).min(1)]).optional(),
-  description: z63.string().optional(),
+  title: z64.string().min(1),
+  titleSource: z64.union([z64.string().min(1), z64.array(z64.string().min(1)).min(1)]).optional(),
+  description: z64.string().optional(),
   category: blockCategoryEnum,
-  icon: z63.string().optional(),
-  tags: z63.array(z63.string()).optional(),
+  icon: z64.string().optional(),
+  tags: z64.array(z64.string()).optional(),
   fields: fieldDefinitionInputSchema.array().min(1),
   dataLoaders: sdkDataLoadersSchema,
   layout: NodeSchema.optional(),
-  variants: z63.record(z63.string().min(1), NodeSchema).optional(),
-  defaultVariant: z63.string().min(1).optional(),
-  variantOptions: z63.record(
-    z63.string().min(1),
-    z63.object({
-      label: z63.string().min(1).optional(),
-      description: z63.string().min(1).optional(),
-      icon: z63.string().min(1).optional()
+  variants: z64.record(z64.string().min(1), NodeSchema).optional(),
+  defaultVariant: z64.string().min(1).optional(),
+  variantOptions: z64.record(
+    z64.string().min(1),
+    z64.object({
+      label: z64.string().min(1).optional(),
+      description: z64.string().min(1).optional(),
+      icon: z64.string().min(1).optional()
     })
   ).optional()
 }).superRefine((data, ctx) => {
@@ -78362,7 +78599,7 @@ var sdkCustomBlockInputSchema = z63.object({
       const exists = data.fields.some((field) => field.id === source);
       if (!exists) {
         ctx.addIssue({
-          code: z63.ZodIssueCode.custom,
+          code: z64.ZodIssueCode.custom,
           message: `titleSource must reference a valid field ID (got "${source}")`,
           path: Array.isArray(data.titleSource) ? ["titleSource", index] : ["titleSource"]
         });
@@ -78371,7 +78608,7 @@ var sdkCustomBlockInputSchema = z63.object({
   }
   if (data.layout && data.variants) {
     ctx.addIssue({
-      code: z63.ZodIssueCode.custom,
+      code: z64.ZodIssueCode.custom,
       message: "Custom block must define either `layout` or `variants`, not both",
       path: ["variants"]
     });
@@ -78380,14 +78617,14 @@ var sdkCustomBlockInputSchema = z63.object({
     const keys = Object.keys(data.variants);
     if (keys.length === 0) {
       ctx.addIssue({
-        code: z63.ZodIssueCode.custom,
+        code: z64.ZodIssueCode.custom,
         message: "`variants` must contain at least one variant key",
         path: ["variants"]
       });
     }
     if (data.defaultVariant && !Object.prototype.hasOwnProperty.call(data.variants, data.defaultVariant)) {
       ctx.addIssue({
-        code: z63.ZodIssueCode.custom,
+        code: z64.ZodIssueCode.custom,
         message: "`defaultVariant` must be a key present in `variants`",
         path: ["defaultVariant"]
       });
@@ -78396,7 +78633,7 @@ var sdkCustomBlockInputSchema = z63.object({
       for (const key of Object.keys(data.variantOptions)) {
         if (!Object.prototype.hasOwnProperty.call(data.variants, key)) {
           ctx.addIssue({
-            code: z63.ZodIssueCode.custom,
+            code: z64.ZodIssueCode.custom,
             message: "`variantOptions` key must exist in `variants`",
             path: ["variantOptions", key]
           });
@@ -78405,74 +78642,74 @@ var sdkCustomBlockInputSchema = z63.object({
     }
   }
 });
-var sdkBlockFieldExtensionInputSchema = z63.object({
+var sdkBlockFieldExtensionInputSchema = z64.object({
   fields: fieldDefinitionInputSchema.array().min(1)
 });
-var sdkBlockFieldExtensionsInputSchema = z63.record(
-  z63.string().min(1),
+var sdkBlockFieldExtensionsInputSchema = z64.record(
+  z64.string().min(1),
   sdkBlockFieldExtensionInputSchema
 );
-var sdkThemePaletteSchema = z63.record(z63.string(), z63.string());
-var sdkThemeConfigSchema = z63.object({
+var sdkThemePaletteSchema = z64.record(z64.string(), z64.string());
+var sdkThemeConfigSchema = z64.object({
   palette: sdkThemePaletteSchema
 });
-var sdkSectionBackgroundSchema = z63.object({
-  id: z63.string().min(1),
-  label: z63.string().min(1),
-  token: z63.string().min(1)
+var sdkSectionBackgroundSchema = z64.object({
+  id: z64.string().min(1),
+  label: z64.string().min(1),
+  token: z64.string().min(1)
 });
-var sdkSectionOptionsConfigSchema = z63.object({
-  backgroundColor: z63.boolean().optional(),
-  backgroundImage: z63.boolean().optional(),
-  backgroundGradient: z63.boolean().optional(),
-  spacing: z63.union([z63.array(z63.enum(["compact", "default", "spacious"])), z63.boolean()]).optional(),
-  textColor: z63.boolean().optional()
+var sdkSectionOptionsConfigSchema = z64.object({
+  backgroundColor: z64.boolean().optional(),
+  backgroundImage: z64.boolean().optional(),
+  backgroundGradient: z64.boolean().optional(),
+  spacing: z64.union([z64.array(z64.enum(["compact", "default", "spacious"])), z64.boolean()]).optional(),
+  textColor: z64.boolean().optional()
 });
-var sdkContainerOptionsConfigSchema = z63.object({
-  maxWidth: z63.union([z63.array(z63.enum(["narrow", "default", "wide", "full"])), z63.boolean()]).optional(),
-  alignment: z63.union([z63.array(z63.enum(["left", "center", "right"])), z63.boolean()]).optional()
+var sdkContainerOptionsConfigSchema = z64.object({
+  maxWidth: z64.union([z64.array(z64.enum(["narrow", "default", "wide", "full"])), z64.boolean()]).optional(),
+  alignment: z64.union([z64.array(z64.enum(["left", "center", "right"])), z64.boolean()]).optional()
 });
-var sdkSiteStyleConfigSchema = z63.object({
-  sectionBackgrounds: z63.array(sdkSectionBackgroundSchema).optional(),
+var sdkSiteStyleConfigSchema = z64.object({
+  sectionBackgrounds: z64.array(sdkSectionBackgroundSchema).optional(),
   sectionOptions: sdkSectionOptionsConfigSchema.optional(),
   containerOptions: sdkContainerOptionsConfigSchema.optional()
 });
-var sdkSiteLayoutConfigSchema = z63.object({
-  footerBlocks: z63.array(
-    z63.object({
-      id: z63.string().min(1).optional(),
-      kind: z63.string().min(1),
-      content: z63.record(z63.string(), z63.unknown()).optional()
+var sdkSiteLayoutConfigSchema = z64.object({
+  footerBlocks: z64.array(
+    z64.object({
+      id: z64.string().min(1).optional(),
+      kind: z64.string().min(1),
+      content: z64.record(z64.string(), z64.unknown()).optional()
     })
   ).optional()
 });
-var sdkFieldSelectOptionSchema = z63.object({
-  value: z63.string(),
-  label: z63.string()
+var sdkFieldSelectOptionSchema = z64.object({
+  value: z64.string(),
+  label: z64.string()
 });
-var sdkBlockFieldConfigSchema = z63.object({
-  options: z63.array(sdkFieldSelectOptionSchema).optional()
+var sdkBlockFieldConfigSchema = z64.object({
+  options: z64.array(sdkFieldSelectOptionSchema).optional()
 });
-var sdkBlockFieldOptionsMapSchema = z63.record(
-  z63.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
+var sdkBlockFieldOptionsMapSchema = z64.record(
+  z64.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
     message: "Block ID must be 'block.*' or 'custom.*' format"
   }),
-  z63.record(z63.string().min(1), sdkBlockFieldConfigSchema)
+  z64.record(z64.string().min(1), sdkBlockFieldConfigSchema)
 ).optional();
-var sdkContentTypeTemplateConfigSchema = z63.object({
-  blocks: z63.array(z63.unknown())
+var sdkContentTypeTemplateConfigSchema = z64.object({
+  blocks: z64.array(z64.unknown())
 }).passthrough();
-var sdkContentTypeConfigSchema = z63.object({
-  key: z63.string().min(1),
-  fields: z63.array(z63.unknown()),
+var sdkContentTypeConfigSchema = z64.object({
+  key: z64.string().min(1),
+  fields: z64.array(z64.unknown()),
   template: sdkContentTypeTemplateConfigSchema.nullable().optional()
 }).passthrough();
-var sdkContentConfigSchema = z63.object({
-  contentTypes: z63.array(sdkContentTypeConfigSchema).optional(),
-  pages: z63.array(z63.unknown()).optional(),
-  entries: z63.array(z63.unknown()).optional(),
-  navigationMenus: z63.array(z63.unknown()).optional(),
-  settings: z63.unknown().optional()
+var sdkContentConfigSchema = z64.object({
+  contentTypes: z64.array(sdkContentTypeConfigSchema).optional(),
+  pages: z64.array(z64.unknown()).optional(),
+  entries: z64.array(z64.unknown()).optional(),
+  navigationMenus: z64.array(z64.unknown()).optional(),
+  settings: z64.unknown().optional()
 }).passthrough();
 var SDK_WORKFLOW_ID_MAX_LENGTH = 120;
 var SDK_WORKFLOW_TITLE_MAX_LENGTH = 120;
@@ -78485,41 +78722,41 @@ var SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH = 120;
 var SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH = 500;
 var SDK_WORKFLOW_ID_PATTERN = /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/;
 var SDK_WORKFLOW_ENDPOINT_PATTERN = /^\//;
-var sdkWorkflowIdSchema = z63.string().min(1).max(SDK_WORKFLOW_ID_MAX_LENGTH).regex(SDK_WORKFLOW_ID_PATTERN, {
+var sdkWorkflowIdSchema = z64.string().min(1).max(SDK_WORKFLOW_ID_MAX_LENGTH).regex(SDK_WORKFLOW_ID_PATTERN, {
   message: "Workflow ID must start with a lowercase letter and use lowercase letters, numbers, dots, underscores, or hyphens"
 });
-var sdkWorkflowEndpointSchema = z63.string().min(1).max(SDK_WORKFLOW_ENDPOINT_MAX_LENGTH).regex(SDK_WORKFLOW_ENDPOINT_PATTERN, { message: 'Workflow endpoint must be a site-relative path starting with "/"' });
-var sdkWorkflowManualTriggerSchema = z63.object({
-  type: z63.literal("manual")
+var sdkWorkflowEndpointSchema = z64.string().min(1).max(SDK_WORKFLOW_ENDPOINT_MAX_LENGTH).regex(SDK_WORKFLOW_ENDPOINT_PATTERN, { message: 'Workflow endpoint must be a site-relative path starting with "/"' });
+var sdkWorkflowManualTriggerSchema = z64.object({
+  type: z64.literal("manual")
 }).strict();
-var sdkWorkflowTriggerSchema = z63.discriminatedUnion("type", [
+var sdkWorkflowTriggerSchema = z64.discriminatedUnion("type", [
   sdkWorkflowManualTriggerSchema
 ]);
-var sdkWorkflowConfirmationSchema = z63.object({
-  title: z63.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
-  body: z63.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
+var sdkWorkflowConfirmationSchema = z64.object({
+  title: z64.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
+  body: z64.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
 }).strict();
-var sdkWorkflowConfigSchema = z63.object({
+var sdkWorkflowConfigSchema = z64.object({
   id: sdkWorkflowIdSchema,
-  title: z63.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
-  description: z63.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
-  contentType: z63.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
+  title: z64.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
+  description: z64.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
+  contentType: z64.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
   endpoint: sdkWorkflowEndpointSchema,
-  triggers: z63.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
+  triggers: z64.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
   confirmation: sdkWorkflowConfirmationSchema.optional()
 }).strict();
-var sdkWorkflowsSchema = z63.array(sdkWorkflowConfigSchema).max(SDK_WORKFLOW_MAX_COUNT, "Maximum 50 workflows per site").refine((workflows) => {
+var sdkWorkflowsSchema = z64.array(sdkWorkflowConfigSchema).max(SDK_WORKFLOW_MAX_COUNT, "Maximum 50 workflows per site").refine((workflows) => {
   const ids = workflows.map((workflow) => workflow.id);
   return ids.length === new Set(ids).size;
 }, { message: "Workflow IDs must be unique" }).optional();
-var riverbankSiteConfigInputSchema = z63.object({
-  siteId: z63.string().uuid(),
-  previewUrl: z63.string().url().optional(),
-  liveUrl: z63.string().url().optional(),
+var riverbankSiteConfigInputSchema = z64.object({
+  siteId: z64.string().uuid(),
+  previewUrl: z64.string().url().optional(),
+  liveUrl: z64.string().url().optional(),
   theme: sdkThemeConfigSchema.optional(),
   styles: sdkSiteStyleConfigSchema.optional(),
   layout: sdkSiteLayoutConfigSchema.optional(),
-  customBlocks: z63.array(sdkCustomBlockInputSchema).max(100, "Maximum 100 custom blocks per site").refine((blocks) => {
+  customBlocks: z64.array(sdkCustomBlockInputSchema).max(100, "Maximum 100 custom blocks per site").refine((blocks) => {
     const ids = blocks.map((b2) => b2.id);
     return ids.length === new Set(ids).size;
   }, { message: "Block IDs must be unique" }).optional(),
@@ -78527,43 +78764,43 @@ var riverbankSiteConfigInputSchema = z63.object({
   blockFieldExtensions: sdkBlockFieldExtensionsInputSchema.optional(),
   workflows: sdkWorkflowsSchema,
   content: sdkContentConfigSchema.optional(),
-  contentDir: z63.string().optional(),
-  sync: z63.object({
-    existingEntries: z63.enum(["skip", "update"]).optional()
+  contentDir: z64.string().optional(),
+  sync: z64.object({
+    existingEntries: z64.enum(["skip", "update"]).optional()
   }).optional(),
-  deploy: z63.object({
-    verifyCommand: z63.string().optional(),
-    prebuildOutput: z63.string().optional()
+  deploy: z64.object({
+    verifyCommand: z64.string().optional(),
+    prebuildOutput: z64.string().optional()
   }).optional(),
-  themeSource: z63.enum(["local", "cms"]).optional(),
-  activeTheme: z63.string().optional(),
-  enablePortal: z63.boolean().optional(),
+  themeSource: z64.enum(["local", "cms"]).optional(),
+  activeTheme: z64.string().optional(),
+  enablePortal: z64.boolean().optional(),
   dashboard: dashboardConfigSchema.optional()
 }).strict();
-var pushSdkConfigBodySchema = z63.object({
+var pushSdkConfigBodySchema = z64.object({
   config: riverbankSiteConfigInputSchema,
-  forceContentTypes: z63.boolean().optional()
+  forceContentTypes: z64.boolean().optional()
 }).strict();
 
 // ../api/src/siteOnboarding.ts
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 var LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS = {
   configure_appointments: {
     requirementId: "configure_appointments",
     reason: "launch_anyway"
   }
 };
-var acknowledgeLaunchRequirementRequestSchema = z64.discriminatedUnion(
+var acknowledgeLaunchRequirementRequestSchema = z65.discriminatedUnion(
   "requirementId",
   [
-    z64.object({
-      requirementId: z64.literal("review_generated_site")
+    z65.object({
+      requirementId: z65.literal("review_generated_site")
     }),
-    z64.object({
-      requirementId: z64.literal(
+    z65.object({
+      requirementId: z65.literal(
         LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.requirementId
       ),
-      overrideReason: z64.literal(
+      overrideReason: z65.literal(
         LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.reason
       )
     })
@@ -78739,79 +78976,79 @@ function isRecord4(value) {
 }
 
 // ../api/src/appointmentSetup.ts
-import { z as z65 } from "zod";
-var appointmentSetupRefSchema = z65.discriminatedUnion("kind", [
-  z65.object({ kind: z65.literal("existing"), id: z65.string().min(1) }),
-  z65.object({ kind: z65.literal("new"), draftId: z65.string().min(1) })
+import { z as z66 } from "zod";
+var appointmentSetupRefSchema = z66.discriminatedUnion("kind", [
+  z66.object({ kind: z66.literal("existing"), id: z66.string().min(1) }),
+  z66.object({ kind: z66.literal("new"), draftId: z66.string().min(1) })
 ]);
-var appointmentSetupVenueChoiceSchema = z65.discriminatedUnion("kind", [
-  z65.object({ kind: z65.literal("none") }),
-  z65.object({ kind: z65.literal("existing"), venueId: z65.string().min(1) }),
-  z65.object({
-    kind: z65.literal("create"),
-    draftId: z65.string().min(1),
-    title: z65.string().trim().min(1),
-    description: z65.string().nullable(),
-    timezone: z65.string().trim().min(1).nullable(),
-    addressJson: z65.record(z65.string(), z65.unknown()),
-    locationJson: z65.object({ lat: z65.number(), lng: z65.number() }).nullable()
+var appointmentSetupVenueChoiceSchema = z66.discriminatedUnion("kind", [
+  z66.object({ kind: z66.literal("none") }),
+  z66.object({ kind: z66.literal("existing"), venueId: z66.string().min(1) }),
+  z66.object({
+    kind: z66.literal("create"),
+    draftId: z66.string().min(1),
+    title: z66.string().trim().min(1),
+    description: z66.string().nullable(),
+    timezone: z66.string().trim().min(1).nullable(),
+    addressJson: z66.record(z66.string(), z66.unknown()),
+    locationJson: z66.object({ lat: z66.number(), lng: z66.number() }).nullable()
   })
 ]);
-var appointmentSetupPaymentDraftSchema = z65.object({
-  priceType: z65.union([z65.literal("free"), z65.literal("paid")])
-});
-var appointmentSetupServiceAssignmentDraftSchema = z65.discriminatedUnion("kind", [
-  z65.object({ kind: z65.literal("all_practitioners") }),
-  z65.object({
-    kind: z65.literal("selected_practitioners"),
-    resourceRefs: z65.array(appointmentSetupRefSchema)
+var appointmentSetupPaymentDraftSchema = z66.object({
+  priceType: z66.union([z66.literal("free"), z66.literal("paid")])
+});
+var appointmentSetupServiceAssignmentDraftSchema = z66.discriminatedUnion("kind", [
+  z66.object({ kind: z66.literal("all_practitioners") }),
+  z66.object({
+    kind: z66.literal("selected_practitioners"),
+    resourceRefs: z66.array(appointmentSetupRefSchema)
   })
 ]);
-var appointmentSetupServiceDraftSchema = z65.object({
+var appointmentSetupServiceDraftSchema = z66.object({
   ref: appointmentSetupRefSchema,
-  title: z65.string().trim().min(1),
-  description: z65.string().nullable(),
-  durationMinutes: z65.number().int().positive(),
-  priceAmount: z65.number().int().nonnegative().nullable(),
-  isActive: z65.boolean(),
-  locationType: z65.union([
-    z65.literal("virtual"),
-    z65.literal("in_person"),
-    z65.literal("hybrid")
+  title: z66.string().trim().min(1),
+  description: z66.string().nullable(),
+  durationMinutes: z66.number().int().positive(),
+  priceAmount: z66.number().int().nonnegative().nullable(),
+  isActive: z66.boolean(),
+  locationType: z66.union([
+    z66.literal("virtual"),
+    z66.literal("in_person"),
+    z66.literal("hybrid")
   ]),
   venue: appointmentSetupVenueChoiceSchema,
-  timezone: z65.string().trim().min(1).nullable(),
+  timezone: z66.string().trim().min(1).nullable(),
   payment: appointmentSetupPaymentDraftSchema,
   assignment: appointmentSetupServiceAssignmentDraftSchema
 });
-var appointmentSetupPractitionerDraftSchema = z65.object({
+var appointmentSetupPractitionerDraftSchema = z66.object({
   ref: appointmentSetupRefSchema,
-  displayName: z65.string().trim().min(1),
-  bio: z65.string().nullable(),
-  timezone: z65.string().trim().min(1),
-  colorHex: z65.string().nullable()
-});
-var appointmentSetupWeeklyWindowDraftSchema = z65.object({
-  weekday: z65.number().int().min(0).max(6),
-  startTime: z65.string(),
-  endTime: z65.string()
-});
-var appointmentSetupAvailabilityDraftSchema = z65.object({
-  kind: z65.literal("weekly_windows"),
+  displayName: z66.string().trim().min(1),
+  bio: z66.string().nullable(),
+  timezone: z66.string().trim().min(1),
+  colorHex: z66.string().nullable()
+});
+var appointmentSetupWeeklyWindowDraftSchema = z66.object({
+  weekday: z66.number().int().min(0).max(6),
+  startTime: z66.string(),
+  endTime: z66.string()
+});
+var appointmentSetupAvailabilityDraftSchema = z66.object({
+  kind: z66.literal("weekly_windows"),
   resourceRef: appointmentSetupRefSchema,
   serviceRef: appointmentSetupRefSchema.nullable(),
-  windows: z65.array(appointmentSetupWeeklyWindowDraftSchema)
+  windows: z66.array(appointmentSetupWeeklyWindowDraftSchema)
 });
 var APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX = 28 * 24 * 60;
 var APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX = 10 * 365 * 24 * 60;
-var appointmentSetupBookingNoticeSchema = z65.object({
-  minLeadMinutes: z65.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
-  maxBookingNoticeMinutes: z65.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
-});
-var applyAppointmentSetupRequestSchema = z65.object({
-  services: z65.array(appointmentSetupServiceDraftSchema),
-  practitioners: z65.array(appointmentSetupPractitionerDraftSchema),
-  availability: z65.array(appointmentSetupAvailabilityDraftSchema),
+var appointmentSetupBookingNoticeSchema = z66.object({
+  minLeadMinutes: z66.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
+  maxBookingNoticeMinutes: z66.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
+});
+var applyAppointmentSetupRequestSchema = z66.object({
+  services: z66.array(appointmentSetupServiceDraftSchema),
+  practitioners: z66.array(appointmentSetupPractitionerDraftSchema),
+  availability: z66.array(appointmentSetupAvailabilityDraftSchema),
   bookingNotice: appointmentSetupBookingNoticeSchema
 });
 
@@ -78830,24 +79067,24 @@ var STAFF_CANCELLATION_CONTEXT_CATEGORIES = [
 ];
 
 // ../api/src/siteBanner.ts
-import { z as z66 } from "zod";
+import { z as z67 } from "zod";
 var SITE_BANNER_SCOPE_VALUES = ["homepage", "all-pages"];
 var SITE_BANNER_TONE_VALUES = ["announcement", "promotion", "notice", "warning"];
 var SITE_BANNER_MAX_TEXT_LENGTH = 320;
 var SITE_BANNER_MAX_PARAGRAPHS = 2;
-var siteBannerScopeSchema = z66.enum(SITE_BANNER_SCOPE_VALUES);
-var siteBannerToneSchema = z66.enum(SITE_BANNER_TONE_VALUES);
-var siteBannerBodySchema = z66.unknown().transform(unwrapRichTextValue);
-var siteBannerCtaSchema = z66.object({
-  label: z66.string().trim().min(1),
+var siteBannerScopeSchema = z67.enum(SITE_BANNER_SCOPE_VALUES);
+var siteBannerToneSchema = z67.enum(SITE_BANNER_TONE_VALUES);
+var siteBannerBodySchema = z67.unknown().transform(unwrapRichTextValue);
+var siteBannerCtaSchema = z67.object({
+  label: z67.string().trim().min(1),
   link: linkPayloadSchema
 });
-var siteBannerSettingsSchema = z66.discriminatedUnion("enabled", [
-  z66.object({
-    enabled: z66.literal(false)
+var siteBannerSettingsSchema = z67.discriminatedUnion("enabled", [
+  z67.object({
+    enabled: z67.literal(false)
   }),
-  z66.object({
-    enabled: z66.literal(true),
+  z67.object({
+    enabled: z67.literal(true),
     scope: siteBannerScopeSchema,
     tone: siteBannerToneSchema,
     body: siteBannerBodySchema,
@@ -78859,11 +79096,11 @@ var siteBannerSettingsInputSchema = siteBannerSettingsSchema.superRefine((value,
     return;
   }
   const analysis = analyzeSiteBannerBody(value.body);
-  for (const issue of analysis.issues) {
+  for (const issue2 of analysis.issues) {
     ctx.addIssue({
-      code: z66.ZodIssueCode.custom,
+      code: z67.ZodIssueCode.custom,
       path: ["body"],
-      message: siteBannerBodyIssueMessage(issue)
+      message: siteBannerBodyIssueMessage(issue2)
     });
   }
 });
@@ -78897,8 +79134,8 @@ function analyzeSiteBannerBody(body) {
     issues
   };
 }
-function siteBannerBodyIssueMessage(issue) {
-  switch (issue) {
+function siteBannerBodyIssueMessage(issue2) {
+  switch (issue2) {
     case "empty":
       return "Banner message is required when the banner is enabled.";
     case "too-many-paragraphs":
@@ -79085,71 +79322,71 @@ function parsePublicProductCategorySelector(value) {
 }
 
 // ../api/src/aiPlayground.ts
-import { z as z67 } from "zod";
-var Rfc6902PatchOp = z67.discriminatedUnion("op", [
+import { z as z68 } from "zod";
+var Rfc6902PatchOp = z68.discriminatedUnion("op", [
   // Standard RFC-6902 operations
-  z67.object({
-    op: z67.literal("add"),
-    path: z67.string(),
-    value: z67.unknown()
+  z68.object({
+    op: z68.literal("add"),
+    path: z68.string(),
+    value: z68.unknown()
   }),
-  z67.object({
-    op: z67.literal("remove"),
-    path: z67.string()
+  z68.object({
+    op: z68.literal("remove"),
+    path: z68.string()
   }),
-  z67.object({
-    op: z67.literal("replace"),
-    path: z67.string(),
-    value: z67.unknown()
+  z68.object({
+    op: z68.literal("replace"),
+    path: z68.string(),
+    value: z68.unknown()
   }),
-  z67.object({
-    op: z67.literal("move"),
-    from: z67.string(),
-    path: z67.string()
+  z68.object({
+    op: z68.literal("move"),
+    from: z68.string(),
+    path: z68.string()
   }),
-  z67.object({
-    op: z67.literal("copy"),
-    from: z67.string(),
-    path: z67.string()
+  z68.object({
+    op: z68.literal("copy"),
+    from: z68.string(),
+    path: z68.string()
   }),
   // Block-level operations (Phase 2)
-  z67.object({
-    op: z67.literal("add_block"),
-    blockKind: z67.string(),
-    afterBlockId: z67.string().nullable(),
-    content: z67.record(z67.string(), z67.unknown()),
-    rationale: z67.string()
+  z68.object({
+    op: z68.literal("add_block"),
+    blockKind: z68.string(),
+    afterBlockId: z68.string().nullable(),
+    content: z68.record(z68.string(), z68.unknown()),
+    rationale: z68.string()
   }),
-  z67.object({
-    op: z67.literal("delete_block"),
-    blockId: z67.string(),
-    rationale: z67.string()
+  z68.object({
+    op: z68.literal("delete_block"),
+    blockId: z68.string(),
+    rationale: z68.string()
   }),
-  z67.object({
-    op: z67.literal("reorder_block"),
-    blockId: z67.string(),
-    afterBlockId: z67.string().nullable(),
-    rationale: z67.string()
+  z68.object({
+    op: z68.literal("reorder_block"),
+    blockId: z68.string(),
+    afterBlockId: z68.string().nullable(),
+    rationale: z68.string()
   })
 ]);
-var PlaygroundProposeRequest = z67.object({
-  request: z67.string().min(1).max(2e3)
+var PlaygroundProposeRequest = z68.object({
+  request: z68.string().min(1).max(2e3)
 });
-var MultiPagePatchEnvelope = z67.object({
-  pageId: z67.string(),
-  blockId: z67.string().optional(),
+var MultiPagePatchEnvelope = z68.object({
+  pageId: z68.string(),
+  blockId: z68.string().optional(),
   // Not present for page-level ops
-  blockKind: z67.string().optional(),
-  blockPurpose: z67.string().optional().nullable(),
-  ops: z67.array(Rfc6902PatchOp),
-  rationale: z67.string(),
-  currentContent: z67.record(z67.string(), z67.unknown()).optional()
-});
-var MultiPageUpdateResponse = z67.object({
-  patches: z67.array(MultiPagePatchEnvelope),
-  assistantMessage: z67.string(),
-  pagesModified: z67.number(),
-  toolCallsUsed: z67.number()
+  blockKind: z68.string().optional(),
+  blockPurpose: z68.string().optional().nullable(),
+  ops: z68.array(Rfc6902PatchOp),
+  rationale: z68.string(),
+  currentContent: z68.record(z68.string(), z68.unknown()).optional()
+});
+var MultiPageUpdateResponse = z68.object({
+  patches: z68.array(MultiPagePatchEnvelope),
+  assistantMessage: z68.string(),
+  pagesModified: z68.number(),
+  toolCallsUsed: z68.number()
 });
 
 // src/data/prefetchBlockData.ts