@riverbankcms/sdk 0.77.1 → 0.78.2

package/dist/server/server.mjs

@@ -1803,7 +1803,16 @@ var ENDPOINT_DEFINITIONS = {
     revalidate: 60,
     tags: ["site-{siteId}", "content-{siteId}-{type}"],
     auth: "user",
-    responseKind: "json"
+    responseKind: "json",
+    errors: ["validation:invalid_input", "resource:not_found", "resource:conflict", "server:internal_error"]
+  },
+  reorderContentEntries: {
+    path: "/sites/{siteId}/content/{type}/order",
+    method: "POST",
+    tags: ["site-{siteId}", "content-{siteId}-{type}"],
+    auth: "user",
+    responseKind: "json",
+    errors: ["validation:invalid_input", "resource:not_found", "resource:conflict", "server:internal_error"]
   },
   getContentTemplate: {
     path: "/sites/{siteId}/content/types/{type}/template",
@@ -3955,6 +3964,14 @@ var ENDPOINT_DEFINITIONS = {
     responseKind: "json",
     errors: []
   },
+  applyDiscountCode: {
+    path: "/public/sites/{siteId}/bookings/discounts/apply",
+    method: "POST",
+    tags: ["site-{siteId}", "booking-discounts"],
+    auth: "public",
+    responseKind: "json",
+    errors: ["validation:invalid_input", "rate_limit:exceeded"]
+  },
   // Batch endpoint for block loader requests (reduces SSR fan-out)
   batchBlockLoaders: {
     path: "/public/sites/{siteId}/block-loaders/batch",
@@ -6408,18 +6425,21 @@ function buildEndpointURL(baseURL, endpoint) {
 function isFormDataBody(value) {
   return typeof FormData !== "undefined" && value instanceof FormData;
 }
+function isUnknownArray(value) {
+  return Array.isArray(value);
+}
 function appendQueryParam(queryParams, key, value) {
   if (value === void 0 || value === null) {
     return;
   }
-  if (Array.isArray(value)) {
+  if (isUnknownArray(value)) {
     const stack2 = [...value].reverse();
     while (stack2.length > 0) {
       const item = stack2.pop();
       if (item === void 0 || item === null) {
         continue;
       }
-      if (Array.isArray(item)) {
+      if (isUnknownArray(item)) {
         stack2.push(...[...item].reverse());
         continue;
       }
@@ -6429,6 +6449,12 @@ function appendQueryParam(queryParams, key, value) {
   }
   queryParams.append(key, String(value));
 }
+function serializePathParam(endpoint, key, value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  throw new Error(`Invalid path param for endpoint ${String(endpoint)}: ${key} must be a string`);
+}
 function invalidateCacheTags(tags2, params) {
   const resolved = getRevalidateTag();
   if (typeof window !== "undefined" || !resolved || !tags2) return;
@@ -6567,8 +6593,9 @@ function createRawCMSClient(headers = {}, baseUrl) {
         const bracePlaceholder = `{${key}}`;
         const colonPlaceholder = `:${key}`;
         if (originalPath.includes(bracePlaceholder) || originalPath.includes(colonPlaceholder)) {
-          url = url.replace(bracePlaceholder, value);
-          url = url.replace(colonPlaceholder, value);
+          const stringValue = serializePathParam(endpoint, key, value);
+          url = url.replace(bracePlaceholder, stringValue);
+          url = url.replace(colonPlaceholder, stringValue);
         } else {
           unusedParams[key] = value;
         }
@@ -6842,7 +6869,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.77.1";
+var SDK_VERSION = "0.78.2";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -6987,6 +7014,16 @@ var RiverbankApiError = class _RiverbankApiError extends Error {
     return lines.join("\n");
   }
 };
+var resilienceStatusSymbol = /* @__PURE__ */ Symbol.for("riverbankcms.sdk.resilienceStatus");
+function attachResilienceStatusToError(error, resilienceStatus) {
+  const target = error !== null && (typeof error === "object" || typeof error === "function") ? error : new Error(error === void 0 ? "Unknown error" : String(error));
+  Object.defineProperty(target, resilienceStatusSymbol, {
+    configurable: true,
+    enumerable: false,
+    value: resilienceStatus
+  });
+  return target;
+}
 
 // src/client/resilience.ts
 var DEFAULT_RETRY_CONFIG = {
@@ -7245,7 +7282,10 @@ var CircuitOpenError = class extends Error {
 var prebuildModule = null;
 function tryRequire(modulePath) {
   try {
-    const req = Function('return typeof require === "function" ? require : null')();
+    const getRequire = new Function(
+      'return typeof require === "function" ? require : null'
+    );
+    const req = getRequire();
     return req ? req(modulePath) : null;
   } catch {
     return null;
@@ -7264,7 +7304,9 @@ function getPrebuildModule() {
     return null;
   }
   try {
-    prebuildModule = tryRequire("../prebuild/loader");
+    prebuildModule = tryRequire(
+      "../prebuild/loader"
+    );
     return prebuildModule;
   } catch {
     return null;
@@ -7324,7 +7366,9 @@ function normalizePublicFormResult(result) {
 }
 function normalizePublicFormsResponse(response) {
   return {
-    forms: response.forms.map((form2) => normalizePublicFormResponse({ form: form2 }).form)
+    forms: response.forms.map(
+      (form2) => normalizePublicFormResponse({ form: form2 }).form
+    )
   };
 }
 function normalizePublicFormsResult(result) {
@@ -7523,7 +7567,10 @@ function createRiverbankClient(config) {
       isDegraded = nowDegraded;
       config.resilience?.onDegradedMode?.(nowDegraded, status);
     }
-    return data;
+    return {
+      data,
+      resilience: status
+    };
   }
   async function resilientFetch(cacheKey, fetcher, options) {
     const requestId = generateRequestId2();
@@ -7547,25 +7594,43 @@ function createRiverbankClient(config) {
       if (allowFallbacks && !isPreview && staleIfError) {
         const stale = cache.getStale(cacheKey);
         if (stale) {
-          return emitStatus("stale", stale.value, statusDetails({
-            staleAgeSec: stale.staleAgeSec,
-            error: { code: "circuit_open", message: "Circuit breaker is open" }
-          }));
+          return emitStatus(
+            "stale",
+            stale.value,
+            statusDetails({
+              staleAgeSec: stale.staleAgeSec,
+              error: {
+                code: "circuit_open",
+                message: "Circuit breaker is open"
+              }
+            })
+          );
         }
       }
       if (allowFallbacks && !isPreview && options.prebuildFallback) {
         const prebuildResult = options.prebuildFallback();
         if (prebuildResult) {
-          return emitStatus("prebuild", prebuildResult.data, statusDetails({
-            prebuildAgeSec: prebuildResult.prebuildAgeSec,
-            error: { code: "circuit_open", message: "Circuit breaker is open" }
-          }));
+          return emitStatus(
+            "prebuild",
+            prebuildResult.data,
+            statusDetails({
+              prebuildAgeSec: prebuildResult.prebuildAgeSec,
+              error: {
+                code: "circuit_open",
+                message: "Circuit breaker is open"
+              }
+            })
+          );
         }
       }
       const circuitState = circuitBreaker.getState();
-      emitStatus("error", null, statusDetails({
-        error: { code: "circuit_open", message: "Circuit breaker is open" }
-      }));
+      emitStatus(
+        "error",
+        null,
+        statusDetails({
+          error: { code: "circuit_open", message: "Circuit breaker is open" }
+        })
+      );
       throw new CircuitOpenError(circuitState);
     }
     try {
@@ -7592,7 +7657,9 @@ function createRiverbankClient(config) {
         circuitBreaker.recordSuccess();
       } else {
         try {
-          const response = await fetcher(options.signal ?? new AbortController().signal);
+          const response = await fetcher(
+            options.signal ?? new AbortController().signal
+          );
           data = unwrapResponse(response);
         } catch (error) {
           convertToTypedError(error);
@@ -7609,28 +7676,51 @@ function createRiverbankClient(config) {
       if (allowFallbacks && !isPreview && staleIfError && cacheEnabled) {
         const stale = cache.getStale(cacheKey);
         if (stale) {
-          const errorInfo2 = error instanceof RiverbankApiError ? { code: error.code, message: error.message } : { message: error.message };
-          return emitStatus("stale", stale.value, statusDetails({
-            staleAgeSec: stale.staleAgeSec,
-            error: errorInfo2
-          }));
+          const errorInfo2 = error instanceof RiverbankApiError ? {
+            code: error.code,
+            message: error.message,
+            status: error.status
+          } : { message: error.message };
+          return emitStatus(
+            "stale",
+            stale.value,
+            statusDetails({
+              staleAgeSec: stale.staleAgeSec,
+              error: errorInfo2
+            })
+          );
         }
       }
       if (allowFallbacks && !isPreview && options.prebuildFallback) {
         const prebuildResult = options.prebuildFallback();
         if (prebuildResult) {
-          const errorInfo2 = error instanceof RiverbankApiError ? { code: error.code, message: error.message } : { message: error.message };
-          return emitStatus("prebuild", prebuildResult.data, statusDetails({
-            prebuildAgeSec: prebuildResult.prebuildAgeSec,
-            error: errorInfo2
-          }));
+          const errorInfo2 = error instanceof RiverbankApiError ? {
+            code: error.code,
+            message: error.message,
+            status: error.status
+          } : { message: error.message };
+          return emitStatus(
+            "prebuild",
+            prebuildResult.data,
+            statusDetails({
+              prebuildAgeSec: prebuildResult.prebuildAgeSec,
+              error: errorInfo2
+            })
+          );
         }
       }
-      const errorInfo = error instanceof RiverbankApiError ? { code: error.code, message: error.message } : { message: error.message };
-      emitStatus("error", null, statusDetails({ error: errorInfo }));
-      throw error;
+      const errorInfo = error instanceof RiverbankApiError ? { code: error.code, message: error.message, status: error.status } : { message: error.message };
+      const failure = emitStatus(
+        "error",
+        null,
+        statusDetails({ error: errorInfo })
+      );
+      throw attachResilienceStatusToError(error, failure.resilience);
     }
   }
+  async function resilientFetchData(cacheKey, fetcher, options) {
+    return (await resilientFetch(cacheKey, fetcher, options)).data;
+  }
   function combineAbortSignals(...signals) {
     const controller = new AbortController();
     for (const signal of signals) {
@@ -7638,32 +7728,45 @@ function createRiverbankClient(config) {
         controller.abort(signal.reason);
         break;
       }
-      signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+      signal.addEventListener("abort", () => controller.abort(signal.reason), {
+        once: true
+      });
     }
     return controller.signal;
   }
   async function resolveEntrySubrouteInternal(args) {
     const { siteId, entryId, kind, segment, stage, signal } = args;
     const cacheKey = `entry-subroute:${siteId}:${entryId}:${kind}:${segment}:${stage ?? "published"}`;
-    return resilientFetch(cacheKey, async (sig) => {
-      return await apiClient({
-        endpoint: "resolveEntrySubroute",
-        params: { siteId, entryId, kind, segment, ...stage ? { stage } : {} },
-        options: { signal: sig }
-      });
-    }, { signal });
+    return resilientFetchData(
+      cacheKey,
+      async (sig) => {
+        return await apiClient({
+          endpoint: "resolveEntrySubroute",
+          params: {
+            siteId,
+            entryId,
+            kind,
+            segment,
+            ...stage ? { stage } : {}
+          },
+          options: { signal: sig }
+        });
+      },
+      { signal }
+    );
   }
-  return {
-    async getSite(params) {
-      const { slug, domain, id, signal, force, currentPath } = params;
-      if (!slug && !domain && !id) {
-        throw new Error(
-          `getSite() requires at least one identifier: slug, domain, or id. Received: ${JSON.stringify(params)}`
-        );
-      }
-      const cacheKey = `site:${slug || domain || id}:${currentPath ?? ""}`;
-      const siteId = id || slug || domain;
-      return resilientFetch(cacheKey, async (sig) => {
+  async function getSiteWithResilienceInternal(params) {
+    const { slug, domain, id, signal, force, currentPath } = params;
+    if (!slug && !domain && !id) {
+      throw new Error(
+        `getSite() requires at least one identifier: slug, domain, or id. Received: ${JSON.stringify(params)}`
+      );
+    }
+    const cacheKey = `site:${slug || domain || id}:${currentPath ?? ""}`;
+    const siteId = id || slug || domain;
+    return resilientFetch(
+      cacheKey,
+      async (sig) => {
         const apiParams = {};
         if (params.slug) apiParams.slug = params.slug;
         if (params.domain) apiParams.domain = params.domain;
@@ -7674,66 +7777,121 @@ function createRiverbankClient(config) {
           endpoint: "getSite",
           params: apiParams,
           // When force=true, bypass Next.js fetch caching (revalidate) as well.
-          options: { signal: sig, ...force ? { cache: "no-store" } : {} }
+          options: {
+            signal: sig,
+            ...force ? { cache: "no-store" } : {}
+          }
         });
-      }, {
+      },
+      {
         signal,
         force,
         prebuildFallback: prebuildLoader && siteId ? () => prebuildLoader.loadSite(siteId) : void 0
-      });
-    },
-    async getPage(params) {
-      const { siteId, path, preview = false, signal } = params;
-      const cacheKey = `page:${siteId}:${path}:${preview}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        return await apiClient({ endpoint: "getContentByPath", params: { siteId }, body: { path, preview }, options: { signal: sig } });
-      }, {
+      }
+    );
+  }
+  async function getPageWithResilienceInternal(params) {
+    const { siteId, path, preview = false, signal } = params;
+    const cacheKey = `page:${siteId}:${path}:${preview}`;
+    return resilientFetch(
+      cacheKey,
+      async (sig) => {
+        return await apiClient({
+          endpoint: "getContentByPath",
+          params: { siteId, path, preview: String(preview) },
+          options: { signal: sig }
+        });
+      },
+      {
         preview,
         signal,
         // Prebuild fallback only for published pages (not preview)
         prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadPage(siteId, path) : void 0
-      });
+      }
+    );
+  }
+  return {
+    async getSite(params) {
+      return (await getSiteWithResilienceInternal(params)).data;
+    },
+    async getSiteWithResilience(params) {
+      return getSiteWithResilienceInternal(params);
+    },
+    async getPage(params) {
+      return (await getPageWithResilienceInternal(params)).data;
+    },
+    async getPageWithResilience(params) {
+      return getPageWithResilienceInternal(params);
     },
     async getEntries(params) {
-      const { siteId, contentType, limit, offset, order, preview = false, mode, entryIds, includeMeta, signal } = params;
+      const {
+        siteId,
+        contentType,
+        limit,
+        offset,
+        order,
+        preview = false,
+        mode,
+        entryIds,
+        includeMeta,
+        signal
+      } = params;
       const entryIdsCacheKey = mode === "manual" && entryIds?.length ? entryIds.join(",") : "";
       const cacheKey = `entries:${siteId}:${contentType}:${limit ?? ""}:${offset ?? ""}:${order ?? ""}:${preview}:${mode ?? ""}:${entryIdsCacheKey}:${includeMeta ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        let orderParam;
-        if (order === "newest") {
-          orderParam = "published_at.desc";
-        } else if (order === "oldest") {
-          orderParam = "published_at.asc";
-        } else if (order === "title") {
-          orderParam = "title.asc";
-        }
-        const apiParams = {
-          siteId,
-          type: contentType,
-          ...typeof limit === "number" && { limit: String(limit) },
-          ...typeof offset === "number" && { offset: String(offset) },
-          ...includeMeta && { meta: "true" },
-          ...orderParam && { order: orderParam },
-          ...preview && { stage: "preview" },
-          ...mode === "manual" && entryIds?.length && {
-            mode: "manual",
-            entryIds: JSON.stringify(entryIds)
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          let orderParam;
+          if (order === "newest") {
+            orderParam = "published_at.desc";
+          } else if (order === "oldest") {
+            orderParam = "published_at.asc";
+          } else if (order === "title") {
+            orderParam = "title.asc";
+          } else if (order === "manual") {
+            orderParam = "manual.asc";
           }
-        };
-        return await apiClient({ endpoint: "listPublishedEntries", params: apiParams, options: { signal: sig } });
-      }, {
-        preview,
-        signal,
-        // Prebuild fallback only for published entries (not preview, not manual mode)
-        prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadEntries(siteId, params) : void 0
-      });
+          const apiParams = {
+            siteId,
+            type: contentType,
+            ...typeof limit === "number" && { limit: String(limit) },
+            ...typeof offset === "number" && { offset: String(offset) },
+            ...includeMeta && { meta: "true" },
+            ...orderParam && { order: orderParam },
+            ...preview && { stage: "preview" },
+            ...mode === "manual" && entryIds?.length && {
+              mode: "manual",
+              entryIds: JSON.stringify(entryIds)
+            }
+          };
+          return await apiClient({
+            endpoint: "listPublishedEntries",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        {
+          preview,
+          signal,
+          // Prebuild fallback only for published entries (not preview, not manual mode)
+          prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadEntries(siteId, params) : void 0
+        }
+      );
     },
     async getEntry(params) {
       const { siteId, contentType, slug, signal } = params;
       const cacheKey = `entry:${siteId}:${contentType}:${slug}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        return await apiClient({ endpoint: "getPublishedEntryPreview", params: { siteId, type: contentType, slug }, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          return await apiClient({
+            endpoint: "getPublishedEntryPreview",
+            params: { siteId, type: contentType, slug },
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async getPublicFormById(params) {
       const { formId, siteId, signal } = params;
@@ -7741,10 +7899,18 @@ function createRiverbankClient(config) {
         throw new Error("getPublicFormById() requires formId and siteId");
       }
       const cacheKey = `public-form:${siteId}:${formId}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const response = await apiClient({ endpoint: "getPublicFormById", params: { formId, siteId }, options: { signal: sig } });
-        return normalizePublicFormResult(response);
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const response = await apiClient({
+            endpoint: "getPublicFormById",
+            params: { formId, siteId },
+            options: { signal: sig }
+          });
+          return normalizePublicFormResult(response);
+        },
+        { signal }
+      );
     },
     async getForms(params) {
       const { siteId, signal } = params;
@@ -7752,34 +7918,42 @@ function createRiverbankClient(config) {
         throw new Error("getForms() requires siteId");
       }
       const cacheKey = `forms:${siteId}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const response = await apiClient({ endpoint: "listPublicForms", params: { siteId }, options: { signal: sig } });
-        return normalizePublicFormsResult(response);
-      }, {
-        signal,
-        prebuildFallback: prebuildLoader ? () => {
-          const result = prebuildLoader.loadForms();
-          if (result) {
-            return {
-              data: {
-                forms: result.data.map((form2) => ({
-                  id: form2.id,
-                  slug: form2.slug,
-                  name: form2.name,
-                  schema: form2.schema,
-                  settings: form2.settings,
-                  schemaJson: form2.schema,
-                  settingsJson: form2.settings,
-                  createdAt: null,
-                  updatedAt: null
-                }))
-              },
-              prebuildAgeSec: result.prebuildAgeSec
-            };
-          }
-          return null;
-        } : void 0
-      });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const response = await apiClient({
+            endpoint: "listPublicForms",
+            params: { siteId },
+            options: { signal: sig }
+          });
+          return normalizePublicFormsResult(response);
+        },
+        {
+          signal,
+          prebuildFallback: prebuildLoader ? () => {
+            const result = prebuildLoader.loadForms();
+            if (result) {
+              return {
+                data: {
+                  forms: result.data.map((form2) => ({
+                    id: form2.id,
+                    slug: form2.slug,
+                    name: form2.name,
+                    schema: form2.schema,
+                    settings: form2.settings,
+                    schemaJson: form2.schema,
+                    settingsJson: form2.settings,
+                    createdAt: null,
+                    updatedAt: null
+                  }))
+                },
+                prebuildAgeSec: result.prebuildAgeSec
+              };
+            }
+            return null;
+          } : void 0
+        }
+      );
     },
     async getPublicBookingServices(params) {
       const { siteId, ids, signal } = params;
@@ -7787,13 +7961,21 @@ function createRiverbankClient(config) {
         throw new Error("getPublicBookingServices() requires siteId");
       }
       const cacheKey = `public-booking-services:${siteId}:${ids ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...ids && { ids }
-        };
-        return await apiClient({ endpoint: "getPublicBookingServices", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...ids && { ids }
+          };
+          return await apiClient({
+            endpoint: "getPublicBookingServices",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async listPublicEvents(params) {
       const {
@@ -7814,22 +7996,30 @@ function createRiverbankClient(config) {
         throw new Error("listPublicEvents() requires siteId");
       }
       const cacheKey = `public-events:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${kind ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...typeof limit === "number" && { limit: String(limit) },
-          ...from && { from },
-          ...to && { to },
-          ...stage && { stage },
-          ...categoryIds && { categoryIds },
-          ...venueId && { venueId },
-          ...kind && { kind },
-          ...entryId && { entryId },
-          ...seriesId && { seriesId },
-          ...includeOccurrenceId && { includeOccurrenceId }
-        };
-        return await apiClient({ endpoint: "listPublicEvents", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...typeof limit === "number" && { limit: String(limit) },
+            ...from && { from },
+            ...to && { to },
+            ...stage && { stage },
+            ...categoryIds && { categoryIds },
+            ...venueId && { venueId },
+            ...kind && { kind },
+            ...entryId && { entryId },
+            ...seriesId && { seriesId },
+            ...includeOccurrenceId && { includeOccurrenceId }
+          };
+          return await apiClient({
+            endpoint: "listPublicEvents",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async getPublicEventDetails(params) {
       const {
@@ -7853,37 +8043,44 @@ function createRiverbankClient(config) {
         throw new Error("getPublicEventDetails() requires siteId");
       }
       const cacheKey = `public-event-details:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${afterStartsAt ?? ""}:${afterId ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${staffMemberId ?? ""}:${kind ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const requestId = "eventDetails";
-        const response = await apiClient({
-          endpoint: "batchBlockLoaders",
-          params: { siteId, ...stage && { stage } },
-          body: {
-            requests: [
-              {
-                id: requestId,
-                endpoint: "getPublicEventDetails",
-                params: {
-                  ...typeof limit === "number" && { limit: String(limit) },
-                  ...from && { from },
-                  ...to && { to },
-                  ...afterStartsAt && { afterStartsAt },
-                  ...afterId && { afterId },
-                  ...categoryIds && { categoryIds },
-                  ...venueId && { venueId },
-                  ...staffMemberId && { staffMemberId },
-                  ...kind && { kind },
-                  ...entryId && { entryId },
-                  ...seriesId && { seriesId },
-                  ...includeOccurrenceId && { includeOccurrenceId }
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const requestId = "eventDetails";
+          const response = await apiClient({
+            endpoint: "batchBlockLoaders",
+            params: { siteId, ...stage && { stage } },
+            body: {
+              requests: [
+                {
+                  id: requestId,
+                  endpoint: "getPublicEventDetails",
+                  params: {
+                    ...typeof limit === "number" && { limit: String(limit) },
+                    ...from && { from },
+                    ...to && { to },
+                    ...afterStartsAt && { afterStartsAt },
+                    ...afterId && { afterId },
+                    ...categoryIds && { categoryIds },
+                    ...venueId && { venueId },
+                    ...staffMemberId && { staffMemberId },
+                    ...kind && { kind },
+                    ...entryId && { entryId },
+                    ...seriesId && { seriesId },
+                    ...includeOccurrenceId && { includeOccurrenceId }
+                  }
                 }
-              }
-            ]
-          },
-          options: { signal: sig }
-        });
-        return normalizeBatchBlockLoaderResult(response, requestId);
-      }, { signal });
+              ]
+            },
+            options: { signal: sig }
+          });
+          return normalizeBatchBlockLoaderResult(
+            response,
+            requestId
+          );
+        },
+        { signal }
+      );
     },
     async listPublicCourses(params) {
       const { siteId, limit, stage, signal } = params;
@@ -7891,14 +8088,22 @@ function createRiverbankClient(config) {
         throw new Error("listPublicCourses() requires siteId");
       }
       const cacheKey = `public-courses:${siteId}:${limit ?? ""}:${stage ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...typeof limit === "number" && { limit: String(limit) },
-          ...stage && { stage }
-        };
-        return await apiClient({ endpoint: "listPublicCourses", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...typeof limit === "number" && { limit: String(limit) },
+            ...stage && { stage }
+          };
+          return await apiClient({
+            endpoint: "listPublicCourses",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async listPublicTeamMembers(params) {
       const { siteId, stage, signal } = params;
@@ -7906,17 +8111,21 @@ function createRiverbankClient(config) {
         throw new Error("listPublicTeamMembers() requires siteId");
       }
       const cacheKey = `public-team-members:${siteId}:${stage ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...stage && { stage }
-        };
-        return await apiClient({
-          endpoint: "listPublicTeamMembers",
-          params: apiParams,
-          options: { signal: sig }
-        });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...stage && { stage }
+          };
+          return await apiClient({
+            endpoint: "listPublicTeamMembers",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async listPublicProducts(params) {
       const { siteId, stage, categorySelector, signal } = params;
@@ -7925,14 +8134,22 @@ function createRiverbankClient(config) {
       }
       const selectorKey = categorySelector ? categorySelector.kind === "category" ? `category:${categorySelector.productCategoryId}` : `current-category-page:${categorySelector.productCategoryEntryId}` : "";
       const cacheKey = `public-products:${siteId}:${stage ?? ""}:${selectorKey}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...stage && { stage },
-          ...encodePublicProductCategorySelector(categorySelector)
-        };
-        return await apiClient({ endpoint: "listPublicProducts", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...stage && { stage },
+            ...encodePublicProductCategorySelector(categorySelector)
+          };
+          return await apiClient({
+            endpoint: "listPublicProducts",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async listPublicPasses(params) {
       const { siteId, categories, signal } = params;
@@ -7940,13 +8157,21 @@ function createRiverbankClient(config) {
         throw new Error("listPublicPasses() requires siteId");
       }
       const cacheKey = `public-passes:${siteId}:${categories ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...categories && { categories }
-        };
-        return await apiClient({ endpoint: "listPublicPasses", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...categories && { categories }
+          };
+          return await apiClient({
+            endpoint: "listPublicPasses",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async listPublicMemberships(params) {
       const { siteId, categories, signal } = params;
@@ -7954,25 +8179,44 @@ function createRiverbankClient(config) {
         throw new Error("listPublicMemberships() requires siteId");
       }
       const cacheKey = `public-memberships:${siteId}:${categories ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...categories && { categories }
-        };
-        return await apiClient({ endpoint: "listPublicMemberships", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...categories && { categories }
+          };
+          return await apiClient({
+            endpoint: "listPublicMemberships",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async resolveEntrySubroute(params) {
       const { siteId, entryId, kind, segment, stage, signal } = params;
       if (!siteId || !entryId || !kind || !segment) {
-        throw new Error("resolveEntrySubroute() requires siteId, entryId, kind, and segment");
+        throw new Error(
+          "resolveEntrySubroute() requires siteId, entryId, kind, and segment"
+        );
       }
-      return resolveEntrySubrouteInternal({ siteId, entryId, kind, segment, stage, signal });
+      return resolveEntrySubrouteInternal({
+        siteId,
+        entryId,
+        kind,
+        segment,
+        stage,
+        signal
+      });
     },
     async resolveEventOccurrence(params) {
       const { siteId, entryId, segment, signal } = params;
       if (!siteId || !entryId || !segment) {
-        throw new Error("resolveEventOccurrence() requires siteId, entryId, and segment");
+        throw new Error(
+          "resolveEventOccurrence() requires siteId, entryId, and segment"
+        );
       }
       const result = await resolveEntrySubrouteInternal({
         siteId,
@@ -7991,13 +8235,17 @@ function createRiverbankClient(config) {
         throw new Error("checkRedirect() requires siteId and path");
       }
       const cacheKey = `redirect:${siteId}:${path}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        return await apiClient({
-          endpoint: "checkRedirect",
-          params: { site: siteId, path },
-          options: { signal: sig }
-        });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          return await apiClient({
+            endpoint: "checkRedirect",
+            params: { site: siteId, path },
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async getAllPublishedRoutes(params) {
       const { siteId, signal } = params;
@@ -8005,13 +8253,17 @@ function createRiverbankClient(config) {
         throw new Error("getAllPublishedRoutes() requires siteId");
       }
       const cacheKey = `routable-content:${siteId}:published`;
-      return resilientFetch(cacheKey, async (sig) => {
-        return await apiClient({
-          endpoint: "getPublicRoutableContent",
-          params: { siteId, publishedOnly: "true" },
-          options: { signal: sig }
-        });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          return await apiClient({
+            endpoint: "getPublicRoutableContent",
+            params: { siteId, publishedOnly: "true" },
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async getSitemapRoutes(params) {
       const { siteId, page, pageSize, signal } = params;
@@ -8019,17 +8271,21 @@ function createRiverbankClient(config) {
         throw new Error("getSitemapRoutes() requires siteId");
       }
       const cacheKey = `sitemap:${siteId}:${page ?? 1}:${pageSize ?? "default"}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        return await apiClient({
-          endpoint: "getPublicSitemapRoutes",
-          params: {
-            siteId,
-            ...page ? { page: String(page) } : {},
-            ...pageSize ? { pageSize: String(pageSize) } : {}
-          },
-          options: { signal: sig }
-        });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          return await apiClient({
+            endpoint: "getPublicSitemapRoutes",
+            params: {
+              siteId,
+              ...page ? { page: String(page) } : {},
+              ...pageSize ? { pageSize: String(pageSize) } : {}
+            },
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     clearCache() {
       cache.clear();
@@ -8049,6 +8305,27 @@ function createRiverbankClient(config) {
   };
 }
 
+// ../core/src/location.ts
+function normalizeLocationAddressText(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+function hasLocationCoordinates(value) {
+  return typeof value?.lat === "number" && typeof value?.lng === "number";
+}
+function toLocationCoordinates(value) {
+  if (!hasLocationCoordinates(value)) {
+    return null;
+  }
+  return {
+    lat: value.lat,
+    lng: value.lng
+  };
+}
+
 // ../api/src/accessAdmin.ts
 import { z } from "zod";
 var managedDomainAddOnPricingSnapshotSchema = z.object({
@@ -8191,27 +8468,6 @@ function formatKeyAsLabel(key) {
 // ../blocks/src/system/manifest/schema.ts
 import { z as z4 } from "zod";
 
-// ../core/src/location.ts
-function normalizeLocationAddressText(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed ? trimmed : null;
-}
-function hasLocationCoordinates(value) {
-  return typeof value?.lat === "number" && typeof value?.lng === "number";
-}
-function toLocationCoordinates(value) {
-  if (!hasLocationCoordinates(value)) {
-    return null;
-  }
-  return {
-    lat: value.lat,
-    lng: value.lng
-  };
-}
-
 // ../media-core/src/transformRect.ts
 function isValidTransformRectStructure(rect) {
   if (!Array.isArray(rect) || rect.length !== 4) return false;
@@ -8294,14 +8550,14 @@ function rotateNormalizedPoint(point, rotation) {
   const x = point.x;
   const y = point.y;
   switch (rotation) {
+    case 0:
+      return { x, y };
     case 90:
       return { x: 1 - y, y: x };
     case 180:
       return { x: 1 - x, y: 1 - y };
     case 270:
       return { x: y, y: 1 - x };
-    default:
-      return { x, y };
   }
 }
 
@@ -8494,6 +8750,8 @@ var uiSchema = z4.object({
   mediaPickerAutoOpen: z4.boolean().optional(),
   showMediaPreview: z4.boolean().optional(),
   showMediaOverlayActions: z4.boolean().optional(),
+  mediaPreviewMaxWidth: z4.enum(["xs", "sm", "md", "none"]).optional(),
+  preventMediaPreviewUpscale: z4.boolean().optional(),
   mediaDelivery: mediaDeliverySchema.optional(),
   mediaDeliveryByVariant: z4.record(z4.string(), mediaDeliverySchema).optional(),
   // Optional input hints for validators/widgets
@@ -8743,6 +9001,9 @@ var repeaterFieldSchema = baseFieldSchema.extend({
   type: z4.literal("repeater"),
   itemLabel: z4.string().default("Item"),
   itemLabelSource: z4.string().optional(),
+  showSummary: z4.boolean().optional(),
+  summaryFields: z4.string().array().optional(),
+  summaryMaxChars: z4.number().int().positive().optional(),
   minItems: z4.number().int().min(0).default(0),
   maxItems: z4.number().int().positive().optional(),
   // Monomorphic mode
@@ -9236,6 +9497,9 @@ function makeBoundaryId(previousBlockId, nextBlockId) {
   const next = encodeURIComponent(nextBlockId);
   return asDesignBoundaryId(`boundary:${previous}:${next}`);
 }
+function assertNever(value, message = "Unhandled Theme V2 variant") {
+  throw new Error(`${message}: ${String(value)}`);
+}
 function brandNonEmptyString(value, label) {
   if (value.length === 0) {
     throw new Error(`${label} must be a non-empty string.`);
@@ -9263,6 +9527,10 @@ var tileTreatmentValues = [
   "quiet",
   "brand-depth"
 ];
+var eventListTreatmentValues = [
+  "plain",
+  "lined-panel"
+];
 var eyebrowTreatmentValues = [
   "plain",
   "pill",
@@ -9320,6 +9588,7 @@ function defineBlockDesignCapability(capability) {
     imageSurfaceMotions: capability.imageSurfaceMotions ?? ["static"],
     testimonialCardTreatments: capability.testimonialCardTreatments ?? ["default"],
     tileTreatments: capability.tileTreatments ?? ["default"],
+    eventListTreatments: capability.eventListTreatments ?? ["plain"],
     eyebrowTreatments: capability.eyebrowTreatments ?? ["plain"],
     ...capability.headingDecorations ? { headingDecorations: capability.headingDecorations } : {},
     ...capability.accordionIconSets ? { accordionIconSets: capability.accordionIconSets } : {}
@@ -9344,9 +9613,98 @@ var blockAppearancePresets = [
       transitionAfter: "soft-fade-short",
       emphasis: "high",
       sectionHeight: "hero",
+      heroComposition: "center",
+      heroTypographyScale: "display",
       imageSurfaceTreatment: { kind: "neutral-wash" }
     }
   }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "hero-bottom-left-panel",
+    target: "hero",
+    label: "Bottom-left panel hero",
+    blockKinds: ["block.hero"],
+    constraints: {
+      layoutFamilies: ["centered", "compact"]
+    },
+    optionGroups: [
+      {
+        id: "image-surface-treatment",
+        label: "Treatment",
+        selectedOptionId: "neutral-scrim",
+        options: [
+          {
+            id: "neutral-scrim",
+            label: "Neutral scrim",
+            designPatch: {
+              imageSurfaceTreatment: { kind: "neutral-scrim", intensity: "balanced" }
+            }
+          },
+          {
+            id: "brand-scrim-primary",
+            label: "Brand scrim",
+            designPatch: {
+              imageSurfaceTreatment: { kind: "brand-scrim", token: "primary", intensity: "balanced" }
+            }
+          }
+        ]
+      }
+    ],
+    layoutPatches: [
+      {
+        constraints: {
+          layoutVariantKeys: ["micro"]
+        },
+        designPatch: {
+          sectionHeight: "banner",
+          heroTypographyScale: "editorial"
+        }
+      }
+    ],
+    design: {
+      sectionSurface: "hero-image",
+      contentFrame: panelFrame("raised"),
+      itemSurface: "none",
+      transitionAfter: "soft-fade-short",
+      emphasis: "high",
+      sectionHeight: "immersive",
+      heroComposition: "bottom-left",
+      heroTypographyScale: "display",
+      imageSurfaceTreatment: { kind: "neutral-scrim", intensity: "balanced" }
+    }
+  }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "hero-poster-image",
+    target: "hero",
+    label: "Poster image hero",
+    blockKinds: ["block.hero"],
+    constraints: {
+      layoutFamilies: ["centered", "compact"]
+    },
+    layoutPatches: [
+      {
+        constraints: {
+          layoutVariantKeys: ["micro"]
+        },
+        designPatch: {
+          sectionHeight: "banner",
+          heroTypographyScale: "display"
+        }
+      }
+    ],
+    design: {
+      sectionSurface: "hero-image",
+      contentFrame: plainFrame,
+      itemSurface: "none",
+      transitionAfter: "soft-fade-short",
+      emphasis: "high",
+      sectionHeight: "immersive",
+      heroComposition: "center",
+      heroTypographyScale: "poster",
+      imageSurfaceTreatment: { kind: "brand-scrim", token: "primary", intensity: "strong" }
+    }
+  }),
   defineBlockAppearancePreset({
     kind: "block-design",
     id: "hero-brand-scrim",
@@ -9396,6 +9754,8 @@ var blockAppearancePresets = [
       transitionAfter: "soft-fade-short",
       emphasis: "high",
       sectionHeight: "immersive",
+      heroComposition: "center",
+      heroTypographyScale: "display",
       imageSurfaceTreatment: { kind: "brand-scrim", token: "primary" }
     }
   }),
@@ -9448,6 +9808,8 @@ var blockAppearancePresets = [
       transitionAfter: "soft-fade-short",
       emphasis: "high",
       sectionHeight: "immersive",
+      heroComposition: "center",
+      heroTypographyScale: "display",
       imageSurfaceTreatment: { kind: "brand-scrim", token: "primary" },
       imageSurfaceMotion: "fixed-frame",
       eyebrowTreatment: "accent-pill-bounce"
@@ -9468,6 +9830,8 @@ var blockAppearancePresets = [
       itemSurface: "none",
       transitionAfter: "soft-fade-short",
       emphasis: "high",
+      heroComposition: "center",
+      heroTypographyScale: "editorial",
       eyebrowTreatment: "accent-pill-bounce"
     }
   }),
@@ -9482,7 +9846,82 @@ var blockAppearancePresets = [
       contentFrame: panelFrame("inset"),
       itemSurface: "none",
       transitionAfter: "none",
-      emphasis: "high"
+      emphasis: "high",
+      heroComposition: "center",
+      heroTypographyScale: "editorial"
+    }
+  }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "hero-split-editorial",
+    target: "hero",
+    label: "Editorial split hero",
+    blockKinds: ["block.hero"],
+    constraints: {
+      layoutFamilies: ["split"]
+    },
+    design: {
+      sectionSurface: "base",
+      contentFrame: plainFrame,
+      itemSurface: "none",
+      transitionAfter: "soft-fade-short",
+      emphasis: "high",
+      heroTypographyScale: "editorial"
+    }
+  }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "hero-split-brand",
+    target: "hero",
+    label: "Brand split hero",
+    blockKinds: ["block.hero"],
+    constraints: {
+      layoutFamilies: ["split"]
+    },
+    design: {
+      sectionSurface: "brand-depth-band",
+      contentFrame: plainFrame,
+      itemSurface: "none",
+      transitionAfter: "soft-fade-short",
+      emphasis: "high",
+      heroTypographyScale: "display",
+      eyebrowTreatment: "accent-pill-bounce"
+    }
+  }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "hero-split-soft-panel",
+    target: "hero",
+    label: "Soft panel split hero",
+    blockKinds: ["block.hero"],
+    constraints: {
+      layoutFamilies: ["split"]
+    },
+    design: {
+      sectionSurface: "muted-band",
+      contentFrame: panelFrame("raised"),
+      itemSurface: "none",
+      transitionAfter: "soft-fade-short",
+      emphasis: "high",
+      heroTypographyScale: "editorial"
+    }
+  }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "hero-split-accent",
+    target: "hero",
+    label: "Accent split hero",
+    blockKinds: ["block.hero"],
+    constraints: {
+      layoutFamilies: ["split"]
+    },
+    design: {
+      sectionSurface: "accent-band",
+      contentFrame: panelFrame("raised"),
+      itemSurface: "none",
+      transitionAfter: "soft-fade-short",
+      emphasis: "high",
+      heroTypographyScale: "display"
     }
   }),
   defineBlockAppearancePreset({
@@ -9515,9 +9954,9 @@ var blockAppearancePresets = [
   }),
   defineBlockAppearancePreset({
     kind: "block-design",
-    id: "intro-soft-earth-statement",
+    id: "intro-organic-statement",
     target: "intro",
-    label: "Soft Earth intro statement",
+    label: "Organic intro statement",
     blockKinds: ["block.intro"],
     design: {
       sectionSurface: "base",
@@ -9548,9 +9987,9 @@ var blockAppearancePresets = [
   }),
   defineBlockAppearancePreset({
     kind: "block-design",
-    id: "feature-cards-soft-earth-offerings",
+    id: "feature-cards-raised-rule",
     target: "feature-cards",
-    label: "Soft Earth offering cards",
+    label: "Raised cards with rule",
     blockKinds: ["block.feature-cards"],
     design: {
       sectionSurface: "base",
@@ -9579,6 +10018,21 @@ var blockAppearancePresets = [
       emphasis: "medium"
     }
   }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "events-lined-panel",
+    target: "events",
+    label: "Lined event panel",
+    blockKinds: ["block.event-calendar", "block.event-listing"],
+    design: {
+      sectionSurface: "base",
+      contentFrame: plainFrame,
+      itemSurface: "none",
+      transitionAfter: "none",
+      emphasis: "medium",
+      eventListTreatment: "lined-panel"
+    }
+  }),
   defineBlockAppearancePreset({
     kind: "block-design",
     id: "schedule-details-accent-section",
@@ -9638,9 +10092,9 @@ var blockAppearancePresets = [
   }),
   defineBlockAppearancePreset({
     kind: "block-design",
-    id: "testimonials-carded-proof",
+    id: "testimonials-simple-cards",
     target: "testimonials",
-    label: "Carded social proof",
+    label: "Simple testimonial cards",
     blockKinds: ["block.testimonials"],
     design: {
       sectionSurface: "base",
@@ -9652,9 +10106,9 @@ var blockAppearancePresets = [
   }),
   defineBlockAppearancePreset({
     kind: "block-design",
-    id: "testimonials-contained-proof",
+    id: "testimonials-raised-panel",
     target: "testimonials",
-    label: "Contained social proof",
+    label: "Raised testimonial panel",
     blockKinds: ["block.testimonials"],
     design: {
       sectionSurface: "muted-band",
@@ -9666,9 +10120,9 @@ var blockAppearancePresets = [
   }),
   defineBlockAppearancePreset({
     kind: "block-design",
-    id: "testimonials-dark-proof",
+    id: "testimonials-accent-panel",
     target: "testimonials",
-    label: "Dark proof panel",
+    label: "Accent testimonial panel",
     blockKinds: ["block.testimonials"],
     design: {
       sectionSurface: "accent-band",
@@ -9680,9 +10134,9 @@ var blockAppearancePresets = [
   }),
   defineBlockAppearancePreset({
     kind: "block-design",
-    id: "testimonials-accent-quote-proof",
+    id: "testimonials-accent-quote-cards",
     target: "testimonials",
-    label: "Accent quote proof",
+    label: "Accent quote cards",
     blockKinds: ["block.testimonials"],
     design: {
       sectionSurface: "accent-band",
@@ -9695,9 +10149,9 @@ var blockAppearancePresets = [
   }),
   defineBlockAppearancePreset({
     kind: "block-design",
-    id: "testimonials-soft-earth-proof-band",
+    id: "testimonials-brand-background-quotes",
     target: "testimonials",
-    label: "Soft Earth proof band",
+    label: "Brand background quotes",
     blockKinds: ["block.testimonials"],
     design: {
       sectionSurface: "brand-depth-band",
@@ -9741,25 +10195,6 @@ var blockAppearancePresets = [
       emphasis: "low"
     }
   }),
-  defineBlockAppearancePreset({
-    kind: "block-design",
-    id: "faq-soft-earth-two-column",
-    target: "faq",
-    label: "Soft Earth two-column FAQ",
-    blockKinds: ["block.faq"],
-    design: {
-      sectionSurface: "base",
-      contentFrame: plainFrame,
-      itemSurface: "flat",
-      transitionAfter: "none",
-      emphasis: "medium",
-      accordionIconTreatment: {
-        iconSet: "plus",
-        colorToken: "primary",
-        motion: "swap"
-      }
-    }
-  }),
   defineBlockAppearancePreset({
     kind: "block-design",
     id: "contact-form-panel",
@@ -11138,7 +11573,8 @@ var accordionSystemSchema = z12.object({
   icon: z12.object({
     style: accordionIconSchema,
     position: z12.enum(["left", "right"]),
-    size: z12.enum(["sm", "md", "lg"])
+    size: z12.enum(["sm", "md", "lg"]),
+    colorToken: themeColorTokenSchema.optional()
   }),
   // Trigger (question) styling
   trigger: z12.object({
@@ -11272,6 +11708,7 @@ var navLinkPaddingXSchema = z16.enum(["none", "tight", "compact", "default", "re
 var navLinkBorderRadiusSchema = z16.enum(["none", "sm", "md", "full"]);
 var navLinkTextSizeSchema = z16.enum(["xs", "sm", "base", "lg"]);
 var navLinkLetterSpacingSchema = z16.enum(["normal", "wide", "wider", "widest"]);
+var navLinkContrastTreatmentSchema = z16.enum(["none", "soft-glow"]);
 var navLinkStyleSchema = z16.object({
   /** Display name for the style */
   name: z16.string().min(1).max(30).optional(),
@@ -11283,6 +11720,8 @@ var navLinkStyleSchema = z16.object({
   textSize: navLinkTextSizeSchema.optional(),
   /** Optional letter spacing override */
   letterSpacing: navLinkLetterSpacingSchema.optional(),
+  /** Optional text-only contrast treatment for transparent/overlay navigation */
+  contrastTreatment: navLinkContrastTreatmentSchema.optional(),
   /** Hover/active color token (for color-change effects) */
   hoverColorToken: themeColorTokenSchema.nullable().optional(),
   /** Padding preset */
@@ -11712,6 +12151,7 @@ var sectionStylesOverrideSchema = z21.object({
   spacing: semanticSpacingSchema.nullable().optional(),
   minHeight: z21.enum(["none", "banner", "hero", "immersive"]).nullable().optional(),
   tileTreatment: z21.enum(tileTreatmentValues).nullable().optional(),
+  eventListTreatment: z21.enum(eventListTreatmentValues).nullable().optional(),
   eyebrowTreatment: z21.enum(eyebrowTreatmentValues).nullable().optional(),
   headingDecoration: headingDecorationSchema.nullable().optional(),
   // Author-level override consumed by later block/editor rendering phases.
@@ -12545,6 +12985,34 @@ var paletteVariantsById = new Map(
   paletteVariants.map((v) => [v.id, v])
 );
 
+// ../theme-core/src/accordions/siteStyleDefaults.ts
+var softEarthAccordionSystem = {
+  background: {
+    type: "solid",
+    colorToken: "background"
+  },
+  spacing: "comfortable",
+  corners: "square",
+  border: null,
+  shadow: null,
+  icon: {
+    style: "plus-minus",
+    position: "right",
+    size: "md",
+    colorToken: "primary"
+  },
+  trigger: {
+    textColorToken: "text",
+    fontWeight: "medium"
+  },
+  hover: {
+    textColorToken: "primary"
+  },
+  content: {
+    textColorToken: "neutral-700"
+  }
+};
+
 // ../theme-core/src/site-styles/headerLooks.ts
 function asHeaderLookId(value) {
   return value;
@@ -12600,7 +13068,7 @@ var headerLayoutCatalog = [
     description: "Detached header chrome that sits over the opening section.",
     structure: "floating-shell",
     variant: "floating",
-    defaultPositioning: "fixed",
+    defaultPositioning: "sticky",
     shrinkOnScroll: true,
     maxRecommendedNavItems: 5,
     allowedLogoShapes: ["none", "text-only", "horizontal"]
@@ -12617,7 +13085,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["classic", "centered"]),
     navInteraction: "color-change",
     surface: "neutral",
-    navTypography: "plain"
+    defaultDepth: "none",
+    navTypography: "plain",
+    moods: ["calm", "professional", "editorial"]
   },
   {
     id: asHeaderStyleId("fine-line"),
@@ -12626,7 +13096,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["classic", "centered"]),
     navInteraction: "underline-grow",
     surface: "bordered",
-    navTypography: "plain"
+    defaultDepth: "line",
+    navTypography: "plain",
+    moods: ["calm", "professional", "editorial"]
   },
   {
     id: asHeaderStyleId("soft-bar"),
@@ -12635,7 +13107,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["classic", "centered"]),
     navInteraction: "pill-background",
     surface: "soft",
-    navTypography: "plain"
+    defaultDepth: "line",
+    navTypography: "plain",
+    moods: ["calm", "professional"]
   },
   {
     id: asHeaderStyleId("pill-nav"),
@@ -12644,7 +13118,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["classic", "centered"]),
     navInteraction: "pill-background",
     surface: "soft",
-    navTypography: "plain"
+    defaultDepth: "none",
+    navTypography: "plain",
+    moods: ["calm"]
   },
   {
     id: asHeaderStyleId("brand-bar"),
@@ -12653,7 +13129,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["classic", "centered"]),
     navInteraction: "color-change",
     surface: "brand-solid",
-    navTypography: "brand-caps"
+    defaultDepth: "none",
+    navTypography: "brand-caps",
+    moods: ["professional", "expressive", "utility"]
   },
   {
     id: asHeaderStyleId("brand-underline"),
@@ -12662,7 +13140,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["classic"]),
     navInteraction: "underline-grow",
     surface: "brand-solid",
-    navTypography: "brand-caps"
+    defaultDepth: "none",
+    navTypography: "brand-caps",
+    moods: ["expressive"]
   },
   {
     id: asHeaderStyleId("brand-pill"),
@@ -12671,7 +13151,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["classic", "centered", "floating"]),
     navInteraction: "pill-background",
     surface: "brand-solid",
-    navTypography: "brand-caps"
+    defaultDepth: "none",
+    navTypography: "brand-caps",
+    moods: ["expressive"]
   },
   {
     id: asHeaderStyleId("serif-line"),
@@ -12680,7 +13162,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["classic", "centered"]),
     navInteraction: "underline-grow",
     surface: "bordered",
-    navTypography: "heading"
+    defaultDepth: "line",
+    navTypography: "heading",
+    moods: ["editorial", "calm"]
   },
   {
     id: asHeaderStyleId("flat-tabs"),
@@ -12689,16 +13173,20 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["classic", "centered"]),
     navInteraction: "flat-block",
     surface: "bordered",
-    navTypography: "quiet-caps"
+    defaultDepth: "shadow",
+    navTypography: "quiet-caps",
+    moods: ["professional", "utility", "expressive"]
   },
   {
     id: asHeaderStyleId("glass"),
     label: "Glass",
     description: "Translucent chrome with frosted navigation backing.",
-    supportedLayoutIds: supportedLayouts(["classic", "floating"]),
+    supportedLayoutIds: supportedLayouts(["floating"]),
     navInteraction: "glass-backed",
     surface: "floating",
-    navTypography: "plain"
+    defaultDepth: "shadow",
+    navTypography: "plain",
+    moods: ["expressive", "calm"]
   },
   {
     id: asHeaderStyleId("minimal-surface"),
@@ -12707,7 +13195,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["floating"]),
     navInteraction: "color-change",
     surface: "floating",
-    navTypography: "plain"
+    defaultDepth: "none",
+    navTypography: "plain",
+    moods: ["editorial", "calm"]
   },
   {
     id: asHeaderStyleId("soft-shell"),
@@ -12716,7 +13206,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["floating"]),
     navInteraction: "pill-background",
     surface: "floating",
-    navTypography: "plain"
+    defaultDepth: "shadow",
+    navTypography: "plain",
+    moods: ["calm", "professional"]
   },
   {
     id: asHeaderStyleId("split-glass"),
@@ -12725,7 +13217,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["floating"]),
     navInteraction: "glass-backed",
     surface: "floating",
-    navTypography: "quiet-caps"
+    defaultDepth: "shadow",
+    navTypography: "quiet-caps",
+    moods: ["expressive"]
   },
   {
     id: asHeaderStyleId("split-pill"),
@@ -12734,7 +13228,9 @@ var headerStyleCatalog = [
     supportedLayoutIds: supportedLayouts(["floating"]),
     navInteraction: "pill-background",
     surface: "floating",
-    navTypography: "heading"
+    defaultDepth: "shadow",
+    navTypography: "heading",
+    moods: ["calm", "editorial"]
   }
 ];
 var headerLayoutsById = new Map(
@@ -12748,7 +13244,6 @@ var headerStyleCompatibilityOrder = /* @__PURE__ */ new Map([
     asHeaderLayoutId("classic"),
     headerStyleRepairChain([
       "minimal",
-      "glass",
       "fine-line",
       "soft-bar",
       "pill-nav",
@@ -12815,7 +13310,13 @@ var headerStyleRepairOrder = /* @__PURE__ */ new Map(
     ],
     [
       asHeaderStyleId("glass"),
-      headerStyleRepairChain(["glass", "minimal-surface", "minimal"])
+      headerStyleRepairChain([
+        "glass",
+        "soft-shell",
+        "fine-line",
+        "minimal-surface",
+        "minimal"
+      ])
     ],
     [
       asHeaderStyleId("soft-shell"),
@@ -12927,6 +13428,23 @@ function getCompatibleHeaderStyleIds(layoutId) {
     }
   );
 }
+function themedHeaderShadow(theme) {
+  switch (theme.shadow.elevation) {
+    case "none":
+      return void 0;
+    case "low":
+      return { elevation: "sm" };
+    case "medium":
+      return { elevation: "md" };
+    case "high":
+      return { elevation: "lg" };
+    default:
+      return assertNever(
+        theme.shadow.elevation,
+        "Unhandled theme shadow elevation"
+      );
+  }
+}
 function solidBrandHeader(theme) {
   const ctaVariant = resolveHeaderCtaVariant(theme, "inverted");
   return {
@@ -13076,9 +13594,7 @@ function practicalUtilityHeader(theme) {
     navColor: "text",
     navStyle: "solid",
     navWeight: "semibold",
-    shadow: {
-      elevation: "sm"
-    },
+    shadow: themedHeaderShadow(theme),
     border: {
       style: "solid",
       width: "thin",
@@ -13147,6 +13663,7 @@ function floatingGlassHeader(theme) {
   return {
     ...transparentOverlayHeader(theme),
     variant: "floating",
+    positioning: "sticky",
     navStyle: "frosted",
     navContainer: {
       type: "glass",
@@ -13662,7 +14179,7 @@ var typographyPresets = [
     heroTypography: {
       headlineSize: "6xl",
       headlineLineHeight: "tight",
-      subheadlineSize: "editorial",
+      subheadlineSize: "2xl",
       subheadlineLineHeight: "normal",
       microHeadlineSize: "6xl",
       microHeadlineLineHeight: "tight",
@@ -13680,6 +14197,8 @@ var typographyPresetsById = new Map(
 );
 
 // ../theme-core/src/site-styles/curatedSiteStyles.ts
+var SOFT_EARTH_SITE_STYLE_ID_VALUE = "site-style:soft-earth";
+var SOFT_EARTH_SITE_STYLE_ID = asSiteStyleId(SOFT_EARTH_SITE_STYLE_ID_VALUE);
 var curatedSiteStyleIdValues = [
   "site-style:calm-studio",
   "site-style:clear-professional",
@@ -13691,7 +14210,7 @@ var curatedSiteStyleIdValues = [
   "site-style:personal-retreat-journal",
   "site-style:tactile-workshop",
   "site-style:modern-wellness",
-  "site-style:soft-earth",
+  SOFT_EARTH_SITE_STYLE_ID_VALUE,
   "site-style:bold-launch",
   "site-style:south-west-twerk-school"
 ];
@@ -13773,7 +14292,10 @@ function uniqueContentFrameKinds() {
 var generatedContentFrameKinds = uniqueContentFrameKinds();
 function defineCuratedSiteStyle(input) {
   const legacyHeaderLookIds = input.recommendedHeaderLookIds ?? ["clean-base"];
-  const inferredHeaderCuration = inferHeaderCurationFromLegacyLooks(legacyHeaderLookIds);
+  const inferredHeaderCuration = inferHeaderCurationFromLegacyLooks(
+    legacyHeaderLookIds,
+    input.tokenRecipes
+  );
   const typographyPresetChoices = input.typographyPresetChoices ?? defaultTypographyPresetChoicesForRecipe(input.tokenRecipes.typography);
   const defaultTypographyPresetId = input.defaultTypographyPresetId ? asTypographyPresetId(input.defaultTypographyPresetId) : typographyPresetChoices[0].id;
   if (!typographyPresetChoices.some(
@@ -13806,6 +14328,7 @@ function defineCuratedSiteStyle(input) {
       supportedTransitions: generatedDesignOptionCatalog.transitions
     },
     ...input.themeOverrides ? { themeOverrides: input.themeOverrides } : {},
+    ...input.defaultBlockVariants ? { defaultBlockVariants: input.defaultBlockVariants } : {},
     recommendedAppearancePresetIds: (input.recommendedAppearancePresetIds ?? []).map(asAppearancePresetId),
     defaultHeaderSelection: input.defaultHeaderSelection ? {
       layoutId: asHeaderLayoutId(input.defaultHeaderSelection.layoutId),
@@ -13864,7 +14387,69 @@ function nonEmptyHeaderStyleChoices(choices, fallbackLayoutId) {
   };
   return [first, ...choices.slice(1)];
 }
-function inferHeaderCurationFromLegacyLooks(lookIds) {
+function uniqueCompatibleHeaderStyleChoices(choices, fallbackLayoutId) {
+  const compatible = new Set(getCompatibleHeaderStyleIds(fallbackLayoutId));
+  const seen = /* @__PURE__ */ new Set();
+  const unique = choices.filter((choice) => {
+    if (!compatible.has(choice.id)) return false;
+    if (seen.has(choice.id)) return false;
+    seen.add(choice.id);
+    return true;
+  });
+  return nonEmptyHeaderStyleChoices(unique, fallbackLayoutId);
+}
+function inferredHeaderStyleValuesForRecipes(layoutId, recipes) {
+  switch (layoutId) {
+    case "classic":
+      if (isExpressiveRecipe(recipes)) {
+        return [
+          "brand-bar",
+          "brand-underline",
+          "flat-tabs",
+          "brand-pill",
+          "fine-line"
+        ];
+      }
+      if (recipes.spacing === "compact") {
+        return ["flat-tabs", "fine-line", "minimal", "brand-bar"];
+      }
+      if (isSerifTypographyRecipe(recipes)) {
+        return ["serif-line", "fine-line", "minimal", "soft-bar"];
+      }
+      if (recipes.radius === "rounded" || recipes.radius === "pill") {
+        return ["soft-bar", "pill-nav", "fine-line", "minimal"];
+      }
+      return ["fine-line", "minimal", "soft-bar", "brand-bar"];
+    case "centered":
+      if (isSerifTypographyRecipe(recipes)) {
+        return ["serif-line", "fine-line", "minimal", "soft-bar"];
+      }
+      if (isExpressiveRecipe(recipes)) {
+        return ["brand-pill", "flat-tabs", "brand-bar", "fine-line"];
+      }
+      if (recipes.radius === "rounded" || recipes.radius === "pill") {
+        return ["soft-bar", "pill-nav", "fine-line", "minimal"];
+      }
+      return ["minimal", "fine-line", "soft-bar"];
+    case "floating":
+      if (isExpressiveRecipe(recipes)) {
+        return ["glass", "split-glass", "brand-pill", "soft-shell"];
+      }
+      if (isSerifTypographyRecipe(recipes)) {
+        return ["split-pill", "minimal-surface", "soft-shell"];
+      }
+      return ["soft-shell", "minimal-surface", "glass"];
+    default:
+      return [];
+  }
+}
+function isExpressiveRecipe(recipes) {
+  return recipes.contrast === "maximum" || recipes.shadow === "layered" || recipes.motion === "expressive";
+}
+function isSerifTypographyRecipe(recipes) {
+  return recipes.typography === "serif-editorial" || recipes.typography === "classic-serif";
+}
+function inferHeaderCurationFromLegacyLooks(lookIds, recipes) {
   const selections = lookIds.map((lookId) => resolveLegacyHeaderLookAlias(asHeaderLookId(lookId))).filter(
     (selection) => Boolean(selection)
   );
@@ -13877,8 +14462,15 @@ function inferHeaderCurationFromLegacyLooks(lookIds) {
   );
   const stylesByLayout = {};
   for (const layoutChoice of layoutChoices) {
-    const styleChoices = selections.filter((selection) => selection.layoutId === layoutChoice.id).map((selection) => headerStyleChoice(selection.styleId));
-    stylesByLayout[unbrandHeaderLayoutId(layoutChoice.id)] = nonEmptyHeaderStyleChoices(styleChoices, layoutChoice.id);
+    const legacyStyleChoices = selections.filter((selection) => selection.layoutId === layoutChoice.id).map((selection) => headerStyleChoice(selection.styleId));
+    const inferredStyleChoices = inferredHeaderStyleValuesForRecipes(
+      layoutChoice.id,
+      recipes
+    ).map((styleId) => headerStyleChoice(styleId));
+    stylesByLayout[unbrandHeaderLayoutId(layoutChoice.id)] = uniqueCompatibleHeaderStyleChoices(
+      [...legacyStyleChoices, ...inferredStyleChoices],
+      layoutChoice.id
+    );
   }
   return {
     defaultHeaderSelection,
@@ -14298,10 +14890,10 @@ var curatedSiteStyles = [
     ]
   }),
   defineCuratedSiteStyle({
-    id: "site-style:soft-earth",
+    id: SOFT_EARTH_SITE_STYLE_ID,
     name: "Soft Earth",
     description: "Warm, grounded, and editorial for yoga studios, retreats, and wellbeing communities.",
-    generationBrief: "Use cream space, terracotta CTAs, olive proof bands, natural imagery, generous but composed spacing, and editorial serif headings. Prefer a real intro section, image-led offering cards, warm community proof, and a simple two-column FAQ when content allows.",
+    generationBrief: "Use cream space, terracotta CTAs, olive quote bands, natural imagery, generous but composed spacing, and editorial serif headings. Prefer a real intro section, image-led offering cards, warm community quotes, and an FAQ with a full-width intro above two columns of questions when content allows.",
     siteCreatorSelection: {
       kind: "site_creator_keyword_heuristic",
       priority: 45
@@ -14371,14 +14963,18 @@ var curatedSiteStyles = [
           paragraphSize: "default",
           headingSize: "editorial"
         }
-      }
+      },
+      accordions: softEarthAccordionSystem
+    },
+    defaultBlockVariants: {
+      "block.faq": "question-columns"
     },
     recommendedAppearancePresetIds: [
       "hero-brand-scrim",
-      "intro-soft-earth-statement",
-      "feature-cards-soft-earth-offerings",
-      "testimonials-soft-earth-proof-band",
-      "faq-soft-earth-two-column",
+      "intro-organic-statement",
+      "feature-cards-raised-rule",
+      "events-lined-panel",
+      "testimonials-brand-background-quotes",
       "contact-form-panel"
     ],
     recommendedHeaderLookIds: [
@@ -14482,7 +15078,7 @@ var curatedSiteStyles = [
       "hero-brand-scrim-fixed-frame",
       "body-text-editorial-intro",
       "schedule-details-brand-depth",
-      "testimonials-accent-quote-proof",
+      "testimonials-accent-quote-cards",
       "contact-form-brand-depth-card"
     ],
     recommendedHeaderLookIds: [
@@ -14577,6 +15173,7 @@ var themeV2RuntimeStyleFieldNames = [
 ];
 var themeV2BlockSpecificRawStyleFieldNames = [
   "_contentCardStyles",
+  "_heroLayoutStyles",
   "_textCardStyles"
 ];
 var themeV2NormalEditorRawStyleFieldNames = [
@@ -14586,6 +15183,10 @@ var themeV2NormalEditorRawStyleFieldNames = [
 var themeV2NormalEditorRawStyleFieldNameSet = new Set(
   themeV2NormalEditorRawStyleFieldNames
 );
+var themeV2CompilerOwnedFieldNames = [
+  ...themeV2RuntimeStyleFieldNames,
+  ...themeV2BlockSpecificRawStyleFieldNames
+];
 
 // ../theme-core/src/site-styles/designState.ts
 var themeV2DesignStateSchemaVersion = 1;
@@ -14600,6 +15201,16 @@ var heroLegibilityStrategySchema = z23.enum([
   "scrim-gradient",
   "solid-panel"
 ]);
+var heroCompositionIntentSchema = z23.enum([
+  "center",
+  "bottom-left"
+]);
+var heroTypographyScaleIntentSchema = z23.enum([
+  "quiet",
+  "editorial",
+  "display",
+  "poster"
+]);
 var sectionHeightIntentSchema = z23.enum([
   "default",
   "banner",
@@ -14635,6 +15246,7 @@ var imageSurfaceTreatmentSchema = z23.discriminatedUnion("kind", [
 ]);
 var testimonialCardTreatmentSchema = z23.enum(["default", "accent-quote"]);
 var tileTreatmentSchema = z23.enum(tileTreatmentValues);
+var eventListTreatmentSchema = z23.enum(eventListTreatmentValues);
 var eyebrowTreatmentSchema = z23.enum(eyebrowTreatmentValues);
 function uniqueNonEmpty(values) {
   const uniqueValues = [...new Set(values)];
@@ -14676,10 +15288,13 @@ var blockDesignPlanSchema = z23.object({
   emphasis: z23.enum(userDesignOptionCatalog.emphases),
   sectionHeight: sectionHeightIntentSchema.optional(),
   heroLegibility: heroLegibilityStrategySchema.optional(),
+  heroComposition: heroCompositionIntentSchema.optional(),
+  heroTypographyScale: heroTypographyScaleIntentSchema.optional(),
   imageSurfaceTreatment: imageSurfaceTreatmentSchema.optional(),
   imageSurfaceMotion: imageSurfaceMotionSchema.optional(),
   testimonialCardTreatment: testimonialCardTreatmentSchema.optional(),
   tileTreatment: tileTreatmentSchema.optional(),
+  eventListTreatment: eventListTreatmentSchema.optional(),
   eyebrowTreatment: eyebrowTreatmentSchema.optional()
 }).strict();
 var styleAuthoritySchema = z23.discriminatedUnion("kind", [
@@ -16079,6 +16694,7 @@ function styledSection(config) {
     renderBackgroundImage = true,
     backgroundImageLoading,
     backgroundImageFetchPriority,
+    allowOverflow = false,
     fullWidthPath
   } = config;
   const renderedBackgroundNodes = backgroundLayer(`${bindFrom}.background`, {
@@ -16113,7 +16729,7 @@ function styledSection(config) {
           // No fallback needed - transform handles all cases via defaultSpacing
         }
       },
-      allowOverflow: {
+      allowOverflow: allowOverflow ? true : {
         $bind: {
           from: `${bindFrom}.background`,
           transforms: [{ id: "background.resolveAllowOverflow" }],
@@ -16808,6 +17424,14 @@ var tileTreatmentSet = new Set(tileTreatmentValues);
 function isTileTreatment(value) {
   return typeof value === "string" && tileTreatmentSet.has(value);
 }
+var eventListTreatmentClassMap = {
+  plain: "",
+  "lined-panel": "rb-event-list-treatment-lined-panel"
+};
+var eventListTreatmentSet = new Set(eventListTreatmentValues);
+function isEventListTreatment(value) {
+  return typeof value === "string" && eventListTreatmentSet.has(value);
+}
 var sectionClassNameTransform = {
   id: "sectionStyles.resolveClassName",
   kind: "string",
@@ -16875,6 +17499,17 @@ var sectionClassNameTransform = {
         `[sectionStyles] Invalid tileTreatment value in _sectionStyles: "${tileTreatment}". Expected one of: ${tileTreatmentValues.join(", ")}.`
       );
     }
+    const eventListTreatment = input?.eventListTreatment;
+    if (isEventListTreatment(eventListTreatment)) {
+      const eventListTreatmentClass = eventListTreatmentClassMap[eventListTreatment];
+      if (eventListTreatmentClass) {
+        classes.push(eventListTreatmentClass);
+      }
+    } else if (typeof eventListTreatment === "string" && process.env.NODE_ENV !== "production") {
+      console.warn(
+        `[sectionStyles] Invalid eventListTreatment value in _sectionStyles: "${eventListTreatment}". Expected one of: ${eventListTreatmentValues.join(", ")}.`
+      );
+    }
     if (hasFixedFrameBackgroundMotion(input)) {
       classes.push(fixedFrameScopeClass);
     }
@@ -17310,6 +17945,35 @@ function sectionState(opts) {
   );
 }
 
+// ../blocks/src/system/node/fragments/headingDecoration.ts
+var defaultBindFrom = "_sectionStyles.headingDecoration";
+function headingDecoration({
+  bindFrom = defaultBindFrom,
+  family,
+  placement,
+  className
+}) {
+  return el(
+    "div",
+    {
+      "aria-hidden": "true",
+      className: {
+        $bind: {
+          from: bindFrom,
+          transforms: [
+            {
+              id: "ui.headingDecorationClassName",
+              options: { baseClass: className, family }
+            }
+          ]
+        }
+      }
+    },
+    null,
+    when(`${bindFrom}.placement`, { equals: placement })
+  );
+}
+
 // ../blocks/src/system/fragments/types.ts
 import { z as z27 } from "zod";
 var FRAGMENT_ID_PATTERN = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/i;
@@ -17395,47 +18059,48 @@ function validateFieldDefinitions(fields3, fragmentId) {
 function prefixFieldId(field, scope) {
   const cloned = cloneFieldDefinition2(field);
   cloned.id = `${scope}.${field.id}`;
-  cloned.defaultValue = cloneUnknown(cloned.defaultValue);
+  const defaultValue = cloned.defaultValue;
+  cloned.defaultValue = cloneUnknown(defaultValue);
   cloned.visibleRoles = cloned.visibleRoles ? [...cloned.visibleRoles] : void 0;
   cloned.ui = cloneUnknown(cloned.ui);
   return cloned;
 }
 function cloneFieldDefinition2(field) {
-  switch (field.type) {
-    case "repeater":
-      if (field.polymorphic && field.itemTypes) {
-        return {
-          ...field,
-          polymorphic: true,
-          itemTypes: Object.fromEntries(
-            Object.entries(field.itemTypes).map(([key, itemType]) => [
-              key,
-              {
-                ...itemType,
-                fields: itemType.fields.map(cloneFieldDefinition2)
-              }
-            ])
-          )
-        };
-      } else if (field.schema) {
-        return {
-          ...field,
-          schema: {
-            fields: field.schema.fields.map(cloneFieldDefinition2)
-          }
-        };
-      }
-      return { ...field };
-    case "group":
+  if (field.type === "repeater") {
+    if (field.polymorphic && field.itemTypes) {
+      return {
+        ...field,
+        polymorphic: true,
+        itemTypes: Object.fromEntries(
+          Object.entries(field.itemTypes).map(([key, itemType]) => [
+            key,
+            {
+              ...itemType,
+              fields: itemType.fields.map(cloneFieldDefinition2)
+            }
+          ])
+        )
+      };
+    }
+    if (field.schema) {
       return {
         ...field,
         schema: {
           fields: field.schema.fields.map(cloneFieldDefinition2)
         }
       };
-    default:
-      return { ...field };
+    }
+    return { ...field };
+  }
+  if (field.type === "group") {
+    return {
+      ...field,
+      schema: {
+        fields: field.schema.fields.map(cloneFieldDefinition2)
+      }
+    };
   }
+  return { ...field };
 }
 function cloneUnknown(value) {
   if (value == null || typeof value !== "object") {
@@ -18088,6 +18753,10 @@ var testimonialsHeadingFragment = defineFragment({
           when("content.heading"),
           bind("content.heading")
         ),
+        headingDecoration({
+          family: "short-center-rule",
+          placement: "under-centered-heading"
+        }),
         text(
           {
             as: "p",
@@ -18759,6 +19428,41 @@ var faqHeadingFragment = defineFragment({
 });
 
 // ../blocks/src/system/fragments/library/faqAccordion.ts
+function createFaqAccordionLayout(options = {}) {
+  return accordionList({
+    collection: "content.items",
+    itemName: "faqItem",
+    indexName: "faqIndex",
+    accordionProps: {
+      className: options.rootClassName ?? "accordion-root",
+      type: "single",
+      collapsible: true
+    },
+    itemProps: {
+      className: {
+        $bind: {
+          from: "content._cardStyles",
+          transforms: [
+            {
+              id: "boxStyles.all",
+              options: {
+                axis: "all",
+                includeSpacing: false,
+                baseClass: "rb-faq-item rb-relative rb-isolate rb-overflow-hidden"
+              }
+            }
+          ]
+        },
+        fallback: "rb-faq-item"
+      },
+      iconStyle: { $bind: { from: "theme.accordions.icon.style" } },
+      // Legacy theme accordion style
+      iconTreatment: { $bind: { from: "content._sectionStyles.accordionIconTreatment" } }
+    },
+    triggerFrom: "faqItem.question",
+    contentFrom: "faqItem.answer"
+  });
+}
 var faqAccordionFragment = defineFragment({
   id: "faqAccordion",
   title: "FAQ Accordion",
@@ -18792,40 +19496,7 @@ var faqAccordionFragment = defineFragment({
       }
     }
   ],
-  layout: accordionList({
-    collection: "content.items",
-    itemName: "faqItem",
-    indexName: "faqIndex",
-    accordionProps: {
-      className: "accordion-root",
-      // CSS-first: all styling handled by theme CSS
-      type: "single",
-      collapsible: true
-    },
-    itemProps: {
-      className: {
-        $bind: {
-          from: "content._cardStyles",
-          transforms: [
-            {
-              id: "boxStyles.all",
-              options: {
-                axis: "all",
-                includeSpacing: false,
-                baseClass: "rb-faq-item rb-relative rb-isolate rb-overflow-hidden rb-border"
-              }
-            }
-          ]
-        },
-        fallback: "rb-faq-item"
-      },
-      iconStyle: { $bind: { from: "theme.accordions.icon.style" } },
-      // Legacy theme accordion style
-      iconTreatment: { $bind: { from: "content._sectionStyles.accordionIconTreatment" } }
-    },
-    triggerFrom: "faqItem.question",
-    contentFrom: "faqItem.answer"
-  })
+  layout: createFaqAccordionLayout()
 });
 
 // ../blocks/src/system/fragments/library/card.ts
@@ -19772,7 +20443,8 @@ function createBlockManifestWithContentShape(config, _contentShape) {
   return createBlockManifest(config);
 }
 function normalizeBlockLayout(layout) {
-  return Array.isArray(layout) ? [...layout] : layout;
+  const rawLayout = layout;
+  return Array.isArray(rawLayout) ? rawLayout : rawLayout;
 }
 function deriveComponentName(id) {
   const base = id.replace(/^block\./, "");
@@ -19878,6 +20550,7 @@ var microLayout = styledSection({
 function splitLayoutWith(children) {
   return styledSection({
     children: styledContainer({
+      baseClassName: "rb-relative rb-isolate rb-overflow-visible",
       children: {
         type: "grid",
         props: {
@@ -19902,6 +20575,7 @@ function splitLayoutWith(children) {
     // The split variants render the image as a real grid column, so suppress
     // the default absolute background image layer while keeping color/overlay.
     renderBackgroundImage: false,
+    allowOverflow: true,
     baseClass: ""
   });
 }
@@ -20055,6 +20729,21 @@ function introHeading(className) {
     bind("content.title")
   );
 }
+function introHeadingGroup(className) {
+  return stack(
+    {
+      gap: "sm",
+      className: "rb-intro-heading-group"
+    },
+    [
+      introHeading(className),
+      headingDecoration({
+        family: "organic-squiggle",
+        placement: "after-heading"
+      })
+    ]
+  );
+}
 function introBody(className = "rb-prose rb-max-w-none") {
   return richText({ className }, bind("content.body"));
 }
@@ -20073,6 +20762,10 @@ function introCopyStack(options = {}) {
     },
     [
       introHeading(options.headingClassName ?? "rb-intro-title"),
+      headingDecoration({
+        family: "organic-squiggle",
+        placement: "after-heading"
+      }),
       introBody(options.bodyClassName),
       introCtas(options.ctaJustify)
     ]
@@ -20112,7 +20805,7 @@ var statementCopyLayout = styledSection({
           className: "rb-intro rb-intro-statement rb-grid rb-grid-cols-1 rb-gap-8 rb-md-grid-cols-2 rb-md-items-start"
         },
         [
-          introHeading("rb-intro-title rb-max-w-xl"),
+          introHeadingGroup("rb-intro-title rb-max-w-xl"),
           stack({ gap: "md", className: "rb-intro-copy rb-max-w-xl" }, [
             introBody(),
             introCtas("start")
@@ -20133,7 +20826,7 @@ var statementMediaLayout = styledSection({
           className: "rb-intro rb-intro-statement-media rb-grid rb-grid-cols-1 rb-gap-8 rb-lg-grid-cols-3 rb-lg-items-center"
         },
         [
-          introHeading("rb-intro-title rb-max-w-xl"),
+          introHeadingGroup("rb-intro-title rb-max-w-xl"),
           stack({ gap: "md", className: "rb-intro-copy rb-max-w-xl" }, [
             introBody(),
             introCtas("start")
@@ -21135,6 +21828,9 @@ function isNodeDefinitionArray(layout) {
 }
 var headingLayout = fragmentLayoutNode(faqHeadingFragment.layout);
 var accordionLayout = fragmentLayoutNode(faqAccordionFragment.layout);
+var questionColumnsAccordionLayout = createFaqAccordionLayout({
+  rootClassName: "accordion-root rb-faq-question-columns rb-grid rb-grid-cols-1 rb-gap-4 rb-lg-grid-cols-2"
+});
 var defaultLayout = styledSection({
   children: styledContainer({
     baseClassName: "rb-relative rb-isolate",
@@ -21148,11 +21844,24 @@ var twoColumnLayout = styledSection({
     children: el(
       "div",
       {
-        className: "rb-faq-two-column rb-grid rb-grid-cols-1 rb-gap-8 rb-lg-grid-cols-2 rb-lg-items-start"
+        className: "rb-faq-split-heading rb-grid rb-grid-cols-1 rb-gap-8 rb-lg-grid-cols-2 rb-lg-items-start"
       },
       [
-        el("div", { className: "rb-faq-two-column-heading" }, [headingLayout]),
-        el("div", { className: "rb-faq-two-column-accordion" }, [accordionLayout])
+        el("div", { className: "rb-faq-split-heading-copy" }, [headingLayout]),
+        el("div", { className: "rb-faq-split-heading-accordion" }, [accordionLayout])
+      ]
+    )
+  }),
+  baseClass: ""
+});
+var questionColumnsLayout = styledSection({
+  children: styledContainer({
+    baseClassName: "rb-relative rb-isolate",
+    children: stack(
+      { gap: "xl", className: "rb-w-full" },
+      [
+        headingLayout,
+        questionColumnsAccordionLayout
       ]
     )
   }),
@@ -21177,7 +21886,8 @@ var faqManifest = createBlockManifest({
   layout: defaultLayout,
   variants: {
     default: defaultLayout,
-    "two-column": twoColumnLayout
+    "two-column": twoColumnLayout,
+    "question-columns": questionColumnsLayout
   },
   defaultVariant: "default",
   variantOptions: {
@@ -21188,6 +21898,10 @@ var faqManifest = createBlockManifest({
     "two-column": {
       label: "Two column",
       description: "A left heading column with FAQ items on the right."
+    },
+    "question-columns": {
+      label: "Question columns",
+      description: "A full-width heading above FAQ items split into two columns."
     }
   },
   description: "Accordion of frequently asked questions and answers.",
@@ -21276,16 +21990,20 @@ var marqueeLoopTransform = {
   summary: "Repeat an array to a minimum length, then duplicate it for seamless marquee looping",
   schema: marqueeLoopOptionsSchema,
   run: (value, options) => {
-    if (!Array.isArray(value) || value.length === 0) return [];
+    const items = toUnknownArray(value);
+    if (items.length === 0) return [];
     const minItems = options?.minItems ?? 10;
     const base = [];
     while (base.length < minItems) {
-      base.push(...value);
+      base.push(...items);
       if (base.length > 1e3) break;
     }
     return [...base, ...base];
   }
 };
+function toUnknownArray(value) {
+  return Array.isArray(value) ? value : [];
+}
 var formattingTransforms = [
   uppercaseTransform,
   fallbackTransform,
@@ -21309,9 +22027,21 @@ var eyebrowTreatmentClassMap = {
   "accent-pill-bounce": "rb-eyebrow-treatment-pill rb-eyebrow-treatment-accent rb-eyebrow-treatment-pill-bounce"
 };
 var eyebrowTreatmentSet = new Set(eyebrowTreatmentValues);
+var headingDecorationFamilySet = new Set(visibleHeadingDecorationFamilyValues);
+var headingDecorationPlacementSet = new Set(visibleHeadingDecorationPlacementValues);
+var headingDecorationColorTokenSet = new Set(headingDecorationColorTokenValues);
 function isEyebrowTreatment(value) {
   return typeof value === "string" && eyebrowTreatmentSet.has(value);
 }
+function isHeadingDecorationFamily(value) {
+  return typeof value === "string" && headingDecorationFamilySet.has(value);
+}
+function isHeadingDecorationPlacement(value) {
+  return typeof value === "string" && headingDecorationPlacementSet.has(value);
+}
+function isHeadingDecorationColorToken(value) {
+  return typeof value === "string" && headingDecorationColorTokenSet.has(value);
+}
 var imageGalleryCornerClassMap = {
   none: "",
   sm: "rb-rounded-sm",
@@ -21415,6 +22145,10 @@ var sectionStateToneTransform = {
   summary: "Map semantic section-state kind to feedback tone",
   run: (value) => sectionStateToneFromUnknown(value)
 };
+var heroTitleLengthThresholds = {
+  medium: { maxCharacters: 42, maxWords: 6 },
+  long: { maxCharacters: 78, maxWords: 11 }
+};
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -21422,6 +22156,14 @@ function readString(obj, key) {
   const v = obj[key];
   return typeof v === "string" ? v : void 0;
 }
+function resolveGeneratedHeroLayoutStyles(content) {
+  const raw = content._heroLayoutStyles;
+  return isPlainObject(raw) ? raw : null;
+}
+function readHeroLayoutString(content, generatedKey, fallbackKey = generatedKey) {
+  const generated = resolveGeneratedHeroLayoutStyles(content);
+  return generated && typeof generated[generatedKey] === "string" ? generated[generatedKey] : readString(content, fallbackKey);
+}
 function resolveHeroVariant(content) {
   const variant = readString(content, "variant");
   if (variant && variant.trim()) return variant.trim();
@@ -21430,14 +22172,14 @@ function resolveHeroVariant(content) {
   return null;
 }
 function resolveHeroContentAlignment(content) {
-  const raw = readString(content, "contentAlignment");
+  const raw = readHeroLayoutString(content, "contentAlignment");
   if (raw === "left" || raw === "center" || raw === "right") return raw;
   const variant = resolveHeroVariant(content);
   if (variant === "split" || variant === "splitReverse") return "left";
   return "center";
 }
 function resolveHeroVerticalAlignment(content) {
-  const raw = readString(content, "verticalAlignment");
+  const raw = readHeroLayoutString(content, "verticalAlignment");
   if (raw === "top" || raw === "center" || raw === "bottom") return raw;
   const sectionStyles = asPartialObject(content._sectionStyles);
   const minHeight = sectionStyles?.minHeight;
@@ -21447,11 +22189,29 @@ function resolveHeroVerticalAlignment(content) {
   return "top";
 }
 function resolveHeroContentMaxWidth(content) {
-  const raw = readString(content, "contentMaxWidth");
+  const raw = readHeroLayoutString(content, "contentMaxWidth");
   if (raw === "default" || raw === "narrow" || raw === "medium" || raw === "wide")
     return raw;
   return "default";
 }
+function resolveHeroTypographyScale(content) {
+  const raw = readHeroLayoutString(
+    content,
+    "typographyScale",
+    "heroTypographyScale"
+  );
+  if (raw === "quiet" || raw === "editorial" || raw === "display" || raw === "poster") {
+    return raw;
+  }
+  return null;
+}
+function resolveHeroTitleLength(content) {
+  const headline = readString(content, "headline")?.trim() ?? "";
+  const wordCount = headline.length === 0 ? 0 : headline.split(/\s+/).length;
+  if (headline.length > heroTitleLengthThresholds.long.maxCharacters || wordCount > heroTitleLengthThresholds.long.maxWords) return "long";
+  if (headline.length > heroTitleLengthThresholds.medium.maxCharacters || wordCount > heroTitleLengthThresholds.medium.maxWords) return "medium";
+  return "short";
+}
 var heroContentWrapperClassSchema = z33.object({
   base: z33.string().optional()
 });
@@ -21464,6 +22224,8 @@ var heroContentWrapperClassTransform = {
     const content = isPlainObject(value) ? value : isPlainObject(context.data) ? context.data : {};
     const alignment = resolveHeroContentAlignment(content);
     const maxWidth = resolveHeroContentMaxWidth(content);
+    const typographyScale = resolveHeroTypographyScale(content);
+    const titleLength = resolveHeroTitleLength(content);
     const textAlignClass = alignment === "center" ? "rb-text-center" : alignment === "right" ? "rb-text-right" : "rb-text-left";
     const maxWidthClass = maxWidth === "narrow" ? "rb-max-w-2xl" : maxWidth === "medium" ? "rb-max-w-3xl" : maxWidth === "wide" ? "rb-max-w-5xl" : "";
     const positionClass = alignment === "center" ? "rb-mx-auto" : alignment === "right" ? "rb-ml-auto" : "";
@@ -21471,7 +22233,9 @@ var heroContentWrapperClassTransform = {
       options?.base,
       textAlignClass,
       maxWidthClass,
-      positionClass
+      positionClass,
+      typographyScale ? `rb-hero-typography-${typographyScale}` : "",
+      `rb-hero-title-${titleLength}`
     ]);
   }
 };
@@ -21771,11 +22535,67 @@ var uiTransforms = [
       const treatment = isEyebrowTreatment(value) ? value : "plain";
       return joinClasses3([baseClass, eyebrowTreatmentClassMap[treatment]]);
     }
+  },
+  {
+    id: "ui.headingDecorationClassName",
+    kind: "string",
+    summary: "Apply constrained Theme V2 heading decoration classes",
+    run: (value, options) => {
+      const baseClass = typeof options?.baseClass === "string" && options.baseClass.trim() ? options.baseClass : "rb-heading-decoration";
+      const decoration = asPartialObject(value);
+      const family = isHeadingDecorationFamily(decoration?.family) ? decoration.family : null;
+      const allowedFamily = isHeadingDecorationFamily(options?.family) ? options.family : null;
+      const placement = isHeadingDecorationPlacement(decoration?.placement) ? decoration.placement : null;
+      const colorToken = isHeadingDecorationColorToken(decoration?.colorToken) ? decoration.colorToken : "primary";
+      if (!family || !placement) return "rb-hidden";
+      if (allowedFamily && family !== allowedFamily) return "rb-hidden";
+      return joinClasses3([
+        baseClass,
+        `rb-heading-decoration-${family}`,
+        `rb-heading-decoration-placement-${placement}`,
+        `rb-heading-decoration-color-${colorToken}`
+      ]);
+    }
   }
 ];
 
 // ../blocks/src/system/transforms/registry/layout.ts
 import { z as z34 } from "zod";
+
+// ../theme-core/src/siteChromePlacement.ts
+var HEADER_POSITIONINGS = ["static", "sticky", "fixed"];
+function parseHeaderPositioning(value) {
+  return isHeaderPositioning(value) ? value : "static";
+}
+function isHeaderPositioning(value) {
+  return typeof value === "string" && HEADER_POSITIONINGS.includes(value);
+}
+function planSiteChromePlacement(positioning) {
+  switch (positioning) {
+    case "static":
+      return {
+        kind: "static",
+        headerRootClassName: null,
+        standaloneShellClassName: null
+      };
+    case "sticky":
+      return {
+        kind: "sticky",
+        headerRootClassName: "rb-sticky rb-top-0",
+        standaloneShellClassName: "sticky top-0 z-40 w-full"
+      };
+    case "fixed":
+      return {
+        kind: "fixed",
+        headerRootClassName: "rb-fixed rb-top-0 rb-left-0 rb-right-0",
+        standaloneShellClassName: "fixed left-0 right-0 top-0 z-40 w-full"
+      };
+    default:
+      return assertNever(positioning);
+  }
+}
+
+// ../blocks/src/system/transforms/registry/layout.ts
 var joinClasses4 = (parts) => parts.filter(
   (part) => typeof part === "string" && part.trim().length > 0
 ).join(" ").replace(/\s+/g, " ").trim();
@@ -21891,7 +22711,8 @@ var headerRootClassTransform = {
       ...options
     };
     const content = asPartialObject(value) ?? {};
-    const positioning = typeof content.positioning === "string" ? content.positioning : "static";
+    const positioning = parseHeaderPositioning(content.positioning);
+    const placement = planSiteChromePlacement(positioning);
     const shrinkOnScroll = Boolean(content.shrinkOnScroll);
     const header = asPartialObject(value);
     const visuals = resolveHeaderVisualStyles(header, context.theme);
@@ -21903,14 +22724,14 @@ var headerRootClassTransform = {
       if (config.blur) classes.push(config.blur);
       if (config.blurSupport) classes.push(config.blurSupport);
     }
-    if (positioning === "sticky") {
+    if (placement.kind === "sticky") {
       classes.push(
         visuals.isTransparent ? config.stickyTransparent : config.sticky
       );
-    } else if (positioning === "fixed") {
+    } else if (placement.kind === "fixed") {
       classes.push(config.fixed);
     }
-    if (shrinkOnScroll && (positioning === "sticky" || positioning === "fixed")) {
+    if (shrinkOnScroll && placement.kind !== "static") {
       classes.push(config.shrink);
     }
     const VALID_VARIANTS = [
@@ -22445,6 +23266,10 @@ function desktopOnlyDisplay(display) {
   return `rb-hidden ${LARGE_DISPLAY_CLASSES[display]}`;
 }
 
+// ../theme-core/src/siteChromeOverlayClearance.ts
+var SITE_CHROME_VISIBLE_HEADER_ATTR = "data-site-chrome-visible-header";
+var SITE_CHROME_VISIBLE_HEADER_SELECTOR = `[${SITE_CHROME_VISIBLE_HEADER_ATTR}="true"]`;
+
 // ../blocks/src/system/blocks/site-header.ts
 var logoRow = link(
   {
@@ -22717,6 +23542,7 @@ var transparentLayout = inline(
 );
 var floatingLayout = inline(
   {
+    [SITE_CHROME_VISIBLE_HEADER_ATTR]: "true",
     className: bindProp("$root.theme.header.maxWidth", {
       transforms: pipe(
         tx("layout.maxWidthClass", {
@@ -23662,6 +24488,10 @@ var sectionHeading = stack(
       when("content.title"),
       bind("content.title")
     ),
+    headingDecoration({
+      family: "short-center-rule",
+      placement: "under-centered-heading"
+    }),
     richText(
       {
         className: "rb-feature-cards-description rb-prose rb-mx-auto rb-max-w-none",
@@ -24843,8 +25673,8 @@ var eventSurfaceScopeValues = [
   "custom"
 ];
 var eventScheduleScopeValues = ["any", "recurring", "oneOff"];
-var asEventCategoryId = (value) => value;
-var asVenueId = (value) => value;
+var unsafeAsEventCategoryId = (value) => value;
+var unsafeAsVenueId = (value) => value;
 function normalizeEventBlockKind(value) {
   return value === "courses" || value === "events" ? value : "all";
 }
@@ -24870,10 +25700,10 @@ function normalizeEventCategoryIds(value) {
   if (Array.isArray(value)) {
     return normalizeIdList(
       value.filter((entry) => typeof entry === "string")
-    ).map(asEventCategoryId);
+    ).map(unsafeAsEventCategoryId);
   }
   if (typeof value === "string") {
-    return normalizeIdList(value.split(",")).map(asEventCategoryId);
+    return normalizeIdList(value.split(",")).map(unsafeAsEventCategoryId);
   }
   return [];
 }
@@ -24886,7 +25716,7 @@ function normalizeEventVenueId(value) {
     return null;
   }
   const trimmed = value.trim();
-  return trimmed ? asVenueId(trimmed) : null;
+  return trimmed ? unsafeAsVenueId(trimmed) : null;
 }
 function normalizeEventStaffMemberId(value) {
   if (typeof value !== "string") {
@@ -26085,7 +26915,7 @@ var COLUMN_CLASSES = {
 };
 function getContainerClass(layout, columns) {
   if (layout === "compact") {
-    return "event-listing-compact-container rb-flex rb-flex-col rb-gap-2";
+    return "event-listing-compact-container rb-flex rb-flex-col";
   }
   if (layout === "stack") {
     return "rb-flex rb-flex-col rb-gap-6";
@@ -28913,6 +29743,7 @@ import { z as z53 } from "zod";
 var storedProductCartItemSchema = z53.object({
   kind: z53.literal("product"),
   productId: z53.string().min(1),
+  productCategoryId: z53.string().min(1).optional().nullable(),
   variantId: z53.string().min(1).optional().nullable(),
   title: z53.string().min(1),
   variantTitle: z53.string().optional().nullable(),
@@ -31417,6 +32248,10 @@ var scheduleTileTreatments = [
   "quiet",
   "brand-depth"
 ];
+var eventListTreatments = [
+  "plain",
+  "lined-panel"
+];
 function scheduleDetailsCapable() {
   return declareBlockDesignCapability({
     sectionSurfaces: "supported",
@@ -31425,6 +32260,14 @@ function scheduleDetailsCapable() {
     tileTreatments: scheduleTileTreatments
   });
 }
+function eventListCapable() {
+  return declareBlockDesignCapability({
+    sectionSurfaces: "supported",
+    contentFrames: ["plain"],
+    itemSurfaces: "unsupported",
+    eventListTreatments
+  });
+}
 function defaultBoundaryBias(visualWeight) {
   return visualWeight === "featured" || visualWeight === "immersive" ? "clear" : "soft";
 }
@@ -31644,7 +32487,8 @@ var systemBlockDefinitionsRaw = [
     flow: bodyFlow,
     layoutProfiles: [
       layoutProfile({ variantKey: "default", family: "stack", weight: "standard" }),
-      layoutProfile({ variantKey: "two-column", family: "split", weight: "standard" })
+      layoutProfile({ variantKey: "two-column", family: "split", weight: "standard" }),
+      layoutProfile({ variantKey: "question-columns", family: "grid", weight: "standard" })
     ]
   })),
   withDesignCapability("block.site-header", siteHeaderBlockDefinition, declareNoBlockDesignCapability("site-chrome"), defineBlockDesignMetadata({
@@ -31738,11 +32582,11 @@ var systemBlockDefinitionsRaw = [
     flow: offeringsFlow,
     layoutProfiles: [layoutProfile({ variantKey: "default", family: "centered", weight: "featured" })]
   })),
-  withDesignCapability("block.event-listing", eventListingBlockDefinition, sectionOnly(), defineBlockDesignMetadata({
+  withDesignCapability("block.event-listing", eventListingBlockDefinition, eventListCapable(), defineBlockDesignMetadata({
     flow: offeringsFlow,
     layoutProfiles: [layoutProfile({ variantKey: "default", family: "stack", weight: "standard" })]
   })),
-  withDesignCapability("block.event-calendar", eventCalendarBlockDefinition, sectionOnly(), defineBlockDesignMetadata({
+  withDesignCapability("block.event-calendar", eventCalendarBlockDefinition, eventListCapable(), defineBlockDesignMetadata({
     flow: offeringsFlow,
     layoutProfiles: [
       layoutProfile({ variantKey: "combined", family: "grid", weight: "standard" }),
@@ -32874,6 +33718,15 @@ ${root} {
 `;
 }
 
+// ../theme-core/src/runtime/themeCssVarNames.ts
+var THEME_RADIUS_CSS_VARS = {
+  block: "--rb-block-radius",
+  button: "--rb-button-radius",
+  input: "--rb-input-radius",
+  legacyCard: "--radius-card",
+  legacyControl: "--radius-control"
+};
+
 // ../theme-core/src/blocks/vars/customer-portal.ts
 function generateCustomerPortalVars({
   themeId
@@ -32887,6 +33740,11 @@ ${root} {
   --cp-muted: rgb(var(--tb-mutedText));
   --cp-border: rgb(var(--tb-border));
   --cp-shadow: var(--shadow-elev);
+  --cp-primary: rgb(var(--tb-primary));
+  --cp-primary-hover: rgb(var(--tb-primary-700, var(--tb-primary)));
+  --cp-error: rgb(var(--tb-destructive));
+  --cp-card-radius: var(${THEME_RADIUS_CSS_VARS.block}, var(${THEME_RADIUS_CSS_VARS.legacyCard}, 0.75rem));
+  --cp-control-radius: var(${THEME_RADIUS_CSS_VARS.input}, var(${THEME_RADIUS_CSS_VARS.legacyControl}, 0.5rem));
 
   /* Shared tab bar (underline style) */
   --rb-tab-border-width: 1px;
@@ -32937,7 +33795,7 @@ ${root} {
   --rb-modal-bg: var(--cp-card-bg);
   --rb-modal-border: var(--cp-card-border);
   --rb-modal-shadow: var(--shadow-lg, var(--shadow-elev));
-  --rb-modal-radius: var(--radius-card);
+  --rb-modal-radius: var(--cp-card-radius);
   --rb-modal-max-width: 560px;
 
   /* Header */
@@ -34318,6 +35176,9 @@ import { jsx as jsx5 } from "react/jsx-runtime";
 import * as React from "react";
 import { Fragment, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
 
+// ../theme-core/src/fonts/uploadFormat.ts
+var MAX_FONT_UPLOAD_BYTES = 5 * 1024 * 1024;
+
 // ../theme-core/src/runtime/buildThemeRuntimeFromBridge.ts
 import { z as z61 } from "zod";
 var themeBridgeConfigSchema = z61.object({
@@ -34514,11 +35375,11 @@ function normalizeContent(block) {
 }
 function normalizeParams(input) {
   if (!input || typeof input !== "object") return {};
-  const entries = Object.entries(input).map(([key, value]) => [
-    key,
-    coerceToString(value)
-  ]);
-  return Object.fromEntries(entries);
+  const output = {};
+  for (const [key, value] of Object.entries(input)) {
+    output[key] = coerceToString(value);
+  }
+  return output;
 }
 function isNonArrayObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -34734,10 +35595,16 @@ var dashboardConfigSchema = z62.object({
 var fieldDefinitionInputSchema = unsafeRetypeZodSchema(fieldSchema);
 var nodeDefinitionSchema = unsafeRetypeZodSchema(NodeSchema);
 var sdkLoaderEndpointSchema = z62.enum(SUPPORTED_LOADER_ENDPOINTS);
+var loaderFallbackScalarSchema = z62.union([
+  z62.string(),
+  z62.number(),
+  z62.boolean(),
+  z62.null()
+]);
 var loaderParamBindingSchema = z62.object({
   $bind: z62.object({
     from: z62.string().min(1, "Binding path is required"),
-    fallback: z62.string().optional()
+    fallback: loaderFallbackScalarSchema.optional()
   })
 });
 var loaderParamValueSchema = z62.union([
@@ -34883,9 +35750,13 @@ var sdkBlockFieldOptionsMapSchema = z62.record(
 var sdkContentTypeTemplateConfigSchema = z62.object({
   blocks: z62.array(z62.unknown())
 }).passthrough();
+var sdkContentTypeOrderingConfigSchema = z62.object({
+  mode: z62.enum(["default", "manual"]).optional()
+}).optional();
 var sdkContentTypeConfigSchema = z62.object({
   key: z62.string().min(1),
   fields: z62.array(z62.unknown()),
+  ordering: sdkContentTypeOrderingConfigSchema,
   template: sdkContentTypeTemplateConfigSchema.nullable().optional()
 }).passthrough();
 var sdkContentConfigSchema = z62.object({
@@ -35091,6 +35962,7 @@ var COURSE_ENROLLMENT_REFUND_FAILED_CODES = [
 ];
 
 // ../api/src/bookingVerticals.ts
+import { z as z64 } from "zod";
 var VERTICAL_IDS = [
   "yoga_wellness",
   "fitness_pt",
@@ -35169,6 +36041,132 @@ var VERTICAL_ID_SET = new Set(VERTICAL_IDS);
 var VERTICAL_PRESET_ID_SET = new Set(
   VERTICAL_BOOKING_PRESETS.map((presetDefinition) => presetDefinition.id)
 );
+function parseVerticalId(value) {
+  return typeof value === "string" && VERTICAL_ID_SET.has(value) ? value : null;
+}
+function parseVerticalPresetId(value) {
+  return typeof value === "string" && VERTICAL_PRESET_ID_SET.has(value) ? value : null;
+}
+function getVerticalPresetDefinition(presetId) {
+  const definition = VERTICAL_BOOKING_PRESETS.find((presetDefinition) => presetDefinition.id === presetId);
+  if (!definition) {
+    throw new Error(`Unhandled vertical preset id: ${presetId}`);
+  }
+  return definition;
+}
+function toNonEmptyVerticalPresetIds(presetIds) {
+  const firstPresetId = presetIds[0];
+  return firstPresetId ? [firstPresetId, ...presetIds.slice(1)] : null;
+}
+function createConfiguredSiteVerticalBookingConfig(verticalId, selectedPresetIds) {
+  return {
+    verticalId,
+    selectedPresetIds
+  };
+}
+function createSiteVerticalBookingConfig(verticalId, selectedPresetIds) {
+  const nonEmptyPresetIds = toNonEmptyVerticalPresetIds(selectedPresetIds);
+  return nonEmptyPresetIds ? createConfiguredSiteVerticalBookingConfig(verticalId, nonEmptyPresetIds) : null;
+}
+function resolveSiteVerticalBookingConfig(rawConfig) {
+  if (!rawConfig) {
+    return { kind: "unconfigured", config: DEFAULT_SITE_VERTICAL_BOOKING_CONFIG };
+  }
+  const verticalId = parseVerticalId(rawConfig.verticalId);
+  const rawPresetIds = Array.isArray(rawConfig.selectedPresetIds) ? rawConfig.selectedPresetIds : [];
+  const selectedPresetIds = rawPresetIds.map(parseVerticalPresetId).filter((presetId) => Boolean(presetId));
+  const config = {
+    verticalId,
+    selectedPresetIds
+  };
+  if (!verticalId && selectedPresetIds.length === 0) {
+    return { kind: "unconfigured", config: DEFAULT_SITE_VERTICAL_BOOKING_CONFIG };
+  }
+  const issues = getSiteVerticalConfigIssues(rawConfig, config);
+  if (issues.length > 0) {
+    return { kind: "invalid", config, issues };
+  }
+  const configuredConfig = verticalId ? createSiteVerticalBookingConfig(verticalId, selectedPresetIds) : null;
+  if (!configuredConfig) {
+    return { kind: "invalid", config, issues: ["empty_selected_presets"] };
+  }
+  return {
+    kind: "configured",
+    config: configuredConfig,
+    selectedPresets: configuredConfig.selectedPresetIds.map(getVerticalPresetDefinition)
+  };
+}
+function getSiteVerticalConfigIssues(rawConfig, config) {
+  const issues = /* @__PURE__ */ new Set();
+  if (rawConfig.verticalId != null && !config.verticalId) {
+    issues.add("unknown_vertical");
+  }
+  if (!config.verticalId && config.selectedPresetIds.length > 0) {
+    issues.add("missing_vertical");
+  }
+  const rawPresetIds = Array.isArray(rawConfig.selectedPresetIds) ? rawConfig.selectedPresetIds : [];
+  if (rawPresetIds.some((presetId) => parseVerticalPresetId(presetId) === null)) {
+    issues.add("unknown_preset");
+  }
+  if (config.verticalId && config.selectedPresetIds.length === 0) {
+    issues.add("empty_selected_presets");
+  }
+  const seenBehaviours = /* @__PURE__ */ new Set();
+  for (const presetId of config.selectedPresetIds) {
+    const presetDefinition = getVerticalPresetDefinition(presetId);
+    if (config.verticalId && presetDefinition.verticalId !== config.verticalId) {
+      issues.add("preset_vertical_mismatch");
+    }
+    if (presetDefinition.availability === "future") {
+      issues.add("future_preset_selected");
+    }
+    if (seenBehaviours.has(presetDefinition.canonicalBehaviour)) {
+      issues.add("duplicate_canonical_behaviour");
+    }
+    seenBehaviours.add(presetDefinition.canonicalBehaviour);
+  }
+  return [...issues];
+}
+var VerticalIdSchema = z64.string().trim().transform((value, ctx) => {
+  const parsed = parseVerticalId(value);
+  if (!parsed) {
+    ctx.addIssue({
+      code: z64.ZodIssueCode.custom,
+      message: "Unknown booking vertical"
+    });
+    return z64.NEVER;
+  }
+  return parsed;
+});
+var VerticalPresetIdSchema = z64.string().trim().transform((value, ctx) => {
+  const parsed = parseVerticalPresetId(value);
+  if (!parsed) {
+    ctx.addIssue({
+      code: z64.ZodIssueCode.custom,
+      message: "Unknown booking preset"
+    });
+    return z64.NEVER;
+  }
+  return parsed;
+});
+var BookingVerticalConfigSchema = z64.object({
+  verticalId: VerticalIdSchema.nullable(),
+  selectedPresetIds: z64.array(VerticalPresetIdSchema).max(20)
+}).transform((value, ctx) => {
+  const resolved = resolveSiteVerticalBookingConfig(value);
+  if (resolved.kind === "invalid") {
+    ctx.addIssue({
+      code: z64.ZodIssueCode.custom,
+      message: `Invalid booking vertical config: ${resolved.issues.join(", ")}`
+    });
+    return z64.NEVER;
+  }
+  return resolved.config;
+});
+var DEFAULT_SITE_VERTICAL_BOOKING_CONFIG = {
+  verticalId: null,
+  selectedPresetIds: []
+};
 function preset(id, verticalId, canonicalBehaviour, label, pluralLabel, description, availability = "onboarding") {
   return {
     id,
@@ -35188,51 +36186,51 @@ function isRecord3(value) {
 }
 
 // ../api/src/appointmentSetup.ts
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 var APPOINTMENT_SETUP_MAX_MINUTES = 1440;
-var appointmentSetupRefSchema = z64.discriminatedUnion("kind", [
-  z64.object({ kind: z64.literal("existing"), id: z64.string().min(1) }),
-  z64.object({ kind: z64.literal("new"), draftId: z64.string().min(1) })
+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) })
 ]);
-var appointmentSetupVenueChoiceSchema = z64.discriminatedUnion("kind", [
-  z64.object({ kind: z64.literal("none") }),
-  z64.object({ kind: z64.literal("existing"), venueId: z64.string().min(1) }),
-  z64.object({
-    kind: z64.literal("create"),
-    draftId: z64.string().min(1),
-    title: z64.string().trim().min(1),
-    description: z64.string().nullable(),
-    timezone: z64.string().trim().min(1).nullable(),
-    addressJson: z64.record(z64.string(), z64.unknown()),
-    locationJson: z64.object({ lat: z64.number(), lng: z64.number() }).nullable()
+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 appointmentSetupPaymentDraftSchema = z64.object({
-  priceType: z64.union([z64.literal("free"), z64.literal("paid")])
-});
-var appointmentSetupServiceAssignmentDraftSchema = z64.discriminatedUnion("kind", [
-  z64.object({ kind: z64.literal("all_practitioners") }),
-  z64.object({
-    kind: z64.literal("selected_practitioners"),
-    resourceRefs: z64.array(appointmentSetupRefSchema)
+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 appointmentSetupServiceDraftSchema = z64.object({
+var appointmentSetupServiceDraftSchema = z65.object({
   ref: appointmentSetupRefSchema,
-  title: z64.string().trim().min(1),
-  description: z64.string().nullable(),
-  durationMinutes: z64.number().int().positive().max(APPOINTMENT_SETUP_MAX_MINUTES),
-  prepMinutes: z64.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
-  cleanupMinutes: z64.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
-  priceAmount: z64.number().int().nonnegative().nullable(),
-  isActive: z64.boolean(),
-  locationType: z64.union([
-    z64.literal("virtual"),
-    z64.literal("in_person"),
-    z64.literal("hybrid")
+  title: z65.string().trim().min(1),
+  description: z65.string().nullable(),
+  durationMinutes: z65.number().int().positive().max(APPOINTMENT_SETUP_MAX_MINUTES),
+  prepMinutes: z65.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
+  cleanupMinutes: z65.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
+  priceAmount: z65.number().int().nonnegative().nullable(),
+  isActive: z65.boolean(),
+  locationType: z65.union([
+    z65.literal("virtual"),
+    z65.literal("in_person"),
+    z65.literal("hybrid")
   ]),
   venue: appointmentSetupVenueChoiceSchema,
-  timezone: z64.string().trim().min(1).nullable(),
+  timezone: z65.string().trim().min(1).nullable(),
   payment: appointmentSetupPaymentDraftSchema,
   assignment: appointmentSetupServiceAssignmentDraftSchema
 }).superRefine((service, ctx) => {
@@ -35251,49 +36249,49 @@ var appointmentSetupServiceDraftSchema = z64.object({
     });
   }
 });
-var appointmentSetupPractitionerDraftSchema = z64.object({
+var appointmentSetupPractitionerDraftSchema = z65.object({
   ref: appointmentSetupRefSchema,
-  displayName: z64.string().trim().min(1),
-  bio: z64.string().nullable(),
-  timezone: z64.string().trim().min(1),
-  colorHex: z64.string().nullable()
-});
-var appointmentSetupWeeklyWindowDraftSchema = z64.object({
-  weekday: z64.number().int().min(0).max(6),
-  startTime: z64.string(),
-  endTime: z64.string()
-});
-var appointmentSetupStartTimePolicyDraftSchema = z64.discriminatedUnion("kind", [
-  z64.object({ kind: z64.literal("automatic_spacing") }),
-  z64.object({
-    kind: z64.literal("regular_interval"),
-    intervalMinutes: z64.union([
-      z64.literal(10),
-      z64.literal(15),
-      z64.literal(20),
-      z64.literal(30),
-      z64.literal(45),
-      z64.literal(60)
+  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 appointmentSetupStartTimePolicyDraftSchema = z65.discriminatedUnion("kind", [
+  z65.object({ kind: z65.literal("automatic_spacing") }),
+  z65.object({
+    kind: z65.literal("regular_interval"),
+    intervalMinutes: z65.union([
+      z65.literal(10),
+      z65.literal(15),
+      z65.literal(20),
+      z65.literal(30),
+      z65.literal(45),
+      z65.literal(60)
     ])
   })
 ]);
-var appointmentSetupAvailabilityDraftSchema = z64.object({
-  kind: z64.literal("weekly_windows"),
+var appointmentSetupAvailabilityDraftSchema = z65.object({
+  kind: z65.literal("weekly_windows"),
   resourceRef: appointmentSetupRefSchema,
   serviceRef: appointmentSetupRefSchema.nullable(),
-  windows: z64.array(appointmentSetupWeeklyWindowDraftSchema),
+  windows: z65.array(appointmentSetupWeeklyWindowDraftSchema),
   startTimePolicy: appointmentSetupStartTimePolicyDraftSchema.optional()
 });
 var APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX = 28 * 24 * 60;
 var APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX = 10 * 365 * 24 * 60;
-var appointmentSetupBookingNoticeSchema = z64.object({
-  minLeadMinutes: z64.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
-  maxBookingNoticeMinutes: z64.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
-});
-var applyAppointmentSetupRequestSchema = z64.object({
-  services: z64.array(appointmentSetupServiceDraftSchema),
-  practitioners: z64.array(appointmentSetupPractitionerDraftSchema),
-  availability: z64.array(appointmentSetupAvailabilityDraftSchema),
+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),
   bookingNotice: appointmentSetupBookingNoticeSchema
 });
 
@@ -35326,24 +36324,24 @@ var STAFF_CANCELLATION_CONTEXT_CATEGORIES = [
 ];
 
 // ../api/src/siteBanner.ts
-import { z as z65 } from "zod";
+import { z as z66 } 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 = z65.enum(SITE_BANNER_SCOPE_VALUES);
-var siteBannerToneSchema = z65.enum(SITE_BANNER_TONE_VALUES);
-var siteBannerBodySchema = z65.unknown().transform(unwrapRichTextValue);
-var siteBannerCtaSchema = z65.object({
-  label: z65.string().trim().min(1),
+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),
   link: linkPayloadSchema
 });
-var siteBannerSettingsSchema = z65.discriminatedUnion("enabled", [
-  z65.object({
-    enabled: z65.literal(false)
+var siteBannerSettingsSchema = z66.discriminatedUnion("enabled", [
+  z66.object({
+    enabled: z66.literal(false)
   }),
-  z65.object({
-    enabled: z65.literal(true),
+  z66.object({
+    enabled: z66.literal(true),
     scope: siteBannerScopeSchema,
     tone: siteBannerToneSchema,
     body: siteBannerBodySchema,
@@ -35357,7 +36355,7 @@ var siteBannerSettingsInputSchema = siteBannerSettingsSchema.superRefine((value,
   const analysis = analyzeSiteBannerBody(value.body);
   for (const issue of analysis.issues) {
     ctx.addIssue({
-      code: z65.ZodIssueCode.custom,
+      code: z66.ZodIssueCode.custom,
       path: ["body"],
       message: siteBannerBodyIssueMessage(issue)
     });
@@ -35545,72 +36543,105 @@ function collectText(node) {
   return (node.content ?? []).map(collectText).join("");
 }
 
+// ../api/src/navigation/dashboardSiteNav.ts
+var hiddenDemoSiteNavSurfaceIds = [
+  "site.newsletter"
+];
+var hiddenDemoSiteNavIds = new Set(
+  hiddenDemoSiteNavSurfaceIds
+);
+var websiteSurfaceIds = [
+  "site.content",
+  "site.footerBlocks",
+  "site.navigation",
+  "site.media",
+  "site.style",
+  "site.performance"
+];
+var websiteSurfaceIdSet = new Set(
+  websiteSurfaceIds
+);
+
+// ../api/src/navigation/dashboardSettingsNav.ts
+var hiddenDemoSettingsNavSurfaceIds = [
+  "settings.features",
+  "settings.domains",
+  "settings.bookings",
+  "settings.emails",
+  "settings.team",
+  "settings.billing",
+  "settings.developer",
+  "settings.apiKeys",
+  "settings.backup"
+];
+var hiddenDemoSettingsNavIds = new Set(hiddenDemoSettingsNavSurfaceIds);
+
 // ../api/src/aiPlayground.ts
-import { z as z66 } from "zod";
-var Rfc6902PatchOp = z66.discriminatedUnion("op", [
+import { z as z67 } from "zod";
+var Rfc6902PatchOp = z67.discriminatedUnion("op", [
   // Standard RFC-6902 operations
-  z66.object({
-    op: z66.literal("add"),
-    path: z66.string(),
-    value: z66.unknown()
+  z67.object({
+    op: z67.literal("add"),
+    path: z67.string(),
+    value: z67.unknown()
   }),
-  z66.object({
-    op: z66.literal("remove"),
-    path: z66.string()
+  z67.object({
+    op: z67.literal("remove"),
+    path: z67.string()
   }),
-  z66.object({
-    op: z66.literal("replace"),
-    path: z66.string(),
-    value: z66.unknown()
+  z67.object({
+    op: z67.literal("replace"),
+    path: z67.string(),
+    value: z67.unknown()
   }),
-  z66.object({
-    op: z66.literal("move"),
-    from: z66.string(),
-    path: z66.string()
+  z67.object({
+    op: z67.literal("move"),
+    from: z67.string(),
+    path: z67.string()
   }),
-  z66.object({
-    op: z66.literal("copy"),
-    from: z66.string(),
-    path: z66.string()
+  z67.object({
+    op: z67.literal("copy"),
+    from: z67.string(),
+    path: z67.string()
   }),
   // Block-level operations (Phase 2)
-  z66.object({
-    op: z66.literal("add_block"),
-    blockKind: z66.string(),
-    afterBlockId: z66.string().nullable(),
-    content: z66.record(z66.string(), z66.unknown()),
-    rationale: z66.string()
+  z67.object({
+    op: z67.literal("add_block"),
+    blockKind: z67.string(),
+    afterBlockId: z67.string().nullable(),
+    content: z67.record(z67.string(), z67.unknown()),
+    rationale: z67.string()
   }),
-  z66.object({
-    op: z66.literal("delete_block"),
-    blockId: z66.string(),
-    rationale: z66.string()
+  z67.object({
+    op: z67.literal("delete_block"),
+    blockId: z67.string(),
+    rationale: z67.string()
   }),
-  z66.object({
-    op: z66.literal("reorder_block"),
-    blockId: z66.string(),
-    afterBlockId: z66.string().nullable(),
-    rationale: z66.string()
+  z67.object({
+    op: z67.literal("reorder_block"),
+    blockId: z67.string(),
+    afterBlockId: z67.string().nullable(),
+    rationale: z67.string()
   })
 ]);
-var PlaygroundProposeRequest = z66.object({
-  request: z66.string().min(1).max(2e3)
+var PlaygroundProposeRequest = z67.object({
+  request: z67.string().min(1).max(2e3)
 });
-var MultiPagePatchEnvelope = z66.object({
-  pageId: z66.string(),
-  blockId: z66.string().optional(),
+var MultiPagePatchEnvelope = z67.object({
+  pageId: z67.string(),
+  blockId: z67.string().optional(),
   // Not present for page-level ops
-  blockKind: z66.string().optional(),
-  blockPurpose: z66.string().optional().nullable(),
-  ops: z66.array(Rfc6902PatchOp),
-  rationale: z66.string(),
-  currentContent: z66.record(z66.string(), z66.unknown()).optional()
+  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 = z66.object({
-  patches: z66.array(MultiPagePatchEnvelope),
-  assistantMessage: z66.string(),
-  pagesModified: z66.number(),
-  toolCallsUsed: z66.number()
+var MultiPageUpdateResponse = z67.object({
+  patches: z67.array(MultiPagePatchEnvelope),
+  assistantMessage: z67.string(),
+  pagesModified: z67.number(),
+  toolCallsUsed: z67.number()
 });
 
 // src/data/prefetchBlockData.ts
@@ -35683,7 +36714,7 @@ async function prefetchBlockData2(page, context, client, options) {
             throw new Error("listPublishedEntries requires siteId and type params");
           }
           const parsedLimit = typeof limit === "string" ? Number.parseInt(limit, 10) : typeof limit === "number" ? limit : void 0;
-          const order = orderBy === "newest" || orderBy === "oldest" || orderBy === "title" || orderBy === "order" ? orderBy : void 0;
+          const order = orderBy === "order" ? "manual" : orderBy === "newest" || orderBy === "oldest" || orderBy === "title" ? orderBy : void 0;
           const parsedEntryIds = mode === "manual" ? parseManualEntryIds(entryIds) : void 0;
           if (mode === "manual" && (!parsedEntryIds || parsedEntryIds.length === 0)) {
             return { entries: [] };
@@ -36239,12 +37270,28 @@ function isPageContent(result) {
 function isEntryContent(result) {
   return result.type === "entry";
 }
+function isContentLoadNotFoundError(error) {
+  if (typeof error !== "object" || error === null || !("status" in error)) {
+    return false;
+  }
+  return Reflect.get(error, "status") === 404;
+}
+function getRejectedReason(result) {
+  return result.reason;
+}
 async function loadContent(params) {
   const { client, siteId, path, preview = false, forceSite } = params;
-  const [site, contentResponse] = await Promise.all([
+  const [siteResult, contentResult] = await Promise.allSettled([
     client.getSite({ id: siteId, ...forceSite ? { force: true } : {} }),
     client.getPage({ siteId, path, preview })
   ]);
+  if (siteResult.status === "rejected" || contentResult.status === "rejected") {
+    const failures = [siteResult, contentResult].filter((result) => result.status === "rejected").map(getRejectedReason);
+    const upstreamFailure = failures.find((error) => !isContentLoadNotFoundError(error));
+    throw upstreamFailure ?? failures[0];
+  }
+  const site = siteResult.value;
+  const contentResponse = contentResult.value;
   const customBlocks = resolveSiteCustomBlocks(site);
   const mediaAssets = Array.isArray(contentResponse.mediaAssets) && contentResponse.mediaAssets.length > 0 ? contentResponse.mediaAssets : void 0;
   if (isEntryResponse(contentResponse)) {